[World Final 2016] Branch Assignment

链接

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的项（即-ksum[j]-jsum[k]）对答案的影响加剧,于是，随j的增加,j的最优决策中的k会单调变大（随j的增加，我们决策时更为看重含j项，为了使含j项减小，我们试图使用更大的k）

这意味着这个方程有决策单调性

本题通过带权二分和决策单调性优化可以做到$O(nlog^2)$

（感觉最近状态很差，午休一直睡不着来着，几个月了吧，先是用N^2log给方哥号上贡献了半屏T，又以为可以nlog做，然后贡献了半屏Wa，最后才发现决策单调性）

代码：

 #include<queue>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define LL long long
 #define P pair <int ,int >
 using namespace std;
 priority_queue <P ,vector <P > ,greater <P > > PQ ;
 int n,b,s,r;
 struct INP{
     int u,v,val;
 }inp[];
 struct ss{
     int to,next,val;
 }e[];
 int first[],num;
 LL d[],f[],sum[];
 int lin[],dis[],que[],grt_st[];
 void build(int ,int ,int );
 void dij(int );
 bool check(LL );
 LL ask(int ,int );
 int main()
 {
     int i,j,k,l;
     LL L,R,mid;
     scanf("%d%d%d%d",&n,&b,&s,&r);
     for(i=;i<=r;i++){
         scanf("%d%d%d",&inp[i].u,&inp[i].v,&inp[i].val);
         build(inp[i].u,inp[i].v,inp[i].val);
     }
     dij(b+);
     for(i=;i<=b;i++)    d[i]=dis[i];
     memset(first,,sizeof(first)),num=;
     for(i=;i<=r;i++)
         build(inp[i].v,inp[i].u,inp[i].val);
     dij(b+);
     for(i=;i<=b;i++)    d[i]+=dis[i];
     sort(d+,d+b+);
     for(i=;i<=b;i++)    sum[i]=sum[i-]+d[i];
     L=,R=b*sum[b],mid=(L+R)>>;
     while(R-L>=){
         if(check(mid))  L=mid;
         else    R=mid-;
         mid=(L+R)>>;
     }
     for(mid=R;mid>=L;mid--)
         if(check(mid)){
             printf("%lld\n",f[b]-s*mid);
             return ;
         }
     return ;
 }
 void build(int f,int t,int val){
     e[++num].next=first[f];
     e[num].to=t,e[num].val=val;
     first[f]=num;
 }
 void dij(int S){
     int i,U;
     memset(dis,0x3f,sizeof(dis));
     dis[S]=;
     P u,v;
     u.first=,u.second=S;
     PQ.push(u);
     while(!PQ.empty()){
         u=PQ.top();
         PQ.pop();
         U=u.second;
         for(i=first[U];i;i=e[i].next)
             if(dis[e[i].to]>dis[U]+e[i].val){
                 dis[e[i].to]=dis[U]+e[i].val;
                 v.first=dis[e[i].to],v.second=e[i].to;
                 PQ.push(v);
             }
     }
 }
 bool check(LL lim){
     int tmp=,i,h=,t=;
     int l,r,mid;
     f[]=lin[]=,grt_st[]=;
     que[t]=;
     for(i=;i<=b;i++){
         l=h+,r=t,mid=(l+r)>>;
         while(r-l>){
             if(i>=grt_st[que[mid]])    l=mid;
             else    r=mid-;
             mid=(l+r)>>;
         }
         for(mid=r;mid>=l;mid--)
             if(i>=grt_st[que[mid]]){
                 f[i]=ask(i,que[mid])+lim,lin[i]=lin[que[mid]]+;
                 break;
             }
         if(i==b)    break;
         grt_st[i]=b+;
         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--;
         if(h<t){
             l=max(grt_st[que[t]],i+),r=grt_st[i]-,mid=(l+r)>>;
             while(r-l>){
                 if(ask(mid,i)<=ask(mid,que[t]))    r=mid;
                 else    l=mid+;
                 mid=(l+r)>>;
             }
             for(mid=l;mid<=r;mid++)
                 if(ask(mid,i)<=ask(mid,que[t])){
                     grt_st[i]=mid;
                     break;
                 }
         }
         if(grt_st[i]!=b+)
             que[++t]=i;
     }
     return lin[b]>=s;
 }
 LL ask(int x,int typ){
     return f[typ]+(x-typ-)*(sum[x]-sum[typ]);
 }