LeetCode第 33 场双周赛

5479. 千位分隔数

给你一个整数 n，请你每隔三位添加点（即 “.” 符号）作为千位分隔符，并将结果以字符串格式返回。

示例 1：

输入：n = 987
输出：“987”
示例 2：

输入：n = 1234
输出：“1.234”
示例 3：

输入：n = 123456789
输出：“123.456.789”
示例 4：

输入：n = 0
输出：“0”

提示：

0 <= n < 2^31

思路

注意n=0的特判

代码

class Solution {
    public String thousandSeparator(int n) {
        StringBuilder sb = new StringBuilder();
        int digit = 0;
        while (n > 0) {
            if (digit > 0 && digit % 3 == 0) {
                sb.append('.');
            }
            int cur = n % 10;
            n /= 10;
            sb.append(cur);
            ++digit;
        }
        return sb.length() == 0? "0": sb.reverse().toString();
    }
}

5480. 可以到达所有点的最少点数目

给你一个 有向无环图 ， n 个节点编号为 0 到 n-1 ，以及一个边数组 edges ，其中 edges[i] = [fromi, toi] 表示一条从点 fromi 到点 toi 的有向边。

找到最小的点集使得从这些点出发能到达图中所有点。题目保证解存在且唯一。

你可以以任意顺序返回这些节点编号。

示例 1：

输入：n = 6, edges = [[0,1],[0,2],[2,5],[3,4],[4,2]]
输出：[0,3]
解释：从单个节点出发无法到达所有节点。从 0 出发我们可以到达 [0,1,2,5] 。从 3 出发我们可以到达 [3,4,2,5] 。所以我们输出 [0,3] 。
示例 2：

输入：n = 5, edges = [[0,1],[2,1],[3,1],[1,4],[2,4]]
输出：[0,2,3]
解释：注意到节点 0，3 和 2 无法从其他节点到达，所以我们必须将它们包含在结果点集中，这些点都能到达节点 1 和 4 。

提示：

2 <= n <= 10^5
1 <= edges.length <= min(10^5, n * (n - 1) / 2)
edges[i].length == 2
0 <= fromi, toi < n
所有点对 (fromi, toi) 互不相同。

思路

找到所有入度为0的节点就是答案

代码

class Solution {
    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
        int[] degrees = new int[n];
        for (List<Integer> edge: edges) {
            ++degrees[edge.get(1)];
        }
        List<Integer> ret = new ArrayList<>();
        for (int i=0; i<n; ++i) {
            if (degrees[i] == 0) {
                ret.add(i);
            }
        }
        return ret;
    }
}

5481. 得到目标数组的最少函数调用次数

给你一个与 nums 大小相同且初始值全为 0 的数组 arr ，请你调用以上函数得到整数数组 nums 。

请你返回将 arr 变成 nums 的最少函数调用次数。

答案保证在 32 位有符号整数以内。

示例 1：

输入：nums = [1,5]
输出：5
解释：给第二个数加 1 ：[0, 0] 变成 [0, 1] （1 次操作）。
将所有数字乘以 2 ：[0, 1] -> [0, 2] -> [0, 4] （2 次操作）。
给两个数字都加 1 ：[0, 4] -> [1, 4] -> [1, 5] （2 次操作）。
总操作次数为：1 + 2 + 2 = 5 。
示例 2：

输入：nums = [2,2]
输出：3
解释：给两个数字都加 1 ：[0, 0] -> [0, 1] -> [1, 1] （2 次操作）。
将所有数字乘以 2 ： [1, 1] -> [2, 2] （1 次操作）。
总操作次数为： 2 + 1 = 3 。
示例 3：

输入：nums = [4,2,5]
输出：6
解释：（初始）[0,0,0] -> [1,0,0] -> [1,0,1] -> [2,0,2] -> [2,1,2] -> [4,2,4] -> [4,2,5] （nums 数组）。
示例 4：

输入：nums = [3,2,2,4]
输出：7
示例 5：

输入：nums = [2,4,8,16]
输出：8

提示：

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9

思路

遍历每一个数，分别计算op=0和op=1的调用次数。在数字变化过程中每次产生的奇数都会对op=0调用的总次数产生影响，op=1则是所有数字的所有变化过程中最大的偶数的调用次数。

代码

class Solution {
    public int minOperations(int[] nums) {
        int odd = 0, even = 0;
        for (int num: nums) {
            int cur = 0;
            while (num > 0) {
                if ((num & 1) != 0) {
                    ++odd;
                    --num;
                } else {
                    ++cur;
                    num >>>= 1;
                }
            }
            even = Math.max(even, cur);
        }
        return odd + even;
    }
}

5482. 二维网格图中探测环

给你一个二维字符网格数组 grid ，大小为 m x n ，你需要检查 grid 中是否存在 相同值 形成的环。

一个环是一条开始和结束于同一个格子的长度 大于等于 4 的路径。对于一个给定的格子，你可以移动到它上、下、左、右四个方向相邻的格子之一，可以移动的前提是这两个格子有 相同的值 。

同时，你也不能回到上一次移动时所在的格子。比方说，环 (1, 1) -> (1, 2) -> (1, 1) 是不合法的，因为从 (1, 2) 移动到 (1, 1) 回到了上一次移动时的格子。

如果 grid 中有相同值形成的环，请你返回 true ，否则返回 false 。

示例 1：

输入：grid = [[“a”,“a”,“a”,“a”],[“a”,“b”,“b”,“a”],[“a”,“b”,“b”,“a”],[“a”,“a”,“a”,“a”]]
输出：true
解释：如下图所示，有 2 个用不同颜色标出来的环：

示例 2：

输入：grid = [[“c”,“c”,“c”,“a”],[“c”,“d”,“c”,“c”],[“c”,“c”,“e”,“c”],[“f”,“c”,“c”,“c”]]
输出：true
解释：如下图所示，只有高亮所示的一个合法环：

示例 3：

输入：grid = [[“a”,“b”,“b”],[“b”,“z”,“b”],[“b”,“b”,“a”]]
输出：false

提示：

m == grid.length
n == grid[i].length
1 <= m <= 500
1 <= n <= 500
grid 只包含小写英文字母。

思路

dfs过程中判断下一跳是否是已经访问的单元格且不是上一跳的单元格，如果满足则有环，否则无环

代码

class Solution {
    private static final int[] MOVX = {-1, 1, 0, 0}, MOVY = {0, 0, -1, 1};
    
    private boolean dfs(char[][] grid, boolean[][] vis, int x, int y, int m, int n, int preX, int preY) {
        vis[x][y] = true;
        for (int i=0; i<4; ++i) {
            int nx = x + MOVX[i], ny = y + MOVY[i];
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] == grid[x][y]) {
                if (vis[nx][ny] && !(nx == preX && ny == preY)) {
                    return true;
                } else if (!vis[nx][ny]) {
                    if (dfs(grid, vis, nx, ny, m, n, x, y)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    public boolean containsCycle(char[][] grid) {
        int m = grid.length, n = grid[0].length;
        boolean[][] vis = new boolean[m][n];
        for (int i=0; i<m; ++i) {
            for (int j=0; j<n; ++j) {
                if (!vis[i][j]) {
                    if (dfs(grid, vis, i, j, m, n, -1, -1)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
}