可行流

对于无源汇问题,方法有两种.


1 从边的角度来处理. 新建超级源汇, 对于每一条有下界的边,x->y, 建立有向边 超级源->y ,容量为x->y下界,建立有向边 x-> 超级汇,容量为x->y下界.建立有向边 x->y,容量为x->y的上界减下界.


2 从点的角度来处理. 新建超级源汇,对于每个点流进的下界和为 in, 流出此点的下界和为out.如果in > out. 建立有向边 超级源->i,容量为in-out.反之,建立有向边 i->超级汇,容量为out-in.


如果超级源的每一条出边都满流,则存在一个可行流,可行流的流量就是每一条逆向边的流量+ 此边下界.


从点的角度的处理方法是边的处理方法的拓展.基于边的处理比较容易理解,但是复杂度较高.
来自  http://www.cnblogs.com/sosi/p/3715737.html
配上一题可行流 zoj 2314

这题可以作为模版——求可行流

代码如下:
/*
* this code is made by LinMeiChen
* Problem: ZOJ 2788
* Type of Problem: 最小割
* Thinking: 不多说直接上题
* Feeling: 第一次思路跟答案几乎吻合，再接再厉
*/
#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<list>
using namespace std;
typedef long long lld;
typedef unsigned int ud;
#define INF_MAX 0x3f3f3f3f
#define eatline() char chch;while((chch=getchar())!='\n')continue;
#define MemsetMax(a) memset(a,0x3f,sizeof a)
#define MemsetZero(a) memset(a,0,sizeof a)
#define MemsetMin(a) memset(a,-1,sizeof a)
#define MemsetFalse(a) MemsetZero(a)
#define PQ priority_queue
#define Q queue
#define maxn 308
#define maxm 40800
struct Edge
{
int v, f;
int up, low;
int next;
}E[maxm];
int k;
int head[maxn], h[maxn];
int level[maxn], stack[maxn];
int inout[maxn];


bool BFS(int s, int t)
{
memset(level, 0, sizeof level);
level[s] = 1;
Q<int>q;
q.push(s);
while (!q.empty())
{
int u = q.front(); q.pop();
if (u == t)
return true;
for (int i = head[u]; i != -1; i = E[i].next)
{
int v = E[i].v;
if (!level[v] && E[i].f > 0)
{
level[v] = level[u] + 1;
q.push(v);
}
}
}
return false;
}


int Dinic(int s, int t)
{
int maxflow = 0;
while (BFS(s, t))
{
memcpy(h, head, sizeof h);
int top = 0;
int u = s;
while (true)
{


if (u == t)
{
int minflow = INF_MAX, flag = 0;
for (int i = 0; i < top; i++)
{
if (minflow>E[stack[i]].f)
{
minflow = E[stack[i]].f;
flag = i;
}
}
for (int i = 0; i < top; i++)
{
E[stack[i]].f -= minflow;
E[stack[i] ^ 1].f += minflow;
}
top = flag;
maxflow += minflow;
u = E[stack[top] ^ 1].v;
}
for (int i = h[u]; i != -1; i = h[u] = E[i].next)
{
int v = E[i].v;
if (level[v] == level[u] + 1 && E[i].f)
break;
}
if (h[u] != -1)
{
stack[top++] = h[u];
u = E[h[u]].v;
}
else
{
if (top == 0)
break;
level[u] = 0;
u = E[stack[--top] ^ 1].v;
}
}
}
return maxflow;
}


void add_edge(int u, int v, int f, int low=0, int up=INF_MAX)
{
E[k].v = v;
E[k].f = f;
E[k].low = low;
E[k].up = up;
E[k].next = head[u];
head[u] = k++;


E[k].v = u;
E[k].f = 0;
E[k].low = low;
E[k].up = up;
E[k].next = head[v];
head[v] = k++;
}


int main()
{
int T;
int n, m;
int u, v, c, f;
scanf("%d", &T);
while (T--)
{
scanf("%d%d", &n, &m);
int s = 0;
int t = n + 1;
k = 0;
memset(head, -1, sizeof head);
memset(inout, 0, sizeof inout);
for (int i = 1; i <= m; i++)
{
scanf("%d%d%d%d", &u, &v, &f, &c);
add_edge(u, v, c - f, f, c);
inout[u] -= f;
inout[v] += f;
}
for (int i = 1; i <= n; i++)
{
if (inout[i] > 0)
{
add_edge(s, i, inout[i]);
}
else
{
add_edge(i, t, -inout[i]);
}
}
Dinic(s, t);
int i, flag = 1;
for (i = head[s]; i != -1; i = E[i].next)
{
if (E[i].f > 0)
{
flag = 0;
break;
}
}
if (flag)
{
printf("YES\n");
for (int i = 0; i < m; i++)
{
printf("%d\n", E[(i << 1) + 1].f + E[(i << 1) + 1].low);
}
}
else
printf("NO\n");
}
return 0;
}
/*
2


4 6
1 2 1 2
2 3 1 2
3 4 1 2
4 1 1 2
1 3 1 2
4 2 1 2


4 6
1 2 1 3
2 3 1 3
3 4 1 3
4 1 1 3
1 3 1 3
4 2 1 3
*/