POJ 3592 Instantaneous Transference

强连通分量

 题意：一个n行m列的矩阵图，上面有3种点，可能是数字x(0<=x<=9)，表示这里有多少个矿石，#表示不能走到这点，*表示传送点，对应一个目标点，可以瞬间传送到目标点。你从（0,0）左上角处出发，行走的方向只能是向左或者向下，要求你走到某个地方（不一定是右下角），让你得到的矿石最多。一个地方的矿石只能采集一次，下次再去到那个点是没有矿石的。注意几点，传送点可能将你传送到#这种点，那么相当于这个传送点是多余的等于没用，另外在传送点可以选择传送或者不传送继续走。

分析：由于传送点的存在，可能使这个有向图构成环，进而可能产生强连通分量，所以先建图，进行一次强连通分量缩点，为什么缩点，因为易知，在一个强连通分量内的点都是可以全部到达的，所以这个点内的矿石都能采集到。缩点后得到一个DAG，对这个DAG重新建图，另外重新计算缩点后每个点有多少矿石（即原来小点的矿石和）。然后从点(0,0)缩点后所在那个大点出发，用BFS搜索，求一次最长路，再取最大值即可

总体来说这题不难，代码量，对于图论的题来讲，也差不多是这么多了，写的时候状态不好，很多小bug，调试很久wa了好几次才过。

这题总的来说也不算难，就Tarjan缩点+bfs搜索最长路

#include <iostream>
#include <cstdio>
#include <cstring>
#include <utility>
#include <vector>
#include <stack>
#include <queue>
using namespace std;
#define N 2100

char a[50][50];
vector<int>mp;
vector<int>e[N];
vector<int>ver[N];
stack<int>sta;
queue<int>que;
int row,col,n;
int dfn[N],low[N],belong[N],dcnt,bcnt;
int val[N],sv[N],d[N];
bool ins[N],inq[N];

void input()
{
    cin >> row >> col;
    n = row * col;
    for(int i=0; i<n; i++) e[i].clear();
    for(int r=0; r<row; r++) cin >> a[r];
    for(int r=0; r<row; r++)
        for(int c=0; c<col; c++)
            if(a[r][c] != '#')
            {
                int x,y,v,u;
                u = r * col + c;
                if(r+1 < row && a[r+1][c] != '#')
                {
                    v = (r+1) * col + c;
                    e[u].push_back(v);
                }
                if(c+1 < col && a[r][c+1] != '#')
                {
                    v = r * col + c+1;
                    e[u].push_back(v);
                }

                if(a[r][c] >= '0' && a[r][c] <= '9')
                    val[u] = a[r][c] - '0';
                else 
                {
                    val[u] = 0;
                    cin >> x >> y;
                    if(a[x][y] != '#')
                    {
                        v = x * col + y;
                        e[u].push_back(v);
                    }
                }

            }
}

void rebuild()
{
    for(int i=1; i<=bcnt; i++) ver[i].clear();
    for(int i=0; i<n; i++)
    {
        int u = belong[i];
        for(int j=0; j<e[i].size(); j++)
        {
            int v = belong[e[i][j]];
            if(u != v) ver[u].push_back(v);
        }
    }
}

void dfs(int u)
{
    dfn[u] = low[u] = ++dcnt;
    sta.push(u); ins[u] = true;
    for(int i=0; i<e[u].size(); i++)
    {
        int v = e[u][i];
        if(!dfn[v])
        {
            dfs(v);
            low[u] = min(low[u] , low[v]);
        }
        else if(ins[v]) low[u] = min(low[u] , dfn[v]);
    }
    if(low[u] == dfn[u])
    {
        ++bcnt;
        sv[bcnt] = 0;
        while(true)
        {
            int x = sta.top();
            sta.pop(); ins[x] = false;
            belong[x] = bcnt;
            sv[bcnt] += val[x];
            if(x == u) break;
        }
    }
}

void Tarjan()
{
    dcnt = bcnt = 0;
    memset(dfn,0,sizeof(dfn));
    memset(ins,false,sizeof(ins));
    for(int i=0; i<n; i++)
        if(!dfn[i])
            dfs(i);
}

void bfs()
{
    while(!que.empty()) que.pop();
    memset(inq,false,sizeof(inq));
    memset(d,-1,sizeof(d));
    int s = belong[0];
    d[s] = sv[s];
    que.push(s);
    inq[s] = 1;
    while(!que.empty())
    {
        int u = que.front();
        que.pop(); inq[u] = 0;
        for(int i=0; i<ver[u].size(); i++)
        {
            int v = ver[u][i];
            if(d[v] < d[u] + sv[v])
            {
                d[v] = d[u] + sv[v];
                if(!inq[v])
                {
                    inq[v] = 1;
                    que.push(v);
                }
            }
        }
    }
}

int main()
{
    int cas;
    cin >> cas;
    while(cas--)
    {
        input();
        Tarjan();
        rebuild();
        bfs();

        int res = 0;
        for(int i=1; i<=bcnt; i++)
            res = max(res , d[i]);
        cout << res << endl;
    }
    return 0;
}