力扣热题100——动态规划(上)

动态规划的题主要就是要抽象出来状态方程跟边界

题一 爬楼梯

这里使用到了滚动数组，可以降低存储数据的空间复杂度
用f(x) = f(x-1)+f(x-2),f(x)表示第x级台阶的方案数，考虑最后一步可能跨了一级台阶，也可能跨了两级台阶。
意思是爬到第x级台阶的方案数等于爬到第(x-1)阶台阶的方案数加上爬到第(x-2)阶台阶的方案数
至于边界就是第0级台阶看做一个方案为f(0) = 1;第一级台阶也只有一种方案就是f(1) = 1
因此状态方程跟边界都得到了

class Solution{
public:
	int climbStairs(int n){
		int p=0,q=0,r=1;
		p = q;
		q = r;
		r = p+q;
	}
	return r;
}

题二 杨辉三角

杨辉三角的特点是其每行的左右两端的数字为1，且每一行的行数等于个数
然后中间的数等于前一行左右上方两个数的和；
于是得到状态方程有f[i][j] = f[i-1][j-1] + f[i-1][j]，而边界就是上面提到的1

class Soulution{
public:
	vector<vector<int>> generate(int numsRows){
		vector<vector<int> > ret(numsRows);
		for(int i=0;i<numsRows;i++){
			ret[i].resize(i+1);
			ret[i][0] = ret[i][i] = 1;
			for(int j=1;j<i;j++){
				ret[i][j] = ret[i-1][j-1] + ret[i-1][j];
			}
		}
		return ret;
	} 
}

下面给出一个使用一维数组的做法，主要是之前有个小公司面试 里面的老板居然让我实现一下 我当时都不知道杨辉三角是什么 贴在下面纪念一下：

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ret;
        for(int i = 1; i <= numRows; i++){ //创建并初始化数组
            vector<int> cur(i);
            cur[0] = cur[i-1] = 1;
            ret.push_back(cur);
        }
        for(int i = 0; i < numRows; i++){ //计算和：f[i][j] = f[i-1][j-1]+f[i-1][j]
            for(int j = 1; j < i; j++){
                ret[i][j] = ret[i-1][j-1] + ret[i-1][j];
            }
        }
        return ret;
    }
};

题三 打家劫舍

首先考虑边界：只有一间屋就偷这一间，有两间屋就偷钱多的
若是超过2间屋，则根据偷的房间由于不能连续，是否偷取当前房子取决于前前一间与当前的金额之和是否比前一间的多因此：
用dp[i]表示前i间房能够偷取到的最多金额数量，则有 dp[i] = max(dp[i-2]+nums(i),dp[i-1])，于是得到了转移方程
而边界条件则是:
dp[0] = nums[0] , dp[1] = max(nums[0],nums[1])
最后的答案便是dp[n-1]
同样这里使用了滚动数组可以节省空间

class Solution{
public:
	int rob(vector<int>& nums){
		if(nums.empty()) return 0;
		if(nums.size()==1) return nums[0];
		int first = nums[0],second = max(nums[0],nums[1]);
		for(int i =2;i<size();i++){
			int temp = second;
			second = max(first+nums[i],second);
			first = temp;
		}
		return second;
	}
}

题四 完全平方数

令 f[i] 表示至少需要多少个数的平方来表示整数 i
这些数会落在[1,根号i]，枚举这些数，假设当前枚举到j，那么我们还需要取若干数的平方，构成i - j^2。则状态方程如下

其中f[0] = 0为边界条件，实际上无法表示0，只是为了保证状态转移过程中遇到j恰为根号i 的情况合法
同时因为计算f[i]时所需要的状态仅有f[i-j^2]，必然小于i，因此我们只需要从小到大地枚举i来计算f[i]即可

class Solution{
public:
	int numSquares(int n){
		vector<int> f(n+1);
		for(int i=1;i<=n;i++){
			minn = min(minn,f[i-j*j]);
		}
		f[i] = minn+1;
	}
	return f[n];
}

题五 零钱兑换

我们采用自下而上的方式进行思考。仍定义 F(i) 为组成金额 i 所需最少的硬币数量，假设在计算 F(i) 之前，我们已经计算出 F(0)−F(i−1) 的答案。 则 F(i) 对应的转移方程应为

class Solution{
public:
    int coinChange(vector<int>& coins,int amount){
        int Max = amount+1;
        vector<int> dp(amount+1,Max);
        dp[0] = 0;
        for(int i=1;i<=amount;++i){
            for(int j=0;j<(int)coins.size();++j){
                if(coins[j]<=i){
                    dp[i] = min(dp[i],dp[i-coins[j]]+1);
                }
            }
        }
        return dp[amount]>amount?-1:dp[amount];
    }

};