feat: leetcode_week_254

Author: OneCodeMonkey

Diff for: contest/leetcode_week_254/leetcode_1967_Number_of_Strings_That_Appear_as_Substrings_in_Word.java

@@ -0,0 +1,17 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Number of Strings That Appear as Substrings in Word.
+// Memory Usage: 39.1 MB, less than 75.00% of Java online submissions for Number of Strings That Appear as Substrings in Word.
+// .
+// T:O(n), S:O(1)
+//
+class Solution {
+    public int numOfStrings(String[] patterns, String word) {
+        int ret = 0;
+        for (String str: patterns) {
+            if (word.contains(str)) {
+                ret++;
+            }
+        }
+
+        return ret;
+    }
+}

Diff for: contest/leetcode_week_254/leetcode_1968_Array_With_Elements_Not_Equal_to_Average_of_Neighbors.java

@@ -0,0 +1,33 @@
+// AC:Runtime: 33 ms, faster than 21.43% of Java online submissions for Array With Elements Not Equal to Average of Neighbors.
+// Memory Usage: 63.5 MB, less than 21.43% of Java online submissions for Array With Elements Not Equal to Average of Neighbors.
+// .
+// T:O(n) ~ O(n^2), S:O(n)
+//
+class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        int size = nums.length;
+        List<Integer> temp = new ArrayList<>(size);
+        for (int i: nums) {
+            temp.add(i);
+        }
+        while (!check(temp)) {
+            Collections.shuffle(temp);
+        }
+        int[] ret = new int[size];
+        for (int i = 0; i < temp.size(); i++) {
+            ret[i] = temp.get(i);
+        }
+
+        return ret;
+    }
+
+    private boolean check(List<Integer> nums) {
+        for (int i = 1; i < nums.size() - 1; i++) {
+            if (nums.get(i) * 2 == nums.get(i - 1) + nums.get(i + 1)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

Diff for: contest/leetcode_week_254/leetcode_1969_Minimum_Non-Zero_Product_of_the_Array_Elements.java

@@ -0,0 +1,23 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Minimum Non-Zero Product of the Array Elements.
+// Memory Usage: 35.4 MB, less than 100.00% of Java online submissions for Minimum Non-Zero Product of the Array Elements.
+// 思路：观察规律可以猜测，最小乘积时，除了 2^p - 1 外，剩下的最大值和最小值两两配对，形成 2^p - 2, 共 (2^p - 2) / 2 对。再计算 pow(x, y), 递归计算，复杂度降为 O(n), n 为原指数
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public int minNonZeroProduct(int p) {
+        long mod = 1000_000_000 + 7, divider = (1L << p) - 1;
+        long powResult = myPow(divider - 1, (divider - 1) / 2, mod);
+        int ret = (int) (((divider % mod) * powResult) % mod);
+        return ret;
+    }
+
+    private long myPow(long x, long y, long mod) {
+        if (y == 0) {
+            return 1;
+        }
+        long temp = myPow(x, y / 2, mod);
+        long p = (temp * temp) % mod;
+
+        return y % 2 == 1 ? (p * (x % mod)) % mod : p;
+    }
+}

Diff for: contest/leetcode_week_254/leetcode_1970_Last_Day_Where_You_Can_Still_Cross.java

@@ -0,0 +1,53 @@
+// AC: Runtime: 81 ms, faster than 33.33% of Java online submissions for Last Day Where You Can Still Cross.
+// Memory Usage: 48 MB, less than 100.00% of Java online submissions for Last Day Where You Can Still Cross.
+// binary search & bfs search of graph
+// T:(nlogn), S:O(n), n = row * col
+//
+class Solution {
+    public int latestDayToCross(int row, int col, int[][] cells) {
+        int left = 0, right = row * col - 1, ret = -1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (check(cells, row, col, mid)) {
+                ret = mid;
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+
+        return ret;
+    }
+
+    private boolean check(int[][] cells, int row, int col, int day) {
+        int[][] grid = new int[row][col];
+        for (int i = 0; i < day; i++) {
+            grid[cells[i][0] - 1][cells[i][1] - 1] = 1;
+        }
+        Queue<int[]> bfs = new ArrayDeque<>();
+        for (int i = 0; i < col; i++) {
+            if (grid[0][i] == 0) {
+                bfs.offer(new int[]{0, i});
+                grid[0][i] = 1;
+            }
+        }
+        int[] dir = new int[]{0, 1, 0, -1, 0};
+        while (!bfs.isEmpty()) {
+            int[] curPoint = bfs.poll();
+            int curRow = curPoint[0], curCol = curPoint[1];
+            if (curRow == row - 1) {
+                return true;
+            }
+            for (int i = 0; i < 4; i++) {
+                int tempRow = curRow + dir[i], tempCol = curCol + dir[i + 1];
+                if (tempRow < 0 || tempRow >= row || tempCol < 0 || tempCol >= col || grid[tempRow][tempCol] == 1) {
+                    continue;
+                }
+                grid[tempRow][tempCol] = 1;
+                bfs.offer(new int[]{tempRow, tempCol});
+            }
+        }
+
+        return false;
+    }
+}