Minimum Cut

Minimum Cut

Time Limit: 3000/2000 MS (Java/Others)    Memory Limit: 65535/102400 K (Java/Others)
Total Submission(s): 769    Accepted Submission(s): 340

Problem Description

Given a simple unweighted graph G (an undirected graph containing no loops nor multiple edges) with n nodes and m edges. Let T be a spanning tree of G.
We say that a cut in G respects T if it cuts just one edges of T.

Since love needs good faith and hypocrisy return for only grief, you should find the minimum cut of graph G respecting the given spanning tree T.

 

 

Input

The input contains several test cases.
The first line of the input is a single integer t (1≤t≤5) which is the number of test cases.
Then t test cases follow.

Each test case contains several lines.
The first line contains two integers n (2≤n≤20000) and m (n−1≤m≤200000).
The following n−1 lines describe the spanning tree T and each of them contains two integers u and v corresponding to an edge.
Next m−n+1 lines describe the undirected graph G and each of them contains two integers u and v corresponding to an edge which is not in the spanning tree T.

 

 

Output

For each test case, you should output the minimum cut of graph G respecting the given spanning tree T.

 

 

Sample Input

1

4 5

1 2

2 3

3 4

1 3

1 4

 

 

Sample Output

Case #1: 2

 

 

Source

2015 ACM/ICPC Asia Regional Shenyang Online

 

题意：在G中有T，问G 最小割中有且仅有一割在 T  中的最小割是多少。

 

考虑每条不属 于 T   边  对 生成树 T  树 边 的覆盖次数。

每条树边被覆盖的次数其实就是断裂这条树边后还需断裂的新边数。

 

在m-n-1行中都是T中没有的边，添加了（u， v）之后，v中的子节点，叶子节点都可以和u联系，那么在求最小割的时候就要删除这条边，使得G中 变成两个由 u 和v 构成的不连通的图。

用cnt 存该点需要被断裂几次，即断裂这条边后 还需要断裂几条边可以使G 不连通。遍历求最小值即最小割

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <cstring>

using namespace std;

#define INF 0x3f3f3f3f
#define min(a,b) (a<b?a:b)
#define N 100005

vector< vector<int> > G;
int deep[N], f[N], cnt[N];

void dfs(int u, int fa, int step)
{
    deep[u] = step;
    cnt[u] = 1;
    f[u] = fa;
    int len = G[u].size();
    for(int i = 0; i < len; i++)
    {
        int v = G[u][i];
        if(v != fa)
            dfs(v, u, step+1);
    }
}

void Lca(int x, int y)
{
    while(x != y)
    {
        if(deep[x] >= deep[y])
        {
            cnt[x]++;
            x = f[x];
        }
        else
        {
            cnt[y]++;
            y = f[y];
        }
    }
}

int main()
{
    int t, i, a, b, n, m, l = 1;
    scanf("%d", &t);
    while(t--)
    {
        G.resize(N);
        G.clear();
        scanf("%d%d", &n, &m);
        for(i = 1; i < n; i++)
        {
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        dfs(1, 0, 1);
        for(; i <= m; i++)
        {
            scanf("%d%d", &a, &b);
            Lca(a, b);
        }
        int ans = INF;
        for(i = 2; i <= n; i++)
            ans = min(ans, cnt[i]);
        printf("Case #%d: %d\n", l++, ans);
    }
    return 0;
}