团队暑期集训 - 基础DP练习

团队暑期集训的题，都比较基础。

A - Max Sum Plus Plus

这道题是由下面这道题改编而来。
P1115 最大子段和
给出一个长度为 n 的序列 a，选出其中连续且非空的一段使得这段和最大。

int a,n,m,f[N],ans = -99999;
int main(){
    cin>>n;
    for(int i = 1;i <= n;++i){
        scanf("%d",&a);
        f[i] = max(f[i - 1] + a,a);
        ans = max(ans,f[i]);
    }
    cout<<ans<<endl;
    return 0;
}

Now I think you have got an AC in Ignatius.L’s “Max Sum” problem. To be a brave ACMer, we always challenge ourselves to more difficult problems. Now you are faced with a more difficult problem.

Given a consecutive number sequence S 1, S 2, S 3, S 4 … S x, … S n (1 ≤ x ≤ n ≤ 1,000,000, -32768 ≤ S x ≤ 32767). We define a function sum(i, j) = S i + … + S j (1 ≤ i ≤ j ≤ n).

Now given an integer m (m > 0), your task is to find m pairs of i and j which make sum(i 1, j 1) + sum(i 2, j 2) + sum(i 3, j 3) + … + sum(i m, j m) maximal (i x ≤ i y ≤ j x or i x ≤ j y ≤ j x is not allowed).

But I`m lazy, I don’t want to write a special-judge module, so you don’t have to output m pairs of i and j, just output the maximal summation of sum(i x, j x)(1 ≤ x ≤ m) instead. ^_

求n个元素数组的m段连续子段和的最大值

dp[i][j]=前j个数选择i段的最大值

状态转移：$dp[i][j]=max(dp[i][j-1],max\{dp[i-1][k]\})+a[j](i-1<=k<=j-1)$

第J个元素可以和前面的连接在一起，构成i段，或者独自成为一段，

如果是独自成为一段的话，那么前j-1个数必须组合出i-1段，选择多种情况里的最大值，

最后由于数据较大，所以要压缩空间，使用滚动数组

#include
#include
#include
#include
using namespace std;
const int N=2000010;
const int INF = 2147483647;

int n,m,maxn;
int f[N],pre[N];
int a[N];

int main(){
    while(~scanf("%d%d",&m,&n)){
        memset(f,0,sizeof f);
        memset(pre,0,sizeof pre);
        for(int i = 1;i <= n;++i)
            scanf("%d",&a[i]);
        for(int i = 1;i <= m;++i){
            maxn = -INF;
            for(int j = i;j <= n;++j){//至少需要m个数组成m组
                f[j] = max(f[j - 1],pre[j - 1]) + a[j];//连上上一组和新开一组
                pre[j - 1] = maxn;
                maxn = max(maxn,f[j]);
            }
        }
        cout<<maxn<<endl;
    }
    return 0;
}

D - 做作业(状态压缩)

有n个任务，每个任务有一个截止时间，超过截止时间一天，要扣一个分。
求如何安排任务，使得扣的分数最少。

Input

有多组测试数据。第一行一个整数表示测试数据的组数
第一行一个整数n(1<=n<=15)
接下来n行，每行一个字符串(长度不超过100)表示任务的名称和两个整数，分别表示任务的截止时间和完成任务需要的天数。 这n个任务是按照字符串的字典序从小到大给出。

Output

每组测试数据，输出最少扣的分数的。 并输出一个完成任务的方案，如果有多个方案，输出字典序最小的一个。

题目要求按字典序从小到大输出，如果没有这个要求，那么我们直接用一个优先队列贪心即可。为了解决字典序的问题，我们要按字典序从大到小枚举作业，在每次更新的时候记录前驱，然后倒序输出(利用递归输出或者怕爆栈可以用栈模拟递归)，因为这样如果是两个数据一样的方案，也会因为我们是从大到小枚举而导致先更新字典序大的，这样倒序输出时就能保证是所有方案里字典序从小到大输出的。

#include
#include
#include
#include
using namespace std;

const int N = 20;
const int INF = 2147483647;
int f[1 << N];//记录当前为状态i的时候的最小扣分
string name[N];
int need[N],ed[N];
int pre[1 << N];
int tim[1 << N];

void out(int x){
    if(!x)return ;
    out(x ^ (1 << pre[x]));
    cout<<name[pre[x]]<<endl;
}
int t,n,m;
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i = 0;i < n;++i){
            cin>>name[i]>>ed[i]>>need[i];
        }
        int bit = 1 << n;
        for(int i = 1;i < bit;i++){
            f[i] = INF;
            for(int j = n - 1;j >= 0;j--){
                if(!(i & (1 << j)))
                    continue;
                int now = i ^ (1 << j);
                int score = tim[now] + need[j] - ed[j];
                if(score < 0)score = 0;
                if(f[i] > f[now] + score){
                    f[i] = f[now] + score;
                    tim[i] = tim[now] + need[j];
                    pre[i] = j;
                }
            }
        }
        printf("%d\n",f[bit - 1]);
        out(bit - 1);
    }
    return 0;
}

E - Super Jumping! Jumping! Jumping!

bobo成功的在他人的帮助下获得了与小姐姐约会的机会，可是如何选择和哪些小姐姐约会呢？bobo希望自己可以循序渐进，同时希望挑战自己的极限，我们假定每个小姐姐有一个“攻略难度值”
从攻略成功第一个小姐姐开始，bobo希望每下一个需要攻略的小姐姐难度更高，同时又希望攻略难度值之和最大，好了，现在小姐姐们排成一排，bobo从左往右开始攻略，只能从左往右开始攻略，请你帮助他找到最大的攻略难度和
注意：只能从左往右开始攻略，小姐姐可以选择跳过不攻略，一定要选择获取攻略难度最大的和，样例已更新
Input
多组输入，每组数据占一行，每行一个整数n表示小姐姐个数，接着n个数a1, a2, …, an表示第i个的小姐姐攻略难度 (ai在32位有符号整型范围内)，n = 0表示输入结束 (0 <= n <= 1000)。
Output
一个数字，表示最大攻略和

还是LIS最长上升子序列，只不过这里需要的答案不是最长上升子序列的长度而是总和，稍微改一下就行了。

#include
#include
#include
#include
using namespace std;

const int N = 100007;

int n,res;
int a[N];
int dp[N];

int main(){
    while(cin>>n && n){
        memset(dp,0,sizeof dp);
        res = 0;
        for(int i = 0;i < n;++i)
            cin>>a[i];
        dp[0] = a[0];
        for(int i = 1;i < n;++i){
            int tmp = 0;
            for(int j = 0;j < i;++j)
                if(a[j] < a[i])
                    tmp = max(dp[j],tmp);
            dp[i] = tmp + a[i];
            
        }
        for(int i = 0;i < n;++i)
            res = max(res,dp[i]);
        cout<<res<<endl;
    }
    return 0;
}

I - 最少拦截系统(最长上升子序列模板)

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹.
怎么办呢?多搞几套系统呗!你说说倒蛮容易,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最少需要多少套拦截系统.
Input
输入若干组数据.每组数据包括:导弹总个数(正整数),导弹依此飞来的高度(雷达给出的高度数据是不大于30000的正整数,用空格分隔)
Output
对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统.

模板不解释。
我用树状数组写不知道为什么会RE，有空了再调试一下。

#include
#include
#include
#include
using namespace std;

const int N = 100007;

int n,res;
int a[N];
int dp[N];

int main(){
    while(cin>>n){
            res = 0;
        for(int i = 0;i < n;++i)
            cin>>a[i];
        for(int i = 0;i < n;++i){
            dp[i] = 1;
            for(int j = 0;j < i;++j)
                if(a[j] < a[i])
                    dp[i] = max(dp[i],dp[j] + 1);
            res = max(res,dp[i]);
        }
        cout<<res<<endl;
    }
    return 0;
}