SPFA+Dinic HDOJ 3416 Marriage Match IV

#include <bits/stdc++.h>
using namespace std;

const int N = 1e3 + 5;
const int M = 1e5 + 5;
const int INF = 0x3f3f3f3f;
struct	Edge	{
int u, v, w, nex;
Edge()	{}
Edge(int u, int v, int w, int nex) : u (u), v (v), w (w), nex (nex) {}
}edge[2][M];
struct Flow	{
int v, cap, rev;
Flow()	{}
Flow(int v, int cap, int rev) : v (v), cap (cap), rev (rev) {}
};
vector<Flow> F
;
int it
;
int lv
;
int head[2]
;
int d[2]
;
bool vis
;
int n, m, e[2];
int a, b, sp;

void init(int id)	{
memset (head[id], -1, sizeof (head[id]));
e[id] = 0;
}

void add_edge(int u, int v, int w, int id)	{
edge[id][e[id]] = Edge (u, v, w, head[id][u]);
head[id][u] = e[id]++;
}

void re_edge(void)	{
init (1);
for (int i=0; i<e[0]; ++i)	{
add_edge (edge[0][i].v, edge[0][i].u, edge[0][i].w, 1);
}
}

void add_flow_edge(int u, int v, int cap)	{
F[u].push_back (Flow (v, cap, (int) F[v].size ()));
F[v].push_back (Flow (u, 0, (int) F[u].size ()-1));
}

void BFS(int s)	{
memset (lv, -1, sizeof (lv));
queue<int> que;	que.push (s);	lv[s] = 0;
while (!que.empty ())	{
int u = que.front ();	que.pop ();
for (int i=0; i<F[u].size (); ++i)	{
Flow &e = F[u][i];
if (e.cap > 0 && lv[e.v] < 0)	{
lv[e.v] = lv[u] + 1;
que.push (e.v);
}
}
}
}

int DFS(int u, int t, int f)	{
if (u == t)	return f;
for (int &i=it[u]; i<F[u].size (); ++i)	{
Flow &e = F[u][i];
if (e.cap > 0 && lv[u] < lv[e.v])	{
int d = DFS (e.v, t, min (f, e.cap));
if (d > 0)	{
e.cap -= d;	F[e.v][e.rev].cap += d;
return d;
}
}
}
return 0;
}

//最大流算法
int Dinic(int s, int t)	{
int flow = 0, f;
for (; ;)	{
BFS (s);
if (lv[t]< 0)	return flow;
memset (it, 0, sizeof (it));
while ((f = DFS (s, t, INF)) > 0)	flow += f;
}
}

void build_max_flow_graph(void)	{
for (int i=1; i<=n; ++i)	F[i].clear ();
for (int i=0; i<m; ++i)	{
Edge &e = edge[0][i];
if (d[0][e.u] + e.w + d[1][e.v] == sp)	{
add_flow_edge (e.u, e.v, 1);
add_flow_edge (e.v, e.u, 0);
}
}
}

void SPFA(int s, int id)	{
memset (d[id], INF, sizeof (d[id]));
memset (vis, false, sizeof (vis));
d[id][s] = 0;	vis[s] = true;
queue<int> que;	que.push (s);
while (!que.empty ())	{
int u = que.front ();	que.pop ();
vis[u] = false;
for (int i=head[id][u]; ~i; i=edge[id][i].nex)	{
int v = edge[id][i].v, w = edge[id][i].w;
if (d[id][v] > d[id][u] + w)	{
d[id][v] = d[id][u] + w;
if (!vis[v])	{
vis[v] = true;	que.push (v);
}
}
}
}
}

int run(void)	{
SPFA (a, 0);
sp = d[0][b];
if (sp == INF)	return 0;
re_edge ();
SPFA (b, 1);
build_max_flow_graph ();
return Dinic (a, b);
}

int main(void)	{
int T;	scanf ("%d", &T);
while (T--)	{
init (0);
scanf ("%d%d", &n, &m);
for (int u, v, w, i=1; i<=m; ++i)	{
scanf ("%d%d%d", &u, &v, &w);
add_edge (u, v, w, 0);
}
scanf ("%d%d", &a, &b);
printf ("%d\n", run ());
}

return 0;
}