LeetCode 题解 1574~1584

Author: LjyYano

solution/1500-1599/1574.Shortest Subarray to be Removed to Make Array Sorted/Solution.java

@@ -0,0 +1,30 @@
+class Solution {
+    public int findLengthOfShortestSubarray(int[] arr) {
+        int n = arr.length;
+        int left = 0;
+        while (left + 1 < n && arr[left] <= arr[left + 1]) {
+            left++;
+        }
+        if (left == n - 1) {
+            return 0;
+        }
+        int right = n - 1;
+        while (right > 0 && arr[right - 1] <= arr[right]) {
+            right--;
+        }
+
+        int res = Math.min(n - left - 1, right);
+
+        int i = 0, j = right;
+
+        while (i <= left && j <= n - 1) {
+            if (arr[i] <= arr[j]) {
+                res = Math.min(res, j - i - 1);
+                i++;
+            } else {
+                j++;
+            }
+        }
+        return res;
+    }
+}

solution/1500-1599/1576.Replace All ?'s to Avoid Consecutive Repeating Characters/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+public String modifyString(String s) {
+        char[] chars = s.toCharArray();
+
+        for (int i = 0; i < chars.length; i++) {
+            if (chars[i] == '?') {
+                // 前面的字符 
+                char ahead = i == 0 ? ' ' : chars[i - 1];
+                // 最后的字符
+                char behind  = i == chars.length - 1 ? ' ' : chars[i + 1];
+                char temp = 'a';
+                while (temp == ahead || temp == behind ) {
+                    temp++;
+                }
+                chars[i] = temp;
+            }
+        }
+        return new String(chars);
+    }
+}

solution/1500-1599/1578.Minimum Deletion Cost to Avoid Repeating Letters/Solution.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int minCost(String s, int[] cost) {
+        int res = 0;
+        char[] word = s.toCharArray();
+        for(int i = 0;i < word.length;i++){
+            char c = word[i];
+            int max = cost[i];
+            int sum = max;
+            while(i + 1 < word.length && word[i + 1] == c){
+                sum += cost[++i];
+                max = Math.max(max,cost[i]);
+            }
+            if(sum != max){
+                res += sum - max;
+            }
+        }
+        return res;
+    }
+}

solution/1500-1599/1579.Remove Max Number of Edges to Keep Graph Fully Traversable/Solution.java

@@ -0,0 +1,47 @@
+class Solution {
+    // https://oi-wiki.org/ds/dsu/#_3
+    private boolean[] used;
+
+    public int maxNumEdgesToRemove(int n, int[][] edges) {
+        used = new boolean[edges.length];
+        // type 为倒序，3, 2, 1
+        Arrays.sort(edges, (a, b) -> Integer.compare(b[0], a[0]));
+        if (!unionFind(n, edges, 1)) return -1;
+        if (!unionFind(n, edges, 2)) return -1;
+        int result = 0;
+        for (boolean u : used) {
+            result += u ? 0 : 1;
+        }
+        return result;
+    }
+
+    private boolean unionFind(int n, int[][] edges, int excludedType) {
+        int[] union = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            union[i] = i;
+        }
+        int cnt = 0;
+        for (int i = 0; i < edges.length; i++) {
+            int[] edge = edges[i];
+            if (edge[0] == excludedType) continue;
+            int rootA = findRoot(union, edge[1]);
+            int rootB = findRoot(union, edge[2]);
+            if (rootA != rootB) {
+                cnt += 1;
+                union[rootA] = rootB;
+                used[i] = true;
+            }
+            if (cnt == n - 1) return true;
+        }
+        return false;
+    }
+
+    private int findRoot(int[] union, int idx) {
+        if (union[idx] != idx) {
+            int root = findRoot(union, union[idx]);
+            union[idx] = root;
+            return root;
+        }
+        return idx;
+    }
+}

solution/1500-1599/1582.Special Positions in a Binary Matrix/Solution.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int numSpecial(int[][] mat) {
+        int rows = mat.length;
+        int cols = mat[0].length;
+        
+        int[] rows1 = new int[rows];
+        int[] cols1 = new int[cols];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (mat[i][j] == 1) {
+                    rows1[i]++;
+                    cols1[j]++;
+                }
+            }
+        }
+        
+        int ans = 0;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (mat[i][j] == 1 && rows1[i] == 1 && cols1[j] == 1) {
+                    ans ++;
+                } 
+            }
+        }
+        
+        return ans;
+    }
+}

solution/1500-1599/1583.Count Unhappy Friends/Solution.java

@@ -0,0 +1,46 @@
+class Solution {
+    public int unhappyFriends(int n, int[][] preferences, int[][] pairs) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int[] pair : pairs) {
+            calcBetter(preferences[pair[0]], map, pair[0], pair[1]);
+            calcBetter(preferences[pair[1]], map, pair[1], pair[0]);
+        }
+        Set<Integer> set = new HashSet<>();
+        for (int i = 0; i < pairs.length; i++) {
+            for (int j = i + 1; j < pairs.length; j++) {
+                if (unhappy(pairs[i][0], pairs[j][0], map)) {
+                    set.add(pairs[i][0]);
+                    set.add(pairs[j][0]);
+                }
+                if (unhappy(pairs[i][1], pairs[j][0], map)) {
+                    set.add(pairs[i][1]);
+                    set.add(pairs[j][0]);
+                }
+                if (unhappy(pairs[i][0], pairs[j][1], map)) {
+                    set.add(pairs[i][0]);
+                    set.add(pairs[j][1]);
+                }
+                if (unhappy(pairs[i][1], pairs[j][1], map)) {
+                    set.add(pairs[i][1]);
+                    set.add(pairs[j][1]);
+                }
+            }
+        }
+        return set.size();
+    }
+
+    private void calcBetter(int[] preference, Map<Integer, Set<Integer>> map, int from, int to) {
+        Set<Integer> betterSet = new HashSet<>();
+        for (int i : preference) {
+            if (i == to) {
+                break;
+            }
+            betterSet.add(i);
+        }
+        map.put(from, betterSet);
+    }
+
+    private boolean unhappy(int x, int y, Map<Integer, Set<Integer>> map) {
+        return map.get(x).contains(y) && map.get(y).contains(x);
+    }
+}

solution/1500-1599/1584.Min Cost to Connect All Points/Solution.java

@@ -0,0 +1,46 @@
+class Solution {
+    static class Edge {
+
+        int x;
+        int y;
+        int len;
+
+        Edge(int x, int y, int len) {
+            this.x = x;
+            this.y = y;
+            this.len = len;
+        }
+    }
+
+    public int minCostConnectPoints(int[][] points) {
+        Queue<Edge> heap = new PriorityQueue<>(Comparator.comparingInt((Edge e) -> e.len));
+        boolean[] marked = new boolean[points.length];
+        marked[0] = true;
+        addVertex(points, marked, 0, heap);
+        int count = 1;
+        int res = 0;
+        while (!heap.isEmpty()) {
+            Edge edge = heap.poll();
+            if (!marked[edge.y]) {
+                res += edge.len;
+                marked[edge.y] = true;
+                addVertex(points, marked, edge.y, heap);
+                count++;
+                if (count == points.length) {
+                    break;
+                }
+            }
+        }
+        return res;
+    }
+
+    public void addVertex(int[][] points, boolean[] marked, int x, Queue<Edge> heap) {
+        for (int i = 0; i < marked.length; i++) {
+            if (marked[i]) {
+                continue;
+            }
+            heap.add(new Edge(x, i,
+                    Math.abs(points[x][0] - points[i][0]) + Math.abs(points[x][1] - points[i][1])));
+        }
+    }
+}