#1185 : 连通性·三(强连通分量+缩点+拓扑排序)

时间限制:
10000ms 单点时限:
1000ms 内存限制:
256MB

描述

暑假到了!!小Hi和小Ho为了体验生活,来到了住在大草原的约翰家。今天一大早,约翰因为有事要出去,就拜托小Hi和小Ho忙帮放牧。

约翰家一共有N个草场,每个草场有容量为W[i]的牧草,N个草场之间有M条单向的路径。

小Hi和小Ho需要将牛羊群赶到草场上,当他们吃完一个草场牧草后,继续前往其他草场。当没有可以到达的草场或是能够到达的草场都已经被吃光了之后,小hi和小Ho就把牛羊群赶回家。

一开始小Hi和小Ho在1号草场,在回家之前,牛羊群最多能吃掉多少牧草?

举个例子:

《#1185 : 连通性·三(强连通分量+缩点+拓扑排序)》

图中每个点表示一个草场,上部分数字表示编号,下部分表示草场的牧草数量w。

在1吃完草之后,小Hi和小Ho可以选择把牛羊群赶到2或者3,假设小Hi和小Ho把牛羊群赶到2:

吃完草场2之后,只能到草场4,当4吃完后没有可以到达的草场,所以小Hi和小Ho就把牛羊群赶回家。

若选择从1到3,则可以到达5,6:

选择5的话,吃完之后只能直接回家。若选择6,还可以再通过6回到3,再到5。

所以该图可以选择的路线有3条:

1->2->4 		total: 11
1->3->5 		total: 9
1->3->6->3->5: 		total: 13
  

所以最多能够吃到的牧草数量为13。

本题改编自USACO月赛金组

提示:强连通分量

输入

第1行:2个正整数,N,M。表示点的数量N,边的数量M。1≤N≤20,000, 1≤M≤100,000

第2行:N个正整数,第i个整数表示第i个牧场的草量w[i]。1≤w[i]≤100,000

第3..M+2行:2个正整数,u,v。表示存在一条从u到v的单向路径。1≤u,v≤N

输出

第1行:1个整数,最多能够吃到的牧草数量。

样例输入

6 6
2 4 3 5 4 4
1 2
2 4
1 3
3 5
3 6
6 3

样例输出

13

思路:

这个题有解题提示,就是用的强连通分量消除有向图中的环,然后缩点成一个新的图,最后再用拓扑排序求解最大的吃草数。

首先这里要注意的是,因为是从1开始的,与1不连通的点不加入新图,也就是求强连通分量和用拓扑排序的时候也必须从1点开始,不然会出错。还有,去除环的时候的价值合并要做好。最后也是最重要的,也是我一直wr无数次的地方,在拓扑排序中,计算最大和的时候不能简单的加和(就像之前的一道拓扑排序题,简单的加和就可以),这里要用一种类似的dp思想,因为有可能两个点a,b都能去c,需要判断哪个大,才从哪个去,不能简单加和,一定要记住这个教训。

代码:

#include<bits/stdc++.h>
using namespace std;
const int maxn=21000+10;
int n,m;
int dfs_clock;
int scc_cnt;
vector<int> G[maxn];
int pre[maxn];
int low[maxn];
int sccno[maxn];
stack<int> S;
vector<int> F[maxn];
int in[maxn],w[maxn];
int w1[maxn];
int dp[maxn];
void topo()
{
    queue<int> Q;
    Q.push(sccno[1]);
    memset(dp,0,sizeof(dp));
    dp[sccno[1]]=w1[sccno[1]];
    while(!Q.empty())
    {
        int u=Q.front(); Q.pop();
        for(int i=0;i<F[u].size();i++)
        {
            int v=F[u][i];
            dp[v]=max(dp[v],w1[v]+dp[u]);
            if(--in[v]==0) Q.push(v);
        }

    }

}
void dfs(int u)
{
    pre[u]=low[u]=++dfs_clock;
    S.push(u);
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i];
        if(!pre[v])
        {
            dfs(v);
            low[u]=min(low[u],low[v]);
        }
        else if(!sccno[v])
        {
            low[u]=min(low[u],pre[v]);
        }
    }
    if(low[u] == pre[u])
    {
        scc_cnt++;
        while(true)
        {
            int x=S.top(); S.pop();
            sccno[x]=scc_cnt;
            w1[scc_cnt]+=w[x];
            if(x==u) break;
        }
    }
}


void find_scc()
{
    scc_cnt=dfs_clock=0;
    memset(sccno,0,sizeof(sccno));
    memset(pre,0,sizeof(pre));
    memset(low,0,sizeof(low));
    dfs(1);
}
int main()
{
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++) G[i].clear();

        memset(w,0,sizeof(w));
        memset(w1,0,sizeof(w1));
        memset(in,0,sizeof(in));
        for(int i=1;i<=n;i++)scanf("%d",&w[i]);
        while(m--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
        }
        find_scc();
        for(int i=1;i<=n;i++) F[i].clear();
        for(int u=1;u<=n;u++)
        for(int i=0;i<G[u].size();i++)
        {
            int v=G[u][i];
            int x=sccno[u], y=sccno[v];
            if(x==y||x==0||y==0)continue;
            in[y]++;
            F[x].push_back(y);


        }
        topo();
        int sum=0;
        for(int i=1;i<=scc_cnt;i++)
        {
            sum=max(sum,dp[i]);
        }
        printf("%d\n",sum);
   return 0;
}

    原文作者:拓扑排序
    原文地址: https://blog.csdn.net/a1046765624/article/details/79619294
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞