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;
}
}