1143.最长公共子序列 | 516.最长回文子序列 | 813.最大平均值和的分组

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace" ，它的长度为 3 。
示例 2：

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc" ，它的长度为 3 。
示例 3：

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0 。 

思路：动态规划

详解最长公共子序列问题，秒杀三道动态规划题目

两个字符串，采用二维DP 

dp函数+备忘录 

dp函数定义：返回s1[i..]和s2[j..]的最长公共子序列的长度 

//dp函数+备忘录
class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> memo(text1.size(),vector<int>(text2.size(),10000));
        return dp(text1,text2,0,0,memo);    
    }
    //dp函数定义：返回s1[i..]和s2[j..]的最长公共子序列的长度
    int dp(string& s1,string& s2,int i,int j,vector<vector<int>>& memo)
    {
        if(i==s1.size()||j==s2.size())//任意一方到头，LCS就等于0
            return 0;
        if(memo[i][j]!=10000)
        {
            return memo[i][j];
        }
        if(s1[i]==s2[j])
            memo[i][j]=1+dp(s1,s2,i+1,j+1,memo);
        else
            memo[i][j]=max(dp(s1,s2,i+1,j,memo),dp(s1,s2,i,j+1,memo));
        return memo[i][j];
    }
};

 dp数组

dp数组定义：s1[0..i-1]和s2[0..j-1]的lcs长度为dp[i][j] 

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        //dp数组定义：s1[0..i-1]和s2[0..j-1]的lcs长度为dp[i][j]
        vector<vector<int>> dp(text1.size()+1,vector<int>(text2.size()+1,0));//当i==0||j==0时，lcs的长度为0
        for(int i=1;i<=text1.size();i++)
        {
            for(int j=1;j<=text2.size();j++)
            {
                if(text1[i-1]==text2[j-1])
                    dp[i][j]=1+dp[i-1][j-1];
                else
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

516.最长回文子序列 

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。
示例 2：

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。

思路：动态规划

虽然只有一个数组/字符串，但是依然采用二维DP，使用i，j两个状态变量

dp函数定义：返回在s[i..j]中，最长回文子序列的长度。

dp函数+备忘录 

//dp函数+备忘录
class Solution {
public:
    int longestPalindromeSubseq(string s) {
        vector<vector<int>> memo(s.size(),vector<int>(s.size(),10000));
        return dp(s,0,s.size()-1,memo);
    }
    //dp函数定义：返回在s[i..j]中，最长回文子序列的长度。
    int dp(string& s,int i,int j,vector<vector<int>>& memo)
    {
        if(i>j)
        return 0;
        if(i==j)//只有一个字母，最长回文子序列长度为1
        return 1;
        if(memo[i][j]!=10000)//备忘录，减少重复计算
            return memo[i][j];
        if(s[i]==s[j])//它俩加上s[i+1,j-1]中的最长回文子序列就是s[i,j]的最长回文子序列
            memo[i][j]=dp(s,i+1,j-1,memo)+2;
        else//说明它俩不可能同时出现在s[i,j]的最长回文子序列中，所以只加它俩中的一个，看看谁的最长回文子序列最长
            memo[i][j]=max(dp(s,i,j-1,memo),dp(s,i+1,j,memo));
        return memo[i][j];
    }
};

dp数组定义:表示s[i..j]中的最长回文子序列的长度 

 dp数组

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n=s.size();
        //dp数组定义:表示s[i..j]中的最长回文子序列的长度
        vector<vector<int>> dp(n,vector<int>(n,0));
        for(int i=0;i<n;i++)
        {
            dp[i][i]=1;
        }
        for(int i=n-2;i>=0;i--)
        {
            for(int j=i+1;j<n;j++)
            {
                if(s[i]==s[j])
                    dp[i][j]=dp[i+1][j-1]+2;
                else
                    dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
            }
        }
        return dp[0][n-1];
    }
};  

813. 最大平均值和的分组

给定数组 nums 和一个整数 k 。我们将给定的数组 nums 分成 最多 k 个相邻的非空子数组 。 分数 由每个子数组内的平均值的总和构成。

注意我们必须使用 nums 数组中的每一个数进行分组，并且分数不一定需要是整数。

返回我们所能得到的最大 分数 是多少。答案误差在 10-6 内被视为是正确的。

示例 1:

输入: nums = [9,1,2,3,9], k = 3
输出: 20.00000
解释: 
nums 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) / 3 + 9 = 20. 
我们也可以把 nums 分成[9, 1], [2], [3, 9]. 
这样的分组得到的分数为 5 + 2 + 6 = 13, 但不是最大值.

示例 2:

输入: nums = [1,2,3,4,5,6,7], k = 4
输出: 20.50000

提示:

• 1 <= nums.length <= 100
• 1 <= nums[i] <= 104
• 1 <= k <= nums.length

 思路：二维dp+前缀和

//划分份数越多，平均值之和就越大，因此想要取得最大值必然是恰好划分成 k 份
class Solution {
public:
    //dp[i][j]表示nums中前i个数分成最多j个非空子数组后所能得到的最大分数
    double largestSumOfAverages(vector<int>& nums, int k) {
        int n=nums.size();
        vector<vector<double>> dp(n+1,vector<double>(k+1,0.0));
        vector<int> preSum(n+1,0);
        for(int i=1;i<=n;i++)//前缀和方便计算平均值
        {
            preSum[i]=preSum[i-1]+nums[i-1];
        }
        for(int i=1;i<=n;i++)//base case 当j==1时，只能都划在一个子数组里
        {
            dp[i][1]=(double)preSum[i]/i;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=2;j<=k;j++)
            {
                for(int r=2;r<=i;r++)//j>1时，枚举最后一个子数组的起点r，2<=r<=i
                {
                    dp[i][j]=max(dp[i][j],dp[r-1][j-1]+(preSum[i]-preSum[r-1])/(i-r+1.0));
                }
            }
        }
        return dp[n][k];
    }
};