【JZOJ3302】供电网络【费用流】

最新推荐文章于 2022-10-30 18:00:00 发布

原创最新推荐文章于 2022-10-30 18:00:00 发布 · 390 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#JZOJ3302 #上下界费用流 #费用流 #动态开边 #orzorzorzorzorzorzorz

费用流专栏收录该内容

11 篇文章

订阅专栏

本文探讨了一种电力网络中的费用流问题，旨在通过优化电力分配，最小化因电力输送产生的额外费用。介绍了一个涉及电力供需、电线输送限制及成本的复杂模型，并详细解释了如何利用费用流算法解决这一问题，包括买入卖出、多余的流量和电线处理等关键步骤。

题目大意：

题目链接：https://jzoj.net/senior/#main/show/3302
阿狸和桃子居住的世界里, 只有一个国家, 这个国家有很多城市, 每个城市直接由中央政府管辖.
电力是这个国家的唯一能源, 但是每个城市的发电能力都不一样, 于是就产生了某些城市电力不足, 而某些城市却电力过剩的情况.
阿狸作为国家的首席工程师, 阿狸的一项重要工作就是均衡整个国家的电力, 使得每个城市的电力都恰好没有剩余或不足.
好在一些城市之间有电线可以输送电力, 这些电线都有自己的输送上限和下限, 并且输送电力的同时会产生大量的热.
每条电线i 发出的热量一定是关于输送电量的一个没有常数项的二次函数,即a_ix^2+b_ix, 并且由于电线是二极管做成的, 很显然只能单向输送电力. 每单位热量需要用1 单位的金币来冷却. 任何两个城市之间, 至多有一条电线.
不幸的是, 有时电力网络不像我们想的那么完美, 某些情况下可能无论如何都不能满足整个国家的电力需求. 这种情况下就只好向别的世界购买电力或者将电力输出给别的世界(注意, 每个城市的电力不能有剩余!), 每个城市买入或者输出电力的价格是不一样的(输出也要花钱).
由于阿狸的国家没有小数的概念, 输送,、购买或者交换电力都必须是以整数1 为单位.
阿狸的任务是最小化金币的花费(买入/送出的费用+电线上发热的冷却费用),他最近被这个问题搞得焦头烂额, 以至于没有时间去陪桃子玩, 结果天天被桃子骂T_T. 好在有你, 万能的程序猿, 请你编写一个程序来帮阿狸解决这个问题吧.

思路：

显然是一个有上下界的费用流。
这道题中以“电力”作为流量，“钱”作为费用。
这道题中，会有3种边：

买入&卖出
多余的流量&不足的流量（流量即电力）
电线

$1 .$ 买入&卖出

由于在一个点买入电是可以再通过电线转移到其他点的，所以任意一个点的买入&卖出流量上限均为 $+\infty$ 。然后由于题目中已经给出了每一个点的买入&卖出流量的费用，所以这里可以直接建边。
在这里插入图片描述

$2 .$ 多余的流量&不足的流量

对于流量，显然如果一个点多出 $x$ 的流量，那么就从源点向这个点连 $x - L [i]$ 的流量，因为若这条边的流量下限为 $L [i]$ ，那么这 $L [i]$ 是一定会流的，所以可以直接在答案中将这 $L [i]$ 做出的贡献加上，然后流量就要减去 $L [i]$ 了。
费用的话正常来说应该为0，但是如果这个点有多余（不足）的流量的话，显然把这些流量流走会更优。所以我们就得让 $s p f a$ 先跑这条路。所以我们可以把这条路的费用设为 $-\infty$ ，最终求出来的 $c o s t$ 再赋值为 $(cost\%\infty+\infty)\%\infty$ 。这样就可以在不改变答案的情况下先跑这条边，因为最短路会优先选择边短的路跑。
在这里插入图片描述

$3 .$ 电线

正常来说，一个点连接到另一个点应该是 $(+\infty,ax^2+bx)$ 。但是考虑到后面的 $ax^2+bx$ 不是一个常数，所以可以考虑拆边。
在这里插入图片描述
这样的话，如果原图流量为 $i$ ，那么在现图就只要流前 $i$ 条路。因为这样的话它们的费用 $ax^2+bx$ 是等于 $a + b + 3 a + b + 5 a + b . . .$ 的。而且后者可以控制每一条边的流量为1且费用为固定常数。

但是这样也有缺点：中间的边的数量太多了，而且很多时候用不到。所以加上一个动态开边就可以了。每次 $s p f a$ 前判断每一条边是否要开一条新边。这样可以大大减少运行时间。

代码：

#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N=210,M=50010,Inf=233333;
int n,m,S,T,cost,ans,tot=1,head[N],dis[N],pre[N],X[M],Y[M],L[M],R[M],A[M],B[M],left[N],cnt[N][N];
bool vis[N];

struct edge
{
	int next,to,flow,cost,from;
}e[M];

void add(int from,int to,int flow,int cost)
{
	e[++tot].to=to;
	e[tot].from=from;
	e[tot].flow=flow;
	e[tot].cost=cost;
	e[tot].next=head[from];
	head[from]=tot;
	
	swap(from,to);
	e[++tot].to=to;
	e[tot].from=from;
	e[tot].flow=0;
	e[tot].cost=-cost;
	e[tot].next=head[from];
	head[from]=tot;
}

void addedge()
{
	for (int i=1;i<=m;i++)
	{
		int u=X[i],v=Y[i];
		if (L[i]==cnt[u][v] && L[i]<R[i])
		{
			L[i]++;
			add(u,v,1,A[i]*(L[i]*2-1)+B[i]);
		}
	}
}

bool spfa()
{
	addedge();
	memset(dis,0x3f3f3f3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	queue<int> q;
	q.push(S);
	dis[S]=0; vis[S]=1;
	while (q.size())
	{
		int u=q.front(),v;
		q.pop();
		vis[u]=0;
		for (int i=head[u];~i;i=e[i].next)
		{
			v=e[i].to;
			if (e[i].flow && dis[v]>dis[u]+e[i].cost)
			{
				dis[v]=dis[u]+e[i].cost;
				pre[v]=i;
				if (!vis[v])
				{
					vis[v]=1;
					q.push(v);
				}
			}
		}
	}
	return dis[T]<=0;
}

void addflow()
{
	for (int x=T;x!=S;x=e[pre[x]].from)
	{
		int u=e[pre[x]].from,v=e[pre[x]].to;
		e[pre[x]].flow--;
		e[pre[x]^1].flow++;
		cnt[u][v]++;
		cnt[v][u]--;
	}
	cost+=dis[T];
}

int MCMF()
{
	while (spfa())
		addflow();
}

int main()
{
	memset(head,-1,sizeof(head));
	scanf("%d%d",&n,&m);
	S=N-2; T=N-1;
	for (int i=1,x,y,z;i<=n;i++)
	{
		scanf("%d%d%d",&left[i],&y,&z);
		add(S,i,Inf,y); add(i,T,Inf,z);
	}
	for (int i=1;i<=m;i++)
	{
		scanf("%d%d%d%d%d%d",&X[i],&Y[i],&A[i],&B[i],&L[i],&R[i]);
		cost+=A[i]*L[i]*L[i]+B[i]*L[i];
		cnt[X[i]][Y[i]]+=L[i]; cnt[Y[i]][X[i]]-=L[i];
		left[X[i]]-=L[i]; left[Y[i]]+=L[i];
	}
	for (int i=1;i<=n;i++)
		if (left[i]>0) add(S,i,left[i],-Inf);
			else add(i,T,-left[i],-Inf);
	MCMF();
	printf("%d",(cost%Inf+Inf)%Inf);
	return 0;
}