COGS 426 血帆海盗 最小割+强连通分量

血帆海盗

问题描述

随着资本的扩大，藏宝海湾贸易亲王在卡利姆多和东部王国大陆各建立了 N/2 个港口。大灾变发生以后，这些港口之间失去了联系，相继脱离了藏宝海湾贸易亲王的管辖，各自为政。
利益的驱动使得每个港口都想和对岸大陆的另一个港口建立贸易合作关系，由于地理位置因素，只有存在直接到达的航线的两个港口才能建立合作，而且每个港口只与对岸一个港口建立合作，因此并不是所有的港口都能找到合作伙伴。
血帆海盗得知这一消息以后，决定对其中一条航线进行干扰性的掠夺。经过分析，血帆海盗计算出最多能有 W 对港口合作。如果两个港口之间只有一条航线，而且这条航线恰好是血帆海盗要掠夺的航线，这两个港口将不能建立合作关系。血帆海盗指挥官菲尔拉伦想知道他们有几种选择，可以让地精们无法建立 W 对港口。

输入格式

第 1行，两个整数 N,M，表示一共的港口个数和航线条数。 接下来 M行，每行两个整数 A,B，表示卡利姆多的港口 A与东部王国的港口 B之间有一
条航线直接连接，其中 1<=A<=N/2，N/2+1<=B<=N。
输出格式
l 一个整数，表示血帆海盗可以选择掠夺的航线条数。
解释：如果掠夺一条航线以后，地精依然可以建立起最多的 W个合作关系（可以有多种），
那么这条航线是不值得掠夺的，否则就是掠夺方案之一。

样例输入

8 5
1 5
1 6
2 7
3 7
4 8
样例输出
1

样例说明

地精做多能建立起合作关系的数量为 3，掠夺(4,8)这条航线后，最多能建立的合作关系的数量减少为 2。

数据规模

40%的数据满足 2<=N<=200，1<=M<=1000
100%的数据满足 2<=N<=100000，1<=M<=100000,保证 N为偶数

解法：

• 首先按照题意建所有边容量为1的图，求最大流，即最大二分匹配，这个值为w，然后明确流量为0边拆掉是没有意义的，因为w不会改变
• 对出整个图的强连通分量，此时的图是求最大流后的剩余图，如果一条边的两点不属于同一个强连通分量，那么拆掉这条边就会使得w减小，如果属于同一个强连通分量(a -> b , 流量为1)，那么删掉这条边，回到最开始的图就是拆掉边(b -> a , 流量为0)，因为在通一个联通分量中，这条边就会别的边代替（因为在一个联通分量中，a能到达b，b能到达a)

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
#include <cassert>
using namespace std ;

const int INF = 1<<27 ;
const int N = 1e5 + 11 ;
const int M = 2e6 + 11 ;

int head[N] , flow[M] , to[M] , from[M] , info[M] ; int nedge ;
int dis[N] , gap[N] ; int gnode ;
int instack[N] , belong[N] , low[N] , dfn[N] ; int color ; int vist ;
vector<int> stk ;
int source , sink ;
int n , m ;

void add_edge(int a , int b , int c) {
    if(head[a] == -1) ++gnode ;
    if(head[b] == -1) ++gnode ;
    to[++nedge] = b ;
    from[nedge] = a ;
    flow[nedge] = c ;
    info[nedge] = head[a] ;
    head[a] = nedge ;
    swap(a , b) ;
    to[++nedge] = b ;
    from[nedge] = a ;
    flow[nedge] = 0 ;
    info[nedge] = head[a] ;
    head[a] = nedge ;
}

void init() {
    fill(head , head+n+3 , -1) ; nedge = -1 ; gnode = 0 ;
    source = 0 , sink = n+1 ;
    int a , b ;
    for(int i = 0 ; i < m ; ++i) {
        scanf("%d%d" ,&a ,&b) ;
        add_edge(a , b , 1) ;
    }
    for(int i = 1 ; i+i <= n ; ++i) {
        add_edge(source , i , 1) ;
        add_edge(i+n/2 , sink  , 1) ;
    }
}

int dfs(int u , int limit) {
    if(u == sink) return limit ;
    int f1 = 0 , f ;
    int minh = gnode-1 ;
    for(int i = head[u] ; i != -1 ; i = info[i]) {
        int v = to[i] ;
        if(flow[i] > 0) {
            if(dis[v] + 1 == dis[u]) {
                f = dfs(v , min(limit , flow[i])) ;
                flow[i] -= f ;
                flow[i^1] += f ;
                limit -= f ;
                f1 += f ;
                if(dis[source] >= gnode) return f1 ;
                if(limit == 0) break ;
            }
            minh = min(minh , dis[v]) ;
        }
    }
    if(f1 == 0) {
        --gap[dis[u]] ;
        if(gap[dis[u]] == 0) dis[source] = gnode ;
        dis[u] = minh + 1 ;
        ++gap[dis[u]] ;
    }
    return f1 ;
}

void sap() {
    fill(dis , dis+n+3 , 0) ;
    fill(gap , gap+n+3 , 0) ;
    gap[source] = gnode ;
    int all = 0 ;
    while(dis[source] < gnode) {
        all += dfs(source , INF) ;
    }
}

void dfs(int u ) {
    dfn[u] = low[u] = ++vist ;
    instack[u] = 1 ;
    stk.push_back(u) ;
    for(int i = head[u] ; i != -1 ; i = info[i]) {
        int v = to[i] ;
        if(flow[i] > 0) {
            if(instack[v] == 0) {
                dfs(v) ;
                low[u] = min(low[u] , low[v]) ;
            }else if(instack[v] == 1) {
                low[u] = min(low[u] , dfn[v]) ;
            }
        }
    }
    if(dfn[u] == low[u]) {
        ++color ;
        while(stk.back() != u) {
            belong[stk.back()] = color ;
            instack[stk.back()] = 2 ;
            stk.pop_back() ;
        }
        belong[u] = color ;
        instack[u] = 2 ;
        stk.pop_back() ;
    }
}

void tarjan() {
    fill(instack , instack +n+3 , 0) ; vist = 0 ;
    stk.clear() ;
    for(int i = source ; i <= sink ; ++i) {
        if(instack[i] == 0) {
            dfs(i) ;
        }
    }
}

int main() {
    while(scanf("%d%d" ,&n ,&m)==2) {
        init() ;
        sap() ;
        tarjan() ;
        int ans = 0 ;
        for(int i = 0 ; i < m ; ++i) {
            if(flow[i*2] == 0 && belong[from[i*2]] != belong[to[i*2]]) ++ans ;
        }
        printf("%d\n" , ans) ;
    }
}