NEUQ-ACM预备队必做题-4/5

补充上周题单中未完成的题目

B3637 最长上升子序列

动态规划模板题，状态转移条件为比a[i]小的数中最长的序列+1

#include <iostream>
using namespace std;

int main() {
    int n,a[5010];
    cin >> n;
    for(int i=0;i<n;i++){
        cin >> a[i];
    }
    int length[5010];
    length[0]=1;
    for(int i=1;i<n;i++){
        int maxNum=0;
        int longestIndex=-1;
        for(int j=0;j<i;j++){
            if(a[i]>a[j]){
                if(length[j]>maxNum){
                    maxNum=length[j];
                    longestIndex=j;
                }
            }
        }
        if(longestIndex==-1){
            length[i]=1;

        }else{
            length[i]=length[longestIndex]+1;
        }

    }
    int MAX=0;
    for(int i=0;i<n;i++){
        if(length[i]>MAX){
            MAX=length[i];
        }
    }
    cout << MAX;
}

P1115 最大子段和

转移条件为，当加上这个元素后，该子段的和比当前元素要大，否则就从该元素开始重新构建子段

#include <iostream>
using namespace std;

int main() {
    int n,a[200010],dp[200010];
    cin >> n;
    for(int i=0;i<n;i++){
        cin >> a[i];
    }
    dp[0]=a[0];
    for(int i=1;i<n;i++){
        if(dp[i-1]+a[i]>a[i]){
            dp[i]=dp[i-1]+a[i];
        }else{
            dp[i]=a[i];
        }
    }
    int max =dp[0];
    for(int i=0;i<n;i++){
        if(dp[i]>max){
            max=dp[i];
        }
    }
    cout << max;
}

P8707 [蓝桥杯 2020 省 AB1] 走方格

每一格的状态转移方程是左格和上格的和，将不能走的格子视为障碍物，障碍物的值固定为0

#include <iostream>
using namespace std;


int main() {
    int m,n,dp[31][31]={0};
    cin >> n>>m;
    dp[1][1]=1;

    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(i%2==0&&j%2==0){
                dp[i][j]=0;
                continue;
            }
            dp[i][j]+=dp[i-1][j]+dp[i][j-1];
        }
    }
    cout << dp[n][m];

}

P1216 [USACO1.5] [IOI1994]数字三角形 Number Triangles

可以为每一个元素指定两个父节点，当遍历三角形数组时，将左右两父节点分别加上当前节点，并比较大小，决定当前节点接下来的值

#include <iostream>
using namespace std;

struct Node{
    int data;
    Node *lParent,*rParent;
};

int main() {
    Node zeroNode={0,NULL,NULL};
    int r;
    Node a[1010][1010];
    cin >> r;
    a[0][0]=zeroNode;
    a[0][1]=zeroNode;
    for(int i=1;i<=r;i++){
        a[i][0]=zeroNode;
        for(int j=1;j<=i;j++){
            cin >> a[i][j].data;
            a[i][j].lParent=&a[i-1][j-1];
            a[i][j].rParent=&a[i-1][j];
        }
        a[i][i+1]=zeroNode;
    }
    for(int i=1;i<=r;i++){
        for(int j=1;j<=i;j++){
            a[i][j].data+=(a[i][j].lParent->data+a[i][j].data)>(a[i][j].rParent->data+a[i][j].data)?a[i][j].lParent->data:a[i][j].rParent->data;
        }
    }
    int max=0;
    for(int i=1;i<=r;i++){
        if(a[r][i].data>max){
            max=a[r][i].data;
        }
    }
    cout << max;
}

P1020 [NOIP1999 普及组] 导弹拦截

第一问为求最大不升子序列，第二问为求最大上升子序列，为减少时间复杂度换用另一个思路求解，即当发现当前元素无法满足序列要求时，根据要求将其放置在原有序列刚好满足要求的位置

#include <iostream>
#include <algorithm>
using namespace std;



int main() {
    int nums[100010],queue1[100010],queue2[100010];
    int n=0;
    while(scanf("%d",nums+n)!=EOF){
        n++;
        if(getchar()=='\n'){break;}
    }
    queue1[0]=queue2[0]=nums[0];
    int index1=0,index2=0;
    for(int i=1;i<n;i++){
        if(nums[i]<=queue1[index1]){
            index1++;
            queue1[index1]=nums[i];
        }else{
            int tempIndex = upper_bound(queue1,queue1+index1,nums[i],greater<int>())-queue1;
            queue1[tempIndex]=nums[i];
        }
        if(nums[i]>queue2[index2]){
            index2++;
            queue2[index2]=nums[i];
        }else{
            int tempIndex = lower_bound(queue2,queue2+index2,nums[i])-queue2;
            queue2[tempIndex]=nums[i];
        }
    }
    cout << ++index1<<' '<<++index2;



}

P1048 [NOIP2005 普及组] 采药

01背包问题，状态转移方程为dp[j]=max{dp[j],dp[j-weights[i]]+values[i]}，遍历时从后往前遍历防止dp的值使用后已经发生了变化

#include <iostream>
using namespace std;


int main() {
    int t,m;
    int weights[101],values[101];
    int dp[1010]={0};
    cin >> t>>m;
    for(int i=1;i<=m;i++){
        cin >> weights[i]>>values[i];
    }
    for(int i=1;i<=m;i++){
        for(int j=t;j>=weights[i];j--){
            dp[j]=max(dp[j],dp[j-weights[i]]+values[i]);
        }
    }
    cout << dp[t];
}

P1616 疯狂的采药

完全背包问题，状态转移方程与01背包问题相同，但是可以通过从前往后遍历保证每一个元素可以被无限次使用

#include <iostream>
using namespace std;


int main() {
    int t,m;
    int weights[10010],values[10010];
    long long dp[10000010]={0};
    cin >> t>>m;
    for(int i=1;i<=m;i++){
        cin >> weights[i]>>values[i];
    }
    for(int i=1;i<=m;i++){
        for(int j=weights[i];j<=t;j++){
            dp[j]=max(dp[j],dp[j-weights[i]]+values[i]);
        }
    }
    cout << dp[t];
}

P1049 [NOIP2001 普及组] 装箱问题

可以直接理解为价值与重量相同的01背包问题

#include <iostream>
using namespace std;
int main() {
    int V,n,a[31];
    int dp[20010]={0};
    cin >> V>>n;
    for(int i=1;i<=n;i++){
        cin >> a[i];
    }

    for(int i=1;i<=n;i++){
        for(int j=V;j>=a[i];j--){
            dp[j]=max(dp[j],dp[j-a[i]]+a[i]);
        }
    }
    cout << V-dp[V];


}

P1833 樱花

混合背包问题，在每次遍历一个物品时要确定物品是属于完全背包、01背包还是多重背包问题，完全背包和01背包求解方式同第一题与第二题，多重背包问题可以拆解为counts[i]个01背包问题，即将可以多次使用的物品视作多个不同的物品，进行01背包求解

#include <iostream>
using namespace std;

struct time{
    int hour;
    int minute;
};

int timeCal(struct time end,struct time start){
    int time;
    if(end.minute>start.minute){
        time+=end.minute-start.minute;
        time += 60*(end.hour-start.hour);
    }else{
        time+=60-start.minute+end.minute;
        time+=60*(end.hour-start.hour-1);
    }
    return time;
}

int main() {
    struct time start,end;
    scanf("%d:%d",&start.hour,&start.minute);
    scanf("%d:%d",&end.hour,&end.minute);
    int t = timeCal(end,start);
    int n,weights[10010],values[10010],counts[10010];
    int dp[10010]={0};
    cin >> n;
    for(int i=1;i<=n;i++){
        cin >> weights[i]>>values[i]>>counts[i];
    }
    for(int i=1;i<=n;i++){
        if(counts[i]==0){
            for(int j=weights[i];j<=t;j++){
                dp[j]=max(dp[j],dp[j-weights[i]]+values[i]);
            }
        }else{
            for(int k=1;k<=counts[i];k++){
                for(int j=t;j>=weights[i];j--){
                    dp[j]=max(dp[j],dp[j-weights[i]]+values[i]);
                }
            }
        }
    }
    cout << dp[t];
}