20200826动态规划（1.最长公共子序列 2. 最长回文子序列 3.博弈问题 石子游戏 ）

1.最长公共子序列
这道题和编辑距离的题 比较类似 使用动态规划
双循环字符串的长度 然后判断若字符相同 则等于前面的 i-1 j-1 进行+1
若不相同 则等于前面的（双前和单前）的最大值
dp时刻注意初始化问题

自己原创代码

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n1=text1.size();
        int n2=text2.size();
        vector<vector<int>>dp(n1+1,vector<int>(n2+1));
        for(int i=1;i<=n1;i++){
            for(int j=1;j<=n2;j++){
                if(text1[i-1]==text2[j-1]){
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                else{
                    dp[i][j]=max(max(dp[i-1][j-1],dp[i-1][j]),dp[i][j-1]);
                }
            }
        }
        return dp[n1][n2];
    }
};

2.最长回文子序列
这道题主要的递推公司自己推导的 就是一个串 两个下标 表示回文检测的首尾位置
如果两当前元素相同 就dp i+1 j-1 并加2 如果不相等 就取前面的两相邻的max
我自己的问题出在 对i j 都进行从左往右循环 但是很明显递推公式的方向是两边向中间的
因此循环方式也应该相反 一左一右即可

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

参考文献
https://blog.csdn.net/zzb5233/article/details/90547852
可以正序也可以逆序

3.石子游戏
直接把两个人的游戏整合成一个分值 A正分 B负分 最后结果如果是正就true 如果是负就false
要注意发牌的顺序问题 使用i+j 是否 mod 2 来判断

注意1：对于循环的选择还是一个要注意的问题
注意2：博弈对于两个人都足够聪明这一点 就是取max 每个人都贪心 选取当前看来最好的一种策略,不不不，我收回我的话，完全不是贪心，你看他是长期策略，因为每次递推都包含了完整的所有选择
，所以选择的是长远的最优策略

class Solution {
public:
    bool stoneGame(vector<int>& piles) {
		int n=piles.size();
        vector<vector<int>>dp(n+2,vector<int>(n+2));
        for(int len=1;len<=n;len++){
            for(int i=0;i<=n-len;i++){
                int j=i+len-1;
                int prioty=(i+j)%2;
                if(prioty==1){
                    dp[i+1][j+1]=max(dp[i+2][j+1]+piles[i],dp[i+1][j]+piles[j]);
                }
                else{
                    dp[i+1][j+1]=max(dp[i+2][j+1]-piles[i],dp[i+1][j]-piles[j]);
                }
            }
        }
        return dp[1][n]>0;
	}
};