【LightOJ】Assassin`s Creed (II) (缩点,传递闭包,二分图匹配,最小路径覆盖)


题目链接:

http://acm.bnu.edu.cn/v3/problem_show.php?pid=23628


这道题是一道图论的综合题。题意较简单,如果对图论部分算法较为熟悉,那么很快便能找到清晰的解题思路。而且这道题中涉及了多种算法,对新手来说这是个很好的训练自己,提升自己的题目。


这是一个有向图A(可能有环)的最小路径覆盖问题。首先,利用【tarjan算法】缩点,得到一个DAG图B,然后用算一次图B的传递闭包,因为下一步利用二分图匹配去算最小路径覆盖的时候,所需要的边不仅仅是图B原来存在的边,而是B图的传递闭包中所有的边,具体原因看这里:

http://www.cnblogs.com/ka200812/archive/2011/07/31/2122641.html


算传递闭包的方法有很多,比如:


1 Floyd-Warshall算法 http://www.nocow.cn/index.php/Floyd-Warshall%E7%AE%97%E6%B3%95#.E6.94.B9.E8.BF.9B.E5.92.8C.E4.BC.98.E5.8C.96

2 对每个点做一次 dfs / bfs(优化)

3 对每个点做一次 spfa(优化)

因为在这道题中,顶点数为10^3,边数为10^5,时间限制是4s,所以用Floyd-Warshall算法会超时,从而只能选择用2,3两种方法,而且必须是利用边邻接表优化过的算法,否则仍然会超时。


剩下的就是利用二分图匹配来算最小路径覆盖,我使用的是【Hopcroft-Carp 算法】。


这道题我前前后后做了一个多月,主要是想尝试找出一个更简单的求最小路径覆盖的方法,但是后来发现自己想到的方法中均出现了不好处理的错误,于是最终还是选择了使用二分图匹配法,之后又发现自己使用【Floyd-Warshall算法】算传递闭包时O(n^3)的复杂度会使得程序超时,转念想到稀疏图中【spfa算法】有更好表现(复杂度为O(ke),k近似为2),最终利用更快的spfa求得传递闭包。此题终结。



最后是3488ms时间AC了,但是和其他人的代码比起来,我自己的代码明显还有更多的优化空间:





代码:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define LL long long
#define db double
#define pi acos(-1.0)
#define pr printf
#define sc scanf
#define mod
#define N 1005
#define M 10003
#define typec int // type of cost
using namespace std;
LL MAX_LL = 0xfffffffffffffffLL;


bool c[N][N],g[N][N];//INIT
bool Bc[N][N];//新建图的邻接表//INIT
int Bin[N];//新建图中每个节点的入度//INIT

int DFN[N];//INIT//DFN[]数组起到了vis[]数组的作用,不用另外开vis[]数组
int LOW[N];
bool instack[N];//判断节点是否在栈中//INIT
int Belong[N];//判断节点属于哪一个分量
int Index,n,m,Bn;//Bn是连通分量的个数//INIT
stack  sta;

void Init()
{
    int i,j;

    while(!sta.empty())
        sta.pop();

    Index = Bn = 0;

    for(i=0; i<=n; ++i)
    {
        instack[i] = 0;
        DFN[i] = 0;
        for(j=0; j<=n; ++j)
            c[i][j] = Bc[i][j] = g[i][j] = 0;
    }
}
void tarjan(int now)
{
    int i;
    DFN[now] = LOW[now] = ++Index;
    sta.push(now);
    instack[now] = 1;//更新now在栈中
    for(i=1; i<=n; ++i)
    {
        if(!c[now][i])
            continue;
        if(!DFN[i])//如果没访问过
        {
            tarjan(i);
            LOW[now] = min(LOW[now],LOW[i]);
        }
        else if(instack[i])//如果在栈中
        {
            LOW[now] = min(LOW[now],DFN[i]);
        }
    }
    if(DFN[now] == LOW[now])
    {
        Bn++;//强连通分量增加

        int t;
        do
        {
            t = sta.top();
            sta.pop();
            instack[t] = 0;//记录出栈
            Belong[t] = Bn;//该节点属于哪个分量
        }
        while(now!=t);
    }
}

const int MAXN = N;
const int INF = 1 << 28;
int Mx[MAXN], My[MAXN], Nx, Ny;
int dx[MAXN], dy[MAXN], dis;
bool vst[MAXN];
bool searchP(void)
{
    queue Q;
    dis = INF;
    memset(dx, -1, sizeof(dx));
    memset(dy, -1, sizeof(dy));
    for (int i = 0; i < Nx; i++)
        if (Mx[i] == -1)
        {
            Q.push(i);
            dx[i] = 0;
        }
    while (!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        if (dx[u] > dis) break;
        for (int v = 0; v < Ny; v++)
            if (g[u][v] && dy[v] == -1)
            {
                dy[v] = dx[u]+1;
                if (My[v] == -1) dis = dy[v];
                else
                {
                    dx[My[v]] = dy[v]+1;
                    Q.push(My[v]);
                }
            }
    }
    return dis != INF;
}
bool DFS(int u)
{
    for (int v = 0; v < Ny; v++)
        if (!vst[v] && g[u][v] && dy[v] == dx[u]+1)
        {
            vst[v] = 1;
            if (My[v] != -1 && dy[v] == dis) continue;
            if (My[v] == -1 || DFS(My[v]))
            {
                My[v] = u;
                Mx[u] = v;
                return 1;
            }
        }
    return 0;
}
int MaxMatch(void)
{
    int res = 0;
    memset(Mx, -1, sizeof(Mx));
    memset(My, -1, sizeof(My));
    while (searchP())
    {
        memset(vst, 0, sizeof(vst));
        for (int i = 0; i < Nx; i++)
            if (Mx[i] == -1 && DFS(i)) res++;
    }
    return res;
}


int head[N],next[M],to[M];//注意每个数组的size
int dis1[N],len[M];

bool vis[N];
int en;//en是边数



void add(int u,int v,int w)
{
    to[en]=v,len[en] = w,next[en] = head[u],head[u] = en++;
}

void spfa(int s)
{

    for(int i=0;i<=Bn;++i)
    {
        dis1[i] = INT_MAX;
        vis[i] = 0;
    }
    queue q;
    q.push(s);
    dis1[s] = 0;
    vis[s] = 1;

    while(!q.empty())
    {
        int u = q.front();
        Bc[s+1][u+1] = 1;
        q.pop();
        vis[u] = 0;
        for(int i=head[u];i!=-1;i=next[i])
        {
            int v = to[i];

            if(dis1[u]+len[i]


你可能感兴趣的:(图论,Tarjan,Tarjan,图论,最小路径覆盖,HopcroftCarp,算法,二分图匹配)