小丑改造计划之动态规划

昨天三道算法题没做出来，很是惭愧，感改造改造自己觉自己像是个小丑，于是痛定思痛，决定
改造改造自己。
就从最熟悉的陌生人–动态规划开始吧。

所谓动态规划就是一种方法，利用历史数据推导出现在所需要的数据，比如青蛙跳台阶啥的。

动态规划有一个做题流程就是
1.确定dp[i]意义
2.找到关系式 dp[i] = dp[i-1] + dp[i-2]
3.找到初始值dp[0]等

方法和思想就是这么简单粗暴
话不多说让我们开始

第一道题是青蛙跳台阶
核心代码 dp[i] = dp[i-1] + dp[i-2]
初始值 dp[0] = 0 dp[1] = 1 dp[2] = 2

第二道题是找右下角的礼物
核心代码是

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];
        }
    }

第三道题是求从左上角到右下角路径值之和最小
核心代码是

 for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + arr[i][j];
        }
    }

时间复杂度为O(m*n)

第四道 编辑距离
核心代码

for (int i = 1; i <= n1; i++) {
        for (int j = 1; j <= n2; j++) {
            // 如果 word1[i] 与 word2[j] 相等。第 i 个字符对应下标是 i-1
            if (word1.charAt(i - 1) == word2.charAt(j - 1)){
                dp[i][j] = dp[i - 1][j - 1];
            }else {
               dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1], dp[i][j - 1]), dp[i - 1][j]) + 1;
            }         
        }
    }

第五道
打家劫舍

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

        return dp[nums.size() - 1];
    }
};

第六道
Leetcode 53. 最大子序和

if(nums.size() == 0) return 0;
int* dp = new int[nums.size()];
dp[0] = nums[0];
int max = dp[0];
for(int i = 1; i < nums.size(); i++)
{
	dp[i] = max(nums[i] + dp[i - 1], nums[i]);
	if(max < dp[i[)
	{
		max = dp[i];
	}
}
return max;

第七道 零钱兑换

	int* dp = new int[amount + 1];
	for(int i = 0; i <= amount; i++) {
                dp[i] = amount + 1;
        }
     dp[0] = 0;
     for(int i =1; i< amount + 1; i++)
     {
		for(int j = 0 ; j < counj.size(); j++)
		{
			if(counj <= i)
			dp[i] = min(dp[j], dp[i - counj[j]] + 1);
		}
	}

	return dp[i];

第八题 正则表达式

int s = s.size();
int p = p.size();
dp[0][0] = true;
for(int i = 2; i <= p; i++)
{
	if(p[i - 1] == '*')
	dp[0][i] = dp[0][i - 2];
}

for(int i = 1; i <= s; i++)
{
	for(int j = 1; j <= p; j++)
	{
		if(s[j -1] == p[j - 1] || p[j - 1] == '.')
		{
			dp[i][j] = dp[i -1][j - 1];
		} 
		else  //*
		{
			if(p[j - 2] != s[i - 1] && p[j - 2] != '.')
			{
				dp[i][j] = dp[i][j - 2];
			}
			else
			{
				dp[i][j] = dp[i - 1][j] || dp[i][j - 2] || dp[i][j - 1]
			}
		}
	}
}

return dp[s][p];