王子 [费用流]

题意

给定$n,k,p,q$，现在要给一段长度为n的格子染黑白，第$i$个格子染成黑色得到$a_i$分，白色$b_i$分

要求连续的$k$个格子中要有至少$p$个黑的，$q$和白的

求最大得分

思路

一眼是没想法的......瞄了一眼题解看到“网络流”三个大字，就会了

还是要多想一些方法，多试试，因为这种题看着不是dp就是什么鬼畜的转化，那转化模型肯定先看是不是网络流

考虑序列模型的经典网络流转化方法

本题中的核心限制是对于每一段$k$区间的颜色数限制

可以看到实际上这个$p,q$就是限制黑色格子的数量是$[p,k-q]$

同时这个限制对于每一个格子而言，这个格子参与$k$个区间的限制

我们考虑这样一个方法：

首先把所有的都涂成白色，然后用跨越一个$k$区间的一点流量来代表变成一个黑格子带来的影响，其他的从$i$到$i+1$的代表一个白格子

那么这样我们把白格子边设成流量上限为$k-q-p$上限，费用为0，代表额外的白变黑的数量上限

黑格子边显然容量为1，费用为对应的格子的$b_i-a_i$

一些细节注意：

首先这个跨越的黑格子边，从$i$出发，终点在$k+i$不是在$k+i-1$

然后注意最开始的$k$个点，没有前驱去到达它们，那么建立一个辅助节点$aux$，从$s->aux$连一条容量为$k-q$的（限制一下），再从$aux$连向$1$到$k$号点

实现上可以把费用流的$ans$初值设为所有白格子分数的和，然后用上面定义的费用直接算就可以了

费用流推荐使用spfa魔改版zkw多路增广，不过本题中单路多路其实差距不大，$EK$还可能更快（因为图的形态问题）

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cassert>
#include<queue>
#define ll long long
using namespace std;
inline ll read(){
	ll re=0,flag=1;char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-') flag=-1;
		ch=getchar();
	}
	while(isdigit(ch)) re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
	return re*flag;
}
ll n,m,l,r,cnte=1,first[1010],dis[1010],vis[1010],ans=0,maxf=0;
struct edge{
	ll to,next,w,cap;
}a[20010];
inline void add(ll u,ll v,ll w,ll cap){
	a[++cnte]=(edge){v,first[u],w,cap};first[u]=cnte;
	a[++cnte]=(edge){u,first[v],-w,0,};first[v]=cnte;
}
queue<ll>q;
bool spfa(ll s,ll t){
	ll i,u,v;
	for(i=s;i<=t+1;i++) dis[i]=-111111111111111ll,vis[i]=0;
	vis[t]=1;dis[t]=0;q.push(t);
	while(!q.empty()){
		u=q.front();q.pop();vis[u]=0;
		for(i=first[u];~i;i=a[i].next){
			v=a[i].to;
			if(!a[i^1].cap) continue;
			if(dis[v]!=-111111111111111ll&&(dis[v]>=dis[u]+a[i^1].w)) continue;
			dis[v]=dis[u]+a[i^1].w;
			if(!vis[v]){
				vis[v]=1;
				q.push(v);
			}
		}
	}
	return dis[s]!=-111111111111111ll;
}
ll dfs(ll u,ll t,ll lim){
	if(u==t||!lim) return lim;
	ll i,v,f,flow=0;vis[u]=1;
	for(i=first[u];~i;i=a[i].next){
		v=a[i].to;if(vis[v]) continue;
		if(dis[v]==dis[u]-a[i].w&&(f=dfs(v,t,min(lim,a[i].cap)))){
			a[i].cap-=f;
			a[i^1].cap+=f;
			flow+=f;
			lim-=f;
			ans+=f*a[i].w;
			if(!lim){vis[u]=0;return flow;}
		}
	}
	dis[u]=-111111111111111ll;
	return flow;
}
void mcmf(ll s,ll t){
	while(spfa(s,t)){
		memset(vis,0,sizeof(vis));
		vis[t]=1;
		while(vis[t]){
			memset(vis,0,sizeof(vis));
			maxf+=dfs(s,t,1e9);
		}
	}
}
ll x[1010],y[1010];
int main(){
	memset(first,-1,sizeof(first));
	n=read();m=read();l=read();r=m-read();ll i;
	for(i=1;i<=n;i++) x[i]=read(),y[i]=read(),ans+=y[i];
	add(0,n+2,0,r);
	for(i=1;i<=m;i++) add(n+2,i,0,1);
	for(i=1;i<=n;i++){
		add(i,i+1,0,r-l);
		add(i,((i<=n-m)?i+m:n+1),x[i]-y[i],1);
	}
	mcmf(0,n+1);
	cout<<ans<<'
';
}