【BZOJ1563】【NOI2009】诗人小G（dp+决策单调性）

Description



Input



Output

对于每组数据，若最小的不协调度不超过1018，则第一行一个数表示不协调度若最小的不协调度超过1018，则输出”Too hard to arrange”(不包含引号)。每个输出后面加”——————–”

Sample Input

4

4 9 3

brysj,

hhrhl.

yqqlm,

gsycl.

4 9 2

brysj,

hhrhl.

yqqlm,

gsycl.

1 1005 6

poet

1 1004 6

poet

Sample Output

108

32

Too hard to arrange

1000000000000000000

【样例说明】

前两组输入数据中每行的实际长度均为6，后两组输入数据每行的实际长度均为4。一个排版方案中每行相邻两个句子之间的空格也算在这行的长度中(可参见样例中第二组数据)。每行末尾没有空格。

HINT

总共10个测试点，数据范围满足：

测试点 T N L P

1 ≤10 ≤18 ≤100 ≤5

2 ≤10 ≤2000 ≤60000 ≤10

3 ≤10 ≤2000 ≤60000 ≤10

4 ≤5 ≤100000 ≤200 ≤10

5 ≤5 ≤100000 ≤200 ≤10

6 ≤5 ≤100000 ≤3000000 2

7 ≤5 ≤100000 ≤3000000 2

8 ≤5 ≤100000 ≤3000000 ≤10

9 ≤5 ≤100000 ≤3000000 ≤10

10 ≤5 ≤100000 ≤3000000 ≤10

所有测试点中均满足句子长度不超过30。

题解：%%%PoPoQQQ大神！！！%%%byvoid大神！！！

首先，可以列出dp方程，这样可得30分（因为有个讨厌的指数）。

列出了dp方程但是只能拿暴力分数的时候，就要想怎么优化了（除非dp根本是错的）。决策单调性我不会证（我是连导数都不会的蒟蒻），但是打表还是可以看出来的。

由于列出的方程是这样的：



我们可以看出这是一个1D1D动态规划，那么决策区间就是连续的段落，于是我们维护一个上凸壳，每次更新的时候用二分就好了。

注意数据比较大，用long double 算完转long long。

代码如下：

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#define ll long double
#define inf 9000000000000000000
#define MAX 1000000000000000000LL
using namespace std;
int t,n,l,p,top;
ll sum[100005],f[100005],from[100005];
char ch[100005][35];
struct nod
{
int l,r,p;
nod(){}
nod(int a,int b,int c):l(a),r(b),p(c){}
}q[100005];
ll read()
{
ll x=0;
char c=getchar();
while(c<'0' || c>'9') c=getchar();
while(c<='9' && c>='0'){x=x*10+c-'0';c=getchar();}
return x;
}
ll pow(ll x)
{
if(x<0) x=-x;
ll ans=1;
for(int i=1;i<=p;i++) ans*=x;
return ans;
}
ll cal(int j,int i)
{
return f[j]+pow(sum[i]-sum[j]+(i-j-1)-l);
}
int find(nod a,int b)
{
int l=a.l,r=a.r;
while(l<=r)
{
int mid=l+r>>1;
if(cal(a.p,mid)<cal(b,mid)) l=mid+1;
else r=mid-1;
}
return l;
}
void dp()
{
int hd=1,tl=0;
q[++tl]=nod(0,n,0);
for(int i=1;i<=n;i++)
{
if(hd<=tl && i>q[hd].r) hd++;
f[i]=cal(q[hd].p,i);from[i]=q[hd].p;
if(hd>tl || cal(i,n)<=cal(q[tl].p,n))
{
while(hd<=tl && cal(i,q[tl].l)<=cal(q[tl].p,q[tl].l)) tl--;
if(hd>tl) q[++tl]=nod(i,n,i);
else
{
int t=find(q[tl],i);
q[tl].r=t-1;
q[++tl]=nod(t,n,i);
}
}
}
}
int main()
{
t=read();
while(t--)
{
n=read(),l=read(),p=read();
for(int i=1;i<=n;i++) scanf("%s",ch[i]);
for(int i=1;i<=n;i++) sum[i]=sum[i-1]+strlen(ch[i]);
dp();
if(f
>MAX) printf("Too hard to arrange\n");
else printf("%lld\n",(long long)(f
));
printf("--------------------\n");
}
return 0;
}