一共多少种路径

路径里找最小：dp/bfs

一共多少种：dp/dfs

1、m*n  不同路径共多少种

leetcode 62:  m*n矩阵从左上角走到右下角有多少种，右/下两种走法，其实就是两者相加。

优化：当前点的值都是由左边的格子和上面的格子的总路径计算而来， 对于之前更早的数据，其实已经用不到了 。也就是只需要pre和当前的上一个的值就好了。因此一维数组就ok pre[j]=pre[j-1]+pre[j]; 也就是当前这个点，等于当前这个list的左边+上一个list这个位置的值

int lujing_1(){
    int m,n;cin>>m>>n;
    //m*n矩阵从左上角走到右下角有多少种，右/下两种走法，其实就是两者相加。
    //方法1
    vector< vector<int> > dp(m+1,vector<int>(n+1,0));
    dp[1][1]=1;
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++){
            if(i==1&&j==1) continue;
            dp[i][j]=dp[i-1][j]+dp[i][j-1];
        }
    cout<<dp[m][n]<<endl;
    //方法2
    vector<int> pre(n,1);
    for(int i=1;i<m;i++)
        for(int j=1;j<n;j++)
            pre[j]+=pre[j-1];
    cout<<pre[n-1];
}

2、m*n  有障碍物 不同路径共多少种

leetcode 63:  m*n矩阵从左上角走到右下角，有障碍物，有多少种，右/下两种走法，如果当前点不是障碍物就还是两者相加，是障碍物就归0.但是要注意边界，第一行和第一列，要看他上面/左边是不是0，如果前面的有0，那后面的就都是0了。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
    if(obstacleGrid.size()==0)   return 0;
    vector<long long> dp(obstacleGrid[0].size(),0);
    long long ok=1;
    for (int i = 0; i < obstacleGrid.size(); ++i) {
         if(obstacleGrid[i][0]==1) ok=0;
        dp[0]=ok;
        for(int j=1;j<obstacleGrid[0].size();j++)
       { if(obstacleGrid[i][j]==1) dp[j]=0;
        else dp[j]=dp[j]+dp[j-1];
       }
    }
    return dp[obstacleGrid[0].size()-1];
    }
};

3、m*n  有障碍物 都要遍历到 不同路径共多少种

leetcode 980 要都遍历到，先统计要遍历多少次，之后可以设置一个变量，遍历过了就--。在到终点的时候如果都遍历到了就放路径里。

class Solution {
public:

int dx[4]={-1,1,0,0};
int dy[4]={0,0,-1,1};

void dfs_1(int nowi,int nowj,vector<vector<int> > visited,vector<vector<int> > grid,int todo,int &ans,int ex,int ey){
    //当前nowi,nowj一定是可以被遍历到的并且visited和todo已经改过了。
    if(nowi==ex && nowj==ey && todo==0)
    {
        ans++;
        return;
    }
    if(todo<=0) return;
    for(int i=0;i<4;i++){
        int nowx=nowi+dx[i];
        int nowy=nowj+dy[i];
        if(nowx>=0 && nowx<grid.size() && nowy>=0 && nowy<grid[0].size() && !visited[nowx][nowy] && grid[nowx][nowy]!=-1){
            visited[nowx][nowy]=1;todo--;
            dfs_1(nowx,nowy,visited,grid,todo,ans,ex,ey);
            visited[nowx][nowy]=0;todo++;
        }
    }
}

    int uniquePathsIII(vector<vector<int>>& grid) {
    if(grid.size()==0||grid[0].size()==0)  return 0;
    vector<vector<int>> visited(grid.size(),vector<int>(grid[0].size(),0));
    int sx,sy,ex,ey,todo=0,ans=0;
    for(int i=0;i<grid.size();i++)
        for(int j=0;j<grid[0].size();j++)
        {
            if(grid[i][j]==1) {sx=i;sy=j;todo++;}
            else if(grid[i][j]==2) {ex=i;ey=j;todo++;}
            else if(grid[i][j]==-1) {visited[i][j]=1;}
            else  todo++;
        }
    visited[sx][sy]=1; todo--;
    dfs_1(sx,sy,visited,grid,todo,ans,ex,ey);
    return ans;
    }
};