DP_1d1d诗人小G

显然：f[i]=min{f[j]+(s[i]-s[j]+i-j-1-l)^p}

此题可以基于决策单调优化

证明，反正我现在不打算学

实际上就是双向队列

不停弹出队头的元素，直到当前位置在队头元素最优的范围内。

然后，每次把当前决策插入队尾，并弹出没它优的答案。

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

typedef long double ll;
const int MAXN=1e5+10;
struct node{int l,r,p;}q[MAXN];
ll sum[MAXN],f[MAXN];
int T,n,l,p;
char s[35];

ll pow(ll x){
  int y=p;ll ret=1;
  while(y){
    if(y&1)ret=ret*x;
    x*=x,y>>=1;
  }
  return ret;
}

ll calc(int x,int y){
  return f[x]+pow(abs(sum[y]-sum[x]+(y-x-1)-l));
}

int find(node x,int i){
  int l=x.l,r=x.r;
  while(l<=r){
    int mid=(l+r)>>1;
    if(calc(i,mid)<=calc(x.p,mid))r=mid-1;
    else l=mid+1;
  }
  return l;
}

void DP_1d1d(){
  int head=1,tail=0;
  q[++tail]=(node){0,n,0};
  for(int i=1;i<=n;i++){
    if(head<=tail && q[head].r<i)head++;
    f[i]=calc(q[head].p,i);
    if(calc(i,n)<=calc(q[tail].p,n)){
      while(head<=tail && calc(q[tail].p,q[tail].l)>=calc(i,q[tail].l) )tail--;
      if(head>tail)q[++tail]=(node){i,n,i};
      else{
        int x=find(q[tail],i);
        q[tail].r=x-1;
        q[++tail]=(node){x,n,i};
      }
    }
  }
}

int main(){
  scanf("%d",&T);
  while(T--){
    scanf("%d%d%d",&n,&l,&p);
    for(int i=1;i<=n;i++)scanf("%s",s),sum[i]=sum[i-1]+strlen(s);
    DP_1d1d();
    if(f[n]>1e18)puts("Too hard to arrange");
    else    printf("%lld\n",(long long)f[n]);
    puts("--------------------");
  }
  return 0;
}