小G是一个出色的诗人，经常作诗自娱自乐。但是，他一直被一件事情所困扰，那就是诗的排版问题。
一首诗包含了若干个句子，对于一些连续的短句，可以将它们用空格隔开并放在一行中，注意一行中可以放的句子数目是没有限制的。小G给每首诗定义了一 个行标准长度（行的长度为一行中符号的总个数），他希望排版后每行的长度都和行标准长度相差不远。显然排版时，不应改变原有的句子顺序，并且小G不允许把 一个句子分在两行或者更多的行内。在满足上面两个条件的情况下，小G对于排版中的每行定义了一个不协调度, 为这行的实际长度与行标准长度差值绝对值的P次方，而一个排版的不协调度为所有行不协调度的总和。
小G最近又作了几首诗，现在请你对这首诗进行排版，使得排版后的诗尽量协调（即不协调度尽量小），并把排版的结果告诉他。
本题中包含多组测试数据。
输入文件中的第一行为一个整数T，表示诗的数量。
接下来为T首诗，这里一首诗即为一组测试数据。每组测试数据中的第一行为三个由空格分隔的正整数N，L，P，其中：N表示这首诗句子的数目，L表示这首诗的行标准长度，P的含义见问题描述。
从第二行开始，每行为一个句子，句子由英文字母、数字、标点符号等符号组成（ASCII码33～127，但不包含'-'）。
对于每组测试数据，若最小的不协调度不超过10^18，则第一行为一个数，表示不协调度。接下来若干行，表示你排版之后的诗。注意：在同一行的相邻两个句子之间需要用一个空格分开。
如果有多个可行解，它们的不协调度都是最小值，则输出任意一个解均可。若最小的不协调度超过10^18，则输出“Too hard to arrange”（不含引号）。每组测试数据结束后输出“--------------------”（不含引号），共20个“-”，“-”的ASCII 码为45，请勿输出多余的空行或者空格。
由于缺少special judge，因此在这里只要求输出最小的不协调度。格式不变，依然以"-"分割。
4
4 9 3
brysj,
hhrhl.
yqqlm,
gsycl.
4 9 2
brysj,
hhrhl.
yqqlm,
gsycl.
1 1005 6
poet
1 1004 6
poet
108
--------------------
32
--------------------
Too hard to arrange
--------------------
1000000000000000000
--------------------
【样例说明】
前两组输入数据中每行的实际长度均为6，后两组输入数据每行的实际长度均为4。一个排版方案中每行相邻两个句子之间的空格也算在这行的长度中（可参见样例中第二组数据）。每行末尾没有空格。
总共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。
这个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动态规划优化初步>>这篇文章说得很好。。。
使用一个栈来维护数据，栈中的每一个元素保存一个决策的起始位置与终了位置，显然这些位置相互连接且依次递增。
当插入一个新的决策时，从后到前扫描栈，对于每一个老决策来说，做这样两件事：
如果在老决策的起点处还是新决策更好，则退栈，全额抛弃老决策，将其区间合并至新决策中，继续扫描下一个决策。
如果在老决策的起点处是老决策好，则转折点必然在这个老决策的区间中；二分查找之，然后新决策进栈，结束。
由于一个决策出栈之后再也不会进入，所以均摊时间为O(1)，但是由于二分查找的存在，所以整个算法的时间复杂度为O(nlogn)。
这题硬是要卡乘爆啊！！！WA了无数遍。。。实现参考hzwer。
// 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 ;
}