leetcode刷题——算法（6）:搜索

最新推荐文章于 2023-04-06 18:06:35 发布
最新推荐文章于 2023-04-06 18:06:35 发布
阅读量317 收藏
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37772475/article/details/104401278
版权

搜索（2.15）

 

 

BFS

1. 计算在网格中从原点到特定点的最短路径长度

修改后做出

 

2. 组成整数的最小平方数数量（2.16）

一开始未做出

※

3. 最短单词路径

思考后做出

 

DFS

1. 查找最大的连通面积

思考后做出

 

2. 矩阵中的连通分量数目

可做出Ok，解法可简化

 

3. 好友关系的连通分量数目

一开始未做出

※

4. 填充封闭区域

一开始未做出

※

5. 能到达的太平洋和大西洋的区域（2.17）

一开始未做出，其实类上。

思维要灵活！

※

Backtracking

1. 数字键盘组合

一开始未做出

※

2. IP 地址划分

一开始未做出

※

3. 在矩阵中寻找字符串

思考后做出

 

4. 输出二叉树中所有从根到叶子的路径

思考后做出

 

5. 排列

思考后做出

 

6. 含有相同元素求排列

一开始未做出

※

7. 组合

修改后做出

※

8. 组合求和

修改后做出

 

9. 含有相同元素的组合求和

修改后做出

 

10. 1-9 数字的组合求和

思考后做出

 

11. 子集

可做出Ok，解法可优化

※

12. 含有相同元素求子集

可做出Ok

 

13. 分割字符串使得每个部分都是回文数

可做出Ok

 

14. 数独（2.18）

一开始未做出

※

15. N 皇后

思考后做出

 

BFS

在程序实现 BFS 时需要考虑以下问题：

  • 队列：用来存储每一轮遍历得到的节点；
  • 标记：对于遍历过的节点，应该将它标记，防止重复遍历。
  • 层数：如果需要层数，可以建立结构体

1. 计算在网格中从原点到特定点的最短路径长度

1091. Shortest Path in Binary Matrix(Medium)

https://leetcode-cn.com/problems/shortest-path-in-binary-matrix/

2. 组成整数的最小平方数数量

279. Perfect Squares (Medium)

https://leetcode-cn.com/problems/perfect-squares/

1.	动态规划
class Solution {
public:
    int numSquares(int n) {
        int dp[n+1];
        for(int i=0;i<=n;i++) 
            dp[i]=i;
        for(int i=4;i<=n;i++)
            for(int j=1;i-j*j>=0;j++)
                if(dp[i-j*j]+1<dp[i]) dp[i]=dp[i-j*j]+1;
        return dp[n];
    }
};
2.	BFS
class Solution {
public:
    int numSquares(int n) {
        vector<bool> flag(n,true);
        queue<int> q;
        q.push(n);
        int step=0;
        while(!q.empty()){
            for(int i=q.size();i>0;i--){
                int cur=q.front();
                if(cur==0) return step;
                q.pop();
                for(int j=1;cur-j*j>=0;j++)
                    if(flag[cur-j*j]){
                        q.push(cur-j*j);
                        flag[cur-j*j]=false;
                    }
            }
            step++;
        }
        return -1;        
    }
};

3. 最短单词路径

127. Word Ladder (Medium)

https://leetcode-cn.com/problems/word-ladder/

DFS

在程序实现 DFS 时需要考虑以下问题：

  • 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
  • 标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。

1. 查找最大的连通面积

695. Max Area of Island (Medium)

https://leetcode-cn.com/problems/max-area-of-island/

2. 矩阵中的连通分量数目

200. Number of Islands (Medium)

https://leetcode-cn.com/problems/number-of-islands/

3. 好友关系的连通分量数目

547. Friend Circles (Medium)

https://leetcode-cn.com/problems/friend-circles/

1.	DFS
非递归解法
class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        int n=M.size(),res=0;
        bool visited[n];
        memset(visited,false,n);

        stack<int> st;
        for(int i=0;i<n;i++){
            if(visited[i]) continue;
            res++;
            visited[i]=true;
            st.push(i);
            while(!st.empty()){
                int cur=st.top();
                st.pop();
                for(int j=0;j<n;j++)
                    if(M[cur][j]==1&&!visited[j]){
                        visited[j]=true;
                        st.push(j);
                    }
            }
        }
        return res;        
    }
};
递归解法
class Solution {
public:
    void dfs(vector<vector<int>>& M,bool visited[],int i,int n){
        for(int j=0;j<n;j++)
            if(M[i][j]==1&&!visited[j]){
                visited[j]=true;
                dfs(M,visited,j,n);
            }
    }
    int findCircleNum(vector<vector<int>>& M) {
        int n=M.size(),res=0;
        bool visited[n];
        memset(visited,false,n);

        for(int i=0;i<n;i++)
            if(!visited[i]){
                res++;
                dfs(M,visited,i,n);
            } 
        return res;        
    }
};

2.	并查集
class Solution {
public:
    int findParent(int parents[],int i){
        if(parents[i]==-1) return i;
        else return findParent(parents,parents[i]);
    }
    void Union(int parents[],int a,int b){
        int fa=findParent(parents,a);
        int fb=findParent(parents,b);
        if(fa!=fb) parents[fa]=fb;
    }
    int findCircleNum(vector<vector<int>>& M) {
        int n=M.size(),res=0;
        int parents[n];
        memset(parents,-1,n*sizeof(int));
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                if(M[i][j]==1) Union(parents,i,j);
        for(int i=0;i<n;i++)
            if(parents[i]==-1) res++;
        return res;        
    }
};

4. 填充封闭区域

130. Surrounded Regions (Medium)

https://leetcode-cn.com/problems/surrounded-regions/

1.	DFS
class Solution {
public:
int loc[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
//非递归解法
    void dfs(vector<vector<char>>& board,int i,int j,int m,int n){
        board[i][j]='-';
        stack<pair<int,int>> st;
        st.push(make_pair(i,j));
        while(!st.empty()){
            pair<int,int> cur=st.top();
            int i=cur.first,j=cur.second;
            st.pop();
            for(int k=0;k<4;k++){
                int x=i+loc[k][0],y=j+loc[k][1];
                if(x<0||x>=m||y<0||y>=n||board[x][y]!='O') continue;
                board[x][y]='-';
                st.push(make_pair(x,y));
            }
        }
}

//递归解法
void dfs(vector<vector<char>>& board,int i,int j,int m,int n){
        board[i][j]='-';
        for(int k=0;k<4;k++){
            int x=i+loc[k][0],y=j+loc[k][1];
            if(x<0||x>=m||y<0||y>=n||board[x][y]!='O') continue;
            dfs(board,x,y,m,n);
        }
    }

    void solve(vector<vector<char>>& board) {
        if(board.size()==0) return ;
        int m=board.size(),n=board[0].size();
        for(int i=0;i<m;i++){
            if(board[i][0]=='O')
                dfs(board,i,0,m,n);
            if(board[i][n-1]=='O')
                dfs(board,i,n-1,m,n);
        }
        for(int i=0;i<n;i++){
            if(board[0][i]=='O')
                dfs(board,0,i,m,n);
            if(board[m-1][i]=='O')
                dfs(board,m-1,i,m,n);
        }
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++){
                if(board[i][j]=='O')
                    board[i][j]='X';
                else if(board[i][j]=='-')
                    board[i][j]='O';
            }
    }
};

 

5. 能到达的太平洋和大西洋的区域

417. Pacific Atlantic Water Flow (Medium)

https://leetcode-cn.com/problems/pacific-atlantic-water-flow/

从边界开始遍历！

class Solution {
public:
    int loc[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
    void dfs(vector<vector<int>>& matrix,int x,int y,int m,int n,vector<vector<bool>>& canReach){
        if(canReach[x][y]) return;
        canReach[x][y]=true;
        for(int i=0;i<4;i++){
            int xx=x+loc[i][0],yy=y+loc[i][1];
            if(xx<0||xx>=m||yy<0||yy>=n||matrix[x][y]>matrix[xx][yy]) continue;
            dfs(matrix,xx,yy,m,n,canReach);
        }
    }
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        vector<vector<int>> res;
        if(matrix.size()==0) return res;
        int m=matrix.size(),n=matrix[0].size();
        vector<vector<bool>> canReachP(m,vector<bool>(n,false)),canReachX(m,vector<bool>(n,false));

        for(int i=0;i<n;i++){
            dfs(matrix,0,i,m,n,canReachP);
            dfs(matrix,m-1,i,m,n,canReachX);
        }
        for(int i=0;i<m;i++){
            dfs(matrix,i,0,m,n,canReachP);
            dfs(matrix,i,n-1,m,n,canReachX);
        }
        int cnt=0;
        for(int i=0;i<m;i++)
           for(int j=0;j<n;j++){
               if(canReachP[i][j]&&canReachX[i][j])
               res.push_back((vector<int>{i,j}));
           }

        return res;
    }
};

Backtracking

Backtracking（回溯）属于 DFS。

  1. 普通 DFS 主要用在 可达性问题 ，这种问题只需要执行到特点的位置然后返回即可。
  2. 而 Backtracking 主要用于求解 排列组合 问题，例如有 { 'a','b','c' } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。

因为 Backtracking 不是立即返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：

  1. 在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样才能在继续递归调用时不用重复访问该元素；
  2. 但是在递归返回时，需要将元素标记为未访问，因为只需要保证在一个递归链中不同时访问一个元素，可以访问已经访问过但是不在当前递归链中的元素。

1. 数字键盘组合

17. Letter Combinations of a Phone Number (Medium)

https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/

class Solution {
public:
    string tel[10]={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    void dfs(string digits,string str,vector<string>& res){
        if(str.size()==digits.size()){
            res.push_back(str);
            return;
        }
        string tmp=tel[digits[str.size()]-'0'];
        for(auto c:tmp){
            str+=c;
            dfs(digits,str,res);
            str.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) {
        vector<string> res;
        if(digits.size()==0) return res;
        dfs(digits,"",res);
        return res;
    }
};

 2. IP 地址划分

93. Restore IP Addresses(Medium)

https://leetcode-cn.com/problems/restore-ip-addresses/

class Solution {
public:
    void dfs(string s,int n,string ip,vector<string>& res){
        if(n==4||s.empty()){
            if(s.empty()&&n==4) res.push_back(ip);
            return;
        }
        if(s[0]=='0'){
            dfs(s.substr(1),n+1,ip+s.substr(0,1)+((n!=3)?".":""),res);
            return;
        }
        int range=(s.size()<3)?s.size():3;
        for(int i=1;i<=range;i++){
            int num=stoi(s.substr(0,i));
            if(num>255||s.size()-i+1>3*(4-n)) break;
            dfs(s.substr(i),n+1,ip+s.substr(0,i)+((n!=3)?".":""),res);
        }
    }
    vector<string> restoreIpAddresses(string s) {
        vector<string> res;
        if(s.empty()) return res;
        dfs(s,0,"",res);
        return res;        
    }
};

 

3. 在矩阵中寻找字符串

79. Word Search (Medium)

https://leetcode-cn.com/problems/word-search/submissions/

4. 输出二叉树中所有从根到叶子的路径

257. Binary Tree Paths (Easy)

https://leetcode-cn.com/problems/binary-tree-paths/

5. 排列

46. Permutations (Medium)

https://leetcode-cn.com/problems/permutations/

6. 含有相同元素求排列

47. Permutations II (Medium)

https://leetcode-cn.com/problems/permutations-ii/

class Solution {
public:
    void backTracking(vector<vector<int>>& res,vector<int>& nums,vector<int> tmp,vector<bool> flag){
        if(nums.size()==tmp.size()){
            res.push_back(tmp);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(i!=0&&nums[i]==nums[i-1]&&!flag[i-1])  //含相同元素写法
                   continue;
            if(flag[i]) continue;
            flag[i]=true;
            tmp.push_back(nums[i]);
            backTracking(res,nums,tmp,flag);
            tmp.pop_back();
            flag[i]=false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> res;
        if(nums.size()==0) return res;
        sort(nums.begin(),nums.end());
        vector<bool> flag(nums.size(),false);
        backTracking(res,nums,vector<int>(),flag);
        return res;
    }
};

7. 组合

77. Combinations (Medium)

https://leetcode-cn.com/problems/combinations/

class Solution {
public:
    void backTracking(vector<vector<int>>& res,vector<int> tmp,int val,int n,int k){
        if(k==0){
            res.push_back(tmp);
            return;
        }
        for(int i=val;i<=n;i++){    //组合写法，i从val开始；排序从0开始
            tmp.push_back(i);       //不需要flag
            backTracking(res,tmp,i+1,n,k-1);
            tmp.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> res;
        if(k==0) return res;
        backTracking(res,vector<int>(),1,n,k);
        return res;
    }
};

8. 组合求和

39. Combination Sum (Medium)

https://leetcode-cn.com/problems/combination-sum/

9. 含有相同元素的组合求和

40. Combination Sum II (Medium)

https://leetcode-cn.com/problems/combination-sum-ii/

10. 1-9 数字的组合求和

216. Combination Sum III (Medium)

https://leetcode-cn.com/problems/combination-sum-iii/

11. 子集

78. Subsets (Medium)

https://leetcode-cn.com/problems/subsets/

class Solution {
public:
    void backTracking(vector<vector<int>>& res,vector<int>& nums,vector<int> tmp,int st,int n){
        if(tmp.size()==n){
            res.push_back(tmp);
        }
        for(int i=st;i<nums.size();i++){
            tmp.push_back(nums[i]);  //不需要flag
            backTracking(res,nums,tmp,i+1,n);
            tmp.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res;
        for(int i=0;i<=nums.size();i++)
            backTracking(res,nums,vector<int>(),0,i);
        return res;
    }
};

12. 含有相同元素求子集

90. Subsets II (Medium)

https://leetcode-cn.com/problems/subsets-ii/

需要flag，解法类似9

13. 分割字符串使得每个部分都是回文数

131. Palindrome Partitioning (Medium)

https://leetcode-cn.com/problems/palindrome-partitioning/

14. 数独

37. Sudoku Solver (Hard)

https://leetcode-cn.com/problems/sudoku-solver/

从最左上角的方格开始 row = 0, col = 0。直到到达一个空方格。

  1. 从1 到 9 迭代循环数组，尝试放置数字 d 进入 (row, col) 的格子。
  2. 如果数字 d 还没有出现在当前行，列和子方块中：
  • 将 d 放入 (row, col) 格子中。
  • 记录下 d 已经出现在当前行，列和子方块中。
  • 如果这是最后一个格子row == 8, col == 8 ：

意味着已经找出了数独的解。

  • 否则，放置接下来的数字。
  • 如果数独的解还没找到：

将最后的数从 (row, col) 移除。

class Solution {
public:
    bool rowUsed[9][10]={false};
    bool colUsed[9][10]={false};
    bool cubeUsed[9][10]={false};
    int cube(int row,int col){
        return (row/3)*3+col/3;
    }
    bool backTracking(vector<vector<char>>& board,int row,int col){
        while(row<9&&board[row][col]!='.'){
            row=(col==8)?row+1:row;
            col=(col==8)?0:col+1;
        }
        if(row==9) return true;
        for(int i=1;i<=9;i++){
            if(rowUsed[row][i]||colUsed[col][i]||cubeUsed[cube(row,col)][i]) 
                continue;
            board[row][col]='0'+i;
            rowUsed[row][i]=colUsed[col][i]=cubeUsed[cube(row,col)][i]=true;
            if(backTracking(board,row,col)) return true;
            rowUsed[row][i]=colUsed[col][i]=cubeUsed[cube(row,col)][i]=false;
            board[row][col]='.';
        }
        return false;
    }
    void solveSudoku(vector<vector<char>>& board) {
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++){
                if(board[i][j]=='.') continue;
                int num=board[i][j]-'0';
                rowUsed[i][num]=true;
                colUsed[j][num]=true;
                cubeUsed[cube(i,j)][num]=true;
            }
        backTracking(board,0,0);
    }
};

15. N 皇后

51. N-Queens (Hard)

https://leetcode-cn.com/problems/n-queens/

sevenjoy007
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题——Complex multiplication复数乘法
12-21
复数乘法题目的思路探讨与源码 复数乘法的题目如下图，该题属于字符串类的题目，主要考察split函数以及字符串函数转整型以及四则运算，虽然属于中级但是难度相对较低。只要区分实数部分和虚数部分即可。...
c++ pair详解
lwgkzl的博客
11-18 1万+
总述： 介绍pair的基本用法，包括pair的创建，排序，使用特性等 1.pair的创建 a.pair&lt;int,int&gt; p或者pair&lt;int,int&gt;p(0,1). b.可以使用make_pair()函数创建一个临时的pair变量,常用作pair作为函数参数时，参数的赋值。make_pair(0,1) c.一般我们可以在using namespace std;...
堆栈刷题记录（更新中）
m0_54229235的博客
04-06 79
是上一篇的后续，特别说明，以下序号均为力扣序号。
LeetCode——BFS
努力努力再努力L
12-04 236
BFS 目录 BFS 介绍 计算在网格中从原点到特定点的最短路径长度 组成整数的最小平方数数量 最短单词路径 1. BFS 介绍 广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。 需要注意的是，遍历过的节点不能再次被遍历。 第一层： 0 -> {6,2,1,5} 第二层： 6 -> {4} 2 -> {} 1 -&g...
C 用DFS(深度优先搜索)求连通块个数
AK_Lady的博客
05-06 4451
图描述的是一些个体之间的关系。与线性表和二叉树不同的是：这些个体之间既不是前驱后继的顺序关系，也不是祖先后代的层次关系，而是错综复杂的网状关系。       和二叉树的遍历类似，图也有DFS和BFS遍历，由于DFS更容易编写，一般用DFS找连通块。下面用一个例子说明。       例题：输入一个m行n列的字符矩阵，统计字符“@”组成多少个八连块。如果两个字符“@”所在的格子相邻（横、纵或者
聚类方法：DBSCAN算法研究（2）--matlab代码实现
热门推荐
zhouxianen1987的博客
04-01 4万+
DBSCAN聚类算法三部分： 1、DBSCAN原理、流程、参数设置、优缺点以及算法； 2、matlab代码实现； 3、C++代码实现及与matlab实例结果比较。 摘要：介绍DBSCAN原理、流程、参数设置、优缺点以及算法的matlab和C++代码实例。
leetcode2-LeetCode_Python3:Leetcode算法刷题——Python3
06-29
Leetcode刷题笔记整理——Python3 By Xyao 本人从2020/04/25开始正式在LeetCode上刷题，于2020/07/04完整刷完一遍剑指offer系列，边刷题边整理笔记。（此处特别感谢LeetCode解题区及评论区的大佬们提供的一些优质...
谷歌师兄的leetcode刷题笔记-References::green_book:一个收集所有参考资料的地方
06-30
谷歌师兄的leetcode刷题笔记参考 :blue_book: Google 的 TensorFlow Lite 是世界上最受欢迎的机器学习框架之一的小兄弟，它专注于这一点——在资源受限的设备上运行神经网络推理 :blue_book: 能够模拟 RISC V 的 ...
leetcode卡-leetcode-practice::cloud:Chittyのleetcode刷题记录:writing_hand:
07-06
此项目记录了Chitty的leetcode刷题日常，写算法难，用js写算法更难。Be a better coding girl 道阻且长。 使用方法 建议clone到本地查看，可以随便学习一下自动化测试插件Jest 简单说就是 Code目录下建立XXX.js,Test...
蓄水池算法leetcode-LeetCode:LeetCode刷题
06-30
蓄水池算法 leetcode LeetCode 一、编译器 （1）Visual Studio Code 简单的代码都用 VSCode 来实现。 （2）Visual Studio 复杂的代码（查找内存溢出）使用 VS 进行调试。 二、代码——C/C++ （1）所有代码都是 gcc(c...
将包含字符数字的字符串分开,使得分开后的字符串前一部分是数字后一部分是字母 （施振振）
maenda的博客
06-11 2630
#include char * formate(char s[])        //这个函数实现字母和数字的分离 {     char ch[100],num[100];    //定义了两个字符型数组 ch mun     int i=0,j=0,k=0;          //定义了三个整型变量     while(s[i]!='\0')             // 用whi
hdu 1856 More is better 并查集
LYHVOYAGE的专栏
05-27 6348
More is better                                                                    Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 327680/102400 K (Java/Others) Problem Description Mr
HDU1856——最大连通分量的节点个数
六天
04-14 5148
并查集的重要应用是求无向图的连通分量或者求连通子图的个数。 在这里解释一下有关连通分量的一些术语。 1.[连通] 在无向图中，如果从顶点vi到顶点vj有路径，则称vi和vj连通。 2.[连通图] 如果图中任意两个顶点之间都连通，则称该图为连通图，否则，称该图为非连通图。 3.[连通分量] 非连通图的极大连通子图称为连通分量，这里所谓的极大是指子图中包含的顶
Leetcode题解-算法-搜索
桑凯旋的博客
08-28 397
文章目录1、BFS1.1 将一个数分解为整数的平方和 1、BFS 1.1 将一个数分解为整数的平方和 279. Perfect Squares(Medium) Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, …) which sum to...
leetcode经典题目（11）--BFS和DFS
我只钓小鱼的博客
09-02 598
矩阵中的最短路径；连通面积，连通分支；数字的排列（有重复与无重复）；组合之和（有序和无序，可重复和不可重复）；子集（有重复和无重复）；分割回文串；字符串与矩阵路径
LeetCode题解——77：组合
努力中的老周的专栏
03-17 168
题目相关 题目链接 LeetCode中国，https://leetcode-cn.com/problems/combinations/。注意需要登录。 题目描述 给定两个整数n和k，返回 1 ...n中所有可能的k个数的组合。 示例 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], ...
前端算法 岛屿的最大面积 DFS(深度优先搜索)
weixin_43779957的博客
08-09 371
给定一个包含了一些 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
leetcode-----一个机器人在m×n大小的地图的左上角。 机器人每次向下或向右移动。机器人要到达地图的右下角。可以有多少种不同的路径从起点走到终点？
sunnnnh的博客
07-11 2060
题目描述 一个机器人在m×n大小的地图的左上角（起点，下图中的标记“start"的位置）。 机器人每次向下或向右移动。机器人要到达地图的右下角。（终点，下图中的标记“Finish"的位置）。 可以有多少种不同的路径从起点走到终点？ 上图是3×7大小的地图，有多少不同的路径？ 备注：m和n小于等于100 public int uniquePaths (int m, int n) { int[][] dp = new int[m][n]; .
【LeetCode】46 全排列 (C++)
rabbitsockx的博客
12-12 931
原题地址：https://leetcode-cn.com/problems/permutations/submissions/ 题目描述： 给定一个没有重复数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [   [1,2,3],   [1,3,2],   [2,1,3],   [2,3,1],   [3,1,2],   [3,2,1] ] 解题方案： 全排...
leetcode刷题手册c++版
最新发布
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值