hdu1827 强联通分量+并查集

题目给定一个有向图，让求覆盖全图所有节点需要通知的最少人数和最少花费是多少。

这里给出的电话关系形成有向图，其中，在一个强连通分量中的所有节点可以互达，用他们中花费最小的点作为代表节点即可，因为只需要通知任意一个节点便能覆盖该连通分量。将一个强连通分量进行缩点后，形成一个无环的新图，可以使用并查集，一个点和其到达的其他点形成一个集合，最后集合的个数便是需要通知的最少人数，每个集合的根节点的花费的和就是总的最小花费。因为对同一个集合内的元素来说，通知根节点总是最划算的方法来覆盖这个集合的所有点，如果通知其他点，还要单独通知根节点，因为其他点无法到达根节点（如果能到就是一个强连通分量中的点，缩点时缩一起了）。

代码比较长，但思路清晰。

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <stack>

using namespace std;

int head[1001];
int v[1001];
int low[1001];
int dfn[1001];
int father[1001];
int instack[1001];
int f[1001];
int n,m;
int cnt;
int ans;
int sum;
stack <int> ms;

struct edge
{
    int to,next;
}e[2001];

edge ne[2001];
int nhead[1001];
int cc;

void init()
{
    memset(head,-1,sizeof(head));
    memset(v,0,sizeof(v));
    memset(instack,0,sizeof(instack));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    for (int i=1;i<=n;i++)
        father[i]=f[i]=i;
    while (!ms.empty())
        ms.pop();
    ans=0;
    cnt=1;
    sum=0;
}

int min(int a,int b)
{
    return a<b?a:b;
}

void tarjan(int u)
{
    dfn[u]=low[u]=cnt++;
    ms.push(u);
    instack[u]=1;
    int cur=head[u];
    while (cur!=-1)
    {
        int p=e[cur].to;
        if (!dfn[p])
        {
            tarjan(p);
            low[u]=min(low[u],low[p]);
        }
        else if (instack[p])
        {
            low[u]=min(low[u],low[p]);
        }
        cur=e[cur].next;
    }
    if (low[u]==dfn[u])
    {
        int s=0x3f3f3f3f;
        int p=ms.top();
        ms.pop();
        instack[p]=0;
        while (p!=u)
        {
            s=min(s,v[p]);
            father[p]=u;
            p=ms.top();
            instack[p]=0;
            ms.pop();
        }
        v[u]=min(s,v[u]);
    }
}

void build()
{
    memset(nhead,-1,sizeof(nhead));
    cc=1;
    for (int i=1;i<=n;i++)
    {
        int cur=head[i];
        int u=father[i];
        while (cur!=-1)
        {
            int p=e[cur].to;
            if (father[p]!=u)
            {
                ne[cc].to=father[p];
                ne[cc].next=nhead[u];
                nhead[u]=cc;
                cc++;
            }
            cur=e[cur].next;
        }
    }
}

int find(int u)
{
    if (f[u]==u)
        return u;
    f[u]=find(f[u]);
    return f[u];
}

void Union()
{
    for (int i=1;i<=n;i++)
    {
        if (father[i]!=i)
            continue;
        //cout<<" "<<i<<" "<<v[i]<<endl;
        int cur=nhead[i];
        while (cur!=-1)
        {
            int p=ne[cur].to;
            f[p]=find(i);
            cur=ne[cur].next;
        }
    }
}

int main()
{
    while (cin>>n>>m)
    {
        init();
        for (int i=1;i<=n;i++)
            cin>>v[i];
        for (int i=1;i<=m;i++)
        {
            int a,b;
            cin>>a>>b;
            e[i].to=b;
            e[i].next=head[a];
            head[a]=i;
        }
        for (int i=1;i<=n;i++)
        {
            if (!dfn[i])
                tarjan(i);
        }
        /*
        cout<<endl;
        for (int i=1;i<=n;i++)
            cout<<i<<" "<<father[i]<<endl;
        cout<<endl;
        */
        build();
        Union();
        for (int i=1;i<=n;i++)
        {
            find(i);
            if (father[i]==i&&f[i]==i)
            {
                //cout<<i<<" "<<f[i]<<endl;
                sum++;
                ans+=v[i];
            }
        }
        cout<<sum<<" "<<ans<<endl;
    }
}