DFS大礼包-小羊的记录本

Leetcode200.岛屿数量

class Solution {
    public int numIslands(char[][] grid) {
        int row=grid.length;
        if(row==0){
            return 0;
        }
		int col=grid[0].length;
		//做标记
		int[][] visited=new int[row][col];
		int result=0;
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				if(grid[i][j]=='1' && visited[i][j]==0) {
					result++;
					dfs(i, j, visited, grid);
				}
			}
			
		}
		return result;
	}
	public void dfs(int x,int y,int[][] visited,char[][] grid) {
		visited[x][y]=1;
		int[] dx= {-1,1,0,0};
		int[] dy= {0,0,-1,1};
		for (int i = 0; i < 4; i++) {
			int newx=x+dx[i];
			int newy=y+dy[i];
			if(newx>=grid.length || newx<0 || newy>=grid[0].length || newy<0) {
				
			}
			else {
				if (grid[newx][newy]=='1' && visited[newx][newy]==0) {
					dfs(newx, newy, visited, grid);
				}
				
			}
		}
	}
}

Leetcode130. 被围绕的区域

class Solution {
	 public void solve(char[][] board) {
		 int row=board.length;
		 if (row==0) {
			return;
		}
		 int col=board[0].length;
		 boolean[][] visited=new boolean[row][col];
		 for (int i = 0; i < visited.length; i++) {
			for (int j = 0; j < visited[0].length; j++) {
				visited[i][j]=false;
			}
		}
		 for (int j = 0; j < col; j++) {
			 //row 1
			 if (board[0][j]=='O') {
				dfs(0,j,board,visited);
			}
			 //row last
			 if (board[row-1][j]=='O') {
				dfs(row-1, j,board,visited);
			}
		}
		 for (int i = 0; i < row; i++) {
				//col 1
				 if (board[i][0]=='O') {
					dfs(i,0,board,visited);
				}
                //col last
				 if (board[i][col-1]=='O') {
					dfs(i, col-1,board,visited);
				}
			}
		 for (int i = 1; i < row-1; i++) {
			for (int j = 1; j < col-1; j++) {
				if (board[i][j]=='O' && visited[i][j]==false) {
					board[i][j]='X';
				}
			}
		}
        return;
		 
	}
	 
	 public void dfs(int x,int y,char[][] board,boolean[][] visited) {
		 visited[x][y]=true;
		 int[] dx= {-1,1,0,0};
		 int[] dy= {0,0,-1,1};
		 for (int i = 0; i < 4; i++) {
			int newx=x+dx[i];
			int newy=y+dy[i];
			if(newx<0 || newx>=board.length||newy<0 || newy>=board[0].length) {
				
			}
			else {
				if (board[newx][newy]=='O' && visited[newx][newy]==false) {
					dfs(newx, newy, board, visited);
				}
				
			}
		}
	 }
}

Leetcode547.朋友圈

思路：
1.一共有n个人，从第1个人开始找，找到它的所有朋友，dfs它朋友的朋友
2.如果有个人没有朋友，自己也是一个圈

class Solution {
    public int findCircleNum(int[][] M) {
        int[] visited =new int[M.length];
        int cnt=0;
        //从每个人开始找朋友
        for(int i=0;i<M.length;i++){
        	//会先看看这个人是不是已经成为了别人的朋友
            if(visited[i]==0){
                dfs(i,visited,M);
                //一个朋友圈
                cnt++;
            }
        }
        return cnt;
    }
    public void dfs(int i,int[] visited,int[][] M){
    	//在找i的朋友
        for(int j=0;j<M.length;j++){
        	//这个人是i的朋友而且之前没有成为别人的朋友
            if(M[i][j]==1 && visited[j]==0){
            	//做标记
                visited[j]=1;
                //找朋友的朋友
                dfs(j,visited,M);
            }
        }
    }
}

Leetcode39.组合总数

关键是查找的思路，如果查找到后面，不符合规定了，直接break

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result=new ArrayList<>();
        Arrays.sort(candidates);
        ArrayList<Integer> sublist=new ArrayList<>();
        //从数组的0位置开始dfs
        dfs(target,candidates,sublist,result,0);
        
        return result;
    }
    public void dfs(int target,int[] candidates,ArrayList<Integer> sublist,List<List<Integer>> result,int index){
        //如果最后刚好，就加入一种情况
        if(target==0){
            result.add(new ArrayList<Integer>(sublist));
            return;
        }
        //j永远是从i开始
        for(int j=index;j<candidates.length;j++){
        	//提前剪枝
            if(target<candidates[j]){
                break;
            }
            //add加入元素
            sublist.add(candidates[j]);
            //dfs:下一次的target
            dfs(target-candidates[j],candidates,sublist,result,j);
            //delete（）
            sublist.remove(sublist.size()-1);
        }
    }
}