【KM】BZOJ1937 [Shoi2004]Mst 最小生成树

这道题拖了好久因为懒，结果1A了，惊讶∑( 口 ||

【题目大意】

给定一张n个顶点m条边的有权无向图。现要修改各边边权，使得给出n-1条边是这张图的最小生成树，代价为变化量的绝对值。求最小代价之和。

【思路】

思路有点神，并不是我这种蒟蒻能够想到的XD

显然由贪心，树边必定变成wi-di，非树边必定变成wi+di (di≥0)

为了满足Mst的性质，考察一条非树边j，它加最小生成树后，必定构成一个环。对于环上的每一条树边i，有wi-di≤wj+dj，即di+dj≥wi-wj。这非常类似于KM的形式x[i]+y[i]≥wt[i][j]。

那么我们就如下操作：对于最小生成树，先预处理出所有节点的深度。对于一条非树边E(u,v)，求出lca(u,v)。对于u->lca,lca->v上的每一条树边，由树边向非树边连一条（w树边-w非树边）的边。然后跑KM。

注意这个值可能小于0，由于变化量的绝对值之和必定大于0，我们就取为0即可。

【错误点】

lca和KM都写挂了一发orz

LCA的时候忘记了swim后，若u==v，返回u。

KM取slack的时候是取min的。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #include<cmath>
 using namespace std;
 const int MAXN=;
 const int MAXM=+;
 const int INF=0x7fffffff;
 struct Edge
 {
     int u,v,w,t;
 }edge[MAXM];
 vector<int> E[MAXN];
 int val[MAXM][MAXM];
 int dep[MAXN],anc[MAXN][],faedge[MAXN];
 int cnt,m,n;

 /**build tree**/
 void addedge(int u,int v,int w)
 {
     edge[++cnt]=(Edge){u,v,w,};
     E[u].push_back(cnt);
     E[v].push_back(cnt);
 }

 void dfs(int rt,int fa,int id)
 {
     dep[rt]=dep[fa]+;
     anc[rt][]=fa;
     faedge[rt]=id;
     for (int i=;i<E[rt].size();i++)
     {
         int now=E[rt][i];
         if (edge[now].t && edge[now].u!=fa && edge[now].v!=fa)
         {
             if (edge[now].u==rt) dfs(edge[now].v,rt,now);
                 else dfs(edge[now].u,rt,now);
         }
     }
 }

 /*lca*/
 int getanc()
 {
     for (int i=;i<;i++)
         for (int j=;j<=n;j++)
             anc[j][i]=anc[anc[j][i-]][i-];
 }

 int swim(int u,int H)
 {
     int i=;
     while (H>)
     {
         if (H&) u=u[anc][i];
         H>>=;
         i++;
     }
     return u;
 }

 int LCA(int u,int v)
 {
     if (dep[u]<dep[v]) swap(u,v);
     if (dep[u]!=dep[v]) u=swim(u,dep[u]-dep[v]);
     if (u==v) return u;//不要忘了这句语句
     for (int i=;i>=;i--)
     {
         if (anc[u][i]!=anc[v][i])
         {
             u=anc[u][i];
             v=anc[v][i];
         }
     }
     return anc[u][];
 }

 /*KM*/

 void Addedge(int u,int v,int w)
 {
     val[u][v]=max(w,);//由于两条边的变化量的绝对值之和不可能为负数，则必定设为0 ☆☆☆☆☆☆
 }

 void build(int a,int b,int id)
 {
     if (dep[a]<dep[b]) swap(a,b);
     while (a!=b)
     {
         Addedge(faedge[a],id,edge[faedge[a]].w-edge[id].w);
         a=anc[a][];
     }
 }

 int fx[MAXM],fy[MAXM],visx[MAXM],visy[MAXM],slack[MAXM],lk[MAXM];

 int Hungary_dfs(int u)
 {
     visx[u]=;
     for (int i=;i<=m;i++)
     {
         int wt=fx[u]+fy[i]-val[u][i];
         if (!visy[i] && wt==)
         {
             visy[i]=;
             if (lk[i]==- || Hungary_dfs(lk[i]))
             {
                 lk[i]=u;
                 return ;
             }
         }
         else slack[i]=min(slack[i],wt);//注意这里是取较小值不是较大
     }
     return ;
 }

 void KM()
 {
     memset(lk,-,sizeof(lk));
     for (int i=;i<=m;i++)
     {
         fx[i]=-INF;
         fy[i]=;
         for (int j=;j<=m;j++) fx[i]=max(fx[i],val[i][j]);
     }
     for (int i=;i<=m;i++)
     {
         memset(visx,,sizeof(visx));
         memset(visy,,sizeof(visy));
         memset(slack,0x3f,sizeof(slack));
         while (!Hungary_dfs(i))
         {
             int delta=INF;
             for (int j=;j<=m;j++)
                 if (!visy[j]) delta=min(delta,slack[j]);
             for (int j=;j<=m;j++)
             {
                 if (visx[j])
                 {
                     fx[j]-=delta;
                     visx[j]=;
                 }
                 if (visy[j])
                 {
                     fy[j]+=delta;
                     visy[j]=;
                 }
             }
         }
     }
     int ans=;
     for (int i=;i<=m;i++) ans+=(fx[i]+fy[i]);
     printf("%d",ans);
 }

 /**main part**/
 void init()
 {
     cnt=;
     scanf("%d%d",&n,&m);
     for (int i=;i<=m;i++)
     {
         int u,v,w;
         scanf("%d%d%d",&u,&v,&w);
         addedge(u,v,w);
     }

     for (int i=;i<=(n-);i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         for (int j=;j<E[x].size();j++)
         {
             int id=E[x][j];
             if ((edge[id].u==x && edge[id].v==y)||(edge[id].v==x && edge[id].u==y))
             {
                 edge[id].t=;
                 break;
             }
         }
     }
     dfs(,,);//建立以1为根的树，方便后续lca操作。注意仅有树边加入，非树边不加入
 }

 void solve()
 {
     memset(val,,sizeof(val));
     getanc();
     for (int i=;i<=m;i++)
     {
         if (!edge[i].t)
         {
             int lca=LCA(edge[i].u,edge[i].v);
             build(edge[i].u,lca,i);
             build(edge[i].v,lca,i);
         }
     }
     KM();
 }

 int main()
 {
     init();
     solve();
     return ;
 }