https://blog.csdn.net/someone_and_anyone/article/details/81044153

当串1 和串2 的位置i和位置j匹配成功时，

dp[i][j]=dp[i-1][j-1]+1,也就是说此状态由状态dp[i-1][j-1]转移而来，用数组记录为1，

当匹配不成功时，dp[i-1][j]和dp[i][j-1]去一个最大的，用数组分别记为2和3.

根据记录数组寻找路径：

当记录数组为1时，说明次时的i和j想等，并且此状态由i-1和j-1转移而来，所以i=i-1,j=j-1

当记录数组为2时，说明此时i和j对应的数符不等，并且此状态由j-1转移而来，所以直接j--;

当记录数组为2时，说明此时i和j对应的数符不等，并且此状态由i-1转移而来，所以直接i--;

#include<bits/stdc++.h>

using namespace std;

const int N=+;

int dp[N][N];

int mark[N][N];

char s1[N],s2[N];

int main()

{

    cin>>s1+>>s2+;

    int n=strlen(s1+);

    int m=strlen(s2+);

    for(int i=;i<=n;i++)

        for(int j=;j<=m;j++){

            if(s1[i]==s2[j]){

                dp[i][j]=dp[i-][j-]+;

                mark[i][j]=;

            }

            else if(dp[i][j-]>dp[i-][j]){

                dp[i][j]=dp[i][j-];

                mark[i][j]=;

            }

            else {

                dp[i][j]=dp[i-][j];

                mark[i][j]=;

            }

         }

    string ans="";

    int i=m,j=n;

    while(i>&&j>){

        if(mark[i][j]==) {

            ans+=s1[i];

            i--;j--;

        }

        else if(mark[i][j]==) {

            j--;

        }

        else i--;

    }

    reverse(ans.begin(),ans.end());

    cout<<ans<<endl;

    return ;

}

LIS：最长上升子序列。

O(n^2)：

　　定义dp[i]表示考虑到第i个元素，他可以拼接到从1~i-1中比它小的元素上去。

　　dp[i]=max(dp[k])+1，代码比较简单，在此省略。

O(nlogn)：

　　定义dp[len]表示当长度为len时的最小元素。

code:

dp[]=a[];

int len=;

for(int i=;i<=n;i++){

    if(a[i]>dp[len]) dp[++len]=a[i];

    else *lower_bound(dp+,dp++len,a[i])=a[i];

}

LCIS：最长公共上升子序列

定义状态dp[i][j]表示考虑前i个字符时，当选中第j个字符时的状态。

在这里第j个字符已经选了，所以前i个字符一定有和它匹配的，当第j个字符和第i个字符不匹配成功时，那第j个字符一定和

前i-1中的一个字符匹配喽，所以转移方程为dp[i][j]=dp[i-1][j]，还是以j结尾。

当第j个字符和第i个字符匹配成功时，dp[i][j]=max(dp[i-1][k])+1，要在和前i-1个匹配的字符中选出状态最好的。

所以状态转移方程为：

dp[i][j]=dp[i-1][j]，匹配成功。

dp[i][j]=max(dp[i-1][k])(k<=j)匹配不成功。

code:

void solve(int t){

    ll n,m;

    cin >> n;

    for (ll i = ; i <= n; i++) cin >> arr[i];;

    cin >> m;

    for (ll i = ; i <= m; i++) cin >> brr[i];

    ll mx = ;

    for (ll i = ; i <= n; i++) {

        mx = ;

        for (ll j = ; j <= m; j++) {

            dp[i][j] = dp[i - ][j];

            if (brr[j] < arr[i]) mx = max(mx, dp[i-][j]);

            else if (arr[i] == brr[j]) dp[i][j] = mx + ;

        }

    }

    ll ans = ;

    for (ll i = ; i <= m; i++)  ans = max(ans, dp[n][i]);

    cout << ans<<"\n"<<"\n";

}

一个例题：

HDU1423:Greatest Common Increasing Subsequence

code:

#include<iostream>

#include<cstdio>

#include<algorithm>

using namespace std;

typedef long long ll;

const ll N = 1E3 + ;

ll arr[N];

ll brr[N];

ll dp[N][N];

void solve(int t){

    ll n,m;

    cin >> n;

    for (ll i = ; i <= n; i++) cin >> arr[i];;

    cin >> m;

    for (ll i = ; i <= m; i++) cin >> brr[i];

    ll mx = ;

    for (ll i = ; i <= n; i++) {

        mx = ;

        for (ll j = ; j <= m; j++) {

            dp[i][j] = dp[i - ][j];

            if (brr[j] < arr[i]) mx = max(mx, dp[i-][j]);

            else if (arr[i] == brr[j]) dp[i][j] = mx + ;

        }

    }

    ll ans = ;

    for (ll i = ; i <= m; i++)  ans = max(ans, dp[n][i]);

    cout << ans<<"\n";

    if(t) cout<<"\n";

}

int main(){

    ll t;

    cin >> t;

    while (t--) solve(t);

    return ;

}

巴特西

LCS（记录路径）+LIS+LCIS

HDU1423:Greatest Common Increasing Subsequence

最新文章

热门文章