CF Round #744 div3 Solution

Promblemset前缀1579

A.Casimir’s String Solitaire

显然A和C的数量加起来等于B的数量时成立。

B.Shifting Sort

不需要minimize，只需要在n步内完成，容易想到每加入一个新的数字时就把前面sort好，也就是暴力往前找到前$i-1$个数字中小于$a[i]$的第一个数，然后将这一部分移动一下即可。

C.Ticks

$n$和$m$都超级小，直接暴力枚举每一个点然后往左上和右上冲即可。

D.Productive Meeting

容易猜到每一步直接让剩余谈话次数最多的和最少的交谈是最优的。

用个set即可

E1.Permutation Minimization by Deque

。。。直接跟队首比较如果比他小就往前面插就行了

E2.Array Optimization by Deque

容易发现，“每一步插在前面或者后面”对后续操作贡献的答案是没有影响的，所以只需要考虑这一步插在前面或者后面即可，树状数组解决。

F.Array Stabilization (AND version)

容易观察到规律，一个序列由许多组闭环组成，对于每一个闭环，显然产生的答案就是$max(连续的1)$。
于是遍历到某个数时，只需要暴力往前把闭环找出来并顺便统计这个闭环的答案即可（顺便给环上的数打上标记，这样序列中每个数最多被标记一次）。
最后每个闭环的答案的max值即是最终答案，注意特判闭环上全是1的情况。

G.Minimal Coverage

观察发现，对于第$i$步操作，比较"你走到了3并且此时已经触碰的区间为[0,5]"和"你走到了1并且此时已经触碰的区间为[-2,3]"两者，你会发现其实对后续影响是相同的，也就是两者其实是等价的。

这提示了我们，我们关注的其实只有
1.走到哪(pos)
2.左右边界

但显然直接维护这些信息是不现实的，复杂度炸飞了。

于是可以想到使用差值DP，设R为右边界到pos的距离，L为左边界到pos的距离，则我们可以维护R-L这一个信息就能得到左右边界。

但此时我们还是需要维护pos和R-L这两个信息，还是会炸。

但实际上通过我们上面的第一段话，我们能够知道其实在同一步结束后，我们并不关心到底pos在哪，只需要知道在R-L的限制下的最短区间长度即可。

这部分的转移还算蛮简单的。

由于左右是差不多的，我们这里就列出向右放线段的转移。

$f[i]$表示$R-L$为$i$时的最短区间长度

$g$数组是每一步的临时数组

当$R>=a[i]$时，显然区间长度不会变

因此$g[j-2\ast a[i]]=min(g[j-2\ast a[i]],f[j])$

当$R<a[i]$时，区间长度变化

$g[j-2\ast R-(a[i]-R)]=min(g[j-2\ast R-(a[i]-R)],f[j]+(a[i]-R))$

怎么知道L和R的值？

$f[i]$不就是$L+R$嘛

所以$L\ast 2=F[i]-i$

$R\ast 2=F[i]+i$

但是$f$数组开多大呢（换句话说，复杂度多少）

容易发现显然不可能冲出$ma{x}_{a_i}$
因此开$2\ast 2000$即可（因为有负数域）

具体看代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<iomanip>
#include<algorithm>
using namespace std;
const int len=2000;
inline int read()
{
	int x=0,f=1;char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=x*10+(c-'0');
		c=getchar();
	}
	return x*f;
}
int t;
int a[10050];
int f[4050],g[4050];
int main()
{
	t=read();
	while(t--)
	{
		int n=read();
		for(int i=1;i<=n;i++) cin>>a[i];
		memset(f,63,sizeof(f));
		f[len+a[1]]=f[len-a[1]]=a[1];
		for(int i=2;i<=n;i++)
		{
			memset(g,63,sizeof(g));
			for(int j=0;j<=2*len;j++)
			{
				if(f[j]<=1e7)
				{
					int k=j-len;
					int L=(f[j]-k)/2,R=(f[j]+k)/2;
					if(R>=a[i]&&(j-2*a[i])>=0) g[j-2*a[i]]=min(g[j-2*a[i]],f[j]);
					if(L>=a[i]&&(j+2*a[i]<=2*len)) g[j+2*a[i]]=min(g[j+2*a[i]],f[j]);
					if(R<a[i]&&(j-2*R-(a[i]-R))>=0) g[j-2*R-(a[i]-R)]=min(g[j-2*R-(a[i]-R)],f[j]+(a[i]-R));
					if(L<a[i]&&(j+2*L+(a[i]-L)<=2*len)) g[j+2*L+(a[i]-L)]=min(g[j+2*L+(a[i]-L)],f[j]+(a[i]-L));
				}
			}
			for(int j=0;j<=2*len;j++) f[j]=g[j];
		}
		int minn=1e9;
		for(int i=0;i<=2*len;i++) minn=min(minn,f[i]);
		cout<<minn<<endl; 
	}
}