update

Author: OneCodeMonkey

leetcode_solved/[editing]leetcode_0239_Sliding_Window_Maximum.cpp

@@ -0,0 +1,38 @@
+// Solution1: treemap
+// AC: Runtime: 700 ms, faster than 5.00% of Java online submissions for Sliding Window Maximum.
+// Memory Usage: 128.4 MB, less than 8.80% of Java online submissions for Sliding Window Maximum.
+// using treemap of size k, to get the highest element
+// T:O(nlogk), S:O(k)
+//
+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        int size = nums.length;
+        int[] ret = new int[size - k + 1];
+
+        TreeMap<Integer, Integer> record = new TreeMap<>(new Comparator<Integer>() {
+            @Override
+            public int compare(Integer o1, Integer o2) {
+                return o2 - o1;
+            }
+        });
+
+        for (int i = 0; i < k; i++) {
+            record.merge(nums[i], 1, Integer::sum);
+        }
+        ret[0] = record.firstKey();
+
+        for (int i = k; i < size; i++) {
+            int time = record.get(nums[i - k]);
+            if (time <= 1) {
+                record.remove(nums[i - k]);
+            } else {
+                record.merge(nums[i - k], -1, Integer::sum);
+            }
+            record.merge(nums[i], 1, Integer::sum);
+
+            ret[i - k + 1] = record.firstKey();
+        }
+
+        return ret;
+    }
+}

leetcode_solved/[editing]leetcode_0295_Find_Median_from_Data_Stream.cpp

@@ -0,0 +1,43 @@
+// AC: Runtime: 210 ms, faster than 9.73% of Java online submissions for Find Median from Data Stream.
+// Memory Usage: 123.5 MB, less than 6.09% of Java online submissions for Find Median from Data Stream.
+// two heap, one is minimum heap, one is maximum heap, keep the size balance, so the top of the two heap makeup median number.
+// add: T:O(logn), find: T:O(1),  S:O(n)
+// 
+class MedianFinder {
+    private PriorityQueue<Integer> record1;
+    private PriorityQueue<Integer> record2;
+    private boolean isEvenSize = true;
+
+    /** initialize your data structure here. */
+    public MedianFinder() {
+        record1 = new PriorityQueue<>(new Comparator<Integer>() {
+            @Override
+            public int compare(Integer o1, Integer o2) {
+                return o2 - o1;
+            }
+        });
+        record2 = new PriorityQueue<>();
+    }
+
+    public void addNum(int num) {
+        if (isEvenSize) {
+            record2.offer(num);
+            record1.offer(record2.poll());
+        } else {
+            record1.offer(num);
+            record2.offer(record1.poll());
+        }
+        isEvenSize = !isEvenSize;
+    }
+
+    public double findMedian() {
+        if (record2.isEmpty()) {
+            return record1.peek();
+        }
+        if (isEvenSize) {
+            return (record1.peek() + record2.peek()) / 2.0;
+        } else {
+            return record1.peek();
+        }
+    }
+}

leetcode_solved/[editing]leetcode_0954_Array_of_Doubled_Pairs.cpp

@@ -0,0 +1,50 @@
+// AC: Runtime: 34 ms, faster than 66.99% of Java online submissions for Array of Doubled Pairs.
+// Memory Usage: 46.7 MB, less than 63.61% of Java online submissions for Array of Doubled Pairs.
+// sort and judge from max, if positive, check max is even and max/2 is never used, is negative, check max * 2 is never used.
+// T:O(nlogn), S:O(n)
+// 
+class Solution {
+    public boolean canReorderDoubled(int[] arr) {
+        int size = arr.length;
+        Arrays.sort(arr);
+
+        HashMap<Integer, List<Integer>> valueToIndex = new HashMap<>();
+        int[] used = new int[size];
+        for (int i = 0; i < size; i++) {
+            if (!valueToIndex.containsKey(arr[i])) {
+                List<Integer> tempList = new LinkedList<>();
+                tempList.add(i);
+                valueToIndex.put(arr[i], tempList);
+            } else {
+                valueToIndex.get(arr[i]).add(i);
+            }
+        }
+
+        for (int i = size - 1; i >= 0; i--) {
+            if (used[i] == 1) {
+                continue;
+            }
+            if (arr[i] >= 0) {
+                if (arr[i] % 2 == 1 || !valueToIndex.containsKey(arr[i] / 2) || valueToIndex.get(arr[i] / 2).size() == 0) {
+                    return false;
+                }
+                List<Integer> tempList = valueToIndex.get(arr[i] / 2);
+                int index = tempList.get(tempList.size() - 1);
+                tempList.remove(tempList.size() - 1);
+                used[index] = 1;
+                used[i] = 1;
+            } else {
+                if (!valueToIndex.containsKey(arr[i] * 2) || valueToIndex.get(arr[i] * 2).size() == 0) {
+                    return false;
+                }
+                List<Integer> tempList = valueToIndex.get(arr[i] * 2);
+                int index = tempList.get(tempList.size() - 1);
+                tempList.remove(tempList.size() - 1);
+                used[index] = 1;
+                used[i] = 1;
+            }
+        }
+
+        return true;
+    }
+}

leetcode_solved/leetcode_0239_Sliding_Window_Maximum.java

@@ -0,0 +1,24 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for The kth Factor of n.
+// Memory Usage: 35.9 MB, less than 55.27% of Java online submissions for The kth Factor of n.
+// .
+// T:O(n), S:O(1)
+//
+class Solution {
+    public int kthFactor(int n, int k) {
+        int temp = 1, count = 0, step = 1;
+        if (n % 2 == 1) {
+            step = 2;
+        }
+        while (temp <= n) {
+            if (n % temp == 0) {
+                count++;
+                if (count == k) {
+                    return temp;
+                }
+            }
+            temp += step;
+        }
+
+        return -1;
+    }
+}

leetcode_solved/leetcode_0295_Find_Median_from_Data_Stream.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int numOfStrings(String[] patterns, String word) {
+        int ret = 0;
+        for (String str: patterns) {
+            if (word.contains(str)) {
+                ret++;
+            }
+        }
+
+        return ret;
+    }
+}

leetcode_solved/leetcode_0954_Array_of_Doubled_Pairs.java

@@ -0,0 +1,28 @@
+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;
+    }
+}

leetcode_solved/leetcode_1492_The_kth_Factor_of_n.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;
+    }
+}

leetcode_solved/leetcode_1967_Number_of_Strings_That_Appear_as_Substrings_in_Word.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;
+    }
+}