.

Author: ZichengQu

Hot100/README.md

@@ -0,0 +1,19 @@
+class Solution {
+    public int solve(int num) {
+        int count = 0;
+
+        while(num >= 5){
+            num -= 5;
+            count += 2;
+            num += 2;
+        }
+
+        while(num >= 3){
+            num -= 3;
+            count += 1;
+            num += 1;
+        }
+
+        return count;
+    }
+}

README.md

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode swapTree(TreeNode root) {
+        dfs(root);
+        return root;
+    }
+
+    private void dfs(TreeNode root){
+        if(root == null){
+            return;
+        }
+        TreeNode temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+
+        dfs(root.left);
+        dfs(root.right);
+    }
+}

力扣训练营/毕业竞赛/1. 第一题.java

@@ -0,0 +1,50 @@
+class Solution {
+    public int cardGame(int[] cardA, int[] cardB) {
+        Arrays.sort(cardA);
+        Arrays.sort(cardB); // 李的牌，排不排序无所谓
+
+        boolean[] used = new boolean[cardA.length]; // 未使用：false，已使用：true
+
+        int winCount = 0;
+
+        for(int i = 0; i < cardB.length; i++){
+            int target = cardB[i]; // 李的出牌
+            int index = binarySearchLarger(cardA, target, used);
+            if(target < cardA[index]){
+                winCount++;
+            }
+        }
+
+        return winCount;
+    }
+
+    // 如果是找 min(num > target), 则使用left。如果是找 max(num < target)，则将下面的换成 if( cardA[mid] >= target, right = mid - 1, 并使用 right
+    private int binarySearchLarger(int[] cardA, int target, boolean[] used){ // 找 argmin(cardA[index] > target)，若不存在，则返回最小可利用的元素
+        int left = 0;
+        int right = cardA.length - 1;
+
+        while(left <= right){ // 找 argmin(cardA[index] > target)
+            int mid = (left + right) / 2;
+            if(cardA[mid] <= target){
+                left = mid + 1;
+            }else{
+                right = mid - 1;
+            }
+        }
+
+        while(left < cardA.length && used[left] == true){ // 若被使用过，则向右寻找
+            left++;
+        }
+
+        if(left == cardA.length){ // 若越界了，说明没有比 target 大的(未被使用过的)元素了
+            left = 0; // 因为没有比 target 大的元素了，那就拿一个最小的元素和 target 去对比吧 (田忌赛马)
+            while(left < cardA.length && used[left] == true){ 
+                left++;
+            }
+        }
+
+        used[left] = true; // 标志为使用过
+
+        return left;
+    }
+}

力扣训练营/毕业竞赛/2. 第二题.java

@@ -0,0 +1,75 @@
+/**
+ * 正确思路，按最短桥的思路，从三个国家往外扩展，3个bfs
+ * O(row * col)
+ */
+
+/**
+ * 方法超时
+ * O(row^2 * col^2)
+ */
+class Solution {
+    public int miniumDistance(int[][] grid) {
+        int minDistance = Integer.MAX_VALUE;
+
+        int row = grid.length;
+        int col = grid[0].length;
+
+        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右
+
+        for(int i = 0; i < row; i++){
+            for(int j = 0; j < col; j++){
+                if(grid[i][j] == 0){
+                    int distance = 1;
+                    int curDistanceA = Integer.MAX_VALUE; // 当前公共领土到三个国家的 max(min(distance))
+                    int curDistanceB = Integer.MAX_VALUE; 
+                    int curDistanceC = Integer.MAX_VALUE; 
+
+                    boolean[][] visited = new boolean[row][col]; // 判断是否访问过
+
+                    Queue<int[]> queue = new LinkedList<>();
+
+                    queue.offer(new int[]{i, j});
+
+                    visited[i][j] = true;
+
+                    pointA: while(!queue.isEmpty()){
+                        int size = queue.size();
+                        while(size-- > 0){
+                            int[] loc = queue.poll();
+                            int x = loc[0];
+                            int y = loc[1];
+                            for(int[] direction: directions){
+                                int new_x = x + direction[0];
+                                int new_y = y + direction[1];
+                                if(new_x >= 0 && new_x < row && new_y >= 0 && new_y < col){
+                                    if(visited[new_x][new_y] == false){
+                                        queue.offer(new int[]{new_x, new_y});
+                                        visited[new_x][new_y] = true;
+
+                                        if(grid[new_x][new_y] == 1 && curDistanceA == Integer.MAX_VALUE){
+                                            curDistanceA = distance;
+                                        }else if(grid[new_x][new_y] == 2 && curDistanceB == Integer.MAX_VALUE){
+                                            curDistanceB = distance;
+                                        }else if(grid[new_x][new_y] == 3 && curDistanceC == Integer.MAX_VALUE){
+                                            curDistanceC = distance;
+                                        }
+                                        if(curDistanceA != Integer.MAX_VALUE && curDistanceB != Integer.MAX_VALUE && curDistanceC != Integer.MAX_VALUE){
+                                        break pointA; 
+                                        }
+                                    }
+                                }
+                            }
+
+                        }
+                        distance++;
+                    }
+                    
+                    distance = Math.max(Math.max(curDistanceA, curDistanceB), curDistanceC); // 最大距离
+                    minDistance = Math.min(minDistance, distance); // 最小
+                }
+            }
+        }
+
+        return minDistance;
+    }
+}

力扣训练营/毕业竞赛/3. 第三题.java

@@ -0,0 +1,13 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode linkedListGame(ListNode head, int num) {
+        // 没做出来
+    }
+}

力扣训练营/毕业竞赛/4. 第四题.java

@@ -0,0 +1,37 @@
+class Solution {
+    public boolean checkBracketSequence(String origin) {
+        int left = 0; // 左括号的剩余个数
+
+        int len = origin.length();
+
+        for(int i = 0; i < len; i++){
+            if(origin.charAt(i) == '('){ // 如果是左括号
+                left++;
+            }else if(origin.charAt(i) == ')'){ // 如果是右括号
+                left--; // 需要使用一个左括号进行匹配
+            }else{
+                int index = i; // 当前位置
+                int num = Integer.parseInt("" + origin.charAt(i)); // 将字符数字转换成整型
+                while((i + 1) < len && origin.charAt(i + 1) >= '0' && origin.charAt(i + 1) <= '9'){ // 如果下一个字符还是数字
+                    num = num * 10 + Integer.parseInt("" + origin.charAt(i + 1));
+                    i++;
+                }
+                if(origin.charAt(index - 1) == '('){ // 如果上一个字符是左括号
+                    left = left - 1 + num; // 则加上当前的个数(num)，并减去之前在if中误认为的左括号(数字前面的)，因为数字前面的左括号是标识符，不算个数
+                }else{
+                    left = left + 1 - num; // 同理，之前else if中的右括号多算了一个，把多减去的补回来，并减去真实的右括号的数量(num)
+                }
+            }
+
+            if(left < 0){ // 如果左括号不够了
+                return false;
+            }
+        }
+
+        if(left != 0){ // 如果最终右括号比左括号多了
+            return false;
+        }
+
+        return true;
+    }
+}

力扣训练营/毕业竞赛/5. 第五题.java

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    int count;
+    int val;
+    public int countNodes(TreeNode root, int val) {
+        count = 0;
+        this.val = val;
+        dfs(root);
+        return count;
+    }
+    private void dfs(TreeNode root){
+        if(root == null){
+            return;
+        }
+        if(root.val == val){
+            count++;
+        }
+        dfs(root.left);
+        dfs(root.right);
+    }   
+}

力扣训练营/毕业竞赛/6. 第六题.java

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    int count = 0;
+    public int countInconsistentNode(TreeNode root1, TreeNode root2) {
+        count = 0;
+        dfs(root1, root2);
+        return count;
+    }
+
+    private void dfs(TreeNode root1, TreeNode root2){
+        if(root1 == null && root2 == null){ // 都为空
+            return;
+        }
+        if(root1 == null || root2 == null){ // 一个为空，一个不为空时，不同情况等于该不为空的结点，及其子孙结点
+            if(root1 == null){
+                count += countNode(root2);
+            }else{
+                count += countNode(root1);
+            }
+            return;
+        }
+        if(root1.val != root2.val){ // 都不为空，但值不相等时，是两个"不同"
+            count += 2;
+        }
+        dfs(root1.left, root2.left);
+        dfs(root1.right, root2.right);
+    }
+
+    private int countNode(TreeNode node){ // 返回当前结点所在的子树的结点数量
+        if(node == null){
+            return 0;
+        }
+        int leftCount = countNode(node.left);
+        int rightCount = countNode(node.right);
+        return leftCount + rightCount + 1;
+    }
+}

力扣训练营/第三周竞赛/1. 第一题.java

@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    PriorityQueue<Integer> pq;
+    public int[] solve(TreeNode root, int[][] operations) {
+        // 最大堆
+        pq = new PriorityQueue(new Comparator<Integer>(){
+            @Override
+            public int compare(Integer val1, Integer val2){
+                return -(val1.intValue() - val2.intValue());
+            }
+        });
+
+        dfs(root, pq); // O(n * log(n))
+
+        int len = operations.length;
+        int[] ans = new int[len];
+
+        for(int i = 0; i < len; i++){
+            int[] operation = operations[i];
+            if(operation[0] == 0){
+                // 将当前值按顺序加入最大堆里
+                pq.offer(operation[1]);
+            }else{ // 删除最大元素
+                pq.poll();
+            }
+            ans[i] = pq.peek(); // 获取最大元素
+        }
+
+        return ans;
+    }
+
+    private void dfs(TreeNode root, PriorityQueue<Integer> pq){
+        if(root == null){
+            return;
+        }
+        pq.offer(root.val);
+        dfs(root.left, pq);
+        dfs(root.right, pq);
+    }
+}