dp杂题（根据个人进度选更）

----19.7.30 今天又开了一个新专题，dp杂题，我依旧按照之前一样，这一个专题更在一起，根据个人进度选更题目;

dp就是动态规划，本人认为，动态规划的核心就是dp状态的设立以及dp转移方程的推导，这也是训练的重中之重，所以代码不那么重要，重要的就是dp的思想;

T1：

A. 消失之物

题目描述

ftiasch 有 N 个物品, 体积分别是 W1, W2, ..., WN。 由于她的疏忽, 第 i 个物品丢失了。 “要使用剩下的 N - 1 物品装满容积为 x 的背包，有几种方法呢？” -- 这是经典的问题了。她把答案记为 Count(i, x) ，想要得到所有1 <= i <= N, 1 <= x <= M的 Count(i, x) 表格。

这道题乍一看以为就是一个裸的背包，但是（本人太弱了）我以上来先想到的是裸的$ 0/1 $背包然后就想跑$ n $遍$  0/1 $背包，但是显然复杂度会爆炸，所以要考虑别的方法，但是还是逃不掉的dp，重点就在状态的转移，这个转移其实可以在之前的0/1背包的基础上进行转移，那么我们可以设f[maxn][2],也就是开一维半的数组，设状态为$ f[j][1] $表示背包容量为j时的方案数，因为题目恶心了我们就是要输出一个矩阵，那么我们就需要再循环i表示当我们去掉i时$  f[j][1] $就是背包容量为j时的方案数，那么就可以列出状态转移方程：(这里的0/1表示能否可以解决！)

$  f[j][0]+=f[j-v[i]] $

$  f[j][1]=f[j][0]+f[j-v[i]][1] （j-v[i]>0）$

$  f[j][1]=f[j][0]  (j-v[i]<=0) $

然后就结束了，一定要记得多多取模（他让输出最低的一位，所以不那么恶心！），这道题没什么细节，就不站代码了，评论区留给你们！

 UPD：这道题skyh的打法刷新了我的dp观，我是真的震惊！

天黄的这道题使用分治带dp打的，很新颖，不愧是dalao（orz），那么我也稍说一下skyh的思路：

$ (after 10 mins...) $其实和我的思路差不多，就是分治了一下，qwq

#include<iostream>
#include<cstdio>
using namespace std;
const int N=2010;
int n,m,w[N];
short dp[15][N];
void solve(int dep,int l,int r){
    if(l==r){
        for(int i=1;i<=m;++i) printf("%d",dp[dep-1][i]);
        puts("");
        return ;
    }
    int mid=l+r>>1;
    for(int i=0;i<=m;++i) dp[dep][i]=dp[dep-1][i];
    for(int i=mid+1;i<=r;++i) for(int j=m;j>=w[i];--j) (dp[dep][j]+=dp[dep][j-w[i]])%=10;
    solve(dep+1,l,mid);
    for(int i=0;i<=m;++i) dp[dep][i]=dp[dep-1][i];
    for(int i=l;i<=mid;++i) for(int j=m;j>=w[i];--j) (dp[dep][j]+=dp[dep][j-w[i]])%=10;
    solve(dep+1,mid+1,r);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i) scanf("%d",&w[i]);
    dp[0][0]=1; solve(1,1,n);
    return 0;
}

//copyright by skyh

//copy from skyh  orz

B. 方伯伯的玉米田

内存限制：128 MiB 时间限制：6000 ms 标准输入输出

 

 

题目描述

方伯伯在自己的农田边散步，他突然发现田里的一排玉米非常的不美。
这排玉米一共有N株，它们的高度参差不齐。
方伯伯认为单调不下降序列很美，所以他决定先把一些玉米拔高，再把破坏美感的玉米拔除掉，使得剩下的玉米的高度构成一个单调不下降序列。
方伯伯可以选择一个区间，把这个区间的玉米全部拔高1单位高度，他可以进行最多K次这样的操作。拔玉米则可以随意选择一个集合的玉米拔掉。
问能最多剩多少株玉米，来构成一排美丽的玉米。

输入格式

第1行包含2个整数n，K，分别表示这排玉米的数目以及最多可进行多少次操作。
第2行包含n个整数，第i个数表示这排玉米，从左到右第i株玉米的高度ai。

输出格式

输出1个整数，最多剩下的玉米数。

这是学长讲过的一道例题，是数据结构优化dp，而且这道题需要证明一个引理;

引理：所有操作的右端点一定是n（最右侧）的那个点。

证明：如果将一个区间内的权值都加上一个数，只会出现两种情况：

　　1.区间的左侧：

　　　　之前比区间内的数小的在操作之后还是比他小;

　　　　之前比区间内的数大的在操作之后没有他大（比他小！）;

　　　　之前比区间内的数大的在操作之后还是比他大;

　　所以区间左侧不会降低ans，还可能增加ans

　　2.区间的右侧：

　　　　之前比区间内的数小在操作之后还是比他小;

　　　　之前比区间内数大的，现在不一定比他大;

　　　　之前比区间内数大的，现在还是比他大;

　所以区间右侧不会升高ans，还可能降低ans;

所以要保证答案最优，就要有区间右侧最小，所以就有所有的操作都以n为有区间的端点;

证明完毕;

接着回到题解，这里有了上面的引理，我们就能推出dp的状态转移方程;

设$ f[i][j] $表示以i为结尾，共被拔高了j次的ans，即以i为结尾，共被j个区间覆盖;

那么，我们根据定义可以推出状态转移方程：

　　$ f[i][j]=max{f[k][l]}+1 (1<=k<=i,1<=l<=j ) $且要合法才能转移;

那么这一看如果暴力求解的话复杂度爆表，所以这个可以使用二维树状数组进行优化，然后就是$ O(n*m) $的复杂度;

代码实现也很简单：

#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<cstdio>
using namespace std;
#define re register
int a[10005],c[10005][505],n,m,maxa,ans,sum,res;
int lowbit(int x){return x&(-x);}
void change(int x,int y,int z)
{
    int yy=y;
    while(x<=maxa+m)
    {
        y=yy;
        while(y<=m+1)
        {
            c[x][y]=max(c[x][y],z);
            y+=lowbit(y);
        }
        x+=lowbit(x);
    }
}
int getsum(int x,int y)
{
    int yy=y,sum=0;
    while(x>0)
    {
        y=yy;
        while(y>0)
        {
            sum=max(sum,c[x][y]);
            y-=lowbit(y);
        }
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    //freopen("simple.txt","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        maxa=max(maxa,a[i]);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=0;j--)
        {
            res=getsum(a[i]+j,j+1)+1;
            change(a[i]+j,j+1,res);
            ans=max(ans,res);
        }
    }
    printf("%d
",ans);
    return 0;
}

C. 拦截导弹

内存限制：512 MiB 时间限制：1500 ms 标准输入输出

 

题目描述

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度、并且能够拦截任意速度的导弹，但是以后每一发炮弹都不能高于前一发的高度，其拦截的导弹的飞行速度也不能大于前一发。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

在不能拦截所有的导弹的情况下，我们当然要选择使国家损失最小、也就是拦截导弹的数量最多的方案。但是拦截导弹数量的最多的方案有可能有多个，如果有多个最优方案，那么我们会随机选取一个作为最终的拦截导弹行动蓝图。

我方间谍已经获取了所有敌军导弹的高度和速度，你的任务是计算出在执行上述决策时，每枚导弹被拦截掉的概率。

输入格式

第一行包含一个正整数

，表示敌军导弹数量；

下面 行按顺序给出了敌军所有导弹信息：

第i+1行包含2个正整数

和

，分别表示第 枚导弹的高度和速度。

输出格式

输出包含两行。

第一行为一个正整数，表示最多能拦截掉的导弹数量；

第二行包含n个0到1之间的实数，第i个数字表示第i枚导弹被拦截掉的概率（你可以保留任意多位有效数字）。

样例

样例输入

4
3 30
4 40
6 60
3 30

样例输出

2
0.33333 0.33333 0.33333 1.00000

数据范围与提示

对于100%的数据，

这个spj其实是假的，并没有部分分，但是这道题确实是一道好题，其实之前做过拦截导弹的简单版，就是线性dp，所以这还是用线性dp，显然是不行的，因为我以为是spj已经WA0好几次了，因为这道题有三个限制条件，要同时满足三个限制条件，不就是cdq分治吗，然后就把统计答案的dp扔到cdq的过程中，然后，就切了。就这样切了，当然不是，反正我不是1A的，记得开double！

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxn=100000;
inline int read()
{
    int x=0,f=1;char cc;cc=getchar();
    while(cc>'9'||cc<'0'){if(cc=='-')f=-1;cc=getchar();}
    while(cc>='0'&&cc<='9'){x=(x<<3)+(x<<1)+(cc^48);cc=getchar();}
    return x;
}
struct tree
{
    int f;double w;
    tree(){f=0,w=0;}
}t[maxn];
int n;
int st[maxn],top=0,th,tv;
inline int lowbit(int x){return x&(-x);}
inline void add(int p,int f,double w)
{
    while(p<n)
    {
        if(t[p].f<f)
        {
            if(t[p].f==0)st[++top]=p;
            t[p].f=f;t[p].w=w;
        }
        else if(t[p].f==f)t[p].w+=w;
        p+=lowbit(p);
    }
    return;
}
tree ask(int p)
{
    tree res;
    while(p)
    {
        if(t[p].f>res.f) res=t[p];
        else if(t[p].f==res.f) res.w+=t[p].w;
        p-=lowbit(p);
    }
    return res;
}
struct Dan
{
    int h,v,f[2],id,t;
    double g[2];
}a[maxn],q[maxn];
int wh[maxn],wv[maxn],id[maxn];
int rk[maxn];
inline bool cmp(int x,int y){return a[x].h<a[y].h||(a[x].h==a[y].h&&a[x].id<a[y].id);}
int cmpid(Dan a,Dan b){return a.id<b.id;}
int cnt=0;
void cdq(int l,int r,int mode)
{
    if(l==r)
    {
        if(a[l].f[mode]<1){a[l].f[mode]=1;a[l].g[mode]=1;}
        return;
    }
    int mid=(l+r)>>1;
    memcpy(q+l,a+l,sizeof(Dan)*(r-l+1));
    int q1=l,q2=mid+1;
    for(int i=l;i<=r;i++)
        if(q[i].t<=mid)a[q1++]=q[i];     
        else a[q2++]=q[i];
    cdq(l,mid,mode);
    q1=l;
    for(int i=mid+1;i<=r;i++)
    {
        while(q1<=mid && a[q1].id<a[i].id) 
            add(a[q1].v,a[q1].f[mode],a[q1].g[mode]),q1++;
        tree res=ask(a[i].v);
        if(!res.f)continue;
        if(res.f+1>a[i].f[mode])
        {
            a[i].f[mode]=res.f+1;
            a[i].g[mode]=res.w;
        }
        else if(res.f+1==a[i].f[mode]) a[i].g[mode]+=res.w;
    }
    while(top){t[st[top]].w=0;t[st[top--]].f=0;}
    cdq(mid+1,r,mode);
    merge(a+l,a+mid+1,a+mid+1,a+r+1,q+l,cmpid);
    memcpy(a+l,q+l,sizeof(Dan)*(r-l+1));
    return;
}
int main()
{
    //freopen("cnm.txt","r",stdin);
    n=read();
    for(int i=1;i<=n;i++)
    {
        a[i].h=read();a[i].v=read();a[i].id=i;
        wh[i]=a[i].h;wv[i]=a[i].v;
        rk[i]=i;
    }
    sort(wh+1,wh+n+1);
    sort(wv+1,wv+n+1);
    th=unique(wh+1,wh+n+1)-wh-1;
    tv=unique(wv+1,wv+n+1)-wv-1;
    for(int i=1;i<=n;i++)
    {
        a[i].h=th-(lower_bound(wh+1,wh+th+1,a[i].h)-wh)+1;
        a[i].v=tv-(lower_bound(wv+1,wv+tv+1,a[i].v)-wv)+1;
    }
    sort(rk+1,rk+n+1,cmp);
    for(int i=1;i<=n;i++)a[rk[i]].t=i;
    cdq(1,n,0);
    for(int i=1;i<=n;i++)
    {
        a[i].h=th-a[i].h+1;
        a[i].v=tv-a[i].v+1;
        a[i].id=n-a[i].id+1;
        a[i].t=n-a[i].t+1;
    }
    reverse(a+1,a+n+1);
    cdq(1,n,1);
    reverse(a+1,a+n+1);
    double smm=0;
    int ans=0;
    for(register int i=1;i<=n;i++)
        ans=max(ans,a[i].f[0]+a[i].f[1]-1);
    printf("%d
",ans);
    for(int i=1;i<=n;i++)
        if(a[i].f[0]==ans)
            smm+=a[i].g[0]*a[i].g[1]*1ll;
    for(int i=1;i<=n;i++)
    {
        double res=a[i].g[0]*a[i].g[1];
        if(a[i].f[0]+a[i].f[1]-1!=ans)printf("%.5lf ",0.0);
        else printf("%.5f ",res/smm);
    }
    return 0;
}

///////这个专题的坑还很大，未完待续.........////////