code vs [网络流24题] 餐巾计划问题

1237 餐巾计划问题

 时间限制: 1 s

 空间限制: 128000 KB

 题目等级 : 钻石 Diamond

题解

 查看运行结果

题目描述  Description

一个餐厅在相继的 N 天里，每天需用的餐巾数不尽相同。假设第 i 天需要 ri块餐巾(i=1，2，…，N)。餐厅可以购买新的餐巾，每块餐巾的费用为 p 分；或者把旧餐巾送到快洗部，洗一块需 m 天，其费用为 f 分；或者送到慢洗部，洗一块需 n 天(n>m)，其费用为 s<f 分。
每天结束时，餐厅必须决定将多少块脏的餐巾送到快洗部，多少块餐巾送到慢洗部，以及多少块保存起来延期送洗。但是每天洗好的餐巾和购买的新餐巾数之和，要满足当天的需求量。
试设计一个算法为餐厅合理地安排好 N 天中餐巾使用计划，使总的花费最小。 
编程找出一个最佳餐巾使用计划.

输入描述 Input Description

第 1 行有 6 个正整数 N,p,m,f,n,s。N 是要安排餐巾使用计划的天数；p 是每块新餐巾的费用；m 是快洗部洗一块餐巾需用天数；f 是快洗部洗一块餐巾需要的费用；n 是慢洗部洗一块餐巾需用天数；s 是慢洗部洗一块餐巾需要的费用。接下来的 N 行是餐厅在相继的 N 天里，每天需用的餐巾数。

输出描述 Output Description

将餐厅在相继的 N 天里使用餐巾的最小总花费输出

样例输入 Sample Input

3 10 2 3 3 2

5

6

7

样例输出 Sample Output

145

题解：这道题是最小费用最大流。此题的关键就是建图。那么如何去建立呢？用到了一个很重要的思想拆点。即把一个点拆成两，那么就出现了两个集合，一个集合xi表示每天脏毛巾，另一个yi表示每天的干净毛巾。

然后根据题意建图：

1. 把每天分为二分图两个集合中的顶点Xi,Yi，建立附加源S汇T。

2. 从S向每个Xi连一条容量为ri，费用为0的有向边。

3. 从每个Yi向T连一条容量为ri，费用为0的有向边。

4. 从S向每个Yi连一条容量为无穷大，费用为p的有向边。

5. 从每个Xi向Xi+1(i+1<=N)连一条容量为无穷大，费用为0的有向边。

6. 从每个Xi向Yi+m(i+m<=N)连一条容量为无穷大，费用为f的有向边。

7. 从每个Xi向Yi+n(i+n<=N)连一条容量为无穷大，费用为s的有向边。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int dis[4100],n,m,f,s,t,p,tot,ans,laste[4100];
int point[4100],next[2000003],remain[2000003],v[2000003],cost[2000003],can[4100];
const int inf=1e9;
void add(int x,int y,int z,int c)
{
  tot++; next[tot]=point[x]; point[x]=tot; v[tot]=y; remain[tot]=z; cost[tot]=c;
  tot++; next[tot]=point[y]; point[y]=tot; v[tot]=x; remain[tot]=0; cost[tot]=-c;
}
int adde(int s,int t)
{
  int minn=inf,now=t;
  while (now!=s)
   {
   	minn=min(minn,remain[laste[now]]);
   	now=v[laste[now]^1];
   }
  now=t;
  while (now!=s)
   {
   	 remain[laste[now]]-=minn;
   	 remain[laste[now]^1]+=minn;
   	 now=v[laste[now]^1];
   }
  return minn;
}
bool spfa(int s,int t)
{
  memset(dis,0x7f,sizeof(dis));
  memset(can,0,sizeof(can));
  can[s]=1; dis[s]=0;
  queue<int> p;
  p.push(s);
  while (!p.empty())
   {
   	int now=p.front(); p.pop(); can[now]=0;
   	for (int i=point[now];i!=-1;i=next[i])
   	 if (remain[i]&&dis[v[i]]>dis[now]+cost[i])
   	 {
   	 	dis[v[i]]=dis[now]+cost[i];
   	 	laste[v[i]]=i;
   	 	if (can[v[i]]==0)
   	 	 can[v[i]]=1,p.push(v[i]);
   	 }
   }
  if (dis[t]>inf)  return false;
  ans+=adde(s,t)*dis[t];
  return true;
}
void mincost(int s,int t)
{
  while (spfa(s,t));
}
int main()
{
  tot=-1; memset(next,-1,sizeof(next)); memset(point,-1,sizeof(point));
  scanf("%d%d%d%d%d%d",&t,&p,&n,&f,&m,&s);
  for (int i=1;i<=t;i++)
   {
   	 int x; 
	 scanf("%d",&x);
	 add(0,i,x,0); add(t+i,t*2+1,x,0); add(0,t+i,inf,p); 
	 if (i!=t)
	  add(i,i+1,inf,0);
	 if (i+n<=t)
	  add(i,t+i+n,inf,f);
	 if (i+m<=t)
	  add(i,t+i+m,inf,s);
   } 
  mincost(0,2*t+1);
  printf("%d",ans);
} 

第一次写最小费用最大流，感觉有点像EK,只不过是把单纯求增广路的部分，加上了spfa，保证每次选择的花费最小。