【样例说明】

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

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

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

这个DP的模型跟玩具装箱几乎一模一样，都是划分型DP。。。

设f[i]表示到第i句话的最优值。。。

记一个前缀和a,  n^2 的转移 f[i]=min(f[i],f[j]+(abs(i-j-1+a[i]-a[j]-L)^p));30分

这题巨坑！！！乘会爆long long！！！ 要开long double！！！

不开就只有10分。。。

这题有决策单调性（自己打表）

对与决策单调性有一个常数优化，即每次从上次最大的能转移的点开始枚举，这样有50分，但在某些题目中，用这个东西经常可以AC！！！

70分的话，在50--70的部分分打玩具装箱的斜率优化。。。

这题是p次方所以不能用斜率优化做。。。

正经的决策单调性的解决办法是什么呢。。。就是二分栈！！！

<<1D1D动态规划优化初步>>这篇文章说得很好。。。

 // MADE BY QT666

 #include<cstdio>

 #include<algorithm>

 #include<cmath>

 #include<iostream>

 #include<queue>

 #include<set>

 #include<cstdlib>

 #include<cstring>

 #include<string>

 #include<ctime>

 #include<iomanip>

 #define lson num<<1

 #define rson num<<1|1

 using namespace std;

 const int N=;

 int gi()

 {

   int x=,flag=;

   char ch=getchar();

   while(ch<''||ch>''){if(ch=='-') flag=-;ch=getchar();}

   while(ch>=''&&ch<='') x=x*+ch-'',ch=getchar();

   return x*flag;

 }

 char ch[];

 long double a[N],f[N];

 int n,L,p;

 struct data{int l,r,p;}q[N];

 long double work(long double x,int p){

     long double ret=;

     if(x<) x=-x;

     for(int i=;i<=p;i++){

         ret*=x;

     }

     return ret;

 }

 long double cal(int j,int i){

     return f[j]+work(a[i]-a[j]+i-j--L,p);

 }

 int find(data t,int x)

 {

     int l=t.l,r=t.r;

     while(l<=r)

     {

         int mid=(l+r)>>;

         if(cal(t.p,mid)<cal(x,mid))

             l=mid+;

         else r=mid-;

     }

     return l;

 }

 main()

 {

     int T;

     T=gi();

     while(T--)

     {

         n=gi(),L=gi(),p=gi();

         for(int i=;i<=n;i++){

             scanf("%s",ch+);

             a[i]=a[i-]+strlen(ch+);

         }

         /*int last=1;

         for(int i=1;i<=n;i++){

             f[i]=work((int)abs(i-1+a[i]-L),p);

             for(int j=last;j<i;j++){

                 int y=f[j]+work((int)abs(i-j-1+a[i]-a[j]-L),p);

                 if(y<f[i]) f[i]=y,last=j;

             }

             }*/

         int head=,tail=;

     q[++tail]=(data){,n,};

     for(int i=;i<=n;i++){

         if(head<=tail&&i>q[head].r)head++;

         f[i]=cal(q[head].p,i);

         if(head>tail||cal(i,n)<=cal(q[tail].p,n)){

             while(head<=tail&&cal(i,q[tail].l)<=cal(q[tail].p,q[tail].l))

                   tail--;

             if(head>tail)

                 q[++tail]=(data){i,n,i};

             else {

                 int t=find(q[tail],i);

                 q[tail].r=t-;

                 q[++tail]=(data){t,n,i};

             }

           }

         }

         if(f[n]>) puts("Too hard to arrange");

         else printf("%lld\n",(long long)f[n]);

         puts("--------------------");

     }

     return ;

 }