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[n]>MAX) printf("Too hard to arrange\n");
        else printf("%lld\n",(long long)(f[n]));
        printf("--------------------\n");
    }
    return 0;
}