POJ 3592 缩点+拓扑排序+最长路

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

题目大意：

　　给定一个n*m的地图，有0-9表示某个格子上的value，‘*’表示该格子上有个时空门，可直接到指定的某个格子（可以自行选择是否使用时空门），‘#’表示该格子无法使用，某个格子的value只能被计算一次，问从起点（规定为左上角，我一直把northwest看成了右上角，伤不起）出发，每次只能往下走一格或往右走一格，最多能得到多大的value。

分析：

　　首先根据给定的关系建图，又因为有时空门的存在，所以必须缩点，

　　对缩点后的图进行拓扑排序之后再dp，即可求得最长路。

（PS： 这题我看了discuss，发现思路什么的对了，就是一点，起点我自己看成了右上角，伤不起啊~！~）

代码（好像我的比较冗长的）：

/*3592    Accepted    428K    0MS    C++    4222B    2012-06-09 16:18:12*/
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

#define mpair make_pair
#define pii pair<int,int>
#define MM(a,b) memset(a,b,sizeof(a));
typedef long long lld;
typedef unsigned long long u64;
template<class T> bool up_max(T& a,const T& b){return b>a? a=b,1 : 0;}
template<class T> bool up_min(T& a,const T& b){return b<a? a=b,1 : 0;}
#define maxn 1640
#define maxm 50

int n,m,k, nv;
int f[maxm][maxm];
char ch[maxm][maxm];

vector<int>g[maxn], adj[maxn];
int mark[maxm][maxm];
pii a[maxn], fp[maxn];

void Read(){
    int i,j,x,y;
    scanf("%d %d\n", &n, &m);
    for(i=0;i<n;++i)
        for(j=0;j<m;++j){
            f[i][j]= i*m + j + 1;
            fp[i*m+j+1]= pii( i, j );
        }
    nv= n*m;

    k= 0;
    for(i=0;i<n;++i){
        for(j=0;j<m;++j){
            scanf("%c", &ch[i][j]);
            if( '*' == ch[i][j] )
                mark[i][j]= ++k;
        }
        getchar();
    }

    for(i=1;i<=k;++i){
        scanf("%d%d", &x, &y);
        a[i]= pii( x, y );
    }
}

void build_graph(){
    int i,j;
    for(i=1;i<=nv;++i) g[i].clear();
    for(i=0;i<n;++i){
        for(j=0;j<m;++j){
            if( '#' == ch[i][j] ) continue;

            if( i+1<n && '#'!=ch[i+1][j] ){ /// go down;
                g[ f[i][j] ].push_back( f[i+1][j] );
            }
            if( j+1<m && '#'!=ch[i][j+1] ){ /// go left;
                g[ f[i][j] ].push_back( f[i][j+1] );
            }
            if( '*' == ch[i][j] ){ /// can use magic power;
                int t= mark[i][j];
                int x= a[t].first, y= a[t].second;
                if( '#' != ch[x][y] ) ///
                    g[ f[i][j] ].push_back( f[x][y] );
            }
        }
    }
}

int c[maxn]; /// each block's sum-value;

int Bcnt, Index, Top;
int low[maxn], dfn[maxn], stack[maxn], belong[maxn];
bool inq[maxn];
void Init_tarjan(){
    Bcnt= Index= Top= 0;
    for(int i=1;i<=nv;++i) low[i]= dfn[i]= inq[i]= 0;
}
void Tarjan(int u){
    stack[++Top]= u;
    inq[u]= 1;
    low[u]= dfn[u]= ++Index;
    for(int i=0;i<g[u].size();++i){
        int v= g[u][i];
        if( !dfn[v] ){
            Tarjan( v );
            up_min( low[u], low[v] );
        }
        else if( inq[v] )
            up_min( low[u], dfn[v] );
    }
    if( low[u]==dfn[u] ){
        ++Bcnt;
        int v;
        do{
            v= stack[Top--];
            inq[v]= 0;
            belong[v]= Bcnt;
            int x= fp[v].first, y= fp[v].second;
            if( '1'<=ch[x][y] && ch[x][y]<='9' )
                c[Bcnt]+= ch[x][y]-'0';
        }while(u!=v);
    }
}

int in[maxn];
void build2(int u){
    inq[u]= 1;
    for(int i=0;i<g[u].size();++i){
        int v= g[u][i];
        if( belong[v] != belong[u] ){
            adj[ belong[u] ].push_back( belong[v] );
            ++in[ belong[v] ];
        }
        if( !inq[v] ) build2(v); /// here!!!!!!!!!!!!!!!!!!!;
    }
}

int *que; ///
int dp[maxn];
int Topsort(){
    int i,head=0,tail=0;
    fill( dp, dp+1+Bcnt, 0 );
    /// for(i=1;i<=Bcnt;++i) if( in[i]==0 ) { que[tail++]= i; dp[i]= c[i]; }
    que[tail++]= belong[1]; ///!!!!!!!!!!!!!
    dp[belong[1]]= c[belong[1]];

    while( head<tail ){
        int u= que[head++];
        for(int i=0;i<adj[u].size();++i){
            int v= adj[u][i];
            if( --in[v] == 0 )
                que[tail++]= v;
        }
    }

    for(i=0;i<tail;++i){
        int u= que[i];
        for(int j=0;j<adj[u].size();++j){
            int v= adj[u][j];
            up_max( dp[v], dp[u]+c[v] );
        }
    }

    int ans= 0;
    for(i=0;i<tail;++i) up_max( ans, dp[ que[i] ] ); /// que[i];
    return ans;
}

int solve(){
    build_graph();
    Init_tarjan();
    fill( c, c+nv+1, 0 );
    Tarjan(1); ///

    for(int i=1;i<=Bcnt;++i) adj[i].clear(), inq[i]= 0, in[i]= 0;
    build2(1);

    que= stack;
    return Topsort();
}

int main()
{
    //freopen("poj3592.in","r",stdin);
    int T;
    cin>>T;
    while(T--){
        Read();
        cout<< solve() <<endl;
    }
}