leetcode 动态规划练习

279. Perfect Squares

给定正整数n，找到最少可分解为几个数的平方和为n。

例如 n = 12 return 3 因为12 = 4+4+4 。给定n = 13 返回 2 因为13 = 4+ 9

class Solution {
public:
    int numSquares(int n) {
        int *a = new int[n+1];
        a[0] = 0;
        for(int i=1; i <=n; ++i )
            {
                for(int j=1; j*j <= i ; ++j )
                {   if(a[i] == 0)
                    {
                        a[i] = a[i-j*j] + 1;
                    }
                    else
                    {
                        a[i] = min(a[i],a[i-j*j]+1);
                    }
                }
            }
        int ans = a[n];
        delete a;
        return ans;
    }
};

53. Maximum Subarray

给定连续数组，求其子数组中和最大的数组，返回最大和

class Solution {
public:

    int maxSubArray(vector<int>& nums) {
        int t = 0;  // 临时数组和，当和小于零时，当前数字肯定是负数将其舍弃，重新归置为0
        int max_t = nums[0]; //全局最后解缓存变量
        for(vector<int>::iterator it = nums.begin(); it != nums.end(); ++it)
        {
            t += (*it);
            max_t = max(max_t , t);
            
            if(t < 0)
            {
                t = 0;
        
            }    
        } 
        
        return max_t;
    }
};

55. Jump Game

维护一个index变量，表示当前可访问的最远位置索引。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n = nums.size();
        if(n <= 1) return true;
        int index= 0;
        for(int i=0; i<=index;++i)
        {
            if(i>=n-1) return true;
            int t = i+nums[i];
            if(t>index) index = t;
            
            
        }
        return false;
    }
};

72. Edit Distance

开一个二维数组d[i][j]来记录a0-ai-1与b0-bj-1之间的编辑距离，要递推时，需要考虑对其中一个字符串的删除操作、插入操作和替换操作分别花费的开销，从中找出一个最小的开销即为所求

dp[i][j]表示a的前i个和b的前j个相同后的最短距离

dp[i][j]来自于三种状态{

    1、删除，dp[i-1][j]+1;

    2、插入，dp[i][j-1]+1;

    3、替换，if(a[i]==b[j]) dp[i][j]=dp[i-1][j-1],else dp[i][j]=dp[i-1][j-1]+1;

class Solution {
public:
    int minDistance(string word1, string word2) {
        int l1 = word1.length();
        int l2 = word2.length();

        vector<vector<int>>dp(l1+1,vector<int>(l2+1));
        // 初始化空字符串的情况
        for(int i=1; i<=l1; ++i)
        {
            dp[i][0] = i;                           
        }
        for(int j=1; j<=l2; ++j)
        {
            dp[0][j] = j;                      
        }
                               
        for(int i=1; i<=l1; ++i)
        {
            for(int j=1; j<=l2; ++j)
            {
                //增加操作
                int insert = dp[i][j-1]+1;
                //删除操作
                int del = dp[i-1][j]+1;
                //替代操作
                int replace = dp[i-1][j-1] + (word1[i - 1]== word2[j - 1] ? 0 : 1);
                dp[i][j] = min(insert,min(del,replace));
            }
        }
        return dp[l1][l2];
    }
};

5. Longest Palindromic Substring

最长回文子串，dp[i][j] = 1表示从i到j是回文。从小到大列举子串长度，当s[i] = s[j]且dp[i+1][j-1]值为1的时候，dp[i][j]=1;

class Solution {
public:
   	string longestPalindrome(string s) {

		int n = s.size();
		vector<vector<int> > dp(n, vector<int>(n));
		int start = 0;
		int end = 0;
		dp[n - 1][n - 1] = 1;
		int len = 1;
		for (int i = n - 2; i >= 0; i--)
		{
			dp[i][i] = 1;
			if (s[i] == s[i + 1])
			{
				dp[i][i + 1] = 1;
				start = i;
				end = i + 1;
			}

		}
		for (int i = n- 1; i >= 0; i--)
		{
			for (int j = 1; i + j<n; ++j)
			{

				if (dp[i + 1][i + j - 1] && s[i] == s[i + j]){

					dp[i][i + j] = 1;
					if (j >len){
						len = j;
						start = i;
						end = i + j;
					
					}
				}
			}

		}
		return s.substr(start, end - start + 1);
	}
};