Dynamic Programming(1)

概念介绍

  动态规划解决问题的方法就是通过解决很多的小问题而解决大问题。而与分治法的区别在于分治法划分出的小问题常常是不包含公共子问题的，动态规划则是小问题之间有着公共子问题。

  动态规划的效率将取决于两个因素，子问题的数量与子问题的解决效率。实际上，动态规划的时间效率就是子问题的数量*子问题的时间效率。

实例分析

接下来将用一些实例分析DP的方法

1. leetcode.62 Unique Paths

从一个矩形的左上角到右下角有多少条不同的路径（只能向下或者向右走），据此我们分析，在(i,j)处时，机器人的上一步

可能是(i-1,j)也可能是(i,j-1)，因此若设f(i,j)表示从起始位置(0,0)到(i,j)位置有多少条路径，则有f(i,j) = f(i-1,j)+f(i,j-1),返回结果为f(m-1,n-1).实现代码如下:

    int uniquePaths(int m, int n) {
    	int **f = new int*[m];
    	f[0] = new int[n];
    	for (int i = 0; i < n; i++) {
    		f[0][i] = 1;
		}
    	for (int i = 1; i < m; i++) {
    		f[i] = new int[n];
            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];
    }

2.leetcode.63 Unique Paths

这是62的一个延伸，在一个矩阵中增加了障碍物，用1表示，这样我们相比于上一题，就要检查(i,j)位置是否可达,不可达就f(i,j)=0;可达就沿用上一题的状态转换方程。代码如下：

    int uniquePathsWithObstacles(vector<vector<int> >& obstacleGrid) {
    	const int m = obstacleGrid.size();
    	const int n = obstacleGrid[0].size();
    	int **f = new int*[m];
    	f[0] = new int[n];
        f[0][0] = (obstacleGrid[0][0]==1)?0:1;
    	for (int i = 1; i < n; i++) {
    		if (obstacleGrid[0][i] == 0) f[0][i] = f[0][i-1];
    		else f[0][i] = 0;
		}
    	for (int i = 1; i < m; i++) {
    		f[i] = new int[n];
    		if (obstacleGrid[i][0] == 0) f[i][0] = f[i-1][0];
    		else f[i][0] = 0;
		}
		for (int i = 1; i < m; i++) {
			for (int j = 1; j < n; j++) {
				if (obstacleGrid[i][j] == 0) f[i][j] = f[i-1][j] + f[i][j-1];
				else f[i][j] = 0;
			}
		}
		return f[m-1][n-1];       
    }

接下来仍然会有几篇是动态规划实例的。