POJ - 3592 - Instantaneous Transference

先上题目：

Instantaneous Transference

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 5461		Accepted: 1193

Description

It was long ago when we played the game Red Alert. There is a magic function for the game objects which is called instantaneous transfer. When an object uses this magic function, it will be transferred to the specified point immediately, regardless of how far it is.

Now there is a mining area, and you are driving an ore-miner truck. Your mission is to take the maximum ores in the field.

The ore area is a rectangle region which is composed by n × m small squares, some of the squares have numbers of ores, while some do not. The ores can't be regenerated after taken.

The starting position of the ore-miner truck is the northwest corner of the field. It must move to the eastern or southern adjacent square, while it can not move to the northern or western adjacent square. And some squares have magic power that can instantaneously transfer the truck to a certain square specified. However, as the captain of the ore-miner truck, you can decide whether to use this magic power or to stay still. One magic power square will never lose its magic power; you can use the magic power whenever you get there.

Input

The first line of the input is an integer T which indicates the number of test cases.

For each of the test case, the first will be two integers N, M (2 ≤ N, M ≤ 40).

The next N lines will describe the map of the mine field. Each of the N lines will be a string that contains M characters. Each character will be an integer X (0 ≤ X ≤ 9) or a '*' or a '#'. The integer X indicates that square hasX units of ores, which your truck could get them all. The '*' indicates this square has a magic power which can transfer truck within an instant. The '#' indicates this square is full of rock and the truck can't move on this square. You can assume that the starting position of the truck will never be a '#' square.

As the map indicates, there are K '*' on the map. Then there follows K lines after the map. The next K lines describe the specified target coordinates for the squares with '*', in the order from north to south then west to east. (the original point is the northwest corner, the coordinate is formatted as north-south, west-east, all from 0 to N - 1,M - 1).

Output

For each test case output the maximum units of ores you can take. 　

Sample Input

1
2 2
11
1*
0 0

Sample Output

3

Source

South Central China 2008 hosted by NUDT

 

　　题意：给你一幅地图(矩阵)，地图上有的点有矿物，有的点是传送门，前面两种都可以走，有的点无法通过。从左上角(西北方)开始走，只可以向南或者向东走，每个位置的矿物只可以吃一遍，问你在这幅地图上走最多可以吃多少的矿物。

　　分析：传送门可能回在地图上构成回路，所以一开始可以先缩点，重新构图，然后跑一边最长路就可以得出结果了。

　　首先用Tarjan缩点，然后再用spfa跑一次最长路。

　　感觉这一题比较坑的地方是构图，在网上看其他人的代码好像都是将二维转为一维，大概就140行~160行，结果我直接用二维来保存dfn,low等信息，写了快200行→_→。

　　中间WA了几次,第一次是求最长路的时候用了dij,后来换成spfa就没事了，当时感觉缩点以后还有环，但是跟师兄讨论的时候发现缩点以后似乎剩下的是一个DAG，那样的话大概是dij写错了一点了···。还有就是对于判断某个可可以走的点下一步可以往那边走的时候，扫了判断是不是个坑，这里少了个判断的原因是一开始以为直接判断dfn就可以看出是不是个坑···结果WA了几次才发现还需要另外判断···。

　　这应该是第二次用Tarjan，再有一点需要注意的是在元素退栈的时候需要标记元素已经不在栈里面了，否者会出错。这是因为在前面的步骤里面两个判断的条件并不是同一个条件，一个是判断子节点访问了没有，另一个是判断子节点在不在栈里面，所以如果没有清楚地标记元素是否在栈里的话就会多进行一些步骤同时结果会出错。

 

上代码：

 

#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#define max(x,y) (x >= y ? x : y)
#define min(x,y) (x <= y ? x : y)
#define MAX 100
using namespace std;

int n,m,index,id;
char map[MAX][MAX];
int star[MAX*MAX];
int starnum;
int sy[MAX][MAX],sx[MAX][MAX];
int dfn[MAX][MAX],low[MAX][MAX],belong[MAX][MAX];
int val[MAX*MAX];
stack<int> sty,stx;
bool instack[MAX][MAX];
int p[MAX*MAX];
typedef struct{
    int to;
    int w;
    int next;
}Edge;
Edge e[MAX*MAX*3];
int tot;
int dist[MAX*MAX];
int Max;

void reset(){
    index=0;
    id=0;
    starnum=0;
    memset(map,0,sizeof(map));
    memset(sy,-1,sizeof(sy));
    memset(sx,-1,sizeof(sx));
    memset(dfn,-1,sizeof(dfn));
    memset(low,-1,sizeof(low));
    memset(belong,-1,sizeof(belong));
    while(!sty.empty()) sty.pop();
    while(!stx.empty()) stx.pop();
    memset(val,0,sizeof(val));
    memset(instack,0,sizeof(instack));
    memset(p,-1,sizeof(p));
    memset(e,0,sizeof(e));
    tot=0;
}

void add(int u,int v,int w){
    e[tot].next=p[u];   e[tot].to=v;    e[tot].w=w; p[u]=tot++;
}

void tarjan(int y,int x){
    dfn[y][x]=low[y][x]=index++;
    sty.push(y);
    stx.push(x);
    instack[y][x]=1;

    if(y+1<n && map[y+1][x]!='#' && dfn[y+1][x]==-1){
        tarjan(y+1,x);
        low[y][x]=min(low[y][x],low[y+1][x]);
    }else if(instack[y+1][x]){
        low[y][x]=min(low[y][x],dfn[y+1][x]);
    }

    if(x+1<m && map[y][x+1]!='#' && dfn[y][x+1]==-1){
        tarjan(y,x+1);
        low[y][x]=min(low[y][x],low[y][x+1]);
    }else if(instack[y][x+1]){
        low[y][x]=min(low[y][x],dfn[y][x+1]);
    }

    if(sy[y][x]!=-1){
        if(dfn[sy[y][x]][sx[y][x]]==-1){
            tarjan(sy[y][x],sx[y][x]);
            low[y][x]=min(low[y][x],low[sy[y][x]][sx[y][x]]);
        }else if(instack[sy[y][x]][sx[y][x]]){
            low[y][x]=min(low[y][x],dfn[sy[y][x]][sx[y][x]]);
        }
    }

    if(dfn[y][x]==low[y][x]){
        int yy,xx;
        id++;
        val[id]=0;
        do{
            yy=sty.top();
            xx=stx.top();
            sty.pop();
            stx.pop();
            belong[yy][xx]=id;
            instack[yy][xx]=0;
            val[id]+=( map[yy][xx]== '*' ? 0 : map[yy][xx]-'0');
        }while(y!=yy || x!=xx);
    }
}

void redraw(){
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            int u,v;
            u=belong[i][j];
            if(i+1<n && belong[i+1][j]!=-1){
                v=belong[i+1][j];
                if(u!=v){
                    add(u,v,val[v]);
                }
            }

            if(j+1<m && belong[i][j+1]!=-1){
                v=belong[i][j+1];
                if(u!=v){
                    add(u,v,val[v]);
                }
            }


            if(sy[i][j]!=-1 && belong[sy[i][j]][sx[i][j]]!=-1){
                v=belong[sy[i][j]][sx[i][j]];
                if(u!=v){
                    add(u,v,val[v]);
                }
            }

        }
    }
}

void spfa(int a){
    bool vin[MAX*MAX]={0};
    memset(dist,0,sizeof(dist));
    queue<int> q;
    while(!q.empty()) q.pop();
    dist[a]=val[a];
    Max=dist[a];
    q.push(a);
    vin[a]=1;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        vin[u]=0;
        for(int v=p[u];v!=-1;v=e[v].next){
            if(dist[e[v].to]<dist[u]+e[v].w){
                dist[e[v].to]=dist[u]+e[v].w;
                if(!vin[e[v].to]){
                    q.push(e[v].to);
                    vin[e[v].to]=1;
                }
                Max=max(Max,dist[e[v].to]);
            }
        }
    }
}

int main()
{
    int t;
    //freopen("data.txt","r",stdin);
    scanf("%d",&t);
    getchar();
    while(t--){
        scanf("%d %d",&n,&m);
        getchar();
        reset();
        for(int i=0;i<n;i++){
            scanf("%s",map[i]);
            for(int j=0;j<m;j++){
                if(map[i][j]=='*'){
                    star[starnum++]=i*m+j;
                }
            }
        }
        for(int i=0;i<starnum;i++){
            int y,x;
            scanf("%d %d",&y,&x);
            getchar();
            if(map[y][x]!='#'){
                sy[star[i]/m][star[i]%m]=y;
                sx[star[i]/m][star[i]%m]=x;
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(map[i][j]!='#' && dfn[i][j]==-1){
                    tarjan(i,j);
                }
            }
        }
        redraw();
        spfa(belong[0][0]);
        printf("%d\n",Max);
    }
    return 0;
}