LeetCode 题解 1554~1569

Author: LjyYano

solution/1500-1599/1544.Make The String Great/Solution.java

@@ -0,0 +1,28 @@
+class Solution {
+    public String makeGood(String s) {
+        return help(s);
+    }
+
+    private String help(String s) {
+        if (s == null || s.length() == 0 || s.length() == 1) {
+            return s;
+        }
+        char[] chars = s.toCharArray();
+        for (int i = 1; i < chars.length; i++) {
+            if (Math.abs(chars[i] - chars[i - 1]) == Math.abs('A' - 'a')) {
+                return help(newString(chars, i));
+            }
+        }
+        return s;
+    }
+
+    private String newString(char[] chars, int i) {
+        StringBuilder tmp = new StringBuilder();
+        for (int j = 0; j < chars.length; j++) {
+            if (j != i && j != i - 1) {
+                tmp.append(chars[j]);
+            }
+        }
+        return tmp.toString();
+    }
+}

solution/1500-1599/1545.Find Kth Bit in Nth Binary String/Solution.java

@@ -0,0 +1,38 @@
+class Solution {
+      public char findKthBit(int n, int k) {
+        if (k == 1 || n == 1) {
+            return '0';
+        }
+        Set<Integer> set = new HashSet<>();
+        int len = calcLength(n, set);
+        if (set.contains(k)) {
+            return '1';
+        }
+        // 中间，返回1
+        if (k < len / 2) {
+            return findKthBit(n - 1, k);
+        } else {
+            if (set.contains(len - k)) {
+                return '1';
+            }
+            return r(findKthBit(n - 1, len - k + 1));
+        }
+    }
+
+    private char r(char b) {
+        if (b == '0') {
+            return '1';
+        }
+        return '0';
+    }
+
+    private int calcLength(int n, Set<Integer> set) {
+        if (n == 1) {
+            return 1;
+        }
+
+        int ans = 2 * calcLength(n - 1, set) + 1;
+        set.add(ans + 1);
+        return ans;
+    }
+}

solution/1500-1599/1546.Maximum Number of Non-Overlapping Subarrays With Sum Equals Target/Solution.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int maxNonOverlapping(int[] nums, int target) {
+        Set<Integer> set = new HashSet<>();
+        set.add(0);
+        int sum = 0, ans = 0;
+        for (int num : nums) {
+            sum += num;
+            if (set.contains(sum - target)) {
+                ans++;
+                set.clear();
+                sum = 0;
+            }
+
+            set.add(sum);
+        }
+        return ans;
+    }
+}

solution/1500-1599/1550.Three Consecutive Odds/Solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public boolean threeConsecutiveOdds(int[] arr) {
+        int count = 0;
+        for (int n : arr) {
+            if (n % 2 == 0) {
+                count = 0;
+            } else {
+                count++;
+                if (count >= 3) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

solution/1500-1599/1551.Minimum Operations to Make Array Equal/Solution.java

@@ -0,0 +1,10 @@
+class Solution {
+    public int minOperations(int n) {
+        int ans = 0;
+        for (int i = 0; i < n / 2; i++) {
+            int curr = 2 * i + 1;
+            ans += Math.abs(n - curr);
+        }
+        return ans;
+    }
+}

solution/1500-1599/1553.Minimum Number of Days to Eat N Oranges/Solution.java

@@ -0,0 +1,13 @@
+class Solution {
+    private Map<Integer, Integer> map = new HashMap<>();
+
+    public int minDays(int n) {
+        if (n < 2) {
+            return n;
+        }
+        if (!map.containsKey(n)) {
+            map.put(n, Math.min(minDays(n / 2) + 1 + n % 2, minDays(n / 3) + 1 + n % 3));
+        }
+        return map.get(n);
+    }
+}

solution/1500-1599/1560.Most Visited Sector in a Circular Track/Solution.java

@@ -0,0 +1,28 @@
+class Solution {
+    public List<Integer> mostVisited(int n, int[] rounds) {
+        int[] ans = new int[n];
+        for (int i = 0; i < rounds.length; i++) {
+            rounds[i]--;
+        }
+        ans[rounds[0]]++;
+        for (int i = 0; i < rounds.length - 1; i++) {
+            int start = rounds[i];
+            int end = rounds[i + 1];
+            if (end <= start) {
+                end += n;
+            }
+            for (int j = start + 1; j <= end; j++) {
+                ans[j % n]++;
+            }
+        }
+
+        int max = Arrays.stream(ans).max().orElse(-1);
+        List<Integer> list = new ArrayList<>();
+        for (int i = 0; i < ans.length; i++) {
+            if (ans[i] == max) {
+                list.add(i + 1);
+            }
+        }
+        return list;
+    }
+}

solution/1500-1599/1561.Maximum Number of Coins You Can Get/Solution.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int maxCoins(int[] piles) {
+        Arrays.sort(piles);
+        int start = 0, end = piles.length - 1, ans = 0;
+        while (start < end) {
+            ans += piles[end - 1];
+            start++;
+            end -= 2;
+        }
+        return ans;
+    }
+}

solution/1500-1599/1562.Find Latest Group of Size M/Solution.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int findLatestStep(int[] arr, int m) {
+        // 倒序遍历 arr，转换为第一次出现 m 个的步骤
+        if (arr.length == m) {
+            return m;
+        }
+        TreeSet<Integer> set = new TreeSet<>();
+        set.add(0);
+        set.add(arr.length + 1);
+        for (int i = arr.length - 1; i >= 0; i--) {
+            int index = arr[i];
+            int l = set.lower(index);
+            int h = set.higher(index);
+            if (index - l - 1 == m || h - index - 1 == m) {
+                return i;
+            }
+            set.add(index);
+        }
+        return -1;
+    }
+}

solution/1500-1599/1566.Detect Pattern of Length M Repeated K or More Times/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+    public boolean containsPattern(int[] arr, int m, int k) {
+        if (arr.length < m * k) {
+            return false;
+        }
+        for (int i = 0; i <= arr.length - m * k; i++) {
+            boolean match = true;
+            for (int j = i + m; j < i + m * k; j++) {
+                if (arr[j] != arr[j - m]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

solution/1500-1599/1567.Maximum Length of Subarray With Positive Product/Solution.java

@@ -0,0 +1,30 @@
+class Solution {
+     public int getMaxLen(int[] nums) {
+        // p[i] = n[i-1] + 1, nums[i] < 0
+        // p[i] = p[i-1] + 1, nums[i] > 0
+        // p[i] = 0, nums[i] = 0
+
+        // n[i] = p[i-1] + 1, nums[i] < 0
+        // n[i] = n[i-1] + 1, nums[i] > 0
+        // n[i] = 0, nums[i] = 0
+        int[] p = new int[nums.length];
+        int[] n = new int[nums.length];
+        p[0] = nums[0] > 0 ? 1 : 0;
+        n[0] = nums[0] < 0 ? 1 : 0;
+        int res = Math.max(p[0], 0);
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] > 0) {
+                p[i] = p[i - 1] + 1;
+                n[i] = n[i - 1] == 0 ? 0 : n[i - 1] + 1;
+            } else if (nums[i] == 0) {
+                p[i] = 0;
+                n[i] = 0;
+            } else {
+                p[i] = n[i - 1] == 0 ? 0 : n[i - 1] + 1;
+                n[i] = p[i - 1] + 1;
+            }
+            res = Math.max(res, p[i]);
+        }
+        return res;
+    }
+}

solution/1500-1599/1569.Number of Ways to Reorder Array to Get Same BST/Solution.java

@@ -0,0 +1,36 @@
+class Solution {
+     int mod = (int) 1e9 + 7;
+
+    public int numOfWays(int[] nums) {
+        if (nums.length < 2) {
+            return 0;
+        }
+        return dfs(Arrays.stream(nums).boxed().collect(Collectors.toList()), calc(nums.length)) - 1;
+    }
+
+    private int dfs(List<Integer> list, int[][] c) {
+        if (list.isEmpty()) {
+            return 1;
+        }
+        List<Integer> left = list.stream().filter(n -> n < list.get(0))
+                .collect(Collectors.toList());
+        List<Integer> right = list.stream().filter(n -> n > list.get(0))
+                .collect(Collectors.toList());
+        return (int) ((long) c[list.size() - 1][left.size()] * dfs(left, c) % mod * dfs(right, c)
+                % mod);
+    }
+
+    private int[][] calc(int n) {
+        int[][] c = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j <= i; j++) {
+                if (j == 0) {
+                    c[i][j] = 1;
+                } else {
+                    c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
+                }
+            }
+        }
+        return c;
+    }
+}