POJ 3592 Instantaneous Transference 缩点构图求最长路

点击打开链接

Instantaneous Transference

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 5496		Accepted: 1208

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

在一个n*m的图中，让你从左上角的点走到右下角的点，每个点都有一个数值代表矿石数量，或者*代表瞬间传送到某个点，或者#代表障碍，你只能往右走或者往下走，走到*处，你可以选择往下走或者往右走或者传送到某个点，每走到矿石处，你可以得到此数量矿石，不过一旦得到，此处矿石数量就变为0，问得到的最多矿石数量是多少。

构图：

如果是矿石，则连接它右面的点和下面的点，当然此点不能是#。

如果是*，则连接它右面的点和下面的点和要传送到的点，当然此点也不能是#。

构完图之后，缩点求出缩点之后每个点的权值，然后重新构图。

最后在缩点之后的图上求一遍最长路，即源点到某点获得的最大的矿石。

不要忘了加上源点的矿石数量。

//912K	0MS
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<queue>
#include<algorithm>
#define M 2007
using namespace std;
int n,m,nodes,cnt,scnt,begin;
int head[M],dfn[M],low[M],vis[M],stack[M],belong[M];
char map[M][M];
int val[M],g[M],head1[M],dis[M];
struct E
{
    int v,next,cap;
} edg[M*M],edg1[M*M];
void init()
{
    nodes=scnt=begin=cnt=0;
    memset(head,-1,sizeof(head));
    memset(head1,-1,sizeof(head1));
    memset(dfn,0,sizeof(dfn));
    memset(stack,0,sizeof(stack));
    memset(low,0,sizeof(low));
    memset(vis,0,sizeof(vis));
    memset(val,0,sizeof(val));
}
void addedge(int u,int v)
{
    edg[nodes].v=v;edg[nodes].next=head[u];
    head[u]=nodes++;
}
void addedge1(int u,int v,int w)
{
    edg1[nodes].v=v; edg1[nodes].next=head1[u];
    edg1[nodes].cap=w;
    head1[u]=nodes++;
}
void tarjan(int x)
{
    int v;
    dfn[x]=low[x]=++cnt;
    stack[++begin]=x;
    for(int i=head[x];i!=-1;i=edg[i].next)
    {
        v=edg[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[x]=min(low[x],low[v]);
        }
        else if(!vis[v])
            low[x]=min(low[x],dfn[v]);
    }
    if(low[x]==dfn[x])
    {
        scnt++;
        do
        {
            v=stack[begin--];
            belong[v]=scnt;
            val[scnt]+=g[v];
            vis[v]=1;
        }while(v!=x);
    }
}
int spfa(int s)                  
{
    for(int i=0; i<=scnt; i++)dis[i]=-1;
    memset(vis,0,sizeof(vis));
    int count=0;
    queue<int>q;
    q.push(s);
    vis[s] =1;
    dis[s]=0;
    while(!q.empty()) 
    {
        int u =q.front();
        q.pop();
        vis[u]=0;
        for(int i=head1[u]; i!=-1; i=edg1[i].next)
        {
            int v=edg1[i].v;
            if(dis[v]<dis[u]+edg1[i].cap)
            {
                dis[v]=dis[u]+edg1[i].cap;
                if(!vis[v])
                {
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
    int maxx=0;
    for(int i=1; i<=scnt; i++) //求s点到其它点的最大距离
        maxx=max(maxx,dis[i]);
    return maxx+val[s];//返回最大距离+源点本身权值
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int xx,yy;
        init();
        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]=='*')
                {
                    scanf("%d%d",&xx,&yy);
                    int a=i*m+j;
                    int b=xx*m+yy;
                    if(map[xx][yy]!='#')addedge(a,b);//连接*到其转到的点
                    if(i+1<n&&map[i+1][j]!='#')addedge(a,a+m);//连接它的下一行的点
                    if(j+1<m&&map[i][j+1]!='#')addedge(a,a+1);//连接它的下一个点
                    g[a]=0;
                }
                else if(map[i][j]!='#')
                {
                    int a=i*m+j;
                    if(i+1<n&&map[i+1][j]!='#'){ addedge(a,a+m);}//连接它的下一行的点
                    if(j+1<m&&map[i][j+1]!='#'){addedge(a,a+1); }//连接它的下一个点
                    g[a]=map[i][j]-'0';
                }
                else g[i*m+j]=0;
        for(int i=0; i<n*m; i++)
            if(!dfn[i])tarjan(i);
        nodes=0;
        for(int u=0; u<n*m; u++)//重新构图
            for(int j=head[u]; j!=-1; j=edg[j].next)
            {
                int v=edg[j].v;
                if(u!=v&&belong[u]!=belong[v])
                    addedge1(belong[u],belong[v],val[belong[v]]);
            }
        int ans=spfa(belong[0]);//求最长路
        printf("%d\n",ans);
    }
    return 0;
}