【BZOJ4842】[Neerc2016]Delight for a Cat 线性规划+费用流

【BZOJ4842】[Neerc2016]Delight for a Cat

Description

ls是一个特别堕落的小朋友，对于n个连续的小时，他将要么睡觉要么打隔膜，一个小时内他不能既睡觉也打隔膜，因此一个小时内他只能选择睡觉或者打隔膜，当然他也必须选择睡觉或打隔膜，对于每一个小时，他选择睡觉或打隔膜的愉悦值是不同的，对于第i个小时，睡觉的愉悦值为si，打隔膜的愉悦值为ei，同时又有一个奥妙重重的规定：对于任意一段连续的k小时，ls必须至少有t1时间在睡觉，t2时间在打隔膜。那么ls想让他获得的愉悦值尽量大，他该如何选择呢？

Input

第一行四个整数,n,k(1<=k<=n<=1000),t1,t2(0<=t1,t2<=k;t1+t2<=k),含义如上所述。

接下来一行n个整数，第i个整数si(0<=si<=1e9)表示睡觉的愉悦值。

接下来一行n个整数，第i个整数ei(0<=ei<=1e9)表示打隔膜的愉悦值。

Output

第一行输出最大的愉悦值。

接下来一行输出一个长度为n的字符串

第i个字符为E则代表第i小时在打隔膜，第i个字符为S则代表第i个小时在睡觉。

Sample Input

10 4 1 2
1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1

Sample Output

69
EEESESEESS

题解：我们先令所有时间都打隔膜，于是在i时刻睡觉的收益就变成了si-ei。我们令第i时刻是否睡觉的状态为xi（xi=0或1），那么限制条件就变成了如下不等式：$t_1 \le x_i+x_{i+1}+...+x_{i+k-1} \le k-t_2$。我们想要最大化$\sum x_i*(s_i-e_i)$，这显然就变成了一个线性规划问题。如何处理线性规划问题？列单纯形表。

然而今天还是去学了用费用流解线性规划的方法。我们先将不等式转化成标准型，即加入新变量y,z（$y,z \in [0,+ \infty ]$）使不等式变成等式：$t_1+y_i=x_i+x_{i+1}+...+x_{i+k-1}=k-t_2-z_i$，接着列出方程组：

$\begin{cases}x_1+x_2+...+x_k=t_1+y_1\\ x_1+x_2+...+x_k=k-t_2-z_1\\ x_2+x_3+...+x_{k+1}=t_1+y_2\\ x_2+x_3+...+x_{k+1}=k-t_2-z_2\\ ...\end{cases}$

根据一个惯用的套路，我们在最下面加入不等式0=0，然后差分，并整理一下：

$\begin{cases}x_1+x_2+...+x_k=t_1+y_1\\ y_1+z_1=(k-t_1-t_2)\\ x_{k+1}+(k-t_1-t_2)=x_2+z_1+y_2\\ y_2+z_2=(k-t_1-t_2)\\ ...\\k-t_2=x_{n-k+1}+x_{n-k+2}+...+x_k+z_{n-k+1}\end{cases}$

我们发现每个变量在等式的左侧和右侧都各出现一次，我们将等式看成点，等式左边看成流出，等式右面看成流入。对于变量x，我们从它流出的点向流入的点连一条边，容量为1费用为si-ei；对于变量y,z，它的容量为$\infty$，费用为0；对于常数项，如果是流出则从该点连向T，流入则从S连向该点，容量为常数项的大小。接着跑最大费用最大流，输出方案时看一下对应的边的容量即可。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef long long ll;
ll ans,tot;
int n,k,t1,t2,cnt,S,T;
int inq[2010],to[100010],next[100010],flow[100010],pe[2010],pv[2010],head[2010],pos[2010],A[2010],B[2010];
ll cost[100010],dis[2010];
queue<int> q;
inline int rd()
{
	int ret=0,f=1;	char gc=getchar();
	while(gc<'0'||gc>'9')	{if(gc=='-')f=-f;	gc=getchar();}
	while(gc>='0'&&gc<='9')	ret=ret*10+gc-'0',gc=getchar();
	return ret*f;
}
inline void add(int a,int b,int c,int d)
{
	if(!d)	return ;
	to[cnt]=b,cost[cnt]=c,flow[cnt]=d,next[cnt]=head[a],head[a]=cnt++;
	to[cnt]=a,cost[cnt]=-c,flow[cnt]=0,next[cnt]=head[b],head[b]=cnt++;
}
inline int bfs()
{
	memset(dis,0x80,sizeof(dis));
	q.push(S),dis[S]=0;
	int u,i;
	while(!q.empty())
	{
		u=q.front(),q.pop(),inq[u]=0;
		for(i=head[u];i!=-1;i=next[i])
		{
			if(dis[to[i]]<dis[u]+cost[i]&&flow[i])
			{
				dis[to[i]]=dis[u]+cost[i],pv[to[i]]=u,pe[to[i]]=i;
				if(!inq[to[i]])	inq[to[i]]=1,q.push(to[i]);
			}
		}
	}
	return dis[T]>ll(0x8080808080808080ll);
}
int main()
{
	n=rd(),k=rd(),t1=rd(),t2=rd();
	S=0,T=((n-k+1)<<1)+2;
	memset(head,-1,sizeof(head));
	int i;
	for(i=1;i<=n;i++)	A[i]=rd();
	for(i=1;i<=n;i++)	B[i]=rd(),tot+=B[i];
	for(i=1;i<=n;i++)	pos[i]=cnt+1,add(max(1,((i-k)<<1)+1),min((i<<1)+1,((n-k+1)<<1)+1),A[i]-B[i],1);
	add(S,1,0,t1);
	for(i=1;i<=n-k+1;i++)
	{
		add(i<<1,(i<<1)-1,0,1<<30),add(i<<1,(i<<1)+1,0,1<<30);
		add(S,i<<1,0,k-t1-t2);
		if(i!=n-k+1)	add((i<<1)+1,T,0,k-t1-t2);
	}
	add(((n-k+1)<<1)+1,T,0,k-t2);
	while(bfs())
	{
		int mf=1<<30;
		for(i=T;i!=S;i=pv[i])	mf=min(mf,flow[pe[i]]);
		ans+=dis[T]*mf;
		for(i=T;i!=S;i=pv[i])	flow[pe[i]]-=mf,flow[pe[i]^1]+=mf;
	}
	printf("%lld\n",tot+ans);
	for(i=1;i<=n;i++)
	{
		if(flow[pos[i]])	printf("S");
		else	printf("E");
	}
	return 0;
}
//2 2 0 0 1 2 2 1

转载于:https://www.cnblogs.com/CQzhangyu/p/7894559.html