TypeScript(—)

SuperMap iClient3D for WebGL 示范案例(一)倾斜模型加载

  返回  

leetcode101-一切皆可搜索

2021/7/20 21:25:46 浏览:

一切皆可搜索

  • 一切皆可搜索
    • 深度遍历搜索
      • leetcode695
      • leetcode547
      • leetcode417
    • 回溯法
      • leetcode46
      • leetcode 77

一切皆可搜索

深度遍历搜索

深度优先搜索(depth-first seach,DFS)在搜索到一个新的节点时,立即对该新节点进行遍历;因此遍历需要用先入后出的栈来实现,也可以通过与栈等价的递归来实现。对于树结构而言,由于总是对新节点调用遍历,因此看起来是向着“深”的方向前进。

leetcode695

在这里插入图片描述

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int res = 0; 
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                if (grid[i][j] == 1) {
                    res = Math.max(res, dfs(i, j, grid));
                }
            }
        } 
        return res;
    }
    // 每次调用的时候默认num为1,进入后判断如果不是岛屿,则直接返回0,就可以避免预防错误的情况。
    // 每次找到岛屿,则直接把找到的岛屿改成0,这是传说中的沉岛思想,就是遇到岛屿就把他和周围的全部沉默。
    // ps:如果能用沉岛思想,那么自然可以用朋友圈思想。有兴趣的朋友可以去尝试。
    private int dfs(int i, int j, int[][] grid) {
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[i].length || grid[i][j] == 0) { 
            return 0;
        } 
        grid[i][j] = 0;
        int num = 1;
        num += dfs(i + 1, j, grid);
        num += dfs(i - 1, j, grid);
        num += dfs(i, j + 1, grid);
        num += dfs(i, j - 1, grid);
        return num;   
    }
}

leetcode547

在这里插入图片描述

class Solution {
    public int findCircleNum(int[][] isConnected) {
        int proviences = isConnected.length;
        boolean[] visited = new boolean[proviences];
        int count =0;
        for(int i = 0; i <proviences; i++){
            if(!visited[i]){
                dfs(isConnected,visited,proviences,i);
                count++;
            }
        }
        return count;
    }
    public void dfs(int[][] isConnected, boolean[] visited,int proviences, int i ){
        for(int j =0; j<proviences;j++){
            if(isConnected[i][j]== 1 &&!visited[j]){
                visited[j]= true;
                dfs(isConnected,visited,proviences,j);
            }
           
        }
    }
}

思路:使用visited记录已搜索得部分;

leetcode417

在这里插入图片描述

class Solution {
    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        if(heights.length == 0||heights[0].length==0)
            return new ArrayList<>();
        int m = heights.length;
        int n = heights[0].length;
        int[][] pacific = new int[m][n];
        int[][] atlantic = new int[m][n];
        //从海洋边界开始
        for(int i =0;i<m;i++){
            for(int j = 0;j<n;j++){
                if(i==0||j==0)
                    dfs(heights,pacific,i,j,heights[i][j]);
                if(i==m-1||j==n-1)
                    dfs(heights,atlantic,i,j,heights[i][j]);
            }
        }
        List<List<Integer>> res = new ArrayList<>();
        for(int i =0;i<m;i++){
            for(int j=0;j<n;j++){
                if(pacific[i][j]==1&&atlantic[i][j]==1)
                    res.add(Arrays.asList(i, j));
            }
        }
        return res;
    }
    public void dfs(int[][] matrix,int[][] aux,int i,int j,int pre){
        if(i<0||j<0||i>matrix.length-1||j>matrix[0].length-1
        ||aux[i][j]==1||matrix[i][j]<pre)
            return;
        aux[i][j]=1;
        dfs(matrix,aux,i-1,j,matrix[i][j]);
        dfs(matrix,aux,i+1,j,matrix[i][j]);
        dfs(matrix,aux,i,j-1,matrix[i][j]);
        dfs(matrix,aux,i,j+1,matrix[i][j]);

    }
}

回溯法

回溯法(backtracking)是优先搜索的一种特殊情况,又称为试探法,常用于需要记录节点状态的深度优先搜索。通常来说,排列、组合、选择类问题使用回溯法比较方便。
顾名思义,回溯法的核心是回溯。在搜索到某一节点的时候,如果我们发现目前的节点(及其子节点)并不是需求目标时,我们回退到原来的节点继续搜索,并且把在目前节点修改的状态还原。变成了 [修改当前节点状态]→[递归子节点]→[回改当前节点状态]。
回溯法修改一般有两种情况,一种是修改最后一位输出,比如**排列组合**;一种是修改访问标记,比如矩阵里搜字符串。

回溯法三部曲

1、递归函数的返回值以及参数
在这里要定义两个全局变量,一个用来存放符合条件单一结果,一个用来存放符合条件结果的集合。
2、回溯函数终止条件
3、单层搜索的过程
模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {
        处理节点;
        backtracking(路径,选择列表); // 递归
        回溯,撤销处理结果
    }
}1

leetcode46

在这里插入图片描述

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        int len = nums.length;
        List<List<Integer>> res = new ArrayList<>();
        if(len == 0) return res;
        boolean[] used = new boolean[len];
        Deque<Integer> path = new ArrayDeque<>(len);
        dfs(nums,len,0,path,used,res);
        return res;
    }
    public void dfs(int[] nums, int len,int depth,Deque<Integer> path,boolean[] used,List<List<Integer>> res){
        if(depth == len){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0;i<len;i++){
            if(!used[i]){
                path.addLast(nums[i]);
                used[i] = true;
                dfs(nums,len,depth+1,path,used,res);
                used[i] = false;
                path.removeLast();
            }
        }
    }
}

重点: path.addLast(nums[i]);
used[i] = true;
dfs(nums,len,depth+1,path,used,res);
used[i] = false;
path.removeLast();
尝试后,再将原来的状态修改回去;

leetcode 77

在这里插入图片描述

class Solution {
    public List<List<Integer>> combine(int n, int k) {      
        List<List<Integer>> res = new ArrayList<>();
        if(k>n) return res;
        List<Integer> path = new ArrayList<>();
        dfs(n,k,1,path,res);
        return res;
    }
    public void dfs(int n, int k ,int start,List<Integer> path,List<List<Integer>> res){
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = start;i<=n;i++){
            path.add(i);
            dfs(n,k,i + 1,path,res);
            path.remove(path.size()-1);
        }
    }
}

联系我们

如果您对我们的服务有兴趣,请及时和我们联系!

服务热线:18288888888
座机:18288888888
传真:
邮箱:888888@qq.com
地址:郑州市文化路红专路93号