leetcode之DP总结

303. Range Sum Query - Immutable

解题思路：给定一个数组，计算给定区间的数字的和。利用DP算出从开始处到i的和，dp[i]=sum[i],代码如下：

class NumArray {
public:
    NumArray(vector<int> nums) 
    {
        sum.push_back(0);
        for(int i=0;i<nums.size();i++)
        {
            sum.push_back(nums[i]+sum.back());
        }
        
    }
    
    int sumRange(int i, int j) 
    {
        return sum[j+1]-sum[i];
        
    }
private:
    vector<int> sum;
};

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(i,j);
 */

53. Maximum Subarray

题目描述：求给定数组的和最大的连续子数组。

思路一：DP，表示到该元素的时候的和最大的连续子数组，代码如下：

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

思路2：不用DP，不需要额外这么多内存，只用两个变量表示即可，代码如下：

class Solution {
public:
    int maxSubArray(vector<int>& nums) 
    {
        int ret=INT_MIN;
        int f=0;
        for(int i=0;i<nums.size();i++)
        {
            f=max(nums[i],f+nums[i]);
            ret=max(ret,f);
        }
        return ret;
    }
};

198. House Robber
题目描述：给很多房子，每个房子有钱，不能同时偷相邻的房子的财物，求可能获得的最多的宝贝。

解题思路：DP。递推公式，我们维护一个一位数组dp，其中dp[i]表示到i位置时不相邻数能形成的最大和,dp[i] = max(num[i] + dp[i - 2], dp[i - 1]),代码如下：

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

213. House Robber II

题目描述：跟上一个题目相比，这里的房子成一个圈,不能同时包含第一个和最后一个。代码如下：

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

337. House Robber III

题目描述：这个题目扩展为二叉树，即不能同时偷直接相邻的节点。

Solution1：二叉树的题目：递归，深度优先遍历，宽度优先遍历,第一种，递归算法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) 
    {
    	if(root==NULL)
    	{
    		return 0;
    	}
    	int val=0;
    	if(root->left)
    	{
    		val=val+rob(root->left->left)+rob(root->left->right);

    	}
    	if(root->right)
    	{
    		val=val+rob(root->right->left)+rob(root->right->right);
    	}
    	return max(root->val+val,rob(root->left)+rob(root->right));
        
    }
};

Solution 2:用hash来存储每一个节点对应的最大值。代码如下：

class Solution {
public:
    int rob(TreeNode* root) 
    {
        unordered_map<TreeNode*, int> m;
        return dfs(root, m);
    }
    int dfs(TreeNode *root, unordered_map<TreeNode*, int> &m) 
    {
        if (!root) return 0;
        if (m.count(root)) return m[root];
        int val = 0;
        if (root->left) 
        {
            val += dfs(root->left->left, m) + dfs(root->left->right, m);
        }
        if (root->right) 
        {
            val += dfs(root->right->left, m) + dfs(root->right->right, m);
        }
        val = max(val + root->val, dfs(root->left, m) + dfs(root->right, m));
        m[root] = val;
        return val;
    }
};

338. Counting Bits
题目描述：给定一个数字N，求从0到N的每个数字二进制表示后1的个数。

解题思路：如果一个数为偶数，那么它包含的1的个数与其除2后的1的个数相同，比如8,4,2,1，如果一个数为奇数，它包含的1的个数等于除2后的数加1，找到相互关系后，代码如下：

代码：

class Solution {
public:
    vector<int> countBits(int num) 
    {
        vector<int> dp(num+1,0);
        dp[1]=1;
        for(int i=2;i<num+1;i++)
        {
            if(i%2==0)
            {
                dp[i]=dp[i/2];
            }
            else
            {
                dp[i]=dp[i/2]+1;
            }
        }
        return dp;

        
    }
};

647. Palindromic Substrings

题目描述：给定一个字符串，求该字符串的所有对称的子串。

解题思路：二维DP问题，DP[j][i]表示子串sub(j,i)是否是对称的子串，如果dp[j][i]=dp[j+1][i-1]+s[i]==s[j].然后统计所有的对称的子串的个数，代码如下：

class Solution {
public:
    int countSubstrings(string s) 
    {
        if(s.size()<=1)
        {
            return s.size();
        }
        int n=s.size();
        vector<vector<bool>> dp(n,vector<bool>(n,false));
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                dp[j][i]=s[j]==s[i]&&((i-j<2)||dp[j+1][i-1])
            }
            dp[i][i]=true;
        }
        int ret=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(dp[i][j])
                {
                    ret++;
                }
            }
        }
        return ret;
    }
};

5. Longest Palindromic Substring
题目描述:求字符串的最长的对称的子串

解题思路：同上

代码如下：

// DP
class Solution {
public:
    string longestPalindrome(string s) 
    {
        int dp[s.size()][s.size()] = {0}, left = 0, right = 0, len = 0;
        for (int i = 0; i < s.size(); ++i) {
            for (int j = 0; j < i; ++j) 
            {
                dp[j][i] = (s[i] == s[j] && (i - j < 2 || dp[j + 1][i - 1]));
                if (dp[j][i] && len < i - j + 1) 
                {
                    len = i - j + 1;
                    left = j;
                    right = i;
                }
            }
            dp[i][i] = 1;
        }
        return s.substr(left, right - left + 1);
    }
};

516. Longest Palindromic Subsequence

题目描述：求最长的对称的子序列。

解题思路：动态规划

代码如下：

class Solution {
public:
    int longestPalindromeSubseq(string s) 
    {
        int n=s.size();
        if(n<=1)
        {
            return n;
        }
        vector<vector<int>> dp(n,vector<int>(n,0));
        for(int i=0;i<n;i++)
        {
            dp[i][i]=1;
            for(int j=i-1;j>=0;j--)
            {
                if(s[i]==s[j])
                {
                    dp[j][i]=dp[j+1][i-1]+2;
                }
                else
                {
                    dp[j][i]=max(dp[j+1][i],dp[j][i-1]);
                }
            }

        }
        return dp[0][n-1];
        
    }
};

413. Arithmetic Slices
题目描述：求一个数组的所有的等差数列的子数组

解题思路:DP

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

343. Integer Break

题目描述：给定一个数字，将该数字至少分成两个，求分开后乘积最大的结果。

解题思路：dp，试着写前几个，发现规律。

class Solution {
public:
    int integerBreak(int n) 
    {
        vector<int>dp(7);
        dp[0]=0;
        dp[1]=0;
        dp[2]=1;
        dp[3]=2;
        dp[4]=4;
        dp[5]=6;
        dp[6]=9;
        for (int i = 7; i <= n; ++i) 
        {
            dp.push_back(dp[i-3]*3);
        }
        return dp[n];
    }
};

646. Maximum Length of Pair Chain

题目描述：给定一个区间数组，求满足要求的最长长度。

Input: [[1,2], [2,3], [3,4]]
Output: 2
Explanation: The longest chain is [1,2] -> [3,4]

解题思路:按照结束值进行排序，即可。

代码：

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) 
    {
        sort(pairs.begin(),pairs.end(),cmp);
        vector<int> pair;
        int ret=0;
        for(int i=0;i<pairs.size();i++)
        {
            if(i==0||pairs[i][0]>pair[1])
            {
                pair=pairs[i];
                ret++;
            }
        }
        return ret;
        
    }
    static bool cmp(vector<int> a,vector<int> b)
    {
        return a[1]<b[1]||a[1]==b[1]&&a[0]<b[0];
    }

 392. Is Subsequence

题目描述：给定两个字符串s和t，判断s是不是t的子串。

解题思路：依次遍历即可；

代码：

class Solution {
public:
    bool isSubsequence(string s, string t) 
    {
        int m=s.size();
        int n=t.size();
        if(m>n)
        {
            return false;
        }
        if(m==n)
        {
            return s==t;
        }
        int i=0;
        int j=0;
        while(i<m&&j<n)
        {
            if(s[i]==t[j])
            {
                i++;
                j++;
            }
            else
            {
                j++;
            }
        }
        if(i==m)
        {
            return true;
        }
        return false;
        
    }
};

494. Target Sum
题目描述：给定一个数组，求能够满足给定和的组合的个数。

Input: nums is [1, 1, 1, 1, 1], S is 3. 
Output: 5
Explanation: 

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

There are 5 ways to assign symbols to make the sum of nums be target 3.

解题思路：深度优先遍历，求每一种组合的结果，然后统计满足要求的结果的个数。

代码如下：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) 
    {
        return help(nums,0,S);
    }
    int help(vector<int>&nums,int start,int S)
    {
        if(start>=nums.size())
        {
            if(S==0)
            {
                return 1;
            }
            return 0;
        }
        return help(nums,start+1,S-nums[start])+help(nums,start+1,S+nums[start]);
    }
};