14-今日三扣(LeetCode)-695-DFS-M-17-回溯-M-70-DP-E_leetcode695为什么不用回溯-CSDN博客

本文链接：https://blog.csdn.net/KuXiaoQuShiHuai/article/details/107599355

695 岛屿最大面积-M-DFS两种写法

题目：

给定一个包含了一些 0 和 1 的非空二维数组 grid 。

一个岛屿是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。




示例 1:




[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。

示例 2:

[[0,0,0,0,0,0,0,0]]

对于上面这个给定的矩阵, 返回 0。

自己构造栈

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        // 存储需要访问的节点
        // 存储x,y
        Stack stack0 = new Stack<Integer> ();
        Stack stack1 = new Stack<Integer>();

        int len1 = grid.length;
        int len2 = grid[0].length;
        int ans = 0;
        for(int i = 0; i<len1; i++){
            for(int j=0; j<len2; j++){
  
                if(grid[i][j] ==0){
                    continue;
                }
                stack0.push(i);
                stack1.push(j);
                int count = 0;
  
                while(!stack0.isEmpty()){
                    int index0 = (int)stack0.pop();
                    int index1 = (int)stack1.pop();
                    // 如果已经被置为0，就跳出。
                    // 尽管入栈之前是检查过一次的
                    // 但是有可能在出栈之前被的节点再次入栈并访问了。
                    if(grid[index0][index1]==0) {
                    	continue;
                    }
                    count++;
                    grid[index0][index1] = 0;
                    if(isLand(index0-1, index1, grid)){
                        stack0.add(index0-1);
                        stack1.add(index1);
                    }
                    if(isLand(index0+1, index1,grid)){
                        stack0.add(index0+1);
                        stack1.add(index1);
                    }
                    if(isLand(index0, index1-1,grid)){
                        stack0.add(index0);
                        stack1.add(index1-1);
                    }
                    if(isLand(index0, index1+1,grid)){
                        stack0.add(index0);
                        stack1.add(index1+1);
                    }
                }
                ans = Math.max(count, ans);
            }
        }
        return ans;

    }
    // 用来判断是否是岛屿
    private boolean isLand(int index0, int index1, int grid[][]){
        int len1 = grid.length;
        int len2 = grid[0].length;
        if(index0>=len1 || index0<0 || index1>=len2 || index1<0){
            return false;
        }
        if(grid[index0][index1]==1){
            return true;
        }
        return false;
    }

递归写法dfs




class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int len1 = grid.length; 
        int len2 = grid[0].length;
        int max = 0;
        for(int i=0; i<len1; i++){
            for (int j = 0; j<len2; j++){
                if(grid[i][j]==0){
                    continue;
                }
                max = Math.max(dfs(i,j,grid), max);
            }
        }
        return max;
    }

    private int dfs(int x, int y, int [][] grid){
        // 递归出口
        // 超出边界
        if(x < 0 || x >= grid.length || y<0 || y>=grid[0].length){
            return 0;
        }
        if(grid[x][y]==0){
            return 0;
        }
        int size=1;
        //设置已经访问过
        grid[x][y] = 0;
        // 寻找该块最大的，深度优先
        size+=dfs(x-1,y,grid);
        size+=dfs(x+1,y,grid);
        size+=dfs(x,y-1,grid);
        size+=dfs(x,y+1,grid);
        return size;
    }
}

17-回溯问题-M

电话号码的字母组合

Leetcode

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VXWoWGFp-1595767865805)(14-今日三扣(LeetCode)]-695-DFS-M-17-回溯-M-70-DP-E.assets/image-20200726091253690.png)

示例:

输入：“23”
输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].

说明:
尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

解决

class Solution {
    private String [] button = {"","","abc","def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    List<String> ans = new LinkedList<>();
    public List<String> letterCombinations(String digits) {
        if(digits.isEmpty()){
            return ans;
        }
        backtrack("",digits);
        return ans;
    }

    private void backtrack(String partAns, String digits){
        // 递归出口
        if(digits.isEmpty() || digits.length()==0){
            ans.add(partAns);
            return;
        }
        // 获得按键
        int num = Integer.valueOf(digits.substring(0,1));
        // 当前按键的字符串
        String str = button[num];
        // 去掉第一个按键
        String nextDigits = digits.substring(1);
  
        for(int i = 0; i<str.length(); i++){
            backtrack(partAns+str.substring(i,i+1), nextDigits);
        }
    }

}

70-动态规划-E

LeetCode

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释：有两种方法可以爬到楼顶。

1 阶 + 1 阶
2 阶

示例 2：

输入： 3
输出： 3
解释：有三种方法可以爬到楼顶。

1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶

解决

使用动态规划思想，设f(x)为x级阶梯的方法数，那么 f(x) = f(x-1)+f(x-2)。

因为最后一步有两种可能，登录一个台阶或者登录两个台阶。

正向计算，从1级阶梯开始

class Solution {
    public int climbStairs(int n) {
        int p = 0; //f(x-2) 
        int q = 0; //f(x-1)
        int ans = 1; //0级时，有1种方案。
        for(int i=1; i<=n ; i++){
            p = q; // f(x-2)
            q = ans; //f(x-1)
            ans = p+q;
        } 
        return ans;
  
    }
}