1138-1139-1237-1792 (4)

gdut-yy · gdut-yy · commit b806e206a9bb · 2023-02-19T22:50:14.000+08:00
diff --git a/leetcode-12/src/main/java/Solution1138.java b/leetcode-12/src/main/java/Solution1138.java
@@ -0,0 +1,50 @@
+public class Solution1138 {
+    public String alphabetBoardPath(String target) {
+        int r = 0, c = 0;
+
+        StringBuilder stringBuilder = new StringBuilder();
+        for (char ch : target.toCharArray()) {
+            int nr = (ch - 'a') / 5;
+            int nc = (ch - 'a') % 5;
+            // 优先 向上走 向左走
+            if (nr < r) {
+                stringBuilder.append("U".repeat(r - nr));
+            }
+            if (nc < c) {
+                stringBuilder.append("L".repeat(c - nc));
+            }
+            if (nr > r) {
+                stringBuilder.append("D".repeat(nr - r));
+            }
+            if (nc > c) {
+                stringBuilder.append("R".repeat(nc - c));
+            }
+            stringBuilder.append("!");
+            r = nr;
+            c = nc;
+        }
+        return stringBuilder.toString();
+    }
+}
+/*
+1138. 字母板上的路径
+https://leetcode.cn/problems/alphabet-board-path/
+
+我们从一块字母板上的位置 (0, 0) 出发，该坐标对应的字符为 board[0][0]。
+在本题里，字母板为board = ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"]，如下所示。
+我们可以按下面的指令规则行动：
+- 如果方格存在，'U' 意味着将我们的位置上移一行；
+- 如果方格存在，'D' 意味着将我们的位置下移一行；
+- 如果方格存在，'L' 意味着将我们的位置左移一列；
+- 如果方格存在，'R' 意味着将我们的位置右移一列；
+- '!' 会把在我们当前位置 (r, c) 的字符 board[r][c] 添加到答案中。
+（注意，字母板上只存在有字母的位置。）
+返回指令序列，用最小的行动次数让答案和目标 target 相同。你可以返回任何达成目标的路径。
+提示：
+1 <= target.length <= 100
+target 仅含有小写英文字母。
+
+模拟。为了保证含有字符 'z' 时能够正常移动，每次移动时优先保证选择上移和左移。
+时间复杂度 O(n)
+空间复杂度 O(1)
+ */
diff --git a/leetcode-12/src/main/java/Solution1139.java b/leetcode-12/src/main/java/Solution1139.java
@@ -0,0 +1,39 @@
+public class Solution1139 {
+    public int largest1BorderedSquare(int[][] grid) {
+        int M = grid.length;
+        int N = grid[0].length;
+        int[][] up = new int[M + 1][N + 1];
+        int[][] left = new int[M + 1][N + 1];
+        int maxL = 0;
+        for (int i = 1; i <= M; i++) {
+            for (int j = 1; j <= N; j++) {
+                if (grid[i - 1][j - 1] == 1) {
+                    up[i][j] = up[i - 1][j] + 1;
+                    left[i][j] = left[i][j - 1] + 1;
+                    int len = Math.min(up[i][j], left[i][j]);
+                    while (up[i][j - len + 1] < len || left[i - len + 1][j] < len) {
+                        len--;
+                    }
+                    maxL = Math.max(maxL, len);
+                }
+            }
+        }
+        return maxL * maxL;
+    }
+}
+/*
+1139. 最大的以 1 为边界的正方形
+https://leetcode.cn/problems/largest-1-bordered-square/
+
+给你一个由若干 0 和 1 组成的二维网格 grid，请你找出边界全部由 1 组成的最大 正方形 子网格，并返回该子网格中的元素数量。如果不存在，则返回 0。
+提示：
+1 <= grid.length <= 100
+1 <= grid[0].length <= 100
+grid[i][j] 为 0 或 1
+
+动态规划
+left[x][y] 表示以 (x,y) 为起点左侧连续 1 的最大数目
+up[x][y] 表示以 (x,y) 为起点上侧连续 1 的最大数目
+时间复杂度 O(mn * min(m,n))
+时间复杂度 O(mn)
+ */
diff --git a/leetcode-12/src/test/java/Solution1138Tests.java b/leetcode-12/src/test/java/Solution1138Tests.java
@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1138Tests {
+    private final Solution1138 solution1138 = new Solution1138();
+
+    @Test
+    public void example1() {
+        String target = "leet";
+        String expected = "DDR!UURRR!!DDD!";
+        Assertions.assertEquals(expected, solution1138.alphabetBoardPath(target));
+    }
+
+    @Test
+    public void example2() {
+        String target = "code";
+        String expected = "RR!DDRR!UUL!R!";
+        Assertions.assertEquals(expected, solution1138.alphabetBoardPath(target));
+    }
+}
diff --git a/leetcode-12/src/test/java/Solution1139Tests.java b/leetcode-12/src/test/java/Solution1139Tests.java
@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1139Tests {
+    private final Solution1139 solution1139 = new Solution1139();
+
+    @Test
+    public void example1() {
+        int[][] grid = UtUtils.stringToInts2("[[1,1,1],[1,0,1],[1,1,1]]");
+        int expected = 9;
+        Assertions.assertEquals(expected, solution1139.largest1BorderedSquare(grid));
+    }
+
+    @Test
+    public void example2() {
+        int[][] grid = UtUtils.stringToInts2("[[1,1,0,0]]");
+        int expected = 1;
+        Assertions.assertEquals(expected, solution1139.largest1BorderedSquare(grid));
+    }
+}
diff --git a/leetcode-13/src/main/java/Solution1237.java b/leetcode-13/src/main/java/Solution1237.java
@@ -0,0 +1,59 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution1237 {
+    public List<List<Integer>> findSolution(CustomFunction customfunction, int z) {
+        List<List<Integer>> resList = new ArrayList<>();
+        int y = 1000;
+        for (int x = 1; x <= 1000; x++) {
+            while (y >= 1 && customfunction.f(x, y) > z) {
+                y--;
+            }
+            if (y >= 1 && customfunction.f(x, y) == z) {
+                resList.add(List.of(x, y));
+            }
+        }
+        return resList;
+    }
+
+    static class CustomFunction {
+        // Returns f(x, y) for any given positive integers x and y.
+        // Note that f(x, y) is increasing with respect to both x and y.
+        // i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
+        public int f(int x, int y) {
+            return x + y;
+        }
+    }
+}
+/*
+1237. 找出给定方程的正整数解
+https://leetcode.cn/problems/find-positive-integer-solution-for-a-given-equation/
+
+给你一个函数  f(x, y) 和一个目标结果 z，函数公式未知，请你计算方程 f(x,y) == z 所有可能的正整数 数对 x 和 y。满足条件的结果数对可以按任意顺序返回。
+尽管函数的具体式子未知，但它是单调递增函数，也就是说：
+f(x, y) < f(x + 1, y)
+f(x, y) < f(x, y + 1)
+函数接口定义如下：
+```
+interface CustomFunction {
+public:
+  // Returns some positive integer f(x, y) for two positive integers x and y based on a formula.
+  int f(int x, int y);
+};
+```
+你的解决方案将按如下规则进行评判：
+- 判题程序有一个由 CustomFunction 的 9 种实现组成的列表，以及一种为特定的 z 生成所有有效数对的答案的方法。
+- 判题程序接受两个输入：function_id（决定使用哪种实现测试你的代码）以及目标结果 z 。
+- 判题程序将会调用你实现的 findSolution 并将你的结果与答案进行比较。
+- 如果你的结果与答案相符，那么解决方案将被视作正确答案，即 Accepted 。
+提示：
+1 <= function_id <= 9
+1 <= z <= 100
+题目保证 f(x, y) == z 的解处于 1 <= x, y <= 1000 的范围内。
+在 1 <= x, y <= 1000 的前提下，题目保证 f(x, y) 是一个 32 位有符号整数。
+
+双指针。
+相似题目: 240. 搜索二维矩阵 II
+https://leetcode.cn/problems/search-a-2d-matrix-ii/
+ */
+
diff --git a/leetcode-13/src/test/java/Solution1237Tests.java b/leetcode-13/src/test/java/Solution1237Tests.java
@@ -0,0 +1,16 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+public class Solution1237Tests {
+    private final Solution1237 solution1237 = new Solution1237();
+
+    @Test
+    public void example1() {
+        Solution1237.CustomFunction customfunction = new Solution1237.CustomFunction();
+        int z = 5;
+        List<List<Integer>> expected = UtUtils.stringToIntegerList2("[[1,4],[2,3],[3,2],[4,1]]");
+        Assertions.assertEquals(expected, solution1237.findSolution(customfunction, z));
+    }
+}
diff --git a/leetcode-18/src/main/java/Solution1792.java b/leetcode-18/src/main/java/Solution1792.java
@@ -0,0 +1,49 @@
+import java.util.PriorityQueue;
+
+public class Solution1792 {
+    public double maxAverageRatio(int[][] classes, int extraStudents) {
+        // pass/total (pass+1)/(total+1)
+        PriorityQueue<int[]> maxHeap = new PriorityQueue<>((o1, o2) -> {
+            // (a+1)/(b+1) - a/b > (c+1)/(d+1) - c/d
+            // (b-a)/b(b+1) > (d-c)/d(d+1)
+            // (b-a)d(d+1) > (d-c)b(b+1)
+            long val1 = (long) (o1[1] - o1[0]) * o2[1] * (o2[1] + 1);
+            long val2 = (long) (o2[1] - o2[0]) * o1[1] * (o1[1] + 1);
+            return Long.compare(val2, val1);
+        });
+        for (int[] cla : classes) {
+            maxHeap.add(new int[]{cla[0], cla[1]});
+        }
+
+        for (int i = 0; i < extraStudents; i++) {
+            int[] poll = maxHeap.remove();
+            maxHeap.add(new int[]{poll[0] + 1, poll[1] + 1});
+        }
+
+        double sum = 0.0;
+        while (!maxHeap.isEmpty()) {
+            int[] poll = maxHeap.remove();
+            sum += (double) poll[0] / poll[1];
+        }
+        return sum / classes.length;
+    }
+}
+/*
+1792. 最大平均通过率
+https://leetcode.cn/problems/maximum-average-pass-ratio/
+
+一所学校里有一些班级，每个班级里有一些学生，现在每个班都会进行一场期末考试。
+给你一个二维数组 classes ，其中 classes[i] = [passi, totali] ，表示你提前知道了第 i 个班级总共有 totali 个学生，其中只有 passi 个学生可以通过考试。
+给你一个整数 extraStudents ，表示额外有 extraStudents 个聪明的学生，他们 一定 能通过任何班级的期末考。你需要给这 extraStudents 个学生每人都安排一个班级，使得 所有 班级的 平均 通过率 最大 。
+一个班级的 通过率 等于这个班级通过考试的学生人数除以这个班级的总人数。平均通过率 是所有班级的通过率之和除以班级数目。
+请你返回在安排这 extraStudents 个学生去对应班级后的 最大 平均通过率。与标准答案误差范围在 10-5 以内的结果都会视为正确结果。
+提示：
+1 <= classes.length <= 10^5
+classes[i].length == 2
+1 <= passi <= totali <= 10^5
+1 <= extraStudents <= 10^5
+
+贪心 + 大顶堆
+聪明的学生 优先分配给 通过率提升最大的班级
+通过率提升 = (a+1)/(b+1) - a/b
+ */
diff --git a/leetcode-18/src/test/java/Solution1792Tests.java b/leetcode-18/src/test/java/Solution1792Tests.java
@@ -0,0 +1,24 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1792Tests {
+    private final Solution1792 solution1792 = new Solution1792();
+    // 与标准答案误差范围在 10-5 以内的结果都会视为正确结果。
+    private static final double DELTA = 1e-5;
+
+    @Test
+    public void example1() {
+        int[][] classes = UtUtils.stringToInts2("[[1,2],[3,5],[2,2]]");
+        int extraStudents = 2;
+        double expected = 0.78333;
+        Assertions.assertEquals(expected, solution1792.maxAverageRatio(classes, extraStudents), DELTA);
+    }
+
+    @Test
+    public void example2() {
+        int[][] classes = UtUtils.stringToInts2("[[2,4],[3,9],[4,5],[2,10]]");
+        int extraStudents = 4;
+        double expected = 0.53485;
+        Assertions.assertEquals(expected, solution1792.maxAverageRatio(classes, extraStudents), DELTA);
+    }
+}
