BZOJ 2521: [Shoi2010]最小生成树

2521: [Shoi2010]最小生成树

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 445  Solved: 262
[Submit][Status][Discuss]

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

Source

day2

[Submit][Status][Discuss]

题目中的操作——将除这条边外所有其他边的权值全部+1——就是忽悠人的，等价于将这条边的权值+1。

利用Kruskal算法的思想，如果将所有边按照权值从小到大排序后，排在指定边之前（包括和指定边权值相同）的边能使得指定边的两点联通，则指定边一定不会被选中。将一条边从指定边之前移走的最小代价就是使得其变得严格大于指定边，插值是$Val_{id}-Val_{i}+1$。把代价作为容量，跑最小割即可。

#include <cstdio>
#include <cstring>

inline char nextChar(void)
{
    static const int siz = 1 << 20;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
    
    return *hd++;
}

inline int nextInt(void)
{
    register int ret = 0;
    register bool neg = false;
    register char bit = nextChar();
    
    for (; bit < 48; bit = nextChar());
        if (bit == '-')neg ^= true;
    
    for (; bit > 47; bit = nextChar())
        ret = ret * 10 + bit - '0';
    
    return neg ? -ret : ret;
}

const int siz = 2005;
const int edg = 2e6 + 5;
const int inf = 2e9 + 7;

int n, m, id, s, t;

struct edge
{
    int x, y, w;
}e[edg];

int hd[siz], to[edg], nt[edg], fl[edg], tot;

inline void add(int u, int v, int f)
{
    nt[tot] = hd[u]; to[tot] = v; fl[tot] = f; hd[u] = tot++;
    nt[tot] = hd[v]; to[tot] = u; fl[tot] = 0; hd[v] = tot++;
}

int dep[siz];

inline bool bfs(void)
{
    static int que[siz];
    static int head, tail;
    
    memset(dep, 0, sizeof(dep));
    
    que[head = 0] = s, tail = dep[s] = 1;
    
    while (head != tail)
    {
        int u = que[head++], v;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (!dep[v = to[i]] && fl[i])
                dep[que[tail++] = v] = dep[u] + 1;
    }
    
    return dep[t];
}

int cur[siz];

inline int min(int a, int b)
{
    return a < b ? a : b;
}

int dfs(int u, int f)
{
    if (!f || u == t)
        return f;
    
    int used = 0, flow, v;
    
    for (int i = cur[u]; ~i; i = nt[i])
        if (dep[v = to[i]] == dep[u] + 1 && fl[i])
        {
            flow = dfs(v, min(fl[i], f - used));
            
            used += flow;
            fl[i] -= flow;
            fl[i^1] += flow;
            
            if (fl[i])
                cur[u] = i;
            
            if (used == f)
                return f;
        }
    
    if (!used)
        dep[u] = 0;
    
    return used;
}

inline int minCut(void)
{
    int minCut = 0, newFlow;
    
    while (bfs())
    {
        memcpy(cur, hd, sizeof(hd));
        
        while (newFlow = dfs(s, inf))
            minCut += newFlow;
    }
    
    return minCut;
}

signed main(void)
{
    n = nextInt();
    m = nextInt();
    
    id = nextInt();
    
    for (int i = 1; i <= m; ++i)
    {
        e[i].x = nextInt();
        e[i].y = nextInt();
        e[i].w = nextInt();
    }
    
    s = e[id].x;
    t = e[id].y;
    
    int lim = e[id].w;
    
    memset(hd, -1, sizeof(hd));
    
    for (int i = 1; i <= m; ++i)
        if (e[i].w <= lim && i != id)
            add(e[i].x, e[i].y, lim + 1 - e[i].w),
            add(e[i].y, e[i].x, lim + 1 - e[i].w);
        
    printf("%d
", minCut());
}

@Author: YouSiki