連結

PDF

bzoj

先求出正置邊和反置邊時b+1到前b個點的最短路dis[0/1][x]（x∈[1,b]），

令D[x]=dis[0][x]+dis[1][x]

然後分組後每個x對代價的貢獻為D[x]*（所在組中元素個數-1）

考慮DP決策分組過程，發現沒有一個很好的序，

不過為了使得代價小，應該把D小的放在個數大的組裡，D大的放在個數少的組裡

由此可以想出，應該是大小相近的元素放在了同一組中，這意味著，先排序，在劃分成s段，的所有情況包含了原問題的最優解

於是把D[1~b]排序後，有方程

$f[i][j]=MIN_{k=0}^{j-1}[f[i-1][k]+(j-k-1)*(sum[j]-sum[k])]$

$O(n^3)$

其中：f[i][j]表示把前j個分成i組的最小值，sum為D的字首和

非法狀態均置為INF

由於可以粗略的知道這個東西在j確定，i為自變數的函式影象上有凸性

（可以玄學地認為，最開始的時候，多劃分一刀可以造成很大的改變，隨著劃分次數越來越多，多劃分一刀的改變越來越微小）

於是，可以使用帶權二分來優化這一DP

即，消去對劃分次數的限制，通過二分來找到一個合適的劃分附加代價，使得即使不限制劃分次數，最後的最優解也恰好滿足我們對劃分數的限制

這樣有了一個新的方程

$f'[j]=MIN_{k=0}^{j-1}[f'[k]+(j-k-1)*(sum[j]-sum[k])]+C$

$O(n^2log)$

考慮優化轉移過程

拆開方程得到

$f'[j]=MIN_{k=0}^{j-1}[f'[k]+(k+1)sum[k]-ksum[j]-jsum[k]]+(j-1)sum[j]+C$

在方程中

當固定j不動時

隨k增加，f'[k]+(k+1)sum[k]項增加，而-ksum[j]-jsum[k]項減小

所以，隨j的增加，j的最優決策中的k會單調後移

這意味著這個方程有決策單調性

本題通過帶權二分和決策單調性優化可以做到$O(nlog^2)$

（感覺最近狀態很差，午休一直睡不著來著，幾個月了吧，先是用N^2log給方哥號上貢獻了半屏T，又以為可以nlog做，然後貢獻了半屏Wa，最後才發現決策單調性）

程式碼：

  1 #include<queue>
  2 #include<cstdio>
  3 #include<cstring>
  4 #include<algorithm>
  5 #define LL long long
  6 #define P pair <int ,int >
  7 using namespace std;
  8 priority_queue <P ,vector <P > ,greater <P > > PQ ;
  9 int n,b,s,r;
 10 struct INP{
 11     int u,v,val;
 12 }inp[50010];
 13 struct ss{
 14     int to,next,val;
 15 }e[50010];
 16 int first[5010],num;
 17 LL d[5010],f[5010],sum[5010];
 18 int lin[5010],dis[5010],que[5010],grt_st[5010];
 19 void build(int ,int ,int );
 20 void dij(int );
 21 bool check(LL );
 22 LL ask(int ,int );
 23 int main()
 24 {
 25     int i,j,k,l;
 26     LL L,R,mid;
 27     scanf("%d%d%d%d",&n,&b,&s,&r);
 28     for(i=1;i<=r;i++){
 29         scanf("%d%d%d",&inp[i].u,&inp[i].v,&inp[i].val);
 30         build(inp[i].u,inp[i].v,inp[i].val);
 31     }
 32     dij(b+1);
 33     for(i=1;i<=b;i++)    d[i]=dis[i];
 34     memset(first,0,sizeof(first)),num=0;
 35     for(i=1;i<=r;i++)
 36         build(inp[i].v,inp[i].u,inp[i].val);
 37     dij(b+1);
 38     for(i=1;i<=b;i++)    d[i]+=dis[i];
 39     sort(d+1,d+b+1);
 40     for(i=1;i<=b;i++)    sum[i]=sum[i-1]+d[i];
 41     L=0,R=b*sum[b],mid=(L+R)>>1;
 42     while(R-L>=3){
 43         if(check(mid))  L=mid;
 44         else    R=mid-1;
 45         mid=(L+R)>>1;
 46     }
 47     for(mid=R;mid>=L;mid--)
 48         if(check(mid)){
 49             printf("%lld\n",f[b]-s*mid);
 50             return 0;
 51         }
 52     return 0;
 53 }
 54 void build(int f,int t,int val){
 55     e[++num].next=first[f];
 56     e[num].to=t,e[num].val=val;
 57     first[f]=num;
 58 }
 59 void dij(int S){
 60     int i,U;
 61     memset(dis,0x3f,sizeof(dis));
 62     dis[S]=0;
 63     P u,v;
 64     u.first=0,u.second=S;
 65     PQ.push(u);
 66     while(!PQ.empty()){
 67         u=PQ.top();
 68         PQ.pop();
 69         U=u.second;
 70         for(i=first[U];i;i=e[i].next)
 71             if(dis[e[i].to]>dis[U]+e[i].val){
 72                 dis[e[i].to]=dis[U]+e[i].val;
 73                 v.first=dis[e[i].to],v.second=e[i].to;
 74                 PQ.push(v);
 75             }
 76     }
 77 }
 78 bool check(LL lim){
 79     int tmp=0,i,h=0,t=1;
 80     int l,r,mid;
 81     f[0]=lin[0]=0,grt_st[0]=1;
 82     que[t]=0;
 83     for(i=1;i<=b;i++){
 84         l=h+1,r=t,mid=(l+r)>>1;
 85         while(r-l>3){
 86             if(i>=grt_st[que[mid]])    l=mid;
 87             else    r=mid-1;
 88             mid=(l+r)>>1;
 89         }
 90         for(mid=r;mid>=l;mid--)
 91             if(i>=grt_st[que[mid]]){
 92                 f[i]=ask(i,que[mid])+lim,lin[i]=lin[que[mid]]+1;
 93                 break;
 94             }
 95         if(i==b)    break;
 96         grt_st[i]=b+1;
 97         while(h<t&&grt_st[que[t]]>i&&ask(grt_st[que[t]],i)<=ask(grt_st[que[t]],que[t]))    grt_st[i]=grt_st[que[t]],t--;
 98         if(h<t){
 99             l=max(grt_st[que[t]],i+1),r=grt_st[i]-1,mid=(l+r)>>1;
100             while(r-l>3){
101                 if(ask(mid,i)<=ask(mid,que[t]))    r=mid;
102                 else    l=mid+1;
103                 mid=(l+r)>>1;
104             }
105             for(mid=l;mid<=r;mid++)
106                 if(ask(mid,i)<=ask(mid,que[t])){
107                     grt_st[i]=mid;
108                     break;
109                 }
110         }
111         if(grt_st[i]!=b+1)
112             que[++t]=i;
113     }
114     return lin[b]>=s;
115 }
116 LL ask(int x,int typ){
117     return f[typ]+(x-typ-1)*(sum[x]-sum[typ]);
118 }