Codeforces Round #267 Div.2 D Fedor and Essay -- 强连通 DFS

题意：给一篇文章，再给一些单词替换关系a b，表示单词a可被b替换，可多次替换，问最后把这篇文章替换后（或不替换）能达到的最小的'r'的个数是多少，如果'r'的个数相等，那么尽量是文章最短。

解法：易知单词间有二元关系，我们将每个二元关系建有向边，然后得出一张图，图中可能有强连通分量（环等），所以找出所有的强连通分量缩点，那个点的minR,Len赋为强连通分量中最小的minR,Len，然后重新建图，跑一个dfs即可得出每个强连通分量的minR,Len，最后O(n)扫一遍替换单词，统计即可。

代码：

#include <iostream>

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <cmath>

#include <algorithm>

#include <string>

#include <vector>

#include <stack>

#include <map>

#define INF 0x3f3f3f3f

#define lll __int64

using namespace std;

#define N 100007



struct Edge

{

    int v,next;

}G[4*N],G2[4*N];

string ss[N];

map<string,int> mp;

int minR[4*N],Len[4*N];

int nR[4*N],nLen[4*N];

int head[4*N],tot,cnt,vis[4*N];

int last[4*N],tot2;

stack<int> stk;

int instk[4*N],now,Time;

int low[4*N],dfn[4*N],bel[4*N];

lll sumR,sumLen;



void addedge(int u,int v)

{

    G[tot].v = v;

    G[tot].next = head[u];

    head[u] = tot++;

}



void addedge2(int u,int v)  //建新图

{

    G2[tot2].v = v;

    G2[tot2].next = last[u];

    last[u] = tot2++;

}



void tarjan(int u)

{

    low[u] = dfn[u] = ++Time;

    stk.push(u);

    instk[u] = 1;

    for(int i=head[u];i!=-1;i=G[i].next)

    {

        int v = G[i].v;

        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])

    {

        cnt++;

        int v;

        do{

            v = stk.top();

            stk.pop();

            instk[v] = 0;

            bel[v] = cnt;

            if(minR[v] < nR[cnt] || (minR[v] == nR[cnt] && Len[v] < nLen[cnt]))

                nR[cnt] = minR[v],nLen[cnt] = Len[v];

        }while(u != v);

    }

}



void Tarjan()

{

    memset(bel,0,sizeof(bel));

    memset(instk,0,sizeof(instk));

    memset(dfn,0,sizeof(dfn));

    memset(low,0,sizeof(low));

    Time = 0,cnt = 0;

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

    int i;

    for(i=1;i<=now;i++)

        if(!dfn[i])

            tarjan(i);

}



void Build()

{

    int i,j;

    memset(last,-1,sizeof(last));

    tot2 = 0;

    for(i=1;i<=now;i++)

    {

        for(j=head[i];j!=-1;j=G[j].next)

        {

            int v = G[j].v;

            if(bel[i] != bel[v])

                addedge2(bel[i],bel[v]);

        }

    }

}



void dfs(int u)

{

    if(vis[u]) return;

    vis[u] = 1;

    for(int i=last[u];i!=-1;i=G2[i].next)

    {

        int v = G2[i].v;

        dfs(v);

        if((nR[v] < nR[u]) || (nR[v] == nR[u] && nLen[v] < nLen[u]))

            nR[u] = nR[v],nLen[u] = nLen[v];

    }

}



int main()

{

    int n,m,i,j,len;

    while(scanf("%d",&n)!=EOF)

    {

        now = 0;

        mp.clear();

        tot = 0;

        memset(head,-1,sizeof(head));

        memset(vis,0,sizeof(vis));

        for(i=1;i<=n;i++)

        {

            cin>>ss[i];

            len = ss[i].length();

            int cntR = 0;

            for(j=0;j<len;j++)

            {

                if(ss[i][j] >= 'A' && ss[i][j] <= 'Z')

                    ss[i][j] = ss[i][j]-'A'+'a';

                if(ss[i][j] == 'r')

                    cntR++;

            }

            if(!mp[ss[i]])

                mp[ss[i]] = ++now;

            Len[mp[ss[i]]] = len;

            minR[mp[ss[i]]] = cntR;

        }

        scanf("%d",&m);

        string sa,sb;

        for(i=1;i<=m;i++)

        {

            sa = "", sb = "";

            cin>>sa>>sb;

            len = sa.length();

            int cntR = 0;

            for(j=0;j<len;j++)

            {

                if(sa[j] >= 'A' && sa[j] <= 'Z')

                    sa[j] = sa[j]-'A'+'a';

                if(sa[j] == 'r')

                    cntR++;

            }

            if(!mp[sa])

                mp[sa] = ++now;

            int a = mp[sa];

            Len[a] = len;

            minR[a] = cntR;



            len = sb.length();

            cntR = 0;

            for(j=0;j<len;j++)

            {

                if(sb[j] >= 'A' && sb[j] <= 'Z')

                    sb[j] = sb[j]-'A'+'a';

                if(sb[j] == 'r')

                    cntR++;

            }

            if(!mp[sb])

                mp[sb] = ++now;

            int b = mp[sb];

            Len[b] = len;

            minR[b] = cntR;

            addedge(a,b);

        }

        memset(nR,INF,sizeof(nR));     //新图的点的minR,Len

        memset(nLen,INF,sizeof(nLen));

        Tarjan();

        Build();

        for(i=1;i<=now;i++)

            if(!vis[i])

                dfs(i);

        sumR = 0,sumLen = 0;

        for(i=1;i<=n;i++)

        {

            int u = bel[mp[ss[i]]];

            sumR += nR[u];

            sumLen += nLen[u];

        }

        printf("%I64d %I64d\n",sumR,sumLen);

    }

    return 0;

}

View Code

 

还有一种做法就是反向建图，然后sort一下，优先从最优的开始dfs，最后就能得出结果，但是我不知道这样为什么一定正确，如果你知道，那么请评论告诉我吧:)