HDU 3861 The King’s Problem (强连通缩点+DAG最小路径覆盖)

<题目链接>

题目大意：

一个有向图，让你按规则划分区域，要求划分的区域数最少。

规则如下：1.所有点只能属于一块区域；2，如果两点相互可达，则这两点必然要属于同一区域；3，区域内任意两点至少有一方能够到达另一方。

解题分析：

双连通的两点必须要属于一块区域，所以可以直接对相互连通的点进行缩点，然后再分析缩点后的图像，因为题目要求划分的区域最少，且区域内的"点"之间至少有一方能够到达另一方。仔细思考后，发现就是对缩点后的图求最小路径覆盖。区域内的"点"至少要有一方能够到达另一方，所以"点"之间连接的道路就可以看成他们之间的匹配关系。图的最小路径覆盖=总点数-最大匹配数。

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

#define clr(a,b) memset(a,b,sizeof(a))
#define rep(i,s,t) for(int i=s;i<=t;i++)
#define pb push_back
const int N = 5e3+10;
int  dfn[N], low[N], stk[N], belong[N], vis[N], match[N];
bool instk[N];
int top, scc, tot, n, m, T;
vector<int>vt[N],G[N];

void init(){
    top=scc=tot=0;
    clr(dfn,0);clr(low,0);clr(instk,false);
}
void Tarjan(int u){       //tarjan进行缩点
    dfn[u]=low[u]=++tot;
    stk[++top]=u;instk[u]=1;
    for(int i=0; i<vt[u].size(); i++){
        int v=vt[u][i];
        if(!dfn[v]){
            Tarjan(v);
            low[u]=min(low[u],low[v]);
        }else if(instk[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u]){
        scc++;
        while(true){
            int v=stk[top--];
            instk[v]=0;
            belong[v]=scc;
            if(v==u)break;
        }
    }
}
bool dfs(int u){    
    for(int i=0; i<G[u].size(); i++){
        int v=G[u][i];
        if(!vis[v]){
            vis[v]=1;
            if(match[v]==-1||dfs(match[v])){
                match[v]=u;
                return true;
            }
        }
    }
    return false;
}
int Hungary(){    //匈牙利匹配,对缩点后的"点"求最大匹配
    int res=0;
    clr(match,-1);
    rep(i,1,scc){
        clr(vis,0);
        if(dfs(i))res++;
    }
    return res;
}
int main(){
    scanf("%d",&T);while(T--){
        scanf("%d%d",&n,&m);
        for(int i=0; i<=n; i++) vt[i].clear();
        rep(i,1,m){
            int u,v;scanf("%d%d",&u,&v);
            vt[u].pb(v);
        }
        init();
        rep(i,1,n)
            if(!dfn[i]) Tarjan(i);     //对所有双连通的点进行缩点
        rep(i,0,n)G[i].clear();
        rep(u,1,n) for(int i=0;i<vt[u].size();i++){
            int v=vt[u][i];
            if(belong[u]!=belong[v])
                G[belong[u]].pb(belong[v]);   
        }
        int res=Hungary();
           printf("%d\n",scc-res);    //求出缩点后的"点"的最小路径覆盖
    }
}

 

 

2018-11-27