Unique Paths

一开始用了搜索的算法，结果超时了。

基本想法是：建一个数组，向下走记为1，向右走记为2那么就是一个由m-1个1，n-1个2的 数组，那么我们求由这些数组成的，但是不重复的数组的个数，即为我们要求的结果（算法复杂度确实高了些）

代码如下：

class Solution {
private:
    int ans;
public:
    int uniquePaths(int m, int n) {
        if(m==0||n==0||(m==1&&n==1)) return 0;
        int steps = m+n-2;
        int *num = new int [steps];
        for(int i = 0;i<m-1;i++)
            num[i] = 1;
        for(int i = m-1;i<steps;i++)
            num[i] = 2;
        bool *used = new bool [steps];
        memset(used,false,sizeof(bool)*steps);
        ans = 0;
        solve(steps,used,num,0);
        
        return ans;
    }
    void solve(int steps,bool *used, int *num,int dep)
    {
        if(dep == steps)
        {
            ans++;
            return;
        }
        for(int i = 0;i<steps;i++)
        {
            if(num[i]==num[i-1]&&i>0&&used[i-1]==0)
                continue;
                
            used[i] = true;
            solve(steps,used,num,dep+1);
            used[i] = false;
        }
    }
};

后来看了别人的博客，才发现用DP，确实，卷进了自己的想法拔不出来，连这个都没有想到- -

基本想法是：因为只能向下和向右走，那么当前点只能由它的左边一个点和右边一个点走到，那么我们只要算出来走到那两个点的解法有多少，加起来就是我们想要的结果了

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int> > f(m, vector<int>(n));
        
        for(int i = 0; i < n; i++)
            f[0][i] = 1;
            
        for(int i = 0; i < m; i++)
            f[i][0] = 1;
            
        for(int i = 1; i < m; i++)
            for(int j = 1; j < n; j++)
                f[i][j] = f[i-1][j] + f[i][j-1];
                
        return f[m-1][n-1];
    }
};