POJ3592 Instantaneous Transference tarjan +spfa

链接：http://poj.org/problem?id=3592

题意：题目大意：给定一个矩阵，西南角为出发点，每个单位都有一订价值的金矿（＃默示岩石，不成达，*默示时佛门，可以达到指定单位），队＃外，每个点只能向右走或向下走，并且可以反复经过一个点。如今请求得最多可以获得多大好处 。

一开始看到这个题，会以为是费用流。但是计划上是在tarjan上的。我觉得如果比赛的时候有这道题估计我也就挂了。

因为这个图大部分的点只有两个后续节点， 但是*会有更多的节点，所以说这样会产生环，因此可以吧整个图求强连通进行缩点，因为每个强连通分量重的点你是可以得到她所有的值。不管走几次，就是那么多，缩完点之后就可以构成DAG这样，就能够求出从belong[1]出发得到的最远的点。一开始逗比了，忘了出发点是左上角，而且dis的赋初值写错了。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <stack>
#define loop(s,i,n) for(i = s;i < n;i++)
#define cl(a,b) memset(a,b,sizeof(a))
using namespace std;
const int maxn = 2000;
struct edge
{
    int u,v,val,next;
};

char map[45][45];
int dfn[maxn],low[maxn],belong[maxn],inst[maxn];
int head[maxn];
vector<edge>edges,es;
int ihead[maxn];
stack<int> st;
int vis[maxn],dis[maxn];
int dfsclock,scc,cnt;
vector<int>trans;
void init(int n)
{
    int i;
    loop(0,i,n+1)
    head[i] = -1;

    edges.clear();
    es.clear();
    dfsclock = scc = cnt = 0;
    trans.clear();
    return ;
}
void addedge(int u,int v,int val)
{
    int m;
    struct edge e;
    e.u = u;
    e.v = v;
    e.next = head[u];
    edges.push_back(e);
    m = edges.size();
    head[u] = m-1;
    return ;
}
void tarjan(int i)
{
    dfn[i] = low[i] = ++dfsclock;
    inst[i] = 1;
    st.push(i);

    int j;
    edge e;
    for(j = head[i]; j != -1; j = e.next)
    {

        e = edges[j];
        int v;
        v = e.v;
        if(!dfn[v])
        {
            tarjan(v);
            low[i] = min(low[v],low[i]);
        }
        else if(inst[v] && dfn[v] < low[i])
            low[i] = dfn[v];
    }

    if(dfn[i] == low[i])
    {
        scc++;
        do
        {
            j = st.top();
            st.pop();
            inst[j] = 0;
            belong[j] = scc;
        }
        while(i != j);
    }
}
void tarjans(int n)
{
    dfsclock = scc = 0;
    memset(dfn,0,sizeof(dfn));
    while(!st.empty())st.pop();

    cl(inst,0);
    cl(belong,0);
    int i;
    loop(1,i,n+1)
    {
        if(!dfn[i]) tarjan(i);
    }
    return ;
}
int spfa(int s,int n)
{
    int i,j;
    dis[s] = 0;
    queue<int>q;
    q.push(s);
    vis[s] = 1;
    while(!q.empty())
    {
        int x;
        x = q.front();


        q.pop();
        vis[x] = 0;
        struct edge e;
        for(i = ihead[x]; i != -1; i = e.next)
        {
            int v;

            e = es[i];
            v = e.v;
            if(dis[v] < dis[x]+e.val)
            {
                dis[v] = dis[x]+e.val;
                q.push(v);
                vis[v] = 1;
            }
        }
    }
    int max = 0;
    for(i = 1; i <= n; i++)
    {
        if(dis[i] > max)
            max = dis[i];
    }

    return max;
}
int val[maxn];
int main()
{
    int t;
    int n,m,k;
    scanf("%d",&t);
    while(t--)
    {
        int i,j;
        int p;
        p = 0;
        scanf("%d %d",&n,&m);
        init(n*m+5);
        loop(0,i,n)
        scanf("%s",map[i]);
        int leap = 0;
        for(i = 0; i < n; i++)
        {
            for(j = 0; j < m; j++)
            {
                if(map[i][j] == '*')
                    trans.push_back(i*m+j+1);
            }
        }

        loop(0,i,trans.size())
        {
            int l,r;
            scanf("%d %d",&l,&r);
            if(map[l][r] == '*')
                addedge(trans[i],l*m+r+1,0);
            else if(map[l][r] != '#')
                addedge(trans[i],l*m+r+1,map[l][r]-'0');
        }

        loop(0,i,n)
        {
            loop(0,j,m)
            {
                if(map[i][j] != '#')
                {
                    
                if(i+1 < n && map[i+1][j] == '*')
                    addedge(i*m+j+1,(1+i)*m+j+1,0);
                else if(i+1 < n && map[i+1][j] != '#')
                    addedge(i*m+j+1,(1+i)*m+j+1,1+map[i+1][j]-'0');

                if(j+1 < m && map[i][j+1] == '*' )
                    addedge(i*m+j+1,(i)*m+2+j,0);
                else if( j+1 < m && map[i][j+1] != '#')
                    addedge(i*m+j+1,i*m+j+2,map[i][j+1]-'0');
                }
            }
        }


        tarjans(m*n);
        // cout<<scc<<endl;
        cl(val,0);

        int sum;
        sum = 0;
        cl(vis,0);
        memset(ihead,-1,sizeof(ihead));
        for(i = 1; i <= m*n; i++)
        {
            int r,l;
            r = (i-1)/m;
            l = (i-1)%m;
            if(map[r][l] != '#' && map[r][l] != '*')
                val[belong[i]] += map[r][l] - '0';
        }

        for(i = 0; i < edges.size(); i++)
        {
            int u,v;
            u = edges[i].u;
            v = edges[i].v;
            if(belong[u] != belong[v])
            {
                u = belong[u];
                v = belong[v];
                struct edge e;
                e.u = u;
                e.v = v;
                e.val = val[v];
                e.next = ihead[u];
                es.push_back(e);
                int m;
                m = es.size();
                ihead[u] = m-1;
            }
        }

        cl(vis,0);
        cl(dis,-1);
        int ans;


        if(scc == 1)
            printf("%d
",val[belong[1]]);
        else
        {
            ans  = 0;
            int ansi;
            ans = spfa(belong[1],scc);
            printf("%d
",ans+val[belong[1]]);
        }

    }
    return 0;
}