week7(动态规划1)

动态规划1

7-1 采药

题目链接

LGP1048

解题思路

01背包的板子题，这里使用了一维数组进行了空间的压缩，注意外层正向循环枚举物品，内层逆向循环枚举空间大小。如果内层循环写成了正向，也就是完全背包；如果两个循环先后倒置了，每一次空间枚举只会放一个物品，是错误的。

#include <bits/stdc++.h>
using namespace std;
int t,n; 
int main(){
    cin>>t>>n;
    vector <int> w,v,f(t+1,0);
//注意vector的使用 
//数组需要push的时候，就不设定数组大小 如w,v
//数组无读入的时候，就需要先设定其大小 如t
    for (int i=1; i<=n; i++){
        int W,V;
        scanf("%d%d",&W,&V);
        w.push_back(W);
        v.push_back(V);
    }
    for (int i=0; i<n; i++){
        for (int j=t; j>=w[i]; j--){
            f[j]=max(f[j],f[j-w[i]]+v[i]);
        }
    }
    cout<<f[t];
   // system("pause");
    return 0;
}

7-2 最长上升子序列

题目链接

LGB3637

解题思路

最长上升子序列的板子题，对于每个i，找到其前面1~i-1中符合条件的最长序列，然后在其后面接上去。

#include <bits/stdc++.h>
using namespace std;
int main(){
    int n;
    vector <int> a;
    cin>>n;
    vector <int> f(n+1,1);
//vector 以n为动态大小 所以应该写在cin>>n后面 否则评测姬上会Runtime error 
    for (int i=0; i<n; i++){
        int tmp;
        scanf("%d",&tmp);
        a.push_back(tmp);
    }

    for (int i=0; i<n; i++){
        for (int j=0; j<i; j++){
            if (a[j]<a[i]){
                f[i]=max(f[i],f[j]+1);
            }
        }
    }
//LIS 利用二分 可优化为O(NlogN)的复杂度

    int ans=0;
    for (int i=0; i<n; i++)
        ans=max(ans,f[i]);
    cout<<ans;
   // system("pause");
    return 0;
}

7-3 最大子段和

题目链接

LGP1115

解题思路

对于每一个i，如果f[i-1]<0，那就必然要抛弃它，白手起家，否则本身的值a[i]加上f[i-1]。

#include <bits/stdc++.h>
using namespace std;
int main(){
    int n;
    cin>>n;
    vector <int> a,f(n+1,0);
    a.push_back(0);
    for (int i=0; i<n; i++){
        int tmp;
        scanf("%d",&tmp);
        a.push_back(tmp);
    }

    int ans=-INT_MAX;

    for (int i=1; i<=n; i++){
        if (f[i-1]>0){
            f[i]=f[i-1]+a[i];
        }
        else {
            f[i]=a[i];
        }
        ans=max(ans,f[i]);
    }
    cout<<ans;
    //system("pause");
    return 0;
}

7-4 LCS

题目链接

LGAT_dp_f

解题思路

（好罕见的题面啊）

解题分为两步，先找到最长公共子序列的个数，再将这个序列输出。
对于问题一，定义数组dp[i][j] 表示s1中以i结尾、s2中以j结尾时，公共子序列的最长长度。如果s1[i]与s2[j]相等，表示这就是一个公共字符，可以直接继承f[i-1][j-1]，即f[i][j]=f[i-1][j-1]+1；如果两者不相等，就需要从f[i-1][j]与f[i][j-1]中选择更大的继承。
对于问题二，我们在求公共子序列的最长长度时，就可以用p[i][j]，在记录每次f[i][j]的值的同时，记录下它时从哪里继承来的，最后倒序递归输出该路径。

#include <bits/stdc++.h>
using namespace std;

char s1[3005],s2[3005];
vector <vector<int> > f,p;

void print(int l,int r){
    
    if (l==0 || r==0){
        return;
    }

    if (p[l][r]==1){
        print(l-1,r-1);
        cout<<s1[l];
    }
    else 
    if (p[l][r]==2){
        print(l-1,r);
    }
    else {
        print(l,r-1);
    }

}

int main(){
    cin>>(s1+1);
    cin>>(s2+1);

    int n,m;
    n=strlen(s1+1);
    m=strlen(s2+1);

    f.resize(n+1,vector<int>(m+1,0));
    p.resize(n+1,vector<int>(m+1,0));
//vector是从0开始的，所以时刻记住要加1 否则数组溢出了 QAQ
//可以主函数外定于vector，读入完n与m后，再resize其大小
    for (int i=1; i<=n; i++){
        for (int j=1; j<=m; j++){
            if (s1[i]==s2[j]){
                f[i][j]=f[i-1][j-1]+1;
                p[i][j]=1;
            }
            else {
                if (f[i-1][j]>f[i][j-1]){
                    f[i][j]=f[i-1][j];
                    p[i][j]=2;
                }
                else {
                    f[i][j]=f[i][j-1];
                    p[i][j]=3;
                }
            }
        }
    }
    print(n,m);

    system("pause");
    return 0;
}