leetcode62. Unique Paths

题目

题目：题目链接

方法一：杨辉三角

这题我其实第一反应是排列组合的数学题，就是一共要走n+m-2次，然后其中要走n-1次右行。也就是组合数C(n-1,n+m-2),当然如果m<n是用C(m-1,n+m-2)的，减少计算量嘛。然后呢组合数就是杨辉三角嘛，这题就算完了。那先打印个杨辉三角吧：

#include<iostream>
#include<vector>
using namespace std;
/*---------------------打印杨辉三角---------------------*/
typedef long long ll;
const int max_size = 200;
vector<vector<ll> > arr(max_size + 5, vector<ll>(max_size + 5, 0));/*存放杨辉三角，从下标1开始*/
/*公式1：C(n,m) = C(n-1,m-1) + C(n,m-1)
*C(n,m)表示从m个不同元素中挑选出n个。
*该等式简单证明：可以先假定一个元素在外面，其余m-1个元素在一起。若该元素在n中，则还需要从m-1个不同元素中挑选出n-1个。
*若不在则需要从需要从m-1个不同元素中挑选出n个。
*/
void YangHuiTri() {
	/*杨辉三角两边都是1*/
	for (int i = 1; i <= max_size; ++i) {
		arr[i][1] = arr[i][i] = 1;
	}
	/*由于前两行已经在上一步形成了，所以从第三行开始*/
	for (int i = 3; i <= max_size; ++i) {
		for (int j = 2; j <= i-1; ++j) {/*每行第一个和最后一个都是1哦*/
			arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];/*由公式1得到*/
		}
	}
}
int main() {
	YangHuiTri();
	int n = 
	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= i; ++j) {
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}
	return 0;
}

根据这个想法可以写出AC代码：

 vector<vector<int> > arr = vector<vector<int> >(105, vector<int>(105, 1));/*先所有都赋值1*/
    void YangHuiTri(int n) {
        /*因为杨辉三角两边都是1，但我们初始化arr是用1初始化的，所以不需要再循环一次了*/
        for (int i = 3; i <= n; ++i) {/*前面两行都是1*/
            for (int j = 2; j <= i - 1; ++j) {/*第一列是1哦*/
                if (arr[i - 1][j - 1] <= 2e9 - arr[i - 1][j])//加法会溢出，不加这里会RE
                    arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                else break;
            }
        }
    }
    int slove1(int m, int n) {
        if (m == 1 || n == 1) return 1;
        if (m == 2 || n == 2) return m + n - 2;
        if (m < n) swap(m, n);
        YangHuiTri(m + n - 1);
        return arr[m + n - 1][n];/*第m行的第n个数可表示为 C(m-1，n-1),所以对于C(m+n-2,n-1)是第m+n-1行的第n个数*/
    }

注： if (arr[i - 1][j - 1] <= 2e9 - arr[i - 1]这部分代码很关键，因为n,m最大可以是100，当算到100时哪怕是long long 都不放不下了，而题目限定答案<=2*10^9,所以超过的肯定不是答案。而直接相加判断也会溢出,所以才用减法表示。

方法二：动态规划

后面看答案发现DP，然后我的妈，真蠢。整得那么复杂干嘛啊。其实我们会发现到(m,n)这个位置只能从(m-1,n)或(m,n-1)这两个位置出发。那递推方程不就出来了吗！即：
$$dp[m][n]=dp[m-1][n]+dp[m][n-1]$$
完事了，然后直接两个for循环就可以了。看代码吧：

int slove2(int m, int n) {
        int dp[m][n];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i == 0 || j == 0) dp[i][j] = 1;
                else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];/*从0开始的*/
    }

其实知道怎么做了，去实现它还是需要考虑很多细枝末节的问题，并不是知道怎么做就会做了的。我在杨辉三角花了很多时间去找bug，开始由于溢出一直RE，哪怕换成long long 还是一样，最后审题才有了上面的判断语句。
感谢您的查看！加油！
最后附完整代码：

class Solution {
public:
    vector<vector<int> > arr = vector<vector<int> >(105, vector<int>(105, 1));/*先所有都赋值1*/
    void YangHuiTri(int n) {
        /*因为杨辉三角两边都是1，但我们初始化arr是用1初始化的，所以不需要再循环一次了*/
        for (int i = 3; i <= n; ++i) {/*前面两行都是1*/
            for (int j = 2; j <= i - 1; ++j) {/*第一列是1哦*/
                if (arr[i - 1][j - 1] <= 2e9 - arr[i - 1][j])//加法会溢出，不加这里会RE
                    arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                else break;
            }
        }
    }
    int slove1(int m, int n) {
        if (m == 1 || n == 1) return 1;
        if (m == 2 || n == 2) return m + n - 2;
        if (m < n) swap(m, n);
        YangHuiTri(m + n - 1);
        return arr[m + n - 1][n];/*第m行的第n个数可表示为 C(m-1，n-1),所以对于C(m+n-2,n-1)是第m+n-1行的第n个数*/
    }
    int slove2(int m, int n) {
        int dp[m][n];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i == 0 || j == 0) dp[i][j] = 1;
                else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];/*从0开始的*/
    }
    int uniquePaths(int m, int n) {
        return slove1(m, n);
        return slove2(m, n);
    }
};

加油！！