一些DP杂题

1.

[HNOI2001] 产品加工

一道简单的背包，然而我还是写了很久QAQ

时间范围是都小于5 显然考虑一维背包，dp[i]表示目前A消耗了i的最小B消耗

注意

if(b[i]) dp[j]=dp[j]+b[i];
 else dp[j]=1e9+7;

可以用B则直接转移，否则要把上一次的这个状态设为正无穷，只能用后两个转移。

//Twenty
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn=+;
const int N=*+;
int n,a[maxn],b[maxn],c[maxn],dp[N],lz[N],ans=1e9+;
int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++) scanf("%d%d%d",&a[i],&b[i],&c[i]);
    memset(dp,,sizeof(dp));
    dp[]=;
    for(int i=;i<=n;i++)
        for(int j=i*;j>=;j--){
            if(b[i]) dp[j]=dp[j]+b[i];
            else dp[j]=1e9+;//!!!!!!!!!!!!!!!!!!!!
            if(a[i]&&j>=a[i]&&dp[j]>dp[j-a[i]]) dp[j]=dp[j-a[i]];
            if(c[i]&&j>=c[i]&&dp[j]>dp[j-c[i]]+c[i]) dp[j]=dp[j-c[i]]+c[i];
            if(i==n) ans=min(max(dp[j],j),ans);
        }
    cout<<ans;
    return ;
}

2.

[HAOI2007]上升序列

看数据范围似乎是n^2可以过的，然而自己之前并不会写nlongn求最长上升子序列的算法就自己YY了一下，写得很丑，单调栈里从短到长从大到小，用了两个二分，一次找找最长的比它小的，一次找长度为它的位置是否可以更新。

这样找到以每个元素打头的最长上升序列，询问就从1到n跑一遍问它能不能到那么长，就保证了字典序最小。

//Twenty
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<stack>
#include<vector>
using namespace std;
const int maxn=+;
int now,n,m,x,maxx,a[maxn],pre[maxn],dp[maxn],sta[maxn],sl=,sr;
int ef(int l,int r,int x){
    int res=-;
    while(l<=r){
        int mid=(l+r)>>;
        if(a[sta[mid]]>x) res=mid,l=mid+;
        else r=mid-;
    }
    return res;
}
void ef2(int l,int r,int len,int x){
    while(l<=r){
        int mid=(l+r)>>;
        if(dp[sta[mid]]==len) { if(a[sta[mid]]<=a[x]) sta[mid]=x; break;}
        if(dp[sta[mid]]<len) l=mid+;
        else if(dp[sta[mid]]>len) r=mid-;
    }
}
void work() {
    for(int i=n;i>=;i--) {
        dp[i]=;
        if(sl<=sr) {
        now=ef(sl,sr,a[i]);
        if(now!=-)
            dp[i]=dp[sta[now]]+;
        }
        maxx=max(maxx,dp[i]);
        while(sr>=sl&&dp[sta[sr]]<=dp[i]&&a[sta[sr]]<=a[i]) {
            sr--;
        }
        if(sr<sl||dp[sta[sr]]<dp[i]) sta[++sr]=i;
        else ef2(sl,sr,dp[i],i);
    }
}
void query(int x){
    if(x>maxx) puts("Impossible");
    else {
        int pre=;
        for(int i=;i<=n;i++) {
            if(dp[i]>=x&&a[i]>pre) {
                pre=a[i];
                if(x==)
                printf("%d",a[i]);
                else printf("%d ",a[i]);
                x--;
                if(!x) break;
            }
        }
        printf("\n");
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++) scanf("%d",&a[i]);
    work();
    scanf("%d",&m);
    for(int i=;i<=m;i++) {
        scanf("%d",&x);
        query(x);
    }
    return ;
}

然而正确的nlogn求最长上升序列并不是这么写的，只用一个二分，不过在下并不是很清楚，懒得学以后再说吧。

从LLJ大佬那里学到了用线段树的做法，开一颗权值线段树，从后往前把Dp值存进去，每个点找它后面的最大Dp值来更新，感觉和正常的nlogn的思路可能差不多。

3.

UVA - 12063 Zeros and Ones

二进制数和它们的位模式对于计算机程序员来说总是非常有趣的。 在这个
您需要计算具有以下属性的正数二进制数的问题：
•数字正好是N位宽，它们没有前导零。
•一和零的频率相等。
•数字是K的倍数。
输入
输入文件包含几个测试用例。 输入的第一行为您提供了测试用例数，
T（1≤T≤100）。 那么T测试用例会跟随，每一行都在一行。 每个测试用例的输入包括
的两个整数，N（1≤N≤64）和K（0≤K≤100）。
产量
对于每组输入，首先打印测试用例编号。 然后打印二进制数的数字

谷歌翻译神坑，1和0频率相同翻译成0和0频率相同，喵喵喵？

把Case打成case被坑了一波。。对拍才发现QAQ

最好的做法是往后加0或者1 不用特判，不会炸整，往前加的话就要特判，然后注意开 long long ,要模两次保证不会炸 (LLJ大佬说要开usinged long long ,因为 long long 只到2^64-1，实际这题只到2^63所以不用）

//Twenty
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
typedef unsigned long long LL;
const int maxn=;
const int maxk=;
int T,n,k;
LL dp[maxn][maxn][maxk],ans,ll=;
void work(){
    if(!k||n&) {printf("0\n"); return;}
    memset(dp,,sizeof(dp));
    dp[][][]=;
    for(int i=;i<=n;i++)
        for(int j=;j<=i;j++)
            for(int l=;l<k;l++) {
               if(j) dp[i][j][(l+((ll=)<<(i-))%k)%k]+=dp[i-][j-][l];
               if(i!=n) dp[i][j][l]+=dp[i-][j][l];
            }
    ans=;
    printf("%llu\n",dp[n][n/][]);
}
int main()
{

    scanf("%d",&T);
    for(int i=;i<=T;i++){
        scanf("%d%d",&n,&k);
        printf("Case %d: ",i);
        work();
    }
    return ;
}

这是往后加的版本

    for(int i=;i<n;i++)
        for(int j=;j<=i;j++)
            for(int l=;l<k;l++) {
               dp[i+][j+][((l<<)|)%k]+=dp[i][j][l];
               dp[i+][j][(l<<)%k]+=dp[i][j][l];
            }

4.

UVA - 1628 Pizza Delivery

我爱记忆化搜索，记忆化搜索最强。

dp[i][j][o][k]表示i到j的订单已处理好，现在在i或者j 还要送k家的最优解

枚举，记忆化

for(int i=;i<l;i++) u=max(u,dfs(i,r,,k-)+e[i]-k*abs(p[i]-p[o==?l:r]));
    for(int i=n;i>r;i--) u=max(u,dfs(l,i,,k-)+e[i]-k*abs(p[i]-p[o==?l:r]));

注意这一段先搜两边再中间，可以达到记忆化效果

代码

//Twenty
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn=+;
int T,now,dp[maxn][maxn][][maxn],vis[maxn][maxn][][maxn],n,p[maxn],e[maxn],ans;
int dfs(int l,int r,int o,int k) {
    if(k==) return ;
    if(vis[l][r][o][k]==now) return dp[l][r][o][k];
    vis[l][r][o][k]=now;
    int &u=dp[l][r][o][k];
    u=;
    for(int i=;i<l;i++) u=max(u,dfs(i,r,,k-)+e[i]-k*abs(p[i]-p[o==?l:r]));
    for(int i=n;i>r;i--) u=max(u,dfs(l,i,,k-)+e[i]-k*abs(p[i]-p[o==?l:r]));
    return u;
}
int main()
{
    scanf("%d",&T);
    for(now=;now<=T;now++) {
    ans=;
    scanf("%d",&n);
    for(int i=;i<=n;i++) scanf("%d",&p[i]);
    for(int i=;i<=n;i++) scanf("%d",&e[i]);
    for(int kk=;kk<=n;kk++)
        for(int i=;i<=n;i++)
        ans=max(ans,dfs(i,i,,kk-)+e[i]-kk*abs(p[i]));
    printf("%d\n",ans);
    }
    return ;
}

5.BZOJ 1009 [HNOI2008]GT考试

一开始傻逼地kmp直接往前跳一个就停了，后来改了又调了好久发现自己Kmp写错了，贼难受。。

就kmp转移然后矩阵优化。

//Twenty
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
int ans,n,m,p,top,a[],nxt[],cnt[],vis[];
struct jz{
    int x[][];
    friend jz operator *(const jz&l,const jz&r){
         jz res;
         for(int i=;i<;i++)
         for(int j=;j<;j++)
         res.x[i][j]=;
         for(int i=;i<;i++)
             for(int j=;j<;j++) {
                 for(int k=;k<;k++)
                     (res.x[i][j]+=(l.x[i][k]*r.x[k][j])%p)%=p;
             }
         return res;
    }
}base,ret,tmp;
void input() {
    scanf("%d%d%d",&n,&m,&p);
    char ch=getchar();
    while(ch<''||ch>'') ch=getchar();
    for(;ch>=''&&ch<='';ch=getchar()) a[++top]=ch-'';
}
int make_nxt(int a[],int *nxt) {
    for (int j=,i=;i<=m;i++) {
        while (j&&a[j+]!=a[i]) j=nxt[j];
        if (a[j+]==a[i]) j++;
        nxt[i]=j;
     }
}
void ksm(int b){
    while(b){
        if(b&) ret=ret*base;
        base=base*base;
        b>>=;
    }
}
void work() {
    for(int i=;i<m;i++) {
        cnt[i]++;
        vis[a[i+]]=i+;
        if(i+!=m) {base.x[i][i+]++;}
        int tp=i;
        while(nxt[tp]) {
            tp=nxt[tp];
            if(vis[a[tp+]]!=i+) {
            vis[a[tp+]]=i+;
            cnt[i]++;
            base.x[i][tp+]++;
            }
        }
        if(vis[a[]]!=i+) {
            cnt[i]++;
            base.x[i][]++;
        }
        base.x[i][]+=(-cnt[i]);
    }
    for(int i=;i<m;i++)
        for(int j=;j<m;j++)
            if(i==j) ret.x[i][j]=;
    ksm(n);
    ans=;
    for(int i=;i<m;i++)
    (ans+=ret.x[][i])%=p;
    printf("%d\n",ans);
}
int main()
{
    input();
    make_nxt(a,nxt);
    work();
    return ;
}

GT考试

6.BZOJ 1855 [SCOI2010]股票交易

在某位学长的博客里看到这题第一句话是省选怎么会考这么简单的题呢，然后就发现自己不会做。。。

神奇的单调队列优化，可能是我单调队列写得太少了。。

很容易知道状态dp[i][j]表示时间为i手中股票为j的最大收益，初始化为极小值，dp[0][0]=0;

然后转移分三种

不买不卖：dp[i][j]=max(dp[i][j],dp[i-1][j]);

买入：dp[i][j]=max(dp[i][j],dp[i-w-1][j-k]-k*ap[i]);

卖出：dp[i][j]=max(dp[i][j],dp[i-w-1][j+k]+k*bp[i]);

然后我们发现后两个枚举k会超时，就把它优化一下 （其实我也。。比较懵逼）

买入：dp[i][j]=max(dp[i][j],dp[i-w-1][k]-(j-k)*ap[i]);

=max(dp[i][j],(dp[i-w-1][k]+k*ap[i])-j*ap[i]);

卖出：dp[i][j]=max(dp[i][j],dp[i-w-1][k]+(k-j)*bp[i]);

=max(dp[i][j],(dp[i-w-1][k]+k*ap[i])-j*bp[i]);

以买入为例，我们发现 这一部分 dp[i-w-1][k]+k*ap[i] （j-k>0,j-k<as[i]）具有单调性，

k>j-as[i] 我们枚举k,然后丢进单调队列， 更新现在的dp[i][k]；

//Twenty
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn=+;
int ans,n,maxp,w,dp[maxn][maxn];
int ap[maxn],bp[maxn],as[maxn],bs[maxn],que[maxn],ql=,qr;
int main()
{
    scanf("%d%d%d",&n,&maxp,&w);
    for(int i=;i<=n;i++)
    scanf("%d%d%d%d",&ap[i],&bp[i],&as[i],&bs[i]);
    memset(dp,,sizeof(dp));
    dp[][]=;
    for(int i=;i<=n;i++) {
        ql=,qr=;
        for(int j=;j<=maxp;j++) {
            dp[i][j]=max(dp[i][j],dp[i-][j]);
            if(i-w->) {
                while(ql<=qr&&que[ql]<j-as[i]) ql++;
                while(ql<=qr&&dp[i-w-][que[qr]]+que[qr]*ap[i]-j*ap[i]<=dp[i-w-][j]) qr--;
                que[++qr]=j;
                if(ql<=qr) dp[i][j]=max(dp[i][j],dp[i-w-][que[ql]]+que[ql]*ap[i]-j*ap[i]);
            }
            else if(j<=as[i]) dp[i][j]=max(dp[i][j],-ap[i]*j);
        }
        ql=,qr=;
        for(int j=maxp;j>=;j--) {
           if(i-w->){
               while(ql<=qr&&que[ql]>j+bs[i]) ql++;
               while(ql<=qr&&dp[i-w-][que[qr]]+que[qr]*bp[i]-j*bp[i]<=dp[i-w-][j]) qr--;
               que[++qr]=j;
               if(ql<=qr) dp[i][j]=max(dp[i][j],dp[i-w-][que[ql]]+que[ql]*bp[i]-j*bp[i]);
           }
        }
    }
    for(int i=;i<=maxp;i++) ans=max(ans,dp[n][i]);
    printf("%d\n",ans);
    return ;
}

股票交易