HDU -- 3468 Treasure Hunting （最大流+BFS）

题目大意：

iSea和朋友去挖宝藏，他的朋友有一个n*m的地图，他们按着地图上A,B....Z,a,b....z汇合点的顺序去寻宝藏，他们每次在下一个汇合点上汇合，再一起重新出发，iSea每次选择走最短的路径到下一个汇合点，为了尽快去到下一个汇合点，iSea在这个途中不管遇到多少个金子，也只能捡一个，问走到最后的标识点的途中iSea最多能捡多少金子（如果无法从一个汇合点走向另一个汇合点，直接输出-1）；

思路分析：

①：设立一个源点，连向每一个标识点，权值为1，表示从每一个汇合点出发的途中只能捡一个金子；

②：设立一个汇点，让每个金子地点连向汇点，权值为1；

③：对每一个汇合点进行一次bfs，找出从当前汇合点到下一个汇合点的所有最短路径，从当前的汇合点连向途中遇到的金子地点，权值为1，表示可以从这个点取走一个金子；

刚开始的思维一直很换乱，被这道题磨了好几个钟头，真心太挫了，不过会用了一个东西，就是求最短路径那里，假如求AB两点的最短路径，先从A点进行一次BFS，在反向从B点进行一次BFS，如果AB的最短路径经过C点，那么她们的距离关系： d[A][point[C]]+d[B][point[C]]=d[A][point[B]], point存放的是每个点在地图中的位置，学会了这个思想，被这道题纠缠了这么久还是很值得很有意义的。。。。

代码实现：

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<vector>
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
using namespace std;
const int N=10060;
const int M=1200000;
const int INF=0x3f3f3f3f;
int n,m,s,t,top,head[N],gap[N],cur[N],dis[N],d[60][N],vis[105][105],pre[N],point[60],tr[N],dx[4]={0,0,1,-1},dy[4]={1,-1,0,0};
char mp[105][105];

struct Edge{
    int to,next,flow;
}edge[M];

struct Node{
    int x,y;
    Node(int _x=0,int _y=0):x(_x),y(_y){}
};

void Addedge(int from,int to,int flow){
    edge[top].to=to,edge[top].next=head[from],edge[top].flow=flow,head[from]=top++;
    edge[top].to=from,edge[top].next=head[to],edge[top].flow=0,head[to]=top++;
}

void Bfs(){
    queue<int> q;
    memset(gap,0,sizeof(gap));
    memset(dis,-1,sizeof(dis));
    gap[0]=1,dis[t]=0;
    q.push(t);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=head[u];i+1;i=edge[i].next){
            if(dis[edge[i].to]==-1){
                dis[edge[i].to]=dis[u]+1;
                gap[dis[edge[i].to]]++;
                q.push(edge[i].to);
            }
        }
    }
}

int Sap(){
    Bfs();
    memset(pre,-1,sizeof(pre));
    for(int i=0;i<=t;++i) cur[i]=head[i];
    int u=s,i,cur_flow,max_flow=0,neck,tmp;
    while(dis[s]<t){
        if(u==t){
            cur_flow=INF;
            for(int i=s;i!=t;i=edge[cur[i]].to){
                if(cur_flow>edge[cur[i]].flow){
                    neck=i;
                    cur_flow=edge[cur[i]].flow;
                }
            }
            for(int i=s;i!=t;i=edge[cur[i]].to){
                tmp=cur[i];
                edge[tmp].flow-=cur_flow;
                edge[tmp^1].flow+=cur_flow;
            }
            max_flow+=cur_flow;
            u=neck;
        }
        int i;
        for(i=cur[u];i!=-1;i=edge[i].next)
            if(edge[i].flow&&dis[u]==dis[edge[i].to]+1) break;
        if(i!=-1){
            cur[u]=i;
            pre[edge[i].to]=u;
            u=edge[i].to;
        }else{
            if(--gap[dis[u]]==0) break;
            cur[u]=head[u];
            int mindis=t;
            for(i=head[u];i!=-1;i=edge[i].next){
                if(edge[i].flow&&mindis>dis[edge[i].to])
                    mindis=dis[edge[i].to];
            }
            dis[u]=mindis+1;
            gap[dis[u]]++;
            if(u!=s) u=pre[u];
        }
    }
    return max_flow;
}

void BFS(int s,int x,int y){
    queue<Node> q;
    memset(vis,0,sizeof(vis));
    memset(d[s],0x3f,sizeof(d[s]));
    d[s][x*m+y]=0;
    q.push(Node(x,y));
    vis[x][y]=1;
    Node now,next;
    while(!q.empty()){
        now=q.front();
        q.pop();
        for(int i=0;i<4;++i){
            next.x=now.x+dx[i],next.y=now.y+dy[i];
            if(next.x<0||next.x>=n||next.y<0||next.y>=m||mp[next.x][next.y]=='#'||vis[next.x][next.y]) continue;
            vis[next.x][next.y]=1;
            d[s][next.x*m+next.y]=d[s][now.x*m+now.y]+1;
            q.push(next);
        }
    }
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        memset(head,-1,sizeof(head));
        top=0;
        int id,c1=0,c2=0,flag=0;
        for(int i=0;i<n;++i){
            scanf("%s",mp[i]);
            for(int j=0;j<m;++j){
                if(mp[i][j]=='*') tr[c1++]=i*m+j;
                if(isalpha(mp[i][j])){
                    c2++;
                    if(mp[i][j]>='A'&&mp[i][j]<='Z') id=mp[i][j]-'A';
                    else if(mp[i][j]>='a'&&mp[i][j]<='z') id=mp[i][j]-'a'+26;
                    point[id]=i*m+j;
                }
            }
        }
        s=c1+c2,t=s+1;
        for(int i=0;i<c2;++i) Addedge(s,i,1);
        for(int i=0;i<c1;++i) Addedge(i+c2,t,1);
        for(int i=0;i<c2;++i)
            BFS(i,point[i]/m,point[i]%m);
        for(int i=0;i<c2-1;++i){
            for(int j=0;j<c1;++j){
                if(d[i][tr[j]]+d[i+1][tr[j]]==d[i][point[i+1]]) Addedge(i,j+c2,1);
                if(d[i][point[i+1]]==INF){
                    flag=1;
                    break;
                }
            }
        }
        if(flag){
            printf("-1\n");
            continue;
        }
        int res=Sap();
        printf("%d\n",res);
    }
}