2021-08-16 动态规划笔记

动态规划

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

1.斐波那契数

int fib(int N) {
        if (N < 2) return N;
        vector<int> dp(N + 1);
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= N; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[N];
    }

优化空间复杂度：

只记录前两个状态，优化成常数空间

int fib(int N) {
        if (N < 2) return N;
        int dp[2];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= N; i++) {
            int sum = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = sum;
        }
        return dp[1];
    }

2.爬楼梯

dp[i]：爬到第i层楼梯，有dp[i]种方法

dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶就是dp[i]。

dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶就是dp[i]。

所以dp[i] = dp[i - 1] + dp[i - 2] ，其实就是斐波那契数列。

 int climbStairs(int n){
        if(n<2) return n;//dp[0]题目中未定义
        int dp[3];//因为需要用到dp[2]
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=n;i++){
            int sum=dp[1]+dp[2];
            dp[1]=dp[2];
            dp[2]=sum; 
        }
        return dp[2];
    }

3.最小花费爬楼梯

dp[i]的定义：第i个台阶所花费的最少体力为dp[i]。

dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];

int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size());
        dp[0]=cost[0];
        dp[1]=cost[1];
        for(int i=2;i<cost.size();i++) {
            dp[i]=min(dp[i-1],dp[i-2])+cost[i];
        }
        return min(dp[cost.size()-1], dp[cost.size()-2]);//最后一步可以理解为不用花费体力 
    }

4.不同路径

dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

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

5.不同路径2

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
	int m=obstacleGrid.size();
	int n=obstacleGrid[0].size();
	vector< vector<int> > dp(m,vector<int> (n,0));
	for(int i=0;i<m && obstacleGrid[i][0]==0;i++){
        dp[i][0]=1;//obstacleGrid[i][0]==0是因为有障碍的点是为1的，
    }              // 第一列的障碍包括障碍之后的点走不了，不赋值 
    for(int j=0;j<n && obstacleGrid[0][j]==0;j++){
        dp[0][j]=1;
    }
    for(int i=1;i<m;i++){
        for(int j=1;j<n;j++){
        	if(obstacleGrid[i][j]==1){//遇到障碍跳出小循环 
        		continue;
			}
            dp[i][j]=dp[i-1][j]+dp[i][j-1];
        }
    } 
    return dp[m-1][n-1];
}

6.整数拆分

dp[i]：分拆数字i，可以得到的最大乘积为dp[i]。

j的含义是对正整数i拆分出的第一个正整数是 j

j*(i-j)是单纯的把整数拆分为两个数相乘,j*dp[i-j]是拆分成两个以上的个数相乘，取其中最大的作为dp[i]
递推式子j*dp[i－j]包含dp[j1]*dp[i－j1]，如：
dp[10]=2*dp[8]=2*（2*3*3）=dp[5]*dp[5]=2*3 *2*3

int integerBreak(int n) {
	vector<int> dp(n+1,0);
	dp[2]=1;
	for(int i=3;i<=n;i++){//???
		for(int j=1;j<i-1;j++){//？？？
			dp[i]=max(dp[i],max(j*(i-j),j*dp[i-j]));
		}
	}
	return dp[n];
}

7.不同的二叉搜索树

dp[i] ：1到i为节点组成的二叉搜索树的个数为dp[i]。

dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

dp[i] += dp [ 以j为头结点左子树节点数量 ] * dp[ 以j为头结点右子树节点数量 ]

int numTrees(int n){
    vector<int> dp(n+1);//需要遍历到n
    dp[0]=1;//空结点也是一颗二叉树
    for(int i=1;i<=n;i++){//i遍历结点数
        for(int j=1;j<=i;j++){//j遍历i范围内每个数作为头结点的状态
            dp[i]+=dp[j-1]*dp[i-j];//j-1即以j为头结点左子树节点数量
        } 
    }
    return dp[n];
}