JZOI 3521 道路覆盖 二分答案+状压dp

题目描述

Tar 把一段凹凸不平的路分成了高度不同的 N 段（每一段相同高度），并用 H[i] 表示第 i 段高度。现在 Tar 一共有 n 种泥土可用，它们都能覆盖给定的连续的 k 个部分。
对于第 i 种泥土，它的价格为 C[i]，可以使得区间 [i,min(n,i+k-1)] 的路段的高度增加 E[i]。
Tar 要设定一种泥土使用计划，使得使用若干泥土后，这条路最低的高度尽量高，并且这个计划必须满足以下两点要求：
（1）每种泥土只能使用一次。
（2）泥土使用成本必须小于等于 M 。
请求出这个最低的高度最高是多少。

输入格式

第一行为如上文所示的三个正整数：N，M，K。
接下来 N 行，每行3个如上文所示的正整数 H[i]，E[i]，C[i]。

输出格式

输出有且只有一个数字，为最底部分的高度的最大值。

样例数据 1

输入

4 20 1
1 3 5
1 7 3
4 6 9
3 5 13

输出

3

备注

【数据范围】

对于 30% 的数据：N≤20。
对于 100% 的数据：1≤K≤11；1≤N≤100；0≤M,H[i],E[i],C[i]≤1000000。

解题报告：

二分+DP
由于是求最小值中的最大值，所以二分答案ans，问题转化为了判定性问题。判定的方法是：每个位置都能到达高度ans的最小费用cost是否<=M。
注意到1<=K<=11，也就是说对于第i个路段，能够提高它高度的泥土只有从第i-K个到第i个。于是使用状态压缩动态规划求cost。f[i][j]表示前i个路段通过泥土使用>=高度ans，且第i - k个到第i个的使用情况为二进制数j的cost,我的代码是从二进制个位表示i的使用情况，所以得到从f[i-1]到f[i]的转移方程为

f[i][j]=min(f[i-1][j>>1],f[i-1][(j>>1)+pow[k-1]])+(j&1)*c[i];

其中f[i-1][j>>1]表示第i-k-1个泥土没用，f[i-1][(j>>1)+pow[k-1]]表示第i-k-1个泥土用了。
若f[i][j]=INF，则表示该状态前i条路中有没达到预定高度或cost超出了m；

g[j]表示在j状态下i可以升高多少。

时间复杂度为$O(log(h_{max}+k*e_{max})*n*2^n)$,在5百万级左右。

具体代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c<'0'||c>'9')&&c!='-';c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=105;
const int K=12;
const int INF=0x3f3f3f3f;
int n,m,k;
int pow[K];
int f[N][1<<K-1],h[N],e[N],c[N],g[1<<K-1];
bool ok[N];

inline int minpow(int x){
    for(int i=k;i>=0;i--)
        if(x>=pow[i])return i;
}

bool check(int x)
{
    memset(f,INF,sizeof(f));f[0][0]=0;
    memset(ok,false,sizeof(ok));
    for(int i=1;i<=n;i++)
    {
        g[0]=0;
        int mx=i<k?pow[i]:pow[k];
        for(int j=0;j<mx;j++)
        {
            int t;
            if(j==0)g[j]=0;
            else 
            {
                t=minpow(j);
                g[j]=g[j-pow[t]]+e[i-t];
            }
            if(g[j]+h[i]<x)continue;
            if(f[i-1][j>>1]==INF&&f[i-1][(j>>1)+pow[k-1]]==INF)continue;
            t=min(f[i-1][j>>1],f[i-1][(j>>1)+pow[k-1]]);
            f[i][j]=t+(j&1)*c[i];
            if(f[i][j]>m)f[i][j]=INF;
            else ok[i]=true;
        }
        if(!ok[i])return false;
    }
    return true;
}

int main()
{
    //freopen("lx.in","r",stdin);
    n=getint(),m=getint(),k=getint();
    pow[0]=1;
    for(int i=1;i<=k;i++)pow[i]=pow[i-1]<<1;
    for(int i=1;i<=n;i++)
        h[i]=getint(),e[i]=getint(),c[i]=getint();

    int l=0,r=12000000;
    while(r>=l)
    {
        int mid=l+r>>1;
        if(check(mid))l=mid+1;
        else r=mid-1;
    }
    cout<<r;
    return 0;
}