bzoj 2229[Zjoi2011]最小割

2229: [Zjoi2011]最小割

Time Limit: 10 Sec  Memory Limit: 259 MB

Description

小白在图论课上学到了一个新的概念——最小割，下课后小白在笔记本上写下了如下这段话： “对于一个图，某个对图中结点的划分将图中所有结点分成两个部分，如果结点s,t不在同一个部分中，则称这个划分是关于s,t的割。 对于带权图来说，将所有顶点处在不同部分的边的权值相加所得到的值定义为这个割的容量，而s,t的最小割指的是在关于s,t的割中容量最小的割” 现给定一张无向图，小白有若干个形如“图中有多少对点它们的最小割的容量不超过x呢”的疑问，小蓝虽然很想回答这些问题，但小蓝最近忙着挖木块，于是作为仍然是小蓝的好友，你又有任务了。

Input

输入文件第一行有且只有一个正整数T，表示测试数据的组数。 对于每组测试数据， 第一行包含两个整数n,m，表示图的点数和边数。 下面m行，每行3个正整数u,v,c(1<=u,v<=n,0<=c<=106)，表示有一条权为c的无向边(u,v) 接下来一行，包含一个整数q，表示询问的个数 下面q行，每行一个整数x，其含义同题目描述。

Output

对于每组测试数据，输出应包括q行，第i行表示第i个问题的答案。对于点对(p,q)和(q,p)，只统计一次（见样例）。

两组测试数据之间用空行隔开。

Sample Input

1
5 0
1
0

Sample Output

10

【数据范围】
对于100%的数据 T<=10,n<=150,m<=3000,q<=30，x在32位有符号整数类型范围内。
图中两个点之间可能有多条边

 

 

这里用到了一个知识点叫最小割树

一个n点的图最多有n-1个最小割

我们可以将一个图变成一个树

则这张图中任意两点的最小割就是最小割树上两点之间最短的割

操作很简单

每次任选两点跑最小割， 分为集合s, t

在两个集合中递归下去

 

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
#define LL long long

using namespace std;

queue<int> q;
const LL inf = 1e18;
const int MAXN = 200;
const int MAXM = 3e3 + 10;
int TT, Q;
int n, m;
int S, T;
LL u, v, c;
int cnt = 0;

LL ans[MAXN][MAXN];
bool vis[MAXN];
int a[MAXN];
int temp[MAXN];
int h[MAXN];
int head[MAXN];

struct edge {
    int v;
    LL c;
    int next;
} g[MAXM * 2];

void addedge(int u, int v, int w)
{
    g[cnt].v = v;
    g[cnt].c = w;
    g[cnt].next = head[u];
    head[u] = cnt++;
}

inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

void restore()
{
    for(int j = 0; j <= cnt; j++) {
        g[j].c = g[j ^ 1].c = ((g[j].c + g[j ^ 1].c) >> 1);
    }
}

bool BFS()
{
    memset(h, -1, sizeof h);
    h[S] = 0;
    q.push(S);
    while(!q.empty()) {
        int t = q.front();
        q.pop();
        for(int j = head[t]; j != -1; j = g[j].next) {
            int to = g[j].v;
            if(h[to] == -1 && g[j].c) {
                h[to] = h[t] + 1;
                q.push(to);
            }
        }
    }
    if(h[T] == -1) {
        return false;
    }
    return true;
}

LL DFS(int x, LL f)
{
    int used = 0;
    if(x == T) {
        return f;
    }
    for(int j = head[x]; j != -1; j = g[j].next) {
        int to = g[j].v;
        if(h[to] == h[x] + 1 && g[j].c) {
            LL w = f - used;
            w = DFS(to, min(w, g[j].c));
            used += w;
            g[j].c -= w, g[j ^ 1].c += w;
            if(used == f) {
                break;
            }
        }
    }
    if(!used) {
        h[x] = -1;
    }
    return used;
}

void search(int x)
{
    vis[x] = 1;
    for(int j = head[x]; j != -1; j = g[j].next) {
        int to = g[j].v;
        if(!vis[to] && g[j].c) {
            search(to);
        }
    }
}

void solve(int l, int r)
{
    //cout<<l<<" "<<r<<endl;
    if(l == r) {
        return;    
    }
    restore();
    S = a[l], T = a[r];
    LL flow = 0;
    while(BFS()) {
        flow += DFS(S, inf);
    }
    memset(vis, 0, sizeof vis);
    search(S);
    int L = l, R = r;
    for(int i = l; i <= r; i++) {
        if(vis[a[i]]) {
            temp[L++] = a[i];
        } else {
            temp[R--] = a[i];
        }
    }
    for(int i = 1; i <= n; i++) {
        if(vis[i]) {
            for(int j = 1; j <= n; j++) {
                if(!vis[j]) {
                    ans[i][j] = ans[j][i] = min(ans[i][j], flow);
                }
            }
        }
    }
    for(int i = l; i <= r; i++) {
        a[i] = temp[i];
    }
    solve(l, L - 1), solve(R + 1, r);
}

void open()
{
    freopen("mincut1.in", "r", stdin);
    //freopen("mincut.out", "w", stdout);
}

void close()
{
    fclose(stdin);
    fclose(stdout);
}
int main()
{
    //open();
    TT = read();
    while(TT--) {
        memset(ans, 0x3f, sizeof ans);
        memset(head, -1, sizeof head);
        cnt = 0;
        n = read(), m = read();
        for(int i = 1; i <= n; i++) {
            a[i] = i;
        }
        for(int i = 1; i <= m; i++) {
            u = read(), v = read(), c = read();
            addedge(u, v, c);
            addedge(v, u, c);
        }
        solve(1, n);
        Q = read();
        while(Q--) {
            int sum = 0;
            LL x = read();
            for(int i = 1; i <= n; i++) {
                for(int j = i + 1; j <= n; j++) {
                    if(ans[i][j] <= x) {
                        sum++;
                    }
                }
            }
            printf("%d
", sum);
        }
        printf("
");
    }
//    close();
    return 0;
}


/*
1
5 0
1
0

*/