1120-1167-1181-1197-1214-1256-1257-1669 (8)

Author: gdut-yy

leetcode-12/src/main/java/Solution1120.java

@@ -0,0 +1,37 @@
+public class Solution1120 {
+    private double max;
+
+    public double maximumAverageSubtree(TreeNode root) {
+        max = 0;
+        dfs(root);
+        return max;
+    }
+
+    // [总和, 个数]
+    private int[] dfs(TreeNode node) {
+        if (node == null) {
+            return new int[]{0, 0};
+        }
+        int[] left = dfs(node.left);
+        int[] right = dfs(node.right);
+        // 5e3 * 1e5
+        int sum = node.val + left[0] + right[0];
+        int cnt = 1 + left[1] + right[1];
+        max = Math.max(max, (double) sum / cnt);
+        return new int[]{sum, cnt};
+    }
+}
+/*
+$1120. 子树的最大平均值
+https://leetcode.cn/problems/maximum-average-subtree/
+
+给你一棵二叉树的根节点 root，找出这棵树的 每一棵 子树的 平均值 中的 最大 值。
+子树是树中的任意节点和它的所有后代构成的集合。
+树的平均值是树中节点值的总和除以节点数。
+提示：
+树中的节点数介于 1 到 5000之间。
+每个节点的值介于 0 到 100000 之间。
+如果结果与标准答案的误差不超过 10^-5，那么该结果将被视为正确答案。
+
+递归
+ */

leetcode-12/src/main/java/Solution1167.java

@@ -0,0 +1,30 @@
+import java.util.PriorityQueue;
+
+public class Solution1167 {
+    public int connectSticks(int[] sticks) {
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        for (int x : sticks) {
+            minHeap.add(x);
+        }
+        int res = 0;
+        while (minHeap.size() > 1) {
+            int cost = minHeap.remove() + minHeap.remove();
+            res += cost;
+            minHeap.add(cost);
+        }
+        return res;
+    }
+}
+/*
+$1167. 连接棒材的最低费用
+https://leetcode.cn/problems/minimum-cost-to-connect-sticks/
+
+你有一些长度为正整数的棍子。这些长度以数组 sticks 的形式给出， sticks[i] 是 第i个 木棍的长度。
+你可以通过支付 x + y 的成本将任意两个长度为 x 和 y 的棍子连接成一个棍子。你必须连接所有的棍子，直到剩下一个棍子。
+返回以这种方式将所有给定的棍子连接成一个棍子的 最小成本 。
+提示：
+1 <= sticks.length <= 10^4
+1 <= sticks[i] <= 10^4
+
+贪心/堆
+ */

leetcode-12/src/main/java/Solution1181.java

@@ -0,0 +1,46 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution1181 {
+    public List<String> beforeAndAfterPuzzles(String[] phrases) {
+        int n = phrases.length;
+        String[][] sp = new String[n][2];
+        for (int i = 0; i < n; i++) {
+            String[] s = phrases[i].split(" ");
+            sp[i] = new String[]{s[0], s[s.length - 1]};
+        }
+        Set<String> m = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    continue;
+                }
+                if (sp[i][0].equals(sp[j][1])) {
+                    m.add(phrases[j] + phrases[i].substring(sp[i][0].length()));
+                }
+            }
+        }
+        List<String> ret = new ArrayList<>(m);
+        Collections.sort(ret);
+        return ret;
+    }
+}
+/*
+$1181. 前后拼接
+https://leetcode.cn/problems/before-and-after-puzzle/
+
+给你一个「短语」列表 phrases，请你帮忙按规则生成拼接后的「新短语」列表。
+「短语」（phrase）是仅由小写英文字母和空格组成的字符串。「短语」的开头和结尾都不会出现空格，「短语」中的空格不会连续出现。
+「前后拼接」（Before and After puzzles）是合并两个「短语」形成「新短语」的方法。我们规定拼接时，第一个短语的最后一个单词 和 第二个短语的第一个单词 必须相同。
+返回每两个「短语」 phrases[i] 和 phrases[j]（i != j）进行「前后拼接」得到的「新短语」。
+注意，两个「短语」拼接时的顺序也很重要，我们需要同时考虑这两个「短语」。另外，同一个「短语」可以多次参与拼接，但「新短语」不能再参与拼接。
+请你按字典序排列并返回「新短语」列表，列表中的字符串应该是 不重复的 。
+提示：
+1 <= phrases.length <= 100
+1 <= phrases[i].length <= 100
+
+哈希表 + 排序
+ */

leetcode-12/src/main/java/Solution1197.java

@@ -0,0 +1,53 @@
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
+
+public class Solution1197 {
+    private static final int[][] DIRECTIONS = {{-2, -1}, {-2, 1}, {2, -1}, {2, 1}, {-1, -2}, {-1, 2}, {1, -2}, {1, 2}};
+
+    public int minKnightMoves(int x, int y) {
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0});
+        Set<Integer> visited = new HashSet<>();
+        visited.add(0);
+        int step = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                int[] cur = queue.remove();
+                if (cur[0] == x && cur[1] == y) {
+                    return step;
+                }
+
+                for (int[] dir : DIRECTIONS) {
+                    int nextM = cur[0] + dir[0];
+                    int nextN = cur[1] + dir[1];
+                    int key = nextM * 1000 + nextN;
+                    if (!visited.contains(key)) {
+                        visited.add(key);
+                        queue.add(new int[]{nextM, nextN});
+                    }
+                }
+            }
+            step++;
+        }
+        return step;
+    }
+}
+/*
+$1197. 进击的骑士
+https://leetcode.cn/problems/minimum-knight-moves/
+
+一个坐标可以从 -infinity 延伸到 +infinity 的 无限大的 棋盘上，你的 骑士 驻扎在坐标为 [0, 0] 的方格里。
+骑士的走法和中国象棋中的马相似，走 “日” 字：即先向左（或右）走 1 格，再向上（或下）走 2 格；或先向左（或右）走 2 格，再向上（或下）走 1 格。
+每次移动，他都可以按图示八个方向之一前进。
+返回 骑士前去征服坐标为 [x, y] 的部落所需的最小移动次数 。本题确保答案是一定存在的。
+提示：
+-300 <= x, y <= 300
+0 <= |x| + |y| <= 300
+
+BFS / 数学
+相似题目: 688. 骑士在棋盘上的概率
+https://leetcode.cn/problems/knight-probability-in-chessboard/
+ */

leetcode-12/src/test/java/Solution1120Tests.java

@@ -0,0 +1,13 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1120Tests {
+    private final Solution1120 solution1120 = new Solution1120();
+
+    @Test
+    public void example1() {
+        TreeNode root = TreeNode.buildTreeNode("[5,6,1]");
+        double expected = 6.00000;
+        Assertions.assertEquals(expected, solution1120.maximumAverageSubtree(root));
+    }
+}

leetcode-12/src/test/java/Solution1167Tests.java

@@ -0,0 +1,27 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1167Tests {
+    private final Solution1167 solution1167 = new Solution1167();
+
+    @Test
+    public void example1() {
+        int[] sticks = {2, 4, 3};
+        int expected = 14;
+        Assertions.assertEquals(expected, solution1167.connectSticks(sticks));
+    }
+
+    @Test
+    public void example2() {
+        int[] sticks = {1, 8, 3, 5};
+        int expected = 30;
+        Assertions.assertEquals(expected, solution1167.connectSticks(sticks));
+    }
+
+    @Test
+    public void example3() {
+        int[] sticks = {5};
+        int expected = 0;
+        Assertions.assertEquals(expected, solution1167.connectSticks(sticks));
+    }
+}

leetcode-12/src/test/java/Solution1181Tests.java

@@ -0,0 +1,41 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+public class Solution1181Tests {
+    private final Solution1181 solution1181 = new Solution1181();
+
+    @Test
+    public void example1() {
+        String[] phrases = {"writing code", "code rocks"};
+        List<String> expected = List.of("writing code rocks");
+        Assertions.assertEquals(expected, solution1181.beforeAndAfterPuzzles(phrases));
+    }
+
+    @Test
+    public void example2() {
+        String[] phrases = {"mission statement",
+                "a quick bite to eat",
+                "a chip off the old block",
+                "chocolate bar",
+                "mission impossible",
+                "a man on a mission",
+                "block party",
+                "eat my words",
+                "bar of soap"};
+        List<String> expected = List.of("a chip off the old block party",
+                "a man on a mission impossible",
+                "a man on a mission statement",
+                "a quick bite to eat my words",
+                "chocolate bar of soap");
+        Assertions.assertEquals(expected, solution1181.beforeAndAfterPuzzles(phrases));
+    }
+
+    @Test
+    public void example3() {
+        String[] phrases = {"a", "b", "a"};
+        List<String> expected = List.of("a");
+        Assertions.assertEquals(expected, solution1181.beforeAndAfterPuzzles(phrases));
+    }
+}

leetcode-12/src/test/java/Solution1197Tests.java

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1197Tests {
+    private final Solution1197 solution1197 = new Solution1197();
+
+    @Test
+    public void example1() {
+        int x = 2;
+        int y = 1;
+        int expected = 1;
+        Assertions.assertEquals(expected, solution1197.minKnightMoves(x, y));
+    }
+
+    @Test
+    public void example2() {
+        int x = 5;
+        int y = 5;
+        int expected = 4;
+        Assertions.assertEquals(expected, solution1197.minKnightMoves(x, y));
+    }
+}

leetcode-13/src/main/java/Solution1214.java

@@ -0,0 +1,50 @@
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution1214 {
+    private int target;
+    private Set<Integer> valSet;
+    private boolean res;
+
+    public boolean twoSumBSTs(TreeNode root1, TreeNode root2, int target) {
+        this.target = target;
+        valSet = new HashSet<>();
+        res = false;
+
+        dfs1(root1);
+        dfs2(root2);
+        return res;
+    }
+
+    private void dfs1(TreeNode node) {
+        if (node == null) {
+            return;
+        }
+        valSet.add(node.val);
+        dfs1(node.left);
+        dfs1(node.right);
+    }
+
+    private void dfs2(TreeNode node) {
+        if (node == null) {
+            return;
+        }
+        if (valSet.contains(target - node.val)) {
+            res = true;
+        }
+        dfs2(node.left);
+        dfs2(node.right);
+    }
+}
+/*
+$1214. 查找两棵二叉搜索树之和
+https://leetcode.cn/problems/two-sum-bsts/
+
+给出两棵二叉搜索树的根节点 root1 和 root2 ，请你从两棵树中各找出一个节点，使得这两个节点的值之和等于目标值 Target。
+如果可以找到返回 True，否则返回 False。
+提示：
+每棵树上节点数在 [1, 5000] 范围内。
+-10^9 <= Node.val, target <= 10^9
+
+DFS + HashSet 暴力匹配
+ */

leetcode-13/src/main/java/Solution1256.java

@@ -0,0 +1,27 @@
+public class Solution1256 {
+    public String encode(int num) {
+        return Integer.toBinaryString(num + 1).substring(1);
+    }
+}
+/*
+$1256. 加密数字
+https://leetcode.cn/problems/encode-number/
+
+给你一个非负整数 num ，返回它的「加密字符串」。
+加密的过程是把一个整数用某个未知函数进行转化，你需要从下表推测出该转化函数：
+```
+n   f(n)
+0   ""
+1   "0"
+2   "1"
+3   "00"
+4   "01"
+5   "10"
+6   "11"
+7   "000"
+```
+提示：
+0 <= num <= 10^9
+
+规律便是 (num+1) 转换为二进制后去掉第一位即可
+ */