BZOJ2521: 最小生成树 题解

Description

Secsa最近对最小生成树问题特别感兴趣。他已经知道如果要去求出一个n个点、m条边的无向图的最小生成树有一个Krustal算法和另一个Prim的算法。另外，他还知道，某一个图可能有多种不同的最小生成树。例如，下面图 3中所示的都是图 2中的无向图的最小生成树：(图略)

当然啦，这些都不是今天需要你解决的问题。Secsa想知道对于某一条无向图中的边AB，至少需要多少代价可以保证AB边在这个无向图的最小生成树中。为了使得AB边一定在最小生成树中，你可以对这个无向图进行操作，一次单独的操作是指：先选择一条图中的边 P1P2，再把图中除了这条边以外的边，每一条的权值都减少1。如图 4所示就是一次这样的操作：(图略)

Input

输入文件的第一行有3个正整数n、m、Lab分别表示无向图中的点数、边数、必须要在最小生成树中出现的AB边的标号。
接下来m行依次描述标号为1,2,3…m的无向边，每行描述一条边。每个描述包含3个整数x、y、d，表示这条边连接着标号为x、y的点，且这条边的权值为d。
输入文件保证1<=x,y<=N,x不等于y,且输入数据保证这个无向图一定是一个连通图。

Output

输出文件只有一行，这行只有一个整数，即，使得标号为Lab边一定出现最小生成树中的最少操作次数。

Sample Input

4 6 1
1 2 2
1 3 2
1 4 3
2 3 2
2 4 4
3 4 5

Sample Output

1

HINT

第1个样例就是问题描述中的例子。
1<=n<=500,1<=M<=800,1<=D<10^6

---

首先除了自己其他的边-1相当于给自己+1
一件显然的事情是我们肯定不会给指定边做+1操作
我们考虑什么时候指定边会不在最小生成树中，我们考虑kruskal的过程，是把边从小到大加入树中的，如果加到(a,b)的时候，a,b在并查集中是连通的，那么(a,b)就不会被加入，也就是说，如果存在一条路径，上面的每一条边权值都不大于w(a,b)，那么(a,b)就可能会不被加入，所以对于每一条可能的从a到b的路径，都要保证至少有1条边权值大于w(a,b)
我们考虑把所有权值不大于w(a,b)的边w(u,v)加进一个新图中((a,b)不算)，权值为w(a,b)+1-w(u,v)，这样只要求这个图的最小割就好了
最小割的源汇点肯定是a和b，考虑到这个图原本是无向的，所以S,T交换肯定对答案没有影响，所以刚开始可以随意指定
但是该怎么给无向图中的边定向呢？如果拆成两条有向边的话，一条无向边对应的两条有向边如果同时被修改的话，答案是不是会算重呢
事实上，我们确实只要把无向边拆成两条有向边连起来就行了，因为我们可以证明，在最小割中，这两条边不会被同时割掉
证明如下：考虑反证法，我们考虑有向边uv和vu，如果它们被同时割掉的话，说明原图中存在两条路径$S...u\rightarrow v...T$和$S...v\rightarrow u...T$，除了uv和vu其他的边都在残余网络中，然后我们发现如果这两条边被同时割掉的话，路径1的前半段和路径2的后半段可以组成一条新的路径，这样的话这个图ST仍是连通的，矛盾

#include <bits/stdc++.h>
using namespace std;

#define LL long long
#define LB long double
#define ull unsigned long long
#define x first
#define y second
#define pb push_back
#define pf push_front
#define mp make_pair
#define Pair pair<int,int>
#define pLL pair<LL,LL>
#define pii pair<double,double>
#define LOWBIT(x) x & (-x)

const int INF=2e9;
const LL LINF=2e16;
const int magic=348;
const int MOD=998244353;
const double eps=1e-10;
const double pi=acos(-1);

inline int getint()
{
    bool f;char ch;int res;
    while (!isdigit(ch=getchar()) && ch!='-') {}
    if (ch=='-') f=false,res=0; else f=true,res=ch-'0';
    while (isdigit(ch=getchar())) res=res*10+ch-'0';
    return f?res:-res;
}

const int MAXN=1e5;

int n,m,ind;
struct Edge
{
    int x,y,c;
    inline void input() {x=getint();y=getint();c=getint();}
}edge[MAXN+48];

int head[MAXN+48],cur[MAXN+48],to[MAXN+48],nxt[MAXN+48],f[MAXN+48],tot=1;
inline void addedge(int s,int t,int cap) {to[++tot]=t;nxt[tot]=head[s];head[s]=tot;f[tot]=cap;}
int S,T;

int depth[MAXN+48],q[MAXN+48],Head,Tail;
inline bool bfs()
{
    int i,x,y;
    for (i=1;i<=n;i++) depth[i]=-1;
    depth[S]=0;q[1]=S;Head=Tail=1;
    while (Head<=Tail)
    {
        x=q[Head++];
        for (i=head[x];i;i=nxt[i])
        {
            y=to[i];
            if (depth[y]==-1 && f[i])
            {
                depth[y]=depth[x]+1;
                q[++Tail]=y;
            }
        }
    }
    if (depth[T]==-1) return false; else return true;
}

inline int dfs(int x,int maxf)
{
    if (x==T) return maxf;
    int y,minf,now,ans=0;
    for (int &i=cur[x];i;i=nxt[i])
    {
        y=to[i];
        if (depth[y]==depth[x]+1 && f[i])
        {
            minf=min(maxf-ans,f[i]);
            now=dfs(y,minf);
            f[i]-=now;f[i^1]+=now;ans+=now;
        }
    }
    if (ans==0) depth[x]=0;
    return ans;
}

int main ()
{
    n=getint();m=getint();ind=getint();int i;
    for (i=1;i<=m;i++) edge[i].input();
    for (i=1;i<=m;i++)
    {
        if (i==ind) continue;
        if (edge[i].c<=edge[ind].c)
        {
            addedge(edge[i].x,edge[i].y,edge[ind].c+1-edge[i].c);
            addedge(edge[i].y,edge[i].x,edge[ind].c+1-edge[i].c);
        }
    }
    S=edge[ind].x;T=edge[ind].y;
    int ans=0;
    while (bfs())
    {
        for (i=1;i<=n;i++) cur[i]=head[i];
        ans+=dfs(S,2e9);
    }
    printf("%d\n",ans);
    return 0;
}