目录
力扣675.为高尔夫比赛砍树
Collections.sort(trees,(a,b)->{
return f.get(a[0]).get(a[1])-f.get(b[0]).get(b[1]);
});这块比较难写
这段代码是Java中的一段代码，用于对名为trees的集合进行排序。这个集合很可能是一个列表（List），其中的元素是某种类型的数组（可能是二维数组或数组的数组）。排序的依据是另一个名为f的映射（可能是Map<K, Map<K, V>>类型的），其中V是实现了Comparable接口的类型（比如Integer或String），以便可以进行比较。
代码中的Collections.sort方法是一个静态方法，用于对列表进行排序。它接受两个参数：要排序的列表和一个Comparator对象，该对象定义了排序的规则。
这里的Comparator是通过lambda表达式定义的，它接受两个参数a和b，这两个参数都是trees列表中的元素（即数组）。lambda表达式返回的值用于决定a和b在排序后的列表中的相对位置。
具体来说，lambda表达式中的f.get(a[0]).get(a[1])和f.get(b[0]).get(b[1])从f映射中分别根据a和b的第一个和第二个元素作为键来获取对应的值。然后，这两个值相减，得到的结果用于确定a和b的顺序。
如果结果为负数，则a会被排在b之前。
如果结果为零，则a和b的顺序不变（但实际的排序稳定性取决于排序算法）。
如果结果为正数，则a会被排在b之后。这段代码假设f映射中的每个键都对应一个非空的映射，且每个内部映射都包含所需的键，并且返回的值是可以相减的。如果这些假设不成立，代码可能会抛出异常。
此外，这种排序方式依赖于f映射中值的自然顺序。如果值的类型没有实现Comparable接口，或者你想要使用不同的排序规则，那么你需要提供自定义的比较逻辑。
class Solution { static int[]dx={0,0,1,-1}; static int[]dy={1,-1,0,0}; //1.确定砍树顺序 public static int cutOffTree(List<List<Integer>> f){ int m=f.size(),n=f.get(0).size(); List<int[]>trees=new ArrayList<>(); for(int i=0;i<m;i++) { for (int j = 0; j < n; j++) { if (f.get(i).get(j) > 1) { //把需要砍的树都放到这个容器里面 trees.add(new int[]{i, j}); } } } //容器的排序，需要去书写比较器 Collections.sort(trees,(a,b)->{ return f.get(a[0]).get(a[1])-f.get(b[0]).get(b[1]); }); //按照顺序砍树 int ret=0; int bx=0,by=0; for(int[]tree:trees){ //bx为当前坐标位置 int x=tree[0],y=tree[1]; //ex,ey为终点的坐标,也就是xy，trees是需要砍的树 int step=bfs(f,bx,by,x,y); if(step==-1){ return -1; } ret+=step; bx=x; by=y; } return ret; } //常规的迷宫 public static int bfs(List<List<Integer>>f,int bx,int by,int ex,int ey) { if (bx == ex && by == ey) return 0; Queue<int[]> q = new LinkedList<>(); int m = f.size(), n = f.get(0).size(); boolean[][] vis = new boolean[m][n]; //标记当前值 q.add(new int[]{bx, by}); //初始化标记 vis[bx][by] = true; int step = 0; while (!q.isEmpty()) { step++; int sz = q.size(); //和上次一样，size是为了看 while (sz != 0) { int[] t = q.poll(); //出当前队列 int a = t[0], b = t[1]; for (int i = 0; i < 4; i++) { int x = a + dx[i], y = b + dy[i]; //下标是否合法 if (x >= 0 && y >= 0 && x < m && y < n && f.get(x).get(y) != 0 && vis[x][y] == false) { //如果到达了位置，就可以直接返回step if (x == ex && y == ey) return step; q.add(new int[]{x, y}); vis[x][y] = true; } } sz--; } } return -1; } }
把前一个的博客心得放上面不知道能不能理解，他假如两个都合适的情况下，一个能到，一个还要再走一步再到，那么长的那个他会把下一步的点放到队列里面，然后那个短的直接就走完了，直接返回了，换句话说也算是比较，一定是最短。
多源最短路问题:
力扣542.01矩阵
正难，反易这个从1开始，把所有的1当成一个巨大的原子1，不太好实现
1.假如判断好距离后，哪个1是这个距离
所以我们把0看成一组，然后通过这组0来去遍历
class Solution {
static int[]dx={0,0,1,-1};
static int[]dy={1,-1,0,0};
public static int[][] updateMatrix(int[][] mat) {
int m=mat.length,n=mat[0].length;
Queue<int[]> q=new LinkedList<>();
//dist两个作用-标记为-1当前位置没有被搜索过，!=-1存储的是最短的距离
int dist[][]=new int[m][n];
for(int i=0;i<m;i++){
Arrays.fill(dist[i],-1);
}
for(int i=0;i<m;i++)
for(int j=0;j<n;j++) {
if(mat[i][j]==0){
dist[i][j]=0;
q.add(new int[]{i,j});
}
}
while(!q.isEmpty()){
/因为队列是先进先出，所以下一个也会是初始化进入的那个
//假如有sz是为了去找最短的路径距离（他是为了处理不同的起点造成的路径不同的情况，那么假如同时间两个不同的起点，假如最短的情况，那么他就会第一时间标记，标记成功之后，他就是那个最短的了）
int []t=q.poll();
int a=t[0], b=t[1];
for(int i=0;i<4;i++){
int x=a+dx[i],y=b+dy[i];
if(x>=0&&x<m&&y>=0&&y<n&&dist[x][y]==-1){
//dist内部就去计数了，所以不需要这个step,
dist[x][y]=dist[a][b]+1;
q.add(new int[]{x,y});
}
}
}
return dist;
}
}没有sz的原因
力扣1020.飞地的数量
解法1：一个一个去判断-超时
解法2:正难则反。（从边界的1开始出发，往里面走，只要边界上的1能走到里面的1，那么就打个标记，不用去计数
class Solution {
static int[] dx = {0, 0, 1, -1};
static int[] dy = {1, -1, 0, 0};
public static int numEnclaves(int[][] grid) {
int m = grid.length, n = grid[0].length;
int count = 0;
Queue<int[]> q = new LinkedList<>();
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
if ((i == 0 || i == m - 1 || j == 0 || j == n - 1) && grid[i][j] == 1) {
//边界上的1我们不去算他，只去保存他的下标就好
grid[i][j]=100;
q.add(new int[]{i, j});
}
}
while (!q.isEmpty()) {
int sz = q.size();
while (sz != 0) {
int[] t = q.poll();
int a = t[0], b = t[1];
for (int i = 0; i < 4; i++) {
int x = a + dx[i], y = b + dy[i];
//检查这里面的假如是1，那么就说明我们能从边界到达，换句话说，他能够出去，那么我们就给他设置成-1，假如遍历不到的，那么就不去改变他
if (x >= 0 && y >= 0 && x < m && y < n && grid[x][y] == 1) {
q.add(new int[]{x, y});
grid[x][y] = -1;
}
}
sz--;
}
}
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
//只去遍历我们从边界到达不到的地方。
if (grid[i][j] == 1)
count++;
}
return count;
}
}