POJ 1273 解题报告

还是按照http://blog.csdn.net/thestoryofsnow/article/details/40942009里面的刷题顺序，最简单的最大流问题。

这道题我在USACO上面已经做过了：http://blog.csdn.net/thestoryofsnow/article/details/38103513 Drainage Ditches问题

这里稍稍改动，主要是把同样两个点之间的pair的所有capacity加到一起了。用的还是我之前写的模板,dfs。
周末刷题的人好多，poj特别挤，程序一直提交不上去。周一就好多了。

Accepted

436K

79MS

C++

2427B

/*
ID: thestor1
LANG: C++
TASK: poj1273
*/
#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <climits>
#include <cassert>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>

using namespace std;

int find_path(vector<vector<int> > &capacity, vector<vector<int> > adjs, const int source, const int sink)
{
int M = capacity.size();
std::vector<bool> visited(M, false);
// from[x] is the previous vertex visited in the shortest path from the source to x
std::vector<int> from(M, -1);
queue<int> Q;
Q.push(source);
visited[source] = true;
int where = -1, next = -1, prev = -1;
bool found = false;
while (!Q.empty())
{
where = Q.front();
Q.pop();
for (int i = 0; i < adjs[where].size(); ++i)
{
next = adjs[where][i];
if (!visited[next] && capacity[where][next] > 0)
{
Q.push(next);
visited[next] = true;
from[next] = where;
if (next == sink)
{
found = true;
break;
}
}
}
if (found)
{
break;
}
}

// we compute the path capacity
where = sink;
int path_cap = -1;
while (from[where] > -1)
{
prev = from[where];
if (path_cap > -1)
{
path_cap = min(path_cap, capacity[prev][where]);
}
else
{
path_cap = capacity[prev][where];
}
where = prev;
}

// we update the residual network; if no path is found the while loop will not be entered
where = sink;
while (from[where] > -1)
{
prev = from[where];
capacity[prev][where] -= path_cap;
capacity[where][prev] += path_cap;
where = prev;
}

// if no path is found, path_cap is infinity
if (path_cap == -1)
{
return 0;
}
return path_cap;
}

int main()
{
int N, M;
while (cin >> N >> M)
{
vector<vector<int> > capacity(M, vector<int>(M, 0));
vector<vector<int> > adjs(M, vector<int>());
for (int i = 0; i < N; ++i)
{
int s, e, c;
cin >> s >> e >> c;
capacity[s - 1][e - 1] += c;
adjs[s - 1].push_back(e - 1);
adjs[e - 1].push_back(s - 1);
}

// max flow
int maxflow = 0;

while (true)
{
int path_cap = find_path(capacity, adjs, 0, M - 1);
if (path_cap == 0)
{
break;
}
else
{
maxflow += path_cap;
}
}

cout << maxflow << endl;
}

return 0;
}