poj 3308 Paratroopers(网络流 最小割 dinic模板)

题意：火星人要和地球人PK，地球人间谍搞到了一份情报：火星人要搞伞兵，登陆在地球一个row*col的地图上，而且知道伞兵的数量和每个伞兵要降落的格子。为了消灭敌人，可以在某一行或者某一列安置激光枪。每个激光枪可以瞬间消灭这一行（或者列）的敌人。

安装消灭第i行的激光枪消费是ri。

安装消灭第j行的激光枪消费是ci。

现在总部要你花费最小的费用，安装好足够的激光枪去消灭所有的火星人，问最小的花费是多少。

这里花费的定义有点不同：是每个激光器消费的乘积。

思路：最小割_最大流，EK超时，用dinic模板做，不是一般的快。把伞兵看成边，行列看成节点，转化为了带权二分图最小点覆盖。加入超级源点和超级汇点，源点和所有行节点相连(权值ri)，所有列节点和汇点相连(权值ci)，如果a行b列有敌人，则把节点a和节点b相连。则问题又可以转化求最小割。

因为对任一敌人<a,b>，必然有source-->a-->b-->sink，故路径上的三条边<source,a>,<a,b>, <b,sink>中至少有一条边在割中,我们把<a,b>的权值设置为无限大，则其不可能被选中。于是割边集中必然有<source,a>和<b,sink>中的至少一条，也即对应选择了相应的行或列，我们把这些边的权值设置为花费，则最小割即是总花费的最小方案。

最小割：对于图中的两个点(一般为源点和汇点)来说，如果把图中的一些边去掉，如果它们之间无法连通的话，则这些边组成的集合就叫为割了。如果这些边有权值，最小割就是指权值之和最小的一个割。

最大流最小割：应用于网络中，指总流量不超过链路可承载的最大值，且在每条子路径上取尽可能少的流量。对任意一个只有一个源点一个汇点的图来说，从源点到汇点的最大流等于最小割。

参考资料：/article/6595299.html
https://comzyh.com/blog/archives/568/
http://blog.sina.com.cn/s/blog_6635898a0100ps4m.html

http://blog.sina.com.cn/s/blog_68629c7701010r91.html

代码1：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=150;//点数的最大值
const int MAXM=20500;//边数的最大值

struct Node
{
int from,to,next;
double cap;
} edge[MAXM];
int tol;

int dep[MAXN];//dep为点的层次
int head[MAXN];

int n;
void init()
{
tol=0;
memset(head,-1,sizeof(head));
}
void addedge(int u,int v,double w)//第一条变下标必须为偶数
{
edge[tol].from=u;
edge[tol].to=v;
edge[tol].cap=w;
edge[tol].next=head[u];
head[u]=tol++;
edge[tol].from=v;
edge[tol].to=u;
edge[tol].cap=0;
edge[tol].next=head[v];
head[v]=tol++;
}

int BFS(int start,int end)
{
int que[MAXN];
int front,rear;
front=rear=0;
memset(dep,-1,sizeof(dep));
que[rear++]=start;
dep[start]=0;
while(front!=rear)
{
int u=que[front++];
if(front==MAXN)front=0;
for(int i=head[u]; i!=-1; i=edge[i].next)
{
int v=edge[i].to;
if(edge[i].cap>0&&dep[v]==-1)
{
dep[v]=dep[u]+1;
que[rear++]=v;
if(rear>=MAXN)rear=0;
if(v==end)return 1;
}
}
}
return 0;
}
double dinic(int start,int end)
{
double res=0;
int top;
int stack[MAXN];//stack为栈，存储当前增广路
int cur[MAXN];//存储当前点的后继
while(BFS(start,end))
{
memcpy(cur,head,sizeof(head));
int u=start;
top=0;
while(1)
{
if(u==end)
{
double min=INF;
int loc;
for(int i=0; i<top; i++)
if(min>edge[stack[i]].cap)
{
min=edge[stack[i]].cap;
loc=i;
}
for(int i=0; i<top; i++)
{
edge[stack[i]].cap-=min;
edge[stack[i]^1].cap+=min;
}
res+=min;
top=loc;
u=edge[stack[top]].from;
}
for(int i=cur[u]; i!=-1; cur[u]=i=edge[i].next)
if(edge[i].cap!=0&&dep[u]+1==dep[edge[i].to])
break;
if(cur[u]!=-1)
{
stack[top++]=cur[u];
u=edge[cur[u]].to;
}
else
{
if(top==0)break;
dep[u]=-1;
u=edge[stack[--top]].from;
}
}
}
return res;
}

int main()//多源多汇点，在前面加个源点，后面加个汇点，转成单源单汇点
{
int start,end,t;
int row,col,par;
double val;
int i,j;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&row,&col,&par);
n=row+col+1;
init();
for(i = 1; i <= row; i ++)
{
scanf("%lf", &val);
addedge(0, i, log(val));
}
for(i = 1; i <= col; i ++)
{
scanf("%lf", &val);
addedge(row + i, n, log(val));
}
while(par --)
{
scanf("%d%d", &i, &j);
addedge(i, row + j, INF);
}

double ans=dinic(0,n);
printf("%.4f\n",exp(ans));
}
return 0;
}

代码2：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<cmath>
using namespace std;
const int nMax = 105;
const int eMax = 1450;
const double inf = 999999;

struct{
int u, v, next;
double c;
}bf[2*eMax];
int ne, head[nMax];
int cur[nMax], ps[nMax], dep[nMax];

void addEdge(int u, int v, double c){    // dinic的加边，还是有点不同的。
bf[ne].u = u;
bf[ne].v = v;
bf[ne].c = c;
bf[ne].next = head[u];
head[u] = ne ++;
bf[ne].u = v;
bf[ne].v = u;
bf[ne].c = 0;
bf[ne].next = head[v];
head[v] = ne ++;
}

double dinic(int s, int t){     // dinic模板：源点为s，汇点为t(这里可以不用知道n的大小)。
double tr, res = 0;
int i, j, k, f, r, top;
while(1){
memset(dep, -1, sizeof(dep));
for(f = dep[ps[0]=s] = 0, r = 1; f != r;)
for(i = ps[f ++], j = head[i]; j; j = bf[j].next)
if(bf[j].c && dep[k=bf[j].v] == -1){
dep[k] = dep[i] + 1;
ps[r ++] = k;
if(k == t){
f = r; break;
}
}
if(dep[t] == -1) break;
memcpy(cur, head, sizeof(cur));
i = s, top = 0;
while(1){
if(i == t){
for(tr = inf, k = 0; k < top; k ++)
if(bf[ps[k]].c < tr)
tr = bf[ps[f=k]].c;
for(k = 0; k < top; k ++){
bf[ps[k]].c -= tr;
bf[ps[k]^1].c += tr;
}
i = bf[ps[top=f]].u;
res += tr;          // 当前的最大流，每次累积上去。
}
for(j = cur[i]; cur[i]; j = cur[i] = bf[cur[i]].next)
if(bf[j].c && dep[i]+1 == dep[bf[j].v]) break;
if(cur[i]){
ps[top ++] = cur[i];
i = bf[cur[i]].v;   // i=bf[cur[i]].v 绝不能写为 bf[cur[i]].v=i，脑残了一次。
}else{
if(top == 0) break;
dep[i] = -1;
i = bf[ps[-- top]].u;
}
}
}
return res;
}

int main(){
int t, row, col, par, n, i, j;
double val;
scanf("%d", &t);
while(t --){
ne = 2;
memset(head, 0, sizeof(head));
scanf("%d%d%d", &row, &col, &par);
n = row + col + 1;
for(i = 1; i <= row; i ++){
scanf("%lf", &val);
addEdge(0, i, log(val));
}
for(i = 1; i <= col; i ++){
scanf("%lf", &val);
addEdge(row + i, n, log(val));
}
while(par --){
scanf("%d%d", &i, &j);
addEdge(i, row + j, inf);
}
double ans = dinic(0, n);
printf("%.4f\n", exp(ans));
}
return 0;
}