kk

src/main/java/com/dota/arr/_3397/Solution.java

@@ -0,0 +1,23 @@
+package com.dota.arr._3397;
+
+import java.util.Arrays;
+
+class Solution {
+	public int maxDistinctElements(int[] nums, int k) {
+		Arrays.sort(nums);
+		var res = 1;
+		int n = nums.length;
+		nums[0] -= k;
+		int pre = nums[0];
+		for (int i = 1; i < n; i++) {
+			int t = nums[i];
+			t = Math.min(Math.max(pre + 1, t-k), t + k);
+			if(t>nums[i]) {
+				res++;
+				pre = t;
+			}
+		}
+
+		return res;
+	}
+}

src/main/java/com/dota/graph/_2101/Solution.java

@@ -0,0 +1,50 @@
+package com.dota.graph._2101;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+	public int maximumDetonation(int[][] bombs) {
+		int n = bombs.length;
+		var g = new ArrayList<List<Integer>>();
+		for (int i = 0; i < n; i++) {
+			g.add(new ArrayList<>());
+			;
+		}
+		int max = 1;
+		for (int i = 0; i < n; i++) {
+			for (int j = i + 1; j < n; j++) {
+				long a = bombs[i][0] - bombs[j][0];
+				long b = bombs[i][1] - bombs[j][1];
+				long c = bombs[i][2];
+				long d = bombs[j][2];
+				if (a * a + b * b <= c * c) {
+					g.get(i).add(j);
+				}
+				if (a * a + b * b <= d * d) {
+					g.get(j).add(i);
+				}
+			}
+		}
+
+		for (int i = 0; i < n; i++) {
+			int size = df(g, new boolean[n], i);
+			if (size > max) {
+				max = size;
+			}
+		}
+
+		return max;
+	}
+
+	int df(List<List<Integer>> g, boolean[] visited, int x) {
+		visited[x] = true;
+		int size = 1;
+		for (Integer i : g.get(x)) {
+			if (!visited[i]) {
+				size += df(g, visited, i);
+			}
+		}
+		return size;
+	}
+}

src/main/java/com/dota/graph/_2316/Solution.java

@@ -0,0 +1,39 @@
+package com.dota.graph._2316;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class Solution {
+	public long countPairs(int n, int[][] edges) {
+		List<Integer>[] g = new ArrayList[n];
+		Arrays.setAll(g, i -> new ArrayList<>());
+		for (int[] edge : edges) {
+			g[edge[0]].add(edge[1]);
+			g[edge[1]].add(edge[0]);
+		}
+
+		var vis = new boolean[n];
+		long res = 0;
+		int sum = 0;
+		for (int i = 0; i < g.length; i++) {
+			if (!vis[i]) {
+				int size = dfs(i, vis, g);
+				res += (long)size * sum;
+				sum += size;
+			}
+		}
+		return res;
+	}
+
+	int dfs(int i, boolean[] visited, List<Integer>[] arr) {
+		visited[i] = true;
+		int size = 1;
+		for (Integer integer : arr[i]) {
+			if (!visited[integer]) {
+				size += dfs(integer, visited, arr);
+			}
+		}
+		return size;
+	}
+}

src/main/java/com/dota/graph/_2492/Solution.java

@@ -0,0 +1,32 @@
+package com.dota.graph._2492;
+
+import java.util.*;
+
+class Solution {
+	public static void main(String[] args) {
+		new Solution().minScore(4, new int[][]{{1,2,2},{1,3,4},{3,4,7}});
+	}
+	int res = Integer.MAX_VALUE;
+	public int minScore(int n, int[][] roads) {
+		List<int[]>[] grid = new ArrayList[n+1];
+		Arrays.setAll(grid, i -> new ArrayList<>());
+		var visited = new boolean[n+1];
+		for (int[] road : roads) {
+			grid[road[0]].add(new int[]{road[1], road[2]});
+			grid[road[1]].add(new int[]{road[0], road[2]});
+		}
+
+		dfs(grid, 1, visited);
+		return res;
+	}
+
+	void dfs(List<int[]>[] grid, int i, boolean[] visited) {
+		visited[i] = true;
+		for (int k = 0; k < grid[i].size(); k++) {
+			res = Math.min(res, grid[i].get(k)[1]);
+			if (!visited[grid[i].get(k)[0]]) {
+				dfs(grid, grid[i].get(k)[0], visited);
+			}
+		}
+	}
+}

src/main/java/com/dota/graph/_2685/Solution.java

@@ -0,0 +1,47 @@
+package com.dota.graph._2685;
+
+import java.util.*;
+
+class Solution {
+	public static void main(String[] args) {
+		new Solution().countCompleteComponents(6, new int[][]{{0,1},{0,2},{1,2},{3,4}});
+	}
+	public int countCompleteComponents(int n, int[][] edges) {
+		List<Integer>[] g = new ArrayList[n];
+		Arrays.setAll(g, i -> {
+			var list = new ArrayList<>();
+			list.add(i);
+			return list;
+		});
+
+		var book = new boolean[n];
+		for (int[] edge : edges) {
+			g[edge[0]].add(edge[1]);
+			g[edge[1]].add(edge[0]);
+		}
+
+		var sum = 0;
+		for (int i = 0; i < n; i++) {
+			if (!book[i]) {
+				var size = dfs(book, i, g);
+				int temp = 0;
+				for (Integer integer : g[i]) {
+					temp += g[integer].size();
+				}
+				if (size * g[i].size() == temp) {
+					sum++;
+				}
+			}
+		}
+		return sum;
+	}
+
+	int dfs(boolean[] book, int i, List<Integer>[] g) {
+		var set = 1;
+		book[i] = true;
+		for (Integer j : g[i]) {
+			if (!book[j]) set += dfs(book, j, g);
+		}
+		return set;
+	}
+}

src/main/java/com/dota/graph/_3310/Solution.java

@@ -0,0 +1,43 @@
+package com.dota.graph._3310;
+
+import java.util.*;
+
+class Solution {
+	public List<Integer> remainingMethods(int n, int k, int[][] invocations) {
+		var book = new boolean[n];
+		book[k] = true;
+		var g = new ArrayList[n];
+		Arrays.setAll(g, i -> new ArrayList());
+		for (int[] invocation : invocations) {
+			g[invocation[0]].add(invocation[1]);
+		}
+
+		df(g, k, book);
+		var res = new ArrayList<Integer>();
+		for (int[] invocation : invocations) {
+			if (!book[invocation[0]] && book[invocation[1]]) {
+				for (int i = 0; i < n; i++) {
+					res.add(i);
+				}
+				return res;
+			}
+		}
+
+		for (int i = 0; i < book.length; i++) {
+			if (!book[i]) {
+				res.add(i);
+			}
+		}
+
+		return res;
+	}
+
+	void df(List<Integer>[] g, int t, boolean[] book) {
+		book[t] = true;
+		for (Integer i : g[t]) {
+			if (!book[i]) {
+				df(g, i, book);
+			}
+		}
+	}
+}

src/main/java/com/dota/graph/_924/Solution.java

@@ -0,0 +1,59 @@
+package com.dota.graph._924;
+
+import java.util.*;
+
+class Solution {
+	public int minMalwareSpread(int[][] graph, int[] initial) {
+		int n = graph.length;
+		//建立图
+		List<List<Integer>> g = new ArrayList<>();
+		for (int i = 0; i < n; i++) {
+			g.add(new ArrayList<>());
+		}
+
+		for (int i = 0; i < graph.length; i++) {
+			for (int j = i+1; j < graph[i].length; j++) {
+				if (graph[i][j] == 1) {
+					g.get(i).add(j);
+					g.get(j).add(i);
+				}
+			}
+		}
+
+		//最小索引
+		int res = initial[0];
+		//最小感染数
+		int min = Integer.MAX_VALUE;
+		Arrays.sort(initial);
+		for (int i : initial) {
+			var size = cal(n, g, initial, i);
+			if (size < min) {
+				res = i;
+				min = size;
+			}
+		}
+
+		return res;
+	}
+
+	int cal(int n, List<List<Integer>> list, int[] initial, int skip) {
+		var set = new HashSet<Integer>();
+		var visited = new boolean[n];
+		for (int i = 0; i < initial.length; i++) {
+			if (initial[i] == skip || visited[initial[i]]) continue;
+			df(list, initial[i], set, visited);
+		}
+
+		return set.size();
+	}
+
+	void df(List<List<Integer>> list, int i, Set<Integer> set, boolean[] visited) {
+		set.add(i);
+		visited[i] = true;
+		for (Integer j : list.get(i)) {
+			if (!visited[j]) {
+				df(list, j, set, visited);
+			}
+		}
+	}
+}

src/main/java/com/dota/gridGraph/_1091/Solution.java

@@ -0,0 +1,39 @@
+package com.dota.gridGraph._1091;
+
+import java.util.ArrayDeque;
+import java.util.LinkedList;
+
+class Solution {
+	int[] next = {-1, 0, 1};
+
+
+	public int shortestPathBinaryMatrix(int[][] grid) {
+		int n = grid.length;
+		if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1) return -1;
+		return bfs(grid);
+	}
+
+	int bfs(int[][] grid) {
+		var book = new boolean[grid.length][grid.length];
+		var queue = new ArrayDeque<int[]>();
+		queue.add(new int[]{0, 0});
+		int cnt = 0;
+		while (!queue.isEmpty()) {
+			int size = queue.size();
+			cnt++;
+			for (int ii = 0; ii < size; ii++) {
+				var n = queue.poll();
+				if (n[0] < 0 || n[1] < 0 || n[0] >= grid.length || n[1] >= grid[0].length || book[n[0]][n[1]] || grid[n[0]][n[1]] == 1)
+					continue;
+				if (n[0] == n[1] && n[0] == grid.length - 1) return cnt;
+				book[n[0]][n[1]] = true;
+				for (int i : next) {
+					for (int i1 : next) {
+						queue.offer(new int[]{n[0] + i, n[1] + i1});
+					}
+				}
+			}
+		}
+		return -1;
+	}
+}

src/main/java/com/dota/gridGraph/_1210/Solution.java

@@ -0,0 +1,52 @@
+package com.dota.gridGraph._1210;
+
+import java.util.ArrayDeque;
+import java.util.HashSet;
+
+record snake(int headX, int headY, int tailX, int tailY) {
+}
+
+class Solution {
+	public int minimumMoves(int[][] grid) {
+		var queue = new ArrayDeque<snake>();
+		var cnt = 0;
+		int n = grid.length;
+		queue.offer(new snake(0, 1, 0, 0));
+		var book = new HashSet<snake>();
+		book.add(new snake(0, 1, 0, 0));
+		while (!queue.isEmpty()) {
+			int size = queue.size();
+			for (int i = 0; i < size; i++) {
+				var s = queue.poll();
+				if (book.contains(s)) continue;
+				book.add(s);
+				if (s.headX() == n - 1 && s.headY() == n - 1 && s.tailX() == n - 1 && s.tailY() == n - 2) return cnt;
+				//蛇水平情况
+				//1:往右移动
+				//2:往下顺时针旋转（下面两个单元格是空的）
+				if (s.headX() == s.tailX()) {
+					if (s.headY()+1<n && grid[s.headX()][s.headY()+1]==0) {
+						queue.offer(new snake(s.headX(), s.headY()+1, s.tailX(), s.tailY()+1));
+					}
+
+					if (s.headX()+1<n && grid[s.headX()+1][s.headY()]==0 && grid[s.tailX()+1][s.tailY()]==0) {
+						queue.offer(new snake(s.tailX()+1, s.tailY(), s.tailX(), s.tailY()));
+					}
+					continue;
+				}
+
+				//垂直情况
+				//1:往下移动
+				//2:往右逆时针旋转(右边两个是空的)
+				if (s.headX()+1<n&&grid[s.headX()+1][s.headY()]==0) {
+					queue.offer(new snake(s.headX()+1, s.headY(), s.headX(), s.headY()));
+				}
+				if (s.headY()+1<n && grid[s.headX()][s.headY()+1]==0 && grid[s.tailX()][s.tailY()+1]==0) {
+					queue.offer(new snake(s.headX()-1, s.headY()+1,s.tailX(),s.tailY()));
+				}
+			}
+			cnt++;
+		}
+		return -1;
+	}
+}

src/main/java/com/dota/gridGraph/_1293/Solution.java

@@ -0,0 +1,50 @@
+package com.dota.gridGraph._1293;
+
+import java.util.ArrayDeque;
+
+class Solution {
+	public int shortestPath(int[][] grid, int k) {
+		if (grid.length == 1 && grid[0].length == 1) {
+			return 0;
+		}
+		var queue = new ArrayDeque<int[]>();
+		k = Math.min(k, grid.length + grid[0].length - 1);
+		queue.add(new int[]{0, 0, k});
+		int cnt = 0;
+		var book = new boolean[grid.length][grid[0].length][k + 1];
+		var next = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		while (!queue.isEmpty()) {
+			int size = queue.size();
+			cnt++;
+			for (int i = 0; i < size; i++) {
+				var t = queue.poll();
+				int x = t[0], y = t[1], z = t[2];
+				for (int[] xy : next) {
+					var nextx = x + xy[0];
+					var nexty = y + xy[1];
+					if (nextx < 0 || nexty < 0 || nextx >= grid.length || nexty >= grid[0].length) continue;
+					if (nextx == grid.length - 1 && nexty == grid[0].length - 1) {
+						return cnt;
+					}
+
+					if (z == 0 && grid[nextx][nexty] == 1) {
+						continue;
+					}
+
+					if (grid[nextx][nexty] == 0 && !book[nextx][nexty][z]) {
+						book[nextx][nexty][z] = true;
+						queue.offer(new int[]{nextx, nexty, z});
+						continue;
+					}
+
+					if (grid[nextx][nexty] == 1 && !book[nextx][nexty][z - 1]) {
+						book[nextx][nexty][z - 1] = true;
+						queue.offer(new int[]{nextx, nexty, z - 1});
+					}
+				}
+			}
+
+		}
+		return -1;
+	}
+}

src/main/java/com/dota/gridGraph/_1559/Solution.java

@@ -0,0 +1,37 @@
+package com.dota.gridGraph._1559;
+
+class Solution {
+	public boolean containsCycle(char[][] grid) {
+		int n = grid.length;
+		int m = grid[0].length;
+		var book = new int[n][m];
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				if (book[i][j] == 0) {
+					var res = df(i, j, i, j, grid[i][j], book, 0, grid);
+					if (res) {
+						return true;
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+	boolean df(int i, int j, int x, int y, char c, int[][] book, int step, char[][] chars) {
+		if (i < 0 || j < 0 || i >= book.length || j >= book[i].length || c != chars[i][j]) {
+			return false;
+		}
+
+		if (book[i][j] == 0) {
+			step++;
+			book[i][j] = step;
+			return df(i + 1, j, i, j, c, book, step, chars) ||
+					df(i - 1, j, i, j, c, book, step, chars) ||
+					df(i, j + 1, i, j, c, book, step, chars) ||
+					df(i, j - 1, i, j, c, book, step, chars);
+		}
+
+		return book[x][y] - book[i][j] > 2;
+	}
+}

src/main/java/com/dota/gridGraph/_1765/Solution.java

@@ -0,0 +1,37 @@
+package com.dota.gridGraph._1765;
+
+import java.util.ArrayDeque;
+
+class Solution {
+	public int[][] highestPeak(int[][] isWater) {
+		int n = isWater.length;
+		int m = isWater[0].length;
+		var queue = new ArrayDeque<int[]>();
+		var book = new boolean[n][m];
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				if (isWater[i][j] == 1) {
+					queue.add(new int[]{i, j});
+					isWater[i][j] = 0;
+					book[i][j] = true;
+				}
+			}
+		}
+		var next = new int[][]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+		while (!queue.isEmpty()) {
+			var xy = queue.poll();
+			int x = xy[0];
+			int y = xy[1];
+			for (int[] ints : next) {
+				int nextX = x + ints[0];
+				int nextY = y + ints[1];
+				if (nextX < 0 || nextY < 0 || nextX >= n || nextY >= m || book[nextX][nextY]) continue;
+				isWater[nextX][nextY] = isWater[x][y] + 1;
+				book[nextX][nextY] = true;
+				queue.offer(new int[]{nextX, nextY});
+			}
+		}
+
+		return isWater;
+	}
+}

src/main/java/com/dota/gridGraph/_1926/Solution.java

@@ -0,0 +1,37 @@
+package com.dota.gridGraph._1926;
+
+import java.util.ArrayDeque;
+
+class Solution {
+
+	public int nearestExit(char[][] maze, int[] entrance) {
+		int x = entrance[0];
+		int y = entrance[1];
+		var queue = new ArrayDeque<int[]>();
+		queue.add(new int[]{x+1, y});
+		queue.add(new int[]{x-1, y});
+		queue.add(new int[]{x, y+1});
+		queue.add(new int[]{x, y-1});
+		maze[x][y] = '+';
+		int cnt = 0;
+		while (!queue.isEmpty()) {
+			cnt++;
+			int t  =queue.size();
+			for (int i = 0; i < t; i++) {
+				var n = queue.poll();
+				if (n[0] < 0 || n[1] < 0 || n[0] >= maze.length || n[1] >= maze[0].length || maze[n[0]][n[1]] == '+') {
+					continue;
+				}
+				if ((n[0]==0||n[1]==0||n[0]==maze.length-1||n[1]==maze[0].length-1)) {
+					return cnt;
+				}
+				maze[n[0]][n[1]] = '+';
+				queue.offer(new int[]{n[0] + 1, n[1]});
+				queue.offer(new int[]{n[0] - 1, n[1]});
+				queue.offer(new int[]{n[0], n[1] + 1});
+				queue.offer(new int[]{n[0], n[1] - 1});
+			}
+		}
+		return -1;
+	}
+}

src/main/java/com/dota/gridGraph/_2146/Solution.java

@@ -0,0 +1,57 @@
+package com.dota.gridGraph._2146;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    public static void main(String[] args) {
+        new Solution().highestRankedKItems(new int[][]{{1,2,0,1},{1,3,3,1},{0,2,5,1}},new int[]{2,3}, new int[]{2,3},2);
+    }
+    public List<List<Integer>> highestRankedKItems(int[][] grid, int[] pricing, int[] start, int k) {
+        var res = new ArrayList<List<Integer>>();
+        var queue = new ArrayDeque<int[]>();
+        queue.add(start);
+        var cnt = 0;
+        var next = new int[][]{{0,-1},{0,1},{1,0},{-1,0}};
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            var arr = new ArrayList<int[]>();
+            for (int i = 0; i < size; i++) {
+                var z = queue.poll();
+                int x = z[0], y = z[1];
+                if (grid[x][y]<=pricing[1]&&grid[x][y]>=pricing[0]) {
+                    arr.add(new int[]{cnt,x,y});
+                }
+
+                if (grid[x][y] >0) {
+                    grid[x][y] = -grid[x][y];
+                }
+                for (int[] ns : next) {
+                    var nextx = x + ns[0];
+                    var nexty = y + ns[1];
+                    if (nextx<0||nexty<0||nextx>=grid.length||nexty>=grid[x].length||grid[nextx][nexty]<=0) continue;
+                    queue.offer(new int[]{nextx,nexty});
+                }
+            }
+            arr.sort((a,b)->{
+                if(a[0]!=b[0]) return a[0]-b[0];
+                if (grid[a[1]][a[2]] != grid[b[1]][b[2]]) {
+                    return grid[b[1]][b[2]] - grid[a[1]][a[2]];
+                }
+                if (a[1]!=b[1]) {
+                    return a[1] - b[1];
+                }
+                return a[2]-b[2];
+            });
+	        for (int[] ints : arr) {
+		        res.add(List.of(ints[1], ints[2]));
+		        if (res.size() == k) {
+			        return res;
+		        }
+	        }
+            cnt++;
+        }
+        return res;
+    }
+}

src/main/java/com/dota/gridGraph/_417/Solution.java

@@ -0,0 +1,53 @@
+package com.dota.gridGraph._417;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+	boolean a = false, b = false;
+
+	public List<List<Integer>> pacificAtlantic(int[][] heights) {
+		var book = new boolean[heights.length][heights[0].length];
+		for (int i = 0; i < book.length; i++) {
+			book[i] = new boolean[heights[0].length];
+		}
+		var res = new ArrayList<List<Integer>>();
+		for (int i = 0; i < heights.length; i++) {
+			for (int j = 0; j < heights[i].length; j++) {
+				a = false;
+				b = false;
+				dfs(i, j, heights, book, heights[i][j]);
+				if (a&&b) {
+					res.add(List.of(i,j));
+				}
+			}
+		}
+		return res;
+	}
+
+	void dfs(int i, int j, int[][] heights, boolean[][] book, int last) {
+		if (a && b) return;
+		if (i < 0 || j < 0) {
+			a = true;
+			return;
+		}
+		if (i >= heights.length || j >= heights[0].length) {
+			b = true;
+			return;
+		}
+
+		if (book[i][j]) {
+			return;
+		}
+		if (heights[i][j] > last) {
+			return;
+		}
+
+		book[i][j] = true;
+		dfs(i + 1, j, heights, book, heights[i][j]);
+		dfs(i - 1, j, heights, book, heights[i][j]);
+		dfs(i, j + 1, heights, book, heights[i][j]);
+		dfs(i, j - 1, heights, book, heights[i][j]);
+		book[i][j] = false;
+	}
+}

src/main/java/com/dota/gridGraph/_675/Solution.java

@@ -0,0 +1,90 @@
+package com.dota.gridGraph._675;
+
+import java.util.*;
+
+class Solution {
+	public static void main(String[] args) {
+		new Solution().cutOffTree(List.of(List.of(54581641, 64080174, 24346381, 69107959), List.of(86374198, 61363882, 68783324, 79706116),
+				List.of(668150, 92178815, 89819108, 94701471), List.of(83920491, 22724204, 46281641, 47531096), List.of(89078499, 18904913, 25462145, 60813308)));
+	}
+
+	int[] next = new int[]{1, -1};
+	int n, m;
+
+	public int cutOffTree(List<List<Integer>> forest) {
+		if (forest.get(0).get(0) == 0) return -1;
+		n = forest.size();
+		m = forest.get(0).size();
+		if (!check(forest)) return -1;
+		// 步数
+		int step = 0;
+		var treeList = new ArrayList<Node>();
+		for (int i = 0; i < forest.size(); i++) {
+			for (int j = 0; j < forest.get(i).size(); j++) {
+				int t = forest.get(i).get(j);
+				if (t > 1) {
+					treeList.add(new Node(i, j, forest.get(i).get(j)));
+				}
+			}
+		}
+		treeList.sort(Comparator.comparingInt(a -> a.v));
+		var last = new int[]{0,0};
+		for (Node node : treeList) {
+			step += bfs(last[0], last[1], node.i,node.j, forest);
+			last = new int[]{node.i, node.j};
+		}
+		return step;
+	}
+
+	int bfs(int i, int j, int endI, int endJ, List<List<Integer>> forest) {
+		var book = new boolean[n][m];
+		var step = 0;
+		var queue = new ArrayDeque<int[]>();
+		queue.offer(new int[]{i, j});
+		while (!queue.isEmpty()) {
+			int size = queue.size();
+			for (int k = 0; k < size; k++) {
+				var c = queue.poll();
+				if (c[0] == endI && c[1] == endJ) return step;
+				if (c[0] < 0 || c[1] < 0 || c[0] >= n || c[1] >= m || book[c[0]][c[1]] || forest.get(c[0]).get(c[1])==0 ) continue;
+				book[c[0]][c[1]] = true;
+				queue.offer(new int[]{c[0] + 1, c[1]});
+				queue.offer(new int[]{c[0] - 1, c[1]});
+				queue.offer(new int[]{c[0], c[1] + 1});
+				queue.offer(new int[]{c[0], c[1] - 1});
+			}
+
+			step++;
+		}
+
+		return 0;
+	}
+
+	record Node(int i, int j, int v) {
+	}
+
+
+	boolean check(List<List<Integer>> forest) {
+		int cnt = 0;
+		int x = 0;
+		int y = 0;
+		for (int i = 0; i < forest.size(); i++) {
+			for (int j = 0; j < forest.get(i).size(); j++) {
+				if (forest.get(i).get(j) > 0) {
+					cnt++;
+					x = i;
+					y = j;
+				}
+			}
+		}
+		var book = new boolean[forest.size()][forest.get(0).size()];
+		return cnt == df(forest, x, y, book);
+	}
+
+	int df(List<List<Integer>> forest, int x, int y, boolean[][] book) {
+		if (x < 0 || y < 0 || x >= forest.size() || y >= forest.get(0).size() || book[x][y] || forest.get(x).get(y) == 0)
+			return 0;
+		book[x][y] = true;
+		return 1 + df(forest, x + 1, y, book) + df(forest, x, y + 1, book) + df(forest, x - 1, y, book) + df(forest, x, y - 1, book);
+	}
+}

src/main/java/com/dota/gridGraph/_749/Solution.java

@@ -0,0 +1,89 @@
+package com.dota.gridGraph._749;
+
+import java.util.*;
+
+class Solution {
+	public int containVirus(int[][] isInfected) {
+		var res = 0;
+		while(true) {
+			int max = 0;
+			Node node = null;
+			for (int i = 0; i < isInfected.length; i++) {
+				for (int j = 0; j < isInfected[i].length; j++) {
+					if (isInfected[i][j] == 1) {
+						var set = new HashSet<Node>();
+						df(isInfected, i, j, set);
+						if (set.size() > max) {
+							max = set.size();
+							node = new Node(i, j);
+						}
+					}
+				}
+			}
+
+			if (node == null) {
+				return res;
+			}
+
+			res += quarantine(isInfected, node.x, node.y);
+
+			// 病毒扩展
+			for (int i = 0; i < isInfected.length; i++) {
+				for (int j = 0; j < isInfected[i].length; j++) {
+					if (isInfected[i][j] == 2) {
+						growth(isInfected, i, j);
+					}
+				}
+			}
+		}
+	}
+
+	void growth(int[][] isInfected, int x, int y) {
+		if (x<0|| x>=isInfected.length || y<0|| y>=isInfected[0].length||isInfected[x][y]==1 || isInfected[x][y]==3) {
+			return;
+		}
+		if (isInfected[x][y]==0) {
+			isInfected[x][y] = 1;
+			return;
+		}
+
+		isInfected[x][y] = 1;
+		growth(isInfected, x, y-1);
+		growth(isInfected, x, y+1);
+		growth(isInfected, x-1, y);
+		growth(isInfected, x+1, y);
+	}
+
+	// 隔离病毒
+	int quarantine(int[][] isInfected, int row, int col) {
+		if (row < 0 || row >= isInfected.length || col < 0 || col >= isInfected[row].length || isInfected[row][col] == 3) {
+			return 0;
+		}
+		if (isInfected[row][col] == 0) {
+			return 1;
+		}
+		isInfected[row][col] = 3;
+		return quarantine(isInfected, row, col + 1) + quarantine(isInfected, row, col - 1) + quarantine(isInfected, row + 1, col) + quarantine(isInfected, row - 1, col);
+	}
+
+	// 遍历病毒
+	void df(int[][] isInfected, int row, int col, Set<Node> set) {
+		if (row < 0 || row >= isInfected.length || col < 0 || col >= isInfected[row].length || isInfected[row][col] == 2 || isInfected[row][col] == 3) {
+			return;
+		}
+
+		if (isInfected[row][col] == 0) {
+			set.add(new Node(row, col));
+			return;
+		}
+
+		isInfected[row][col] = 2;
+		df(isInfected, row - 1, col, set);
+		df(isInfected, row + 1, col, set);
+		df(isInfected, row, col - 1, set);
+		df(isInfected, row, col + 1, set);
+	}
+
+	record Node(int x, int y) {
+	}
+}

src/main/java/com/dota/gridGraph/_827/Solution.java

@@ -0,0 +1,77 @@
+package com.dota.gridGraph._827;
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+class Solution {
+	public int largestIsland(int[][] grid) {
+		int res = 0;
+		var map = new HashMap<Integer, Integer>();
+		var idx = 2;
+		for (int i = 0; i < grid.length; i++) {
+			for (int j = 0; j < grid[0].length; j++) {
+				if (grid[i][j] == 1) {
+					goin(i, j, grid, idx, map);
+					idx++;
+				}
+			}
+		}
+
+		for (int i = 0; i < grid.length; i++) {
+			for (int j = 0; j < grid[0].length; j++) {
+				if (grid[i][j] == 0) {
+					int sum = df(i, j, grid, map);
+					res = Math.max(res, sum);
+				}
+			}
+		}
+		int n = grid.length;
+		return res==0?n*n:res;
+	}
+
+	void goin(int i, int j, int[][] grid, int idx, HashMap<Integer, Integer> map) {
+		if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] != 1) return;
+		grid[i][j] = idx;
+		map.merge(idx, 1, Integer::sum);
+		goin(i - 1, j, grid, idx, map);
+		goin(i + 1, j, grid, idx, map);
+		goin(i, j - 1, grid, idx, map);
+		goin(i, j + 1, grid, idx, map);
+	}
+
+	int df(int i, int j, int[][] grid, HashMap<Integer, Integer> map) {
+		var set = new HashSet<Integer>();
+		int sum = 1;
+		int t = dfs(i - 1, j, grid, map);
+		if (t > 0) {
+			sum += t;
+			set.add(grid[i - 1][j]);
+		}
+
+		t = dfs(i + 1, j, grid, map);
+		if (t > 0 && !set.contains(grid[i + 1][j])) {
+			sum += t;
+			set.add(grid[i + 1][j]);
+		}
+
+		t = dfs(i, j - 1, grid, map);
+		if (t > 0 && !set.contains(grid[i][j - 1])) {
+			sum += t;
+			set.add(grid[i][j - 1]);
+		}
+		t = dfs(i, j + 1, grid, map);
+		if (t > 0 && !set.contains(grid[i][j + 1])) {
+			sum += t;
+			set.add(grid[i][j + 1]);
+		}
+		return sum;
+	}
+
+	int dfs(int i, int j, int[][] grid, HashMap<Integer, Integer> map) {
+		if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] == 0) {
+			return 0;
+		}
+
+		return map.get(grid[i][j]);
+	}
+}

src/main/java/com/dota/gridGraph/_909/Solution.java

@@ -0,0 +1,51 @@
+package com.dota.gridGraph._909;
+
+import java.util.ArrayDeque;
+
+class Solution {
+	public int snakesAndLadders(int[][] board) {
+		var cnt = -1;
+		int n = board.length;
+		var book = new boolean[n * n + 1];
+		var queue = new ArrayDeque<Integer>();
+		queue.add(1);
+		while (!queue.isEmpty()) {
+			cnt++;
+			int size = queue.size();
+			for (int s = 0; s < size; s++) {
+				int p = queue.poll();
+				if (p == n * n) {
+					return cnt;
+				}
+				for (int i = 1; i <= 6 && p + i <= n * n; i++) {
+					var next = p + i;
+					if (book[next]) continue;
+					var xy = getXy(next, n);
+					var x = xy[0];
+					var y = xy[1];
+
+					book[next] = true;
+					if (board[x][y] == -1) {
+						queue.offer(next);
+						continue;
+					}
+
+					//跳到下一步
+					queue.offer(board[x][y]);
+				}
+			}
+		}
+		return -1;
+	}
+
+	// k是编号
+	// 从编号获取坐标
+	int[] getXy(int no, int n) {
+		var m = (no - 1) / n;
+		var l = (no - 1) % n;
+		if (m % 2 == 1) {
+			return new int[]{n - 1 - m, n - l - 1};
+		}
+		return new int[]{n - 1 - m, l};
+	}
+}

src/main/java/com/dota/gridGraph/_934/Solution.java

@@ -0,0 +1,48 @@
+package com.dota.gridGraph._934;
+
+import java.util.ArrayDeque;
+
+class Solution {
+    public int shortestBridge(int[][] grid) {
+        var res = -1;
+        int n = grid.length, m = grid[0].length;
+        var deque = new ArrayDeque<int[]>();
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (grid[i][j] == 1) {
+                    df(i, j, grid, deque);
+                }
+                while (!deque.isEmpty()) {
+                    int size = deque.size();
+                    for (int l = 0; l < size; l++) {
+                        var k = deque.poll();
+                        var x = k[0];
+                        var y = k[1];
+                        if (x < 0 || y < 0 || x >= n || y >= m || grid[x][y] == 4) continue;
+                        if (grid[x][y] == 1) {
+                            return res;
+                        }
+                        grid[x][y] = 4;
+                        deque.offer(new int[]{x + 1, y});
+                        deque.offer(new int[]{x - 1, y});
+                        deque.offer(new int[]{x, y + 1});
+                        deque.offer(new int[]{x, y - 1});
+                    }
+                    res++;
+                }
+            }
+        }
+        return res;
+    }
+    void df(int i, int j, int[][] grid, ArrayDeque<int[]> deque) {
+        if (i<0||j<0||i>=grid.length||j>=grid[0].length||grid[i][j]!=1) {
+            return;
+        }
+        grid[i][j] = -1;
+        deque.offer(new int[]{i, j});
+        df(i+1,j,grid,deque);
+        df(i-1,j,grid,deque);
+        df(i,j-1,grid,deque);
+        df(i,j+1,grid,deque);
+    }
+}

src/main/java/com/dota/gridGraph/_lcp63/Solution.java

@@ -0,0 +1,77 @@
+package com.dota.gridGraph._lcp63;
+
+import java.util.ArrayList;
+
+class Solution {
+
+	public int[][] ballGame(int num, String[] plate) {
+		var res = new ArrayList<int[]>();
+		int n = plate.length;
+		int m = plate[0].length();
+		// 方向 上下左右 1,2,3,4
+		for (int i = 1; i < n - 1; i++) {
+			if (dfs(num, i, 0, plate, 4) && plate[i].charAt(0)=='.') {
+				res.add(new int[]{i, 0});
+			}
+			if (dfs(num, i, m - 1, plate, 3)&&plate[i].charAt(m-1)=='.') {
+				res.add(new int[]{i, m - 1});
+			}
+		}
+		for (int i = 1; i < m - 1; i++) {
+			if (dfs(num, 0, i, plate, 2)&&plate[0].charAt(i)=='.') {
+				res.add(new int[]{0, i});
+			}
+			if (dfs(num, n - 1, i, plate, 1)&&plate[n-1].charAt(i)=='.') {
+				res.add(new int[]{n - 1, i});
+			}
+		}
+		var arr = new int[res.size()][];
+		for (int i = 0; i < res.size(); i++) {
+			arr[i] = res.get(i);
+		}
+		return arr;
+	}
+
+	boolean dfs(int num, int i, int j, String[] plate, int to) {
+		if (i < 0 || j < 0 || i >= plate.length || j >= plate[0].length() || num < 0) {
+			return false;
+		}
+
+		return switch (plate[i].charAt(j)) {
+			case 'W' -> {
+				if (to == 1) {
+					yield dfs(num - 1, i, j - 1, plate, 3);
+				} else if (to == 2) {
+					yield dfs(num - 1, i, j + 1, plate, 4);
+				} else if (to == 3) {
+					yield dfs(num - 1, i + 1, j, plate, 2);
+				} else {
+					yield dfs(num - 1, i - 1, j, plate, 1);
+				}
+			}
+			case 'E' -> {
+				if (to == 1) {
+					yield dfs(num - 1, i, j + 1, plate, 4);
+				} else if (to == 2) {
+					yield dfs(num - 1, i, j - 1, plate, 3);
+				} else if (to == 3) {
+					yield dfs(num - 1, i - 1, j, plate, 1);
+				} else {
+					yield dfs(num - 1, i + 1, j, plate, 2);
+				}
+			}
+			case '.' -> {
+				if (to == 1) {
+					yield dfs(num - 1, i - 1, j, plate, to);
+				} else if (to == 2) {
+					yield dfs(num - 1, i + 1, j, plate, to);
+				} else if (to == 3) {
+					yield dfs(num - 1, i, j - 1, plate, to);
+				} else {
+					yield dfs(num - 1, i, j + 1, plate, to);
+				}
+			}
+			default -> true;
+		};
+	}
+}