BZOJ 1563: [NOI2009]诗人小G 决策单调性

1563: [NOI2009]诗人小G

Time Limit: 100 Sec  Memory Limit: 64 MB
Submit: 2856  Solved: 936
[Submit][Status][Discuss]

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。

这个题一眼并不好发现决策单调性

但其实是可以证明的 具体见https://www.byvoid.com/zhs/blog/noi-2009-poet

决策单调性的讲解可见https://wenku.baidu.com/view/29a17c214b73f242336c5fe0.html?from=search

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<map>
#include<set>
using namespace std;

//typedef long long ll;
typedef long double ll;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){x=10*x+ch-'0';ch=getchar();}
	return x*f;
}
void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=100100;
const ll inf=ll(1e18);

struct node
{
	int l,r,d;
	// interval and its decition point
}q[N];

int n,L,P;
int len[N],sum[N];

inline ll get_pow(ll x)
{
	ll res(1);
	for(int i=1;i<=P;++i) res*=x;
	return abs(res);
}

ll f[N];

inline ll get_f(int i,int j)
{return f[j]+get_pow(sum[i]-sum[j]+i-j-1-L);}

int find(int tail,int i)
{
	int l(q[tail-1].l),r(q[tail-1].r),mid;
	while(l<=r)
	{
		mid=(l+r)>>1;
		get_f(mid,q[tail-1].d)<get_f(mid,i) ? l=mid+1 : r=mid-1;
	}
	return l-1;
}

void solve()
{
	register int i,tmp,head(0),tail(1);
	q[head]=(node){0,n,0};
	for(i=1;i<=n;++i)
	{
		if(head<tail && i>q[head].r) head++;
		f[i]=get_f(i,q[head].d);
		if( head>=tail || get_f(n,i)<=get_f(n,q[tail-1].d) )
		{
			while( head<tail && get_f(q[tail-1].l,i)<=get_f(q[tail-1].l,q[tail-1].d) )
				tail--;
			if(head>=tail) q[tail++]=(node){i,n,i};
			else
			{
				tmp=find(tail,i);
				q[tail-1].r=tmp;
				q[tail++]=(node){tmp+1,n,i};
			}
		}
	}
	if(f[n]>inf) puts("Too hard to arrange");
	else cout<<(long long)f[n]<<endl;
	puts("--------------------");
}

char s[100];

int main()
{
	register int T=read(),i;
	while(T--)
	{
		n=read(),L=read(),P=read();
		for(i=1;i<=n;++i)
			scanf("%s",s+1),
			len[i]=strlen(s+1),
			sum[i]=sum[i-1]+len[i];
		solve();
	}
}