POJ 1459 Power Network——(网络流入门)

POJ 1459 Power Network

题目链接：http://poj.org/problem?id=1459
I/O坑爹。。

一开始的想法：
理论虽然简单，实现起来怀疑人生。
问题主要在于用什么模型存储网络，并且可以快速读写(这是核心问题)。
用矩阵存储一直TLE，后来一直想用map，但是感觉还是不行，最后还是换成链表了。

第一次写的，用矩阵存储。一直TLE，我以为矩阵费时间，，后来发现神tm居然控制台一直在等待输入，。。。
所以一直TLE！！！！要在scanf()前面加一个 ~(非)。。。
不过也挺好，写了两种实现，而且有些关键地方不一样：存储的是   点！！还是   边序号！！
不过用链表存图就是麻烦，经常pair，tuple满天飞。。。不知道有没有什么好的结构存储必要的连接信息。。#include <stdio.h>
#include <vector>
#include <queue>
using namespace std;

//POJ 1459 Power Network

const int MAXN = 100 + 2;
const int inf = 0x7fffffff;
char temp[20]; //buffer
int main() {
int n;
while (~scanf("%d", &n))
{
int flow[MAXN][MAXN], cap[MAXN][MAXN];
for (int i = 0; i < MAXN; ++i)
for (int j = 0; j < MAXN; ++j)
{
flow[i][j] = 0;
cap[i][j] = 0;
}
int ps, c, l;
scanf("%d %d %d", &ps, &c, &l);
int S = n, T = n + 1;
vector<vector<int> >node(n + 2); //node[i]数组 表示和i相连的点

//读边
for (int i = 0; i < l; ++i)
{
int from, to, ca;
scanf("%s", temp); sscanf(temp, "(%d,%d)%d", &from, &to, &ca);
cap[from][to] = ca;
if (cap[to][from])continue; //平行边重复记录
node[from].push_back(to);
node[to].push_back(from);
}

//读S相关的边
for (int i = 0; i < ps; ++i)
{
int to, ca;
scanf("%s", temp); sscanf(temp, "(%d)%d", &to, &ca);
cap[S][to] = ca;
if (cap[to][S])continue; //平行边重复记录
node[S].push_back(to);
node[to].push_back(S);
}

//读T相关的边
for (int i = 0; i < c; ++i)
{
int from, ca;
scanf("%s", temp); sscanf(temp, "(%d)%d", &from, &ca);
cap[from][T] = ca;
if (cap[T][from])continue; //平行边重复记录
node[from].push_back(T);
node[T].push_back(from);
}

int maxFlow = 0;
vector<int> aug(n + 2); //aug[i] 表示S到i的可改进量
vector<int> path(n + 2); //p[i] 表示增广路径上的 i的进入点
//BFS查找增广路径
while (true)
{
for (int i = 0; i < n + 2; ++i)aug[i] = 0;
queue<int>q;
q.push(S);
aug[S] = inf;
while (!q.empty())
{
int x = q.front();
q.pop();
int size = node[x].size();
for (int i = 0; i < size; ++i)
{
int t = node[x][i];
if (!aug[t] //访问过的就跳过，当然也可以不跳。。。
&& (cap[x][t] > flow[x][t] //x->t
|| flow[t][x] > 0) //t->x
)
{
path[t] = x; //记录进入点
aug[t] = min(aug[x] //更新残存容量
, max(cap[x][t] - flow[x][t], flow[t][x]));
q.push(t);
}
}
if (aug[T])break; //已经找到一条增广路径
}
if (!aug[T])break; //没有增广路径，结束，返回结果
//有增广路径，从path[]倒着更新
//这条路径上最小值就是aug[T]
int min_aug = aug[T];
for (int u = T; u != S; u = path[u])
{
if (flow[path[u]][u] < cap[path[u]][u])
flow[path[u]][u] += min_aug;
else
flow[u][path[u]] -= min_aug;
}
//流加上这个值
maxFlow += min_aug;
}
//没有增广路径，结束，返回结果
printf("%d\n", maxFlow);
}
system("pause");
return 0;
}

第二次写，用链表(数组实现)，
这个用时居然多一些，差点就想用tuple了，信息使用不如矩阵方便。。。#include <stdio.h>
#include <vector>
#include <queue>
using namespace std;

const int inf = 0x7fffffff;
char temp[20]; //buffer

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

int main() {
int n;
while (~scanf("%d", &n))
{
int ps, c, l;
scanf("%d %d %d", &ps, &c, &l);
int S = n, T = n + 1;
vector<vector<std::pair<int, bool> > > //node[i]数组 int表示和i相连的边序号
node(n + 2); //bool表示 true 出边; false 入边

vector<Edge> edges;
int edge_num = 0; //边序号
//读边
for (int i = 0; i < l; ++i)
{
int from, to, cap;
scanf("%s", temp); sscanf(temp, "(%d,%d)%d", &from, &to, &cap);
edges.push_back(Edge(from, to, cap, 0));
node[from].push_back(make_pair(edge_num, 1));
node[to].push_back(make_pair(edge_num, 0));
edg
a46e
e_num++;
}

//读S相关的边
for (int i = 0; i < ps; ++i)
{
int to, cap;
scanf("%s", temp); sscanf(temp, "(%d)%d", &to, &cap);
edges.push_back(Edge(S, to, cap, 0));
node[S].push_back(make_pair(edge_num, 1));
node[to].push_back(make_pair(edge_num, 0));
edge_num++;
}

//读T相关的边
for (int i = 0; i < c; ++i)
{
int from, cap;
scanf("%s", temp); sscanf(temp, "(%d)%d", &from, &cap);
edges.push_back(Edge(from, T, cap, 0));
node[from].push_back(make_pair(edge_num, 1));
node[T].push_back(make_pair(edge_num, 0));
edge_num++;
}

int maxFlow = 0;
vector<int> aug(n + 2); //aug[i] 表示S到i的可改进量
vector<pair<int, bool> > path(n + 2); //p[i] 表示增广路径上的 i的进入边序号和方向
//BFS查找增广路径
while (true)
{
for (int i = 0; i < n + 2; ++i)aug[i] = 0;
queue<int> q;
q.push(S);
aug[S] = inf;
while (!q.empty())
{
int x = q.front();
q.pop();
int size = node[x].size();
for (int i = 0; i < size; ++i)
{
//注：因为本题平行边的原因，
//有可能会出现四次 x-t
int num = node[x][i].first;
bool out = node[x][i].second;
Edge& e = edges[num];
int t = out ? e.to : e.from;
if (aug[t])continue; //访问过的就跳过，当然也可以不跳。。。

if (out&&e.cap > e.flow) //x->t 还能进一些
{
path[t] = make_pair(num, 0); //记录进入边序号和方向
aug[t] = min(aug[x], e.cap - e.flow); //更新残存容量
q.push(t);
}

if (!out&&e.flow > 0) //x<-t 退回去一些
{
path[t] = make_pair(num, 1); //记录进入边序号和方向
aug[t] = min(aug[x], e.flow); //更新残存容量
q.push(t);
}
}
if (aug[T])break; //已经找到一条增广路径
}
if (!aug[T])break; //没有增广路径，结束，返回结果
//有增广路径，从path[]倒着更新
//这条路径上最小值就是aug[T]
int min_aug = aug[T];
for (int u = T; u != S;)
{
int num = path[u].first;
bool out = path[u].second;
if (!out) //原来的流：p_u-->u
edges[num].flow += min_aug;
else //原来的流：p_u<--u
edges[num].flow -= min_aug;
u = out ? edges[num].to : edges[num].from;
}
//流加上这个值
maxFlow += min_aug;
}
//没有增广路径，结束，返回结果
printf("%d\n", maxFlow);
}
system("pause");
return 0;
}