复习lc，除了把之前刷过的题看一遍，还要把比较简单的周赛做一做（说是简单，但是对于还没有ak过的我，也不算太简单了）
1.
难度简单0
给你一个整数
n，请你每隔三位添加点（即 "." 符号）作为千位分隔符，并将结果以字符串格式返回。
示例 1：
输入：n = 987 输出："987"示例 2：
输入：n = 1234 输出："1.234"示例 3：
输入：n = 123456789 输出："123.456.789"示例 4：
输入：n = 0 输出："0"
提示：
0 <= n < 2^31
本题按照题意模拟就行了，另外要考虑到各种情况，除了给出的case，还有负数的情况，负数的符号在这里也被看作是一位
比如-123，应该是-.123
另外我们一位位往下取的时候是从最低位起的，所以顺序和原来的数相反，这里只要使用stringbuilder的reverse方法即可
class Solution {
public String thousandSeparator(int n) {
if(n==0){
return "0";
}
StringBuilder sb=new StringBuilder();
int on=n;
n=Math.abs(n);
int c=0;
while(n!=0){
sb.append(n%10);
n/=10;
c++;
if(c%3==0&&n!=0){
sb.append('.');
}
}
if(on<0){
if(c%3==0){
sb.append('.');
}
sb.append('-');
}
return sb.reverse().toString();
}
}2.
难度中等5
给你一个 有向无环图 ，
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^51 <= edges.length <= min(10^5, n * (n - 1) / 2)edges[i].length == 20 <= fromi, toi < n- 所有点对
(fromi, toi)互不相同。
本题对题目给出的要求分析一下更加好做：找到最小的点集使得从这些点出发能到达图中所有点
所以如果一个点能够由该点集内的点到达，那么他就没有必要放进该点集
该点集的意义在于，如果该点不作为起点，那么没有点可以到达它
所以我们要的就是入度为0的点，因此只要统计一下即可：
class Solution {
// 要找到一个最小的set，使其作为起点，可以到达全部的点
// 那么只需要找到所有入度为0的点，因为如果他们不作为起点，就没人能到达他们
public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
int[] in=new int[n];
for(List<Integer> e:edges){
in[e.get(1)]++;
}
List<Integer> rs=new ArrayList<>();
for(int i=0;i<n;i++){
if(in[i]==0){
rs.add(i);
}
}
return rs;
}
}难度中等4
给你一个与
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^50 <= nums[i] <= 10^9
这里显然执行乘以2的操作能够让数字变化的更快，从而更快的达到目标
但是有的时候我们不得不执行+1，比如0->1
受题目提示，这里从nums到arr进行转换：
class Solution {
// 题意：将一个全为0的数组变为nums
// 两种操作：一种是将某一个元素加1
// 一种是将所有的元素乘以2
// 要求最少的操作数
// 根据提示：从nums到arr，如果全部为偶数，那么一直除以二
// 否则，逐个减一
public int minOperations(int[] nums) {
int c=0;
while(true){
boolean allEven=true;
boolean allZero=true;
int oddCount=0;
for(int i:nums){
if(i!=0){
allZero=false;
}
if((i&1)==1){
allEven=false;
oddCount++;
}
}
if(allZero){
break;
}
for(int i=0;i<nums.length;i++){
if(allEven){
nums[i]/=2;
}else{
if(nums[i]%2==1)
nums[i]-=1;
}
}
c+=allEven?1:oddCount;
}
return c;
}
}难度困难8
给你一个二维字符网格数组
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.lengthn == grid[i].length1 <= m <= 5001 <= n <= 500grid只包含小写英文字母。
理解题意：
一个环是一条开始和结束于同一个格子的长度 大于等于 4 的路径
这里并不需要计算环的长度，实际上，只要dfs最终回到了当前搜素路径上一个已访问的节点，只要这个节点不是当前节点的上一个，那么就已经是一个符合条件的环了
class Solution {
private int[] drows = {-1, 1, 0, 0};
private int[] dcols = {0, 0, -1, 1};
private boolean flag = false;
private boolean[][] marked;
private void dfs(char[][] grid, int row, int col, Integer lastRow, Integer lastCol) {
if (flag) {
return;
}
marked[row][col] = true;
for (int i = 0; i < 4; i++) {
int trow = row + drows[i];
int tcol = col + dcols[i];
// 越界或者不同或者返回上一个，那么continue
if (trow < 0 || trow >= marked.length || tcol < 0 || tcol >= marked[0].length || grid[row][col] != grid[trow][tcol] || (lastRow != null && lastCol != null && trow == lastRow && tcol == lastCol)) {
continue;
}
if (marked[trow][tcol]) {
flag = true;
}
dfs(grid, trow, tcol, row, col);
}
}
public boolean containsCycle(char[][] grid) {
marked = new boolean[grid.length][grid[0].length];
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[i].length; j++) {
if (flag) {
return flag;
} else {
if (!marked[i][j])
dfs(grid, i, j, null, null);
}
}
}
return flag;
}
}和一般dfs相比，这里有几个细节：
首先还是要明确环的定义
(第一次提交没通过，搞得我以为这个很复杂，结果发现错的是一个无关的地方，总之这就是一个简单的dfs，当然，前提是想明白这里环的含义以及怎么处理）
补充一下：这里为什么marked每次dfs之前，不reset，因为，加入从一个点开始dfs，遍历图中经过了另一个点，但是没有遇到环
那么从上述提到的另一个点开始dfs，会有环吗？显然是不会的，因为每次dfs都是遍历完一个连通分量
454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
