POJ 3057 网络流 Evacuation

题意：

有一个n×m的房间，四周每个格子要么是墙要么是门。中间部分是墙或者人。

现在所有人要从房间逃出去，每个人的速度为1，也就是每个单位时间只能向上下左右四个方向走一格。

多个人可以站在同一个格子上，但是每个时刻每个门只能通过一格人，求所有人从房间中逃出去所需要的最少时间。

分析：

把每个人看成一个点，然后把每个时刻和门组成的二元组看成一个点。

如果两点之间连一条边表示这个人在这个时刻从这个门逃出去。

所以我们可以从小到大将时间逐渐加1，直到找到最大匹配为止。

在增加点的时候，可以在之前最大流基础上增广，这样更快。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <map>
 #define MP make_pair
 using namespace std;

 typedef pair<int, int> PII;

 const int INF = 0x3f3f3f3f;
 const int maxh = ;
 const int maxnode = ;

 char maze[maxh][maxh];
 int id[maxh][maxh];

 int row, col;

 vector<PII> people, doors;

 int dx[] = { , , -,  };
 int dy[] = { , , , - };

 int dist[][];  //the distance from every door to people
 int steps[maxh][maxh];

 bool inline in(int x, int y) { return x >=  && x < row && y >=  && y < col; }

 bool vis[maxh][maxh];

 void bfs(PII s)
 {
     int st = id[s.first][s.second];
     steps[s.first][s.second] = ;
     queue<PII> Q;
     Q.push(s);
     memset(vis, false, sizeof(vis));
     vis[s.first][s.second] = true;

     while(!Q.empty())
     {
         PII t = Q.front(); Q.pop();
         for(int i = ; i < ; i++)
         {
             int x = t.first + dx[i];
             int y = t.second + dy[i];
             if(in(x, y) && !vis[x][y] && maze[x][y] == '.')
             {
                 vis[x][y] = true;
                 dist[st][id[x][y]] = steps[x][y] = steps[t.first][t.second] + ;
                 Q.push(MP(x, y));
             }
         }
     }
 }

 struct Edge
 {
     int from, to, cap, flow;
     Edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f) {}
 };

 int nodes;
 vector<int> G[maxnode];
 vector<Edge> edges;

 void init()
 {
     edges.clear();
     for(int i = ; i < nodes; i++) G[i].clear();
 }

 void AddEdge(int u, int v, int cap)
 {
     edges.push_back(Edge(u, v, cap, ));
     edges.push_back(Edge(v, u, , ));
     int m = edges.size();
     G[u].push_back(m - );
     G[v].push_back(m - );
 }

 int s, t;
 bool visit[maxnode];
 int d[maxnode], cur[maxnode];

 bool BFS()
 {
     memset(visit, false, sizeof(visit));
     queue<int> Q;
     Q.push(s);
     d[s] = ;
     visit[s] = true;

     while(!Q.empty())
     {
         int u = Q.front(); Q.pop();
         for(int i = ; i < G[u].size(); i++)
         {
             Edge& e = edges[G[u][i]];
             int v = e.to;
             if(!visit[v] && e.cap > e.flow)
             {
                 visit[v] = true;
                 Q.push(v);
                 d[v] = d[u] + ;
             }
         }
     }

     return visit[t];
 }

 int DFS(int u, int a)
 {
     if(u == t || a == ) return a;
     int flow = , f;
     for(int& i = cur[u]; i < G[u].size(); i++)
     {
         Edge& e = edges[G[u][i]];
         int v = e.to;
         if(d[v] == d[u] +  && (f = DFS(v, min(a, e.cap - e.flow))) > )
         {
             e.flow += f;
             edges[G[u][i]^].flow -= f;
             flow += f;
             a -= f;
             if(a == ) break;
         }
     }
     return flow;
 }

 int Maxflow()
 {
     int flow = ;
     while(BFS())
     {
         memset(cur, , sizeof(cur));
         flow += DFS(s, INF);
     }
     return flow;
 }

 void Readuce()
 {
     for(int i = ; i < edges.size(); i++)
         edges[i].cap -= edges[i].flow, edges[i].flow = ;
 }

 int main()
 {
     int T; scanf("%d", &T);
     while(T--)
     {
         scanf("%d%d", &row, &col);
         for(int i = ; i < row; i++) scanf("%s", maze[i]);

         memset(id, , sizeof(id));
         people.clear(); doors.clear();
         int psz = , dsz = ;
         for(int i = ; i < row; i++)
             for(int j = ; j < col; j++)
             {
                 if(maze[i][j] == 'D') { doors.push_back(MP(i, j)); id[i][j] = dsz++; }
                 else if(maze[i][j] == '.') { people.push_back(MP(i, j)); id[i][j] = psz++; }
             }

         memset(dist, 0x3f, sizeof(dist));
         for(int i = ; i < dsz; i++) bfs(doors[i]);
         bool unreachable = false;
         for(int i = ; i < psz; i++)
         {
             bool reach = false;
             for(int j = ; j < dsz; j++)
                 if(dist[j][i] < INF) { reach = true; break; }
             if(reach == false) { unreachable = true; break; }
         }

         if(unreachable) { puts("impossible"); continue; }

         int tot_time = ;
         s = , t = ;
         nodes =  + psz;
         init();
         for(int i = ; i < psz; i++) AddEdge(s, i + , );

         int matches = ;
         for(;;)
         {
             tot_time++;
             for(int i = ; i < dsz; i++)
             {
                 G[nodes].clear();
                 AddEdge(nodes, t, );
                 for(int j = ; j < psz; j++)
                     if(dist[i][j] <= tot_time) AddEdge(j + , nodes, );
                 nodes++;
             }
             matches += Maxflow();
             if(matches == psz) break;
             Readuce();
         }
         printf("%d\n", tot_time);
     }

     return ;
 }

代码君