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+;
 struct node{int l,r,p;}q[MAXN];
 ll sum[MAXN],f[MAXN];
 int T,n,l,p;
 char s[];

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

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

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

 void DP_1d1d(){
   int head=,tail=;
   q[++tail]=(node){,n,};
   for(int i=;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-;
         q[++tail]=(node){x,n,i};
       }
     }
   }
 }

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

DP_1d1d