【力扣】从零开始的 dfs（全排列，回溯）

已于 2023-11-23 19:00:10 修改
阅读量580 收藏 1
点赞数 2
分类专栏： 力扣刷题集 文章标签： 深度优先 leetcode 算法
于 2023-10-02 13:18:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66228897/article/details/133490513
版权

从零开始的 dfs（全排列，回溯）

文章目录

46. 全排列

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

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

47. 全排列 II

47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

解题思路

​ 这题和上一题要求去重，要解决重复问题，我们只要设定一个规则，保证在填第 i 个数的时候重复数字只会被填入一次即可。而在本题解中，我们选择对原数组排序，保证相同的数字都相邻，然后每次填入的数一定是这个数所在重复数集合中「从左往右第一个未被填过的数字」，即如下的判断条件：

if(i>0 && nums[i]==nums[i-1] && visit[i-1]==false)
	continue;

class Solution {
    static int n;
    static boolean[] visit;
    static List<List<Integer>> res;
    public List<List<Integer>> permuteUnique(int[] nums) {
        n=nums.length;
        res=new ArrayList<>();
        Deque<Integer> deque=new ArrayDeque<>();
        visit=new boolean[n];
        Arrays.sort(nums);
        dfs(deque,0,nums);

        return res;
    }
    static void dfs(Deque<Integer> deque,int len,int[] nums)
    {
        if(len==n)
        {
            res.add(new ArrayList<>(deque));
            return;
        }
        for(int i=0;i<n;i++)
        {
            if(i>0 && nums[i]==nums[i-1] && visit[i-1]==false)
                continue;
            if(visit[i]==false)
            {
                visit[i]=true;
                deque.addLast(nums[i]);
                dfs(deque,len+1,nums);
                visit[i]=false;
                deque.removeLast();
            }
        }
        return ;
    }
}

77. 组合

77. 组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

class Solution {
    static List<List<Integer>> res;//答案
    static boolean[] visit;//标记
    public List<List<Integer>> combine(int n, int k) {
        res=new ArrayList<>();
        visit=new boolean[n+1];//[1,n]
        Deque<Integer> deque=new ArrayDeque<>();
        dfs(deque,0,k,n,1);
        return res;
    }
    static void dfs(Deque<Integer> deque,int s,int k,int n,int c)
    {
        if(s==k)
        {
            res.add(new ArrayList<>(deque));
            return;
        }
        for(int i=c;i<=n;i++)
        {

            if(visit[i]==false)
            {
                visit[i]=true;
                deque.addLast(i);
                dfs(deque,s+1,k,n,i+1);
                deque.removeLast();
                visit[i]=false;
            }
        }
        return;
    }
}

78. 子集

78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

class Solution {
    static boolean[] visit;//标记数组
    static List<List<Integer>> res;//结果
    static int n;//测试样例长度
    public List<List<Integer>> subsets(int[] nums) {
        Deque<Integer> deque=new ArrayDeque<>();
        res=new ArrayList<>();
        n=nums.length;
        visit=new boolean[n];
        //遍历长度从0到n-1
        for(int i=0;i<=n;i++)
        {
            Arrays.fill(visit,false);
            dfs(deque,0,i,nums,0);
        }
        return res;
    }
    static void dfs(Deque<Integer> deque,int s,int k,int[] nums,int c)
    {
        if(s==k)
        {
            res.add(new ArrayList<>(deque));
            return;
        }
        for(int i=c;i<n;i++)
        {
            if(visit[i]==false)
            {
                visit[i]=true;
                deque.addLast(Integer.valueOf(nums[i]));
                dfs(deque,s+1,k,nums,i+1);
                deque.removeLast();
                visit[i]=false;
            }
        }
        return;
    }
}

79. 单词搜索

79. 单词搜索

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例 1：

img

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

class Solution {
    static int n,m,l;//方格大小
    static boolean f;//答案
    static int[] dx=new int[]{0,0,1,-1};
    static int[] dy=new int[]{1,-1,0,0};//方向数组
    static boolean[][] visit;//标记数组
    public boolean exist(char[][] board, String word) {
        n=board.length;
        m=board[0].length;
        l=word.length();
        f=false;
        visit=new boolean[n][m];
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                for(boolean[] b:visit)
                {
                    Arrays.fill(b,false);
                }
                if(board[i][j]==word.charAt(0))
                {
                    visit[i][j]=true;
                    dfs(board,0,i,j,word);
                    if(f==true)
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    static void dfs(char[][] board,int s,int i,int j,String word)
    {
        if(s==l-1)
        {
            f=true;
            return;
        }
        for(int q=0;q<4;q++)
        {
            int x=dx[q]+i;
            int y=dy[q]+j;
            if (x>=0 && x<n && y>=0 && y<m && visit[x][y]==false && board[x][y] == word.charAt(s + 1)) {
                visit[x][y]=true;
                dfs(board, s + 1, x, y, word);
                visit[x][y]=false;
            }
        }
        return;

    }
}

1219. 黄金矿工

1219. 黄金矿工

你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为 m * n 的网格 grid 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量；如果该单元格是空的，那么就是 0。

为了使收益最大化，矿工需要按以下规则来开采黄金：

  • 每当矿工进入一个单元，就会收集该单元格中的所有黄金。
  • 矿工每次可以从当前位置向上下左右四个方向走。
  • 每个单元格只能被开采（进入）一次。
  • 不得开采（进入）黄金数目为 0 的单元格。
  • 矿工可以从网格中 任意一个 有黄金的单元格出发或者是停止。

示例 1：

输入：grid = [[0,6,0],[5,8,7],[0,9,0]]
输出：24
解释：
[[0,6,0],
 [5,8,7],
 [0,9,0]]
一种收集最多黄金的路线是：9 -> 8 -> 7。

class Solution {
    static int[] dx={0,0,1,-1};
    static int[] dy={1,-1,0,0};//方向向量
    static int n,m,max;
    static boolean[][] visit;//标记
    public int getMaximumGold(int[][] grid) {

        n=grid.length;
        m=grid[0].length;
        visit=new boolean[n][m];
        max=0;
        for(int i=0;i<n;i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] != 0) {
                    for (boolean[] a : visit) {
                        Arrays.fill(a, false);
                    }
                    visit[i][j]=true;
                    max=Math.max(max,grid[i][j]);
                    dfs(grid, i, j, grid[i][j]);
                }
            }
        }
        return max;
    }
    static void dfs(int[][] grid,int i,int j,int s)
    {
        for(int t=0;t<4;t++)
        {
            int x=dx[t]+i;
            int y=dy[t]+j;
            if(x>=0 && x<n && y>=0 && y<m && grid[x][y]!=0 && visit[x][y]==false)
            {
                visit[x][y]=true;
                s+=grid[x][y];
                max=Math.max(max,s);
                dfs(grid,x,y,s);
                s-=grid[x][y];
                visit[x][y]=false;
            }
        }
        return;
    }
}

面试题 08.02. 迷路的机器人

设想有个机器人坐在一个网格的左上角，网格 r 行 c 列。机器人只能向下或向右移动，但不能走到一些被禁止的网格（有障碍物）。设计一种算法，寻找机器人从左上角移动到右下角的路径。

img

网格中的障碍物和空位置分别用 1 和 0 来表示。

返回一条可行的路径，路径由经过的网格的行号和列号组成。左上角为 0 行 0 列。如果没有可行的路径，返回空数组。

示例 1:

输入:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
输出: [[0,0],[0,1],[0,2],[1,2],[2,2]]
解释: 
输入中标粗的位置即为输出表示的路径，即
0行0列（左上角） -> 0行1列 -> 0行2列 -> 1行2列 -> 2行2列（右下角）

**说明：**r 和 c 的值均不超过 100。

class Solution {
    static int n,m;
    static Deque<List<Integer>> deque;
    static int[] dx=new int[]{0,1};
    static int[] dy=new int[]{1,0};
    static boolean[][] dp;
    static int min;
    public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {

        n=obstacleGrid.length;
        m=obstacleGrid[0].length;
        dp=new boolean[n][m];
        for(boolean[] a:dp)
        {
            Arrays.fill(a,true);
        }
        deque=new ArrayDeque<>();
        if(obstacleGrid[0][0]==1 || obstacleGrid[n-1][m-1]==1)
        {
            return deque.stream().toList();
        }


        min=Integer.MAX_VALUE;
        List<Integer> l=new ArrayList<>();
        l.add(0);
        l.add(0);
        deque.add(l);
        if(!dfs(obstacleGrid,0,0))
        {
            deque.removeFirst();
        }
        return deque.stream().toList();
    }
    static boolean dfs(int[][] obstacleGrid,int i, int j)
    {
        //从左上角到右下角，边走边记录当前位置，回退时撤销当前位置
        //因为只能从下走或者从右走，不存在走过已经走过的格子，所以不需要标记数组
        if(dp[i][j]==false)
        {
            return false;
        }

        if(i==n-1 && j==m-1)
        {
            return true;
        }
        for(int t=0;t<2;t++)
        {
            int x=dx[t]+i;
            int y=dy[t]+j;
            if(x<n && y<m && obstacleGrid[x][y]==0)
            {
                List<Integer> list=new ArrayList<>();
                list.add(x);
                list.add(y);
                deque.addLast(list);
                if(dfs(obstacleGrid,x,y))
                {
                    return true;
                }
                else
                    deque.removeLast();
            }
        }
        dp[i][j]=false;
        return false;
    }
}

494. 目标和

494. 目标和

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

  • 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

class Solution {
    int res=0;
    public int findTargetSumWays(int[] nums, int target) {
        dfs(nums,0,0,target);
        return res;
    }
    void dfs(int[] nums,int i,int s,int target)
    {
        if(i==nums.length)
        {
            if(s==target)
                res++;
            return;
        }
        dfs(nums,i+1,s+nums[i],target);
        dfs(nums,i+1,s-nums[i],target);
        return;
    }

}

491. 递增子序列

491. 递增子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

class Solution {
    static int n;
    static List<List<Integer>> res;
    public List<List<Integer>> findSubsequences(int[] nums) {
        res=new ArrayList<>();
        n=nums.length;
        Deque<Integer> deque=new ArrayDeque<>();
        for(int i=2;i<=n;i++)
        {
            dfs(nums,deque,i,0);
        }
        return res;
    }
    static void dfs(int[] nums,Deque<Integer> deque,int k,int c)
    {
        if(deque.size()==k)
        {
            res.add(new ArrayList<>(deque));
            return;
        }
        Set<Integer> set=new HashSet<>();
        for(int i=c;i<n;i++)
        {
            if(set.contains(nums[i]))
            {
                continue;
            }
            set.add(nums[i]);
            if(deque.size()==0 || (deque.size()!=0 && deque.getLast()<=nums[i])) {
                deque.addLast(nums[i]);
                dfs(nums, deque, k, i + 1);
                deque.removeLast();
            }
        }
        return;
    }
}

LCR 157. 套餐内商品的排列顺序

LCR 157. 套餐内商品的排列顺序

某店铺将用于组成套餐的商品记作字符串 goods，其中 goods[i] 表示对应商品。请返回该套餐内所含商品的 全部排列方式 。

返回结果 无顺序要求，但不能含有重复的元素。

示例 1:

输入：goods = "agew"
输出：["aegw","aewg","agew","agwe","aweg","awge","eagw","eawg","egaw","egwa","ewag","ewga","gaew","gawe","geaw","gewa","gwae","gwea","waeg","wage","weag","wega","wgae","wgea"]

class Solution {
    boolean[] visit;
    int n;
    Set<String> set;
    public String[] goodsOrder(String goods) {
        set=new HashSet<>();
        n=goods.length();
        visit=new boolean[n];
        Deque<Character> str=new ArrayDeque<>();
        dfs(goods,str,0);
        return set.toArray(new String[0]);
    }
    void dfs(String good, Deque<Character> str, int count)
    {

        if(count==n)
        {
            String s="";
            for(Character ch:str)
            {
                s+=ch;
            }
            set.add(s);
            return;
        }
        for(int i=0;i<n;i++)
        {
            if(visit[i]==false)
            {
                visit[i]=true;
                str.addLast(good.charAt(i));
                dfs(good,str,count+1);
                str.removeLast();
                visit[i]=false;
            }

        }
    }

}

17. 电话号码的字母组合

17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

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

img

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

class Solution {
    List<String> res=new ArrayList<>();
    String[] str={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    public List<String> letterCombinations(String digits) {
        StringBuilder sb=new StringBuilder();
        if(digits.length()==0)
        {
            return res;
        }
        dfs(digits,sb,0);
        return res;
    }
    void dfs(String digits,StringBuilder sb,int index)
    {
        //判断结束条件
        if(index==digits.length())
        {
            res.add(sb.toString());
            return;
        }
        String s=str[digits.charAt(index)-'0'];
        //选择s中的一个字符
        for(int i=0;i<s.length();i++)
        {
            sb.append(s.charAt(i));
            dfs(digits,sb,index+1);
            //回溯
            sb.deleteCharAt(index);
        }
        return;
    }
}
Ys20
关注
专栏目录
DFS回溯-经典全排列问题（力扣）
m0_51305283的博客
03-07 599
对于全排列问题，常用的做法是设置一个vis数组来确定位置i上的数字是否被访问，因为是全排列问题，所以不同的顺序也是不一样的排列，因此每次都是从起点开始询问**(注意起点到底是0还是1)**
[算法题解详细]DFS解力扣46全排列
2401_84092574的博客
04-20 931
技术是没有终点的，也是学不完的，最重要的是活着、不秃。零基础入门的时候看书还是看视频，我觉得成年人，何必做选择题呢，两个都要。喜欢看书就看书，喜欢看视频就看视频。最重要的是在自学的过程中，一定不要眼高手低，要实战，把学到的技术投入到项目当中，解决问题，之后进一步锤炼自己的技术。技术学到手后，就要开始准备面试了，找工作的时候一定要好好准备简历，毕竟简历是找工作的敲门砖，还有就是要多做面试题，复习巩固。有需要面试题资料的朋友点击这里可以免费领取。
力扣dfs
qq_45598881的博客
11-15 728
DFS（深度优先搜索） 深度优先搜索也可以用来检测环路：记录每个遍历过的节点的父节点，若一个节点被再次遍历且父节点不同，则说明有环。我们也可以用之后会讲到的拓扑排序判断是否有环路，若最后存在入度不为零的点，则说明有环。 有时我们可能会需要对已经搜索过的节点进行标记，以防止在遍历时重复搜索某个节点，这种做法叫做状态记录或记忆化（memoization）。 给定一个二维的 0-1 矩阵，其中 0 表示海洋，1 表示陆地。单独的或相邻的陆地可以形成岛屿，每个格子只与其上下左右四个格子相邻。求最大的岛屿面积。 In
[算法题解详细]回溯解力扣46全排列
2401_84092903的博客
04-20 897
技术是没有终点的，也是学不完的，最重要的是活着、不秃。零基础入门的时候看书还是看视频，我觉得成年人，何必做选择题呢，两个都要。喜欢看书就看书，喜欢看视频就看视频。最重要的是在自学的过程中，一定不要眼高手低，要实战，把学到的技术投入到项目当中，解决问题，之后进一步锤炼自己的技术。技术学到手后，就要开始准备面试了，找工作的时候一定要好好准备简历，毕竟简历是找工作的敲门砖，还有就是要多做面试题，复习巩固。有需要面试题资料的朋友点击这里可以免费领取。
[算法题解详细]回溯解力扣46全排列(1)
2401_84092868的博客
04-20 865
由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！点击【学习资料】即可免费领取！篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！点击【学习资料】即可免费领取！[外链图片转存中…(img-B75O1rfm-1713608669400)][外链图片转存中…(img-GcRZn5JE-1713608669400)]
力扣爆刷第175天之回溯全家桶（组合、排列、子集、分割、棋盘）
qq_43511039的博客
09-05 980
力扣爆刷第175天之回溯全家桶 文章目录力扣爆刷第175天之回溯全家桶零、回溯题心法：模板：一、77. 组合二、216. 组合总和 III三、17. 电话号码的字母组合四、39. 组合总和五、40. 组合总和 II六、131. 分割回文串七、93. 复原 IP 地址八、78. 子集九、90. 子集 II十、491. 非递减子序列十一、46. 全排列十二、47. 全排列 II十三、332. 重新安排行程十四、51. N 皇后十五、37. 解数独 零、回溯题心法： 心法一共分两步，第一步熟背心法，第二步学会分辨
力扣207、210
qq_45678698的博客
09-25 428
第六十九天 --- 力扣207、210前言题目一思路图的存储（有向图）拓扑排序拓扑排序实现DFSBFS代码：（DFS+BFS）DFSBFS 前言 207 和 210 本质上一个题，就是改变了输出结果而已，我这两个题一个用于学习，一个用于自我检验，看是否真的搞懂了，建议读者也这么尝试。 题目一 力扣:207 力扣:210 思路 图的存储（有向图） 1、根据题意，有一系列的课程以及课程之间的顺序，课程抽象成节点，课程之间的顺序是边，有点集和边集，经典图的问题，所以第一个事情就是图到底该咋存。 2、最常用的方
力扣刷题笔记：回溯、广搜、深搜、矩阵（18）
小竤的博客
07-09 338
46. 全排列 1、用二维数组代替输出数组。 2、用左右标记代替标记数组，但这样的操作输出不是有序，若有序应使用标记数组。 void backtrack(vector<vector<int>>& res, vector<int>& output, int first, int len){ // 所有数都填完了 if (first == len) { res.emplace_back(outpu
[算法题解详细]DFS解力扣78子集
2401_84092694的博客
04-20 867
面试题千万不要死记，一定要自己理解，用自己的方式表达出来，在这里预祝各位成功拿下自己心仪的offer。需要完整面试题的朋友可以点击蓝色字体免费获取[外链图片转存中…(img-src1LpV2-1713608509986)][外链图片转存中…(img-oMIl2vsY-1713608509986)][外链图片转存中…(img-Cw6ideTV-1713608509987)][外链图片转存中…(img-dsLpeY3p-1713608509987)]
回溯算法整理学习（C++版）
bianxia123456的博客
06-06 538
写在前面 最开始接触回溯算法是八皇后问题，经典的N皇后问题，当时看了代码就觉得很神奇，但是理解不了为什么是这样的，当时在2n皇后python版一文里面写的题解是 2n皇后问题，解决这个先要知道n皇后问题的解法。下面我们先介绍一下n皇后问题。 n皇后问题是有nxn的棋盘，有n个皇后，皇后与皇后之间不能在同一行，同一列，以及对角线上。问皇后能有多少种排列方式（皇后都是一样的）。 我们采用两个函数，一个函数判断皇后在这个位置上是否合法（是否同行，是否同列，是否对角线）。 另一个函数用来深搜，搜到一条符合条件的路
写给零基础的前端算法入门指南，acmer带女友刷80+【递归与回溯篇】｜牛气冲天新年征文
超逸の学习技术博客
02-16 3314
前言 各位小伙伴们新年好呀，时隔一周，俺又回来更新文章啦！在上一篇发出去之后，虽然没有得到很多的阅读量，但是后面几篇文章还是得要更新出来，我想总能够帮助一小部分人咯~ 现在和大家分享一下我们是如何准备算法这一块的，春招即将开启，还能最后准备一下，希望对大家有所帮助。 原本打算通过一篇文章介绍一下，推荐一下自己的刷题方式和刷题路线，得到一些伙伴的反馈：最好还是更加详细，面向零基础，小白这些，还有github访问速度也是一方面问题，可能图片都加载不出来。 因此，我打算分模块出几期文章，这样你只用通过首发在.
20210702力扣第322题：零钱兑换(java)
EenKine的博客
07-02 1105
题目 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。 你可以认为每种硬币的数量是无限的。 示例 1： 输入：coins = [1, 2, 5], amount = 11 输出：3 解释：11 = 5 + 5 + 1 示例 2： 输入：coins = [2], amount = 3 输出：-1 示例 3： 输入：coins = [1], amount = 0 输出：0 示例 4： 输
力扣刷题笔记
weixin_53536363的博客
05-05 277
力扣刷题笔记
21天力扣打卡记录
qq_52598196的博客
11-13 405
21天力扣打卡记录
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5154
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
LeetCode 每日一题 2024/9/23-2024/9/29
AlphaTao的博客
09-28 496
记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步
LeetCode 面试经典150题 66.加一
qq_57349657的博客
09-27 323
加一
LeetCode[中等] 739. 每日温度
最新发布
Theolulu的博客
09-30 440
给定一个整数数组，表示每天的温度，返回一个数组answer，其中answer[i]是指对于第i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0来代替。
力扣 回溯算法 java
10-18
在递归函数中，我们首先将当前状态加入到解集中，然后从当前位置开始搜索下一个状态。在搜索下一个状态时，我们将当前元素加入到路径中，并递归调用自身来搜索下一个状态。当搜索完所有可能的状态后，我们需要回溯到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值