LA 6395 SurelyYouCongest 最大流

题意：一个城市有n个路口m条路，每一条路一次性只能让一个人通过，否则就会形成阻塞。但是在路口的人数是不限的，现在给出一些人的位置，他们同时出发赶往路口1，同时他们只走最短的路，问你在不形成阻塞的前提下最多有多少人能到达路口1。

思路：

1：求出1到其他路口的最短路，然后只保留最短路。

2：只有当人在到路口1的距离相同的路口才有可能形成阻塞。

3：对人到路口距离排序，对于相同距离的人跑最大流，一层一层累加即可。

这题刚开始的思路很好出，但是往往会忽略思路2，导致WA。还有对于每一层如果不是现建图，现跑最大流，而是先建好图再一层一层累加的话会超时。不愧是Final题~

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

#define REP( i, a, b ) for( int i = a; i < b; i++ )
#define FOR( i, a, b ) for( int i = a; i <= b; i++ )
#define CLR( a, x ) memset( a, x, sizeof a )
#define CPY( a, x ) memcpy( a, x, sizeof a )
#define bug puts("bug....")

const int maxn = 25000 + 10;
const int maxe = 110000 + 10;
const int INF = 1e9;

struct Edge{
int v, c, f;
int next;
Edge() {}
Edge(int v, int c, int f, int next) : v(v), c(c), f(f), next(next) {}
};

struct ISAP{
int n, s, t;
int num[maxn], cur[maxn], d[maxn], p[maxn];
int Head[maxn], cntE;
int Q[maxn], head, tail;
int visit[maxn];
Edge edge[maxe];
void Init(int n){
this -> n = n;
cntE = 0;
CLR(Head, -1);
}
void Add(int u, int v, int c){
edge[cntE] = Edge(v, c, 0, Head[u]);
Head[u] = cntE++;
edge[cntE] = Edge(u, 0, 0, Head[v]);
Head[v] = cntE++;
}
void Bfs(){
CLR(d, -1);
CLR(num, 0);
d[t] = 0;
head = tail = 0;
Q[tail++] = t;
num[0] = 1;
while(head != tail){
int u = Q[head++];
for(int i = Head[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(~d[e.v]) continue;
d[e.v] = d[u] + 1;
Q[tail++] = e.v;
num[d[e.v]] ++;
}
}
}
int Maxflow(int s, int t){
this -> s = s;
this -> t = t;
CPY(cur, Head);
Bfs();
int flow = 0, u = p[s] = s;
while(d[s] < n){
if(u == t){
int f = INF, neck;
for(int i = s; i != t; i = edge[cur[i]].v){
if(f > edge[cur[i]].c - edge[cur[i]].f){
f = edge[cur[i]].c - edge[cur[i]].f;
neck = i;
}
}
for(int i = s; i != t; i = edge[cur[i]].v){
edge[cur[i]].f += f;
edge[cur[i]^1].f -= f;
}
flow += f;
u = neck;
}
int ok = 0;
for(int i = cur[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(e.c > e.f && d[e.v] + 1 == d[u]){
ok = 1;
cur[u] = i;
p[e.v] = u;
u = e.v;
break;
}
}
if(!ok){
int m = n - 1;
if(--num[d[u]] == 0) break;
for(int i = Head[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(e.c - e.f > 0 && m > d[e.v]){
cur[u] = i;
m = d[e.v];
}
}
++num[d[u] = m + 1];
u = p[u];
}
}
return flow;
}
}solver;

struct E{
int u, d;
int next;
E(int u = 0, int d = 0, int next = 0) : u(u), d(d), next(next) {}
bool operator < (const E &rhs) const{
return d > rhs.d;
}
};

const int inf = 0x3f3f3f3f;
int H[maxn], cnte;
int vis[maxn], dist[maxn];
Edge edges[maxe];

void dijkstra(int s){
priority_queue<E> Q;
Q.push(E(s, 0));
memset(vis, 0, sizeof(vis));
memset(dist, inf, sizeof(dist));
dist[s] = 0;
while(!Q.empty()){
E cur = Q.top(); Q.pop();
int u = cur.u;
int d = cur.d;
if(vis[u]) continue;
vis[u] = 1;
for(int i = H[u]; ~i; i = edges[i].next){
int v = edges[i].v;
int d = edges[i].c;
if(dist[v] > dist[u] + d){
dist[v] = dist[u] + d;
Q.push(E(v, dist[v]));
}
}
}
}

void init(){
memset(H, -1, sizeof(H));
cnte = 0;
}

void Add(int u, int v, int d){
edges[cnte] = Edge(v, d, 0, H[u]);
H[u] = cnte++;
edges[cnte] = Edge(u, d, 0, H[v]);
H[v] = cnte++;
}

void build_graph(int u){
if(vis[u]) return;
vis[u] = 1;
for(int i = H[u]; ~i; i = edges[i].next){
int v = edges[i].v;
int d = edges[i].c;
if(dist[v] + d == dist[u]){
solver.Add(u, v, 1);
build_graph(v);
}
}
}

bool cmp(int a, int b){
return dist[a] < dist[b];
}

int n, m, c;
int pos[1010];

int find_same(int k){
int len = 0;
for(int i = k; i < c; i++){
if(dist[pos[i]] == dist[pos[k]]) len++;
else break;
}
return k + len - 1;
}

void solve(){
int S = 0, T = 1;
init();
for(int i = 0; i < m; i++){
int u, v, d;
scanf("%d%d%d", &u, &v, &d);
Add(u, v, d);
}
for(int i = 0; i < c; i++)
scanf("%d", &pos[i]);
dijkstra(1);
int ans = 0;
sort(pos, pos + c, cmp);
for(int i = 0, j = 0; i < c; i = j + 1){
j = find_same(i);
solver.Init(n + 1);
memset(vis,0, sizeof(vis));
for(int k = i; k <= j; k++){
solver.Add(S, pos[k], 1);
build_graph(pos[k]);
}
ans += solver.Maxflow(S, T);
}
printf("%d\n", ans);
}

int main()
{
//freopen("in.txt", "r", stdin);
while(~scanf("%d%d%d", &n, &m ,&c)) solve();
return 0;
}