POJ3592 Instantaneous Transference【强连通分量】【最长路】

题目链接：

http://poj.org/problem?id=3592

题目大意：

有一个N*M的矩阵地图，矩阵中用了多种字符代表不同的地形，如果是数字X(0~9)，则表示

该区域为矿区，有X单位的矿产。如果是"*"，则表示该区域为传送点，并且对应唯一一个目标

坐标。如果是"#",，则表示该区域为山区，矿车不能进入。现在矿车的出发点在坐标(0，0)点。

并且(0，0)点一定不是"#"区域。矿车只能向右走、向下走或是遇到传送点的时候可以传送到

指定位置。那么问题来了：矿车最多能采到多少矿。

思路：

如果把N*M个矩阵单位看做是N*M个点，编号为0~N*M。然后从一个坐标到另一个坐标看做

是两点之间的边。到达的坐标所拥有的矿产为边的权值。那么问题就变成了：矿车从节点0出发，

所能达到的最长路径。但是除了向右走和向下走的边，考虑到还有传送点和目标坐标构成的边，

原图上就会多了很多回退边，构成了很多的有向环。有向环的出现，使得矿车能够采到的矿产

增多了一部分，只要能走到有向环内，则该环内所有点的矿产都能被采到。但是问题也出来了，

如果不做处理，直接搜索路径，那么矿车很可能会走进环内不出来。

于是想到了缩点，把有向环缩为一个点，也就是强连通分量缩点。并记录强连通分量中的总矿产

值。缩点后，原图就变成了一个有向无环图(DAG)。然后重新建立一个新图(DAG)，对新图求最

长路径(用SPFA算法)，得到源点(0，0)到各点的最长路径。从中找出最长的路径，就是所求的结

果。

需要注意很多点：

1."*"区域能够传送到"#"区域。。。

2.矿车开始的地方是(0，0)

3.有多组数据，一定注意数据的清空

AC代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN = 1610;
const int MAXM = 50050;
const int INF = 0xffffff0;

struct EdgeNode
{
    int to;
    int next;

}Edges[MAXM],Edges1[MAXM];              //存放原图，新图
int Head[MAXN],Head1[MAXN];

int vis[MAXN],vist[MAXN];              //标记访问
int dfn[MAXN],low[MAXN],belong[MAXN];    //开始访问时间次序，栈中最早访问时间
int Stack[MAXN];            //缩点用到的栈
int m,id,ip,scc,lay,N,M;                //id原图边数，ip新图边数
int cost[MAXN],sum[MAXN];   //cost为原图每点的值，sum为强连通分量的值
char Map[50][50];     //存放原图
int Dist[MAXN],outque[MAXN];

void AddEdges(int u,int v)  //原图加边
{
    Edges[id].to = v;
    Edges[id].next = Head[u];
    Head[u] = id++;
}

void AddEdges1(int u,int v) //新图加边
{
    Edges1[ip].to = v;
    Edges1[ip].next = Head1[u];
    Head1[u] = ip++;
}

int TarBFS(int pos)
{
    int v;
    vis[pos] = 1;
    low[pos] = dfn[pos] = ++lay;
    Stack[m++] = pos;
    for(int i = Head[pos]; i != -1; i = Edges[i].next)
    {
        int v = Edges[i].to;
        if( !dfn[v] )
        {
            TarBFS(v);
            low[pos] = min(low[pos], low[v]);
        }
        else if( vis[v] )
            low[pos] = min(low[pos], low[v]);
    }

    if(dfn[pos] == low[pos])
    {
        ++scc;
        do
        {
            v = Stack[--m];
            sum[scc] += cost[v];
            belong[v] = scc;
            vis[v] = 0;
        }while(v != pos);
    }
    return 0;
}

void ReBuildMap()       //重建新图(DAG)
{
    ip = 0;
    for(int u = 0; u < N*M; ++u)
        for(int k = Head[u]; k != -1; k = Edges[k].next)
        {
            int v = Edges[k].to;
            if(belong[u] != belong[v])
                AddEdges1(belong[u],belong[v]);
        }

}

void SPFA()             //求最长路
{
    memset(vist,0,sizeof(vist));
    memset(Dist,0,sizeof(Dist));
    queue<int> Q;
    Q.push(belong[0]);
    vist[belong[0]] = 1;
    Dist[belong[0]] = sum[belong[0]];

    while( !Q.empty() )
    {
        int u = Q.front();
        Q.pop();
		vist[u] = 0;

        for(int i = Head1[u]; i != -1; i = Edges1[i].next)
        {
            int v = Edges1[i].to;
            if(Dist[v] < Dist[u] + sum[v])
            {
                Dist[v] = Dist[u] + sum[v];
                if( !vist[v] )
                {
                    vist[v] = 1;
                    Q.push(v);
                }
            }
        }
    }
}
int main()
{
    int T,x,y;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&N,&M);
        memset(Head,-1,sizeof(Head));
        memset(Head1,-1,sizeof(Head1));
        memset(cost,0,sizeof(cost));
        memset(vis,0,sizeof(vis));
        memset(low,0,sizeof(low));
        memset(dfn,0,sizeof(dfn));
        memset(sum,0,sizeof(sum));

        for(int i = 0; i < N; ++i)
            scanf("%s",Map[i]);

        for(int i = 0; i < N; ++i)
        {
            for(int j = 0; j < M; ++j)
            {
                if(Map[i][j] != '#')
                {
                    if(i+1 < N && Map[i+1][j] != '#')   //向下走
                        AddEdges(i*M+j,(i+1)*M+j);
                    if(j+1 < M && Map[i][j+1] != '#')   //向右走
                        AddEdges(i*M+j,i*M+j+1);

                    cost[i*M+j] = Map[i][j] - '0';

                    if(Map[i][j] == '*')
                    {
                        cost[i*M+j] = 0;
                        scanf("%d%d",&x,&y);
                        if(Map[x][y] != '#')
                            AddEdges(i*M+j,x*M+y);
                    }
                }
            }
        }
        scc = id = m = lay = 0;
        for(int i = 0; i < N*M; ++i)
            if(!dfn[i])
                TarBFS(i);

        ReBuildMap();
        SPFA();
        int ans = -1;
        for(int i = 1; i <= scc; ++i)
            if(ans < Dist[i])
                ans = Dist[i];
        printf("%d\n",ans);
    }

    return 0;
}
/*
100
10 10
12345678*0
2345678901
345678*012
456*890123
5678901234
6789*12345
7890123456
890*234567
901234*678
0123*56789
2 2
3 3
4 4
5 5
6 6
7 7
8 8

3 3
*1*
2*1
11*
1 1
2 2
1 3
1 1

答案为：
124
5
*/

失败代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
using namespace std;
const int MAXN = 1610;
const int MAXM = 50050;
const int INF = 0xffffff0;

struct EdgeNode
{
    int to;
    int next;

}Edges[MAXM],Edges1[MAXM];
int Head[MAXN],Head1[MAXN];

int vis[MAXN],vist[MAXN];              //标记访问
int dfn[MAXN],low[MAXN];    //开始访问时间次序，栈中最早访问时间
int Stack[MAXN];            //缩点用到的栈
int m,id,ip,scc,lay,N,M;                //id原图边数，ip新图边数
int cost[MAXN],sum[MAXN];   //cost为原图每点的值，sum为强连通分量的值
char Map[50][50];       //存放原图
int Dist[MAXN],outque[MAXN];
stack<int> S;

void AddEdges(int u,int v)  //原图加边
{
    Edges[id].to = v;
    Edges[id].next = Head[u];
    Head[u] = id++;
}

void AddEdges1(int u,int v)
{
    Edges1[ip].to = v;
    Edges1[ip].next = Head1[u];
    Head1[u] = ip++;
}

int TarBFS(int pos)
{
    vis[pos] = 1;
    low[pos] = dfn[pos] = lay++;
    S.push(pos);
    for(int i = Head[pos]; i != -1; i = Edges[i].next)
    {
        if( dfn[Edges[i].to] == 0)
        {
            TarBFS(Edges[i].to);
            if(low[Edges[i].to] < low[pos])
                low[pos] = low[Edges[i].to];
        }
        else if( vis[Edges[i].to] == 1 && dfn[Edges[i].to] < low[pos])
            low[pos] = dfn[Edges[i].to];
    }
    int v;
    if(dfn[pos] == low[pos])
    {
        scc++;
        do
        {
            v = S.top();
            S.pop();
            sum[scc] += cost[v];
            low[v] = scc;
            vis[v] = 2;
        }while(v != pos);
    }
    return 0;
}

void Tarjan()
{
    m = 0;

    for(int i = 0; i < N*M; ++i)
    {
        if(vis[i] == 0)
            TarBFS(i);
    }
}

void ReBuildMap()
{
    ip = 0;
    for(int i = 0; i < N*M; ++i)
        for(int k = Head[i]; k != -1; k = Edges[k].next)
            if(low[i] != low[Edges[k].to])
                AddEdges1(low[i],low[Edges[k].to]);
}

int SPFA()
{
    memset(vist,0,sizeof(vist));
    memset(outque,0,sizeof(outque));
    memset(Dist,0,sizeof(Dist));
    queue<int> Q;
    Q.push(low[0]);
    vist[low[0]] = 1;
    Dist[low[0]] = sum[low[0]];

    while( !Q.empty() )
    {
        int u = Q.front();
        Q.pop();
		vist[u] = 0;
        outque[u]++;
        if(outque[u] > scc)
            return false;

        for(int i = Head1[u]; i != -1; i = Edges1[i].next)
        {
            if(Dist[u] + sum[Edges1[i].to] > Dist[Edges1[i].to])
            {
                Dist[Edges1[i].to] = Dist[u] + sum[Edges1[i].to];
                if( !vist[Edges1[i].to] )
                {
                    vist[Edges1[i].to] = 1;
                    Q.push(Edges1[i].to);
                }
            }
        }
    }
    return true;
}
int main()
{
    int T,x,y;
    scanf("%d",&T);
    while(T--)
    {
        memset(Head,-1,sizeof(Head));
        memset(Head1,-1,sizeof(Head1));
        memset(cost,0,sizeof(cost));
        memset(vis,0,sizeof(vis));
        memset(low,0,sizeof(low));
        memset(dfn,0,sizeof(dfn));
        memset(sum,0,sizeof(sum));
        memset(Edges,0,sizeof(Edges));
        memset(Edges1,0,sizeof(Edges1));
        memset(Map,0,sizeof(Map));
        scc = id = 0;
        lay = 1;

        scanf("%d%d",&N,&M);
        for(int i = 0; i < N; ++i)
            scanf("%s",Map[i]);

        for(int i = 0; i < N; ++i)
        {
            for(int j = 0; j < M; ++j)
            {
                if(Map[i][j] != '#')
                {
                    if(i+1 < N && Map[i+1][j] != '#')   //向下走
                        AddEdges(i*M+j,(i+1)*M+j);
                    if(j+1 < M && Map[i][j+1] != '#')   //向右走
                        AddEdges(i*M+j,i*M+j+1);

                    cost[i*M+j] = Map[i][j] - '0';

                    if(Map[i][j] == '*')
                    {
                        cost[i*M+j] = 0;
                        scanf("%d%d",&x,&y);
                        if(Map[x][y] != '#')
                            AddEdges(i*M+j,x*M+y);
                    }
                }
            }
        }

        Tarjan();

        ReBuildMap();
        SPFA();
        int ans = -1;
        for(int i = 1; i <= scc; ++i)
            if(ans < Dist[i])
                ans = Dist[i];
        printf("%d\n",ans);
    }

    return 0;
}