NYOJ247 虚拟的城市之旅（强联通缩点+dfs）

题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=247

大意：有n个城市， m条道路；每个两个城市之间最多有一条道路直接相连；道路有些是双向的有些是单向的，有一种商品在各个城市的物价不相同， 现在你可以从1号城市走到n号城市，道路可以走多次；问你可以最多赚多少钱（只能买卖一次）。

我看了这道题之后没思路， 就上网百度一下题解， 发现别人就用了两次广搜就过了， 第一次从1搜到n，用一个数组minval【i】表示从1搜到i物品的最低单价。把图反向之后从n搜到1， 用一个数组maxval【i】表示从1搜到i物品的最高单价。最后把所有两次都能搜到的点maxval 和 minval的差值找出来，取最大即可。

但是这到题的正解是强联通缩点+dfs；先把图处理成一个DAG，保存每个节点的最高单价，和最低单价。dfs时从1所在的节点，搜到n所在的节点。

广搜的代码：

 
#include<stdio.h>
#include<string.h>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn = 100000 + 10;
vector<int> G[maxn], Rg[maxn];
int minn[maxn], maxm[maxn], val[maxn];
bool vis[maxn], rvis[maxn];
int n, m;
void Add(int a, int b)
{
    G[a].push_back(b);
    Rg[b].push_back(a);//把图反向
}
void bfs()
{
    memset(vis, false, sizeof(vis));
    memset(rvis, false, sizeof(rvis));
    int s = 1;//从1开始搜
    queue<int> Q;
    Q.push(s);
    vis[s] = true;
    while(!Q.empty())
    {
        int x = Q.front();
        Q.pop();
        for(int i = 0; i < G[x].size(); i++)
        {
            int v = G[x][i];
            minn[v] = min(minn[v], minn[x]);
            if(!vis[v])
            {
                Q.push(v);
                vis[v] = true;
            }
        }
    }
    s = n;//从n反着搜
    Q.push(s);
    rvis[s] = true;
    while(!Q.empty())
    {
        int x = Q.front();
        Q.pop();
        for(int i = 0; i < Rg[x].size(); i++)
        {
            int v = Rg[x][i];
            maxm[v] = max(maxm[v], maxm[x]);
            if(!rvis[v])
            {
                Q.push(v);
                rvis[v] = true;
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d", &n, &m))
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &val[i]);
            minn[i] = maxm[i] = val[i];
            G[i].clear(), Rg[i].clear();
        }
        while(m--)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            if(c == 2)
                Add(b, a);
            Add(a, b);
        }
        bfs();
        int ans = 0;
        for(int i = 1; i <= n; i++)//查询
            if(vis[i] && rvis[i] && ans<maxm[i]-minn[i])
                ans = maxm[i] - minn[i];
        printf("%d\n", ans);
    }
    return 0;
}
        

强联通+dfs

#include<stdio.h>
#include<string.h>
#include<vector>
#include<stack>
#include<set>
#include<algorithm>
using namespace std;
const int maxn = 100000 + 10;
const int inf = 0x3f3f3f3f;
vector<int> G[maxn];
set<int> Sg[maxn];
int dfn[maxn], low[maxn], sccno[maxn], maxval[maxn], minval[maxn], val[maxn];
vector<int> scc[maxn];
stack<int> S;
int cur, scc_cnt, s, sn, ans;
void dfs(int u)//强联通缩点
{
    low[u] = dfn[u] = ++cur;
    S.push(u);
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!dfn[v])
        {
            dfs(v);
            low[u] = min(low[u], low[v]);
        }
        else if(!sccno[v])
            low[u] = min(low[u], dfn[v]);
    }
    if(low[u] == dfn[u])
    {
        ++scc_cnt;
        scc[scc_cnt].clear();
        while(!S.empty())
        {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            scc[scc_cnt].push_back(x);
            if(x == u)
                break;
        }
    }
}
void find_scc(int n)强联通初始化
{
    memset(dfn, 0, sizeof(dfn));
    memset(sccno, 0, sizeof(sccno));
    cur = scc_cnt = 0;
    dfs(1);
}
void Gg(int n)//缩点后从新构图
{
    for(int i = 0; i <= scc_cnt; i++)
        Sg[i].clear();
    memset(minval, 0x3f, sizeof(minval));
    memset(maxval, 0, sizeof(maxval));

    for(int i = 1; i <= scc_cnt; i++)
    {
        for(int j = 0; j < scc[i].size(); j++)
        {
            int x = scc[i][j];
            if(x == n)
                sn = i;
            if(x == 1)
                s = i;
            minval[i] = min(minval[i], val[x]);
            maxval[i] = max(maxval[i], val[x]);
        }
    }
    for(int i = 1; i <= n; i++)
    {
        for(int j = 0; j < G[i].size(); j++)
        {
            int v = G[i][j];
            if(sccno[i] != sccno[v])//用set的是为了方便， 因为强联通缩点后，任意连个节点之间可能有多条边相连，只需要建一条就行了， set有自动去重功能
                Sg[sccno[i]].insert(sccno[v]);
        }
    }
}
void dfs(int u, int minn, int maxm)//minn表示所能搜到点的最小单价, maxm为但前所能到节点赚的最大价值
{
    minn = min(minn, minval[u]);
    maxm = max(maxm, maxval[u]-minn);
    if(u == sn)
    {
        ans = max(ans, maxm);
        return ;
    }
    set<int> :: iterator it;
    for(it = Sg[u].begin(); it != Sg[u].end(); it++)
    {
        int v = *it;
        dfs(v, minn, maxm);
    }
}
int main()
{
    int n, m;
    while(~scanf("%d%d", &n, &m))
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &val[i]);
            G[i].clear();
        }
        while(m--)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            if(c == 2)
                G[b].push_back(a);
            G[a].push_back(b);
        }
        find_scc(n);
        Gg(n);
        ans = 0;
        dfs(s, inf, -inf);
        printf("%d\n", ans);
    }
    return 0;
}