标签：rttr int 题解 px py CF1051G 连续 操作

（Link，Div2，2900）

考场上看到这道题：哇！这个操作好神奇！哇！样例这个操作方案太妙了！卧槽？为什么总费用还能是负数？（花30min模拟样例）什么阴间操作，毫无规律可循，跑路跑路。……

笔者赛场上的思维能力仅限于此。言归正传，提升观察的高度，发现每个 \(a_i\) 操作前或操作后总有一个 \(a_j\) 与之相邻，于是往 \(a\) 值域上的连续段上去想。设初始的 \(a\) 序列为 \(p\)，下文的 \(a\) 均指若干次操作后得到的 \(a\)。跳出出题人挖的思维陷阱，从结果出发，先上两个很重要的 Lemma：

1.每加入一个 \(p_i\) 后经操作得到的满足要求（两两不同）的 \(a_1,\cdots,a_{i}\) 组成的集合是确定的，不确定性仅在于如何分配这个集合中的 \(i\) 个数到 \(1,\cdots,i\) 中去；

2.答案与操作过程无关而仅与最终的序列 \(a\) 有关，对于一种 \(a\) 我们的答案为 \(\sum_{j=1}^i (a_j-p_j)\times b_j=\sum_{j=1}^ia_jb_j-\sum_{j=1}^i p_jb_j\)。

第二个较为浅显，一次让 \(a_j\gets a_j+1\) 的操作花费为 \(b_j\)，让 \(a_j\gets a_j-1\) 的操作花费为 \(-b_j\)，所以对于这个 \(j\)，从 \(p_j\) 转移到 \(a_j\) 的费用便一定是 \((a_j-p_j)\times b_j\)。

对于第一个，数学归纳。\(i=1\) 时显然；若 \(a_1,\cdots,a_{i-1}(i>1)\) 组成的集合确定，设其为 \(S_{i-1}\)，将其排序后形成的连续段为 \([l_1,r_1],\cdots,[l_s,r_s](r_k<l_{k+1})\)，分情况讨论：

• \(\not\exists k,p_i\in[l_k-1,r_k+1]\)，那么任何 \(j<i\) 都不可能和 \(i\) 发生操作，\(a_i\) 动弹不得只能成为 \(p_i\)，集合仍然确定；

• 否则，方便起见设 \(l_0=r_0=-\infty,l_{s+1}=r_{s+1}=\infty\)，找到 \(\min\{k:l_k>p_i\}\)，则初始状态下 \(a_i=p_i\) 会就近加入一个连续段，可能的情况有：

  • Ⅰ.只加入 \([l_k,r_k]\)，当且仅当 \(r_{k-1}+1<p_i=l_k-1\)；
  • Ⅱ.只加入 \([l_{k-1},r_{k-1}]\)，当且仅当 \(p_i\le r_{k-1}+1\)；
  • Ⅲ.同时加入 \([l_{k-1},r_{k-1}]\) 和 \([l_k,r_k]\)（即把它们合并起来），当且仅当 \(r_{k-1}+1=p_i=l_k-1\)。

  无论如何初始时 \(a_i=p_i\) 总会加入一个连续段。接下来 \(a_i\) 会和这个连续段内的数进行各种乱七八糟的操作，其中我们发现一种可以维持集合满足要求的操作方案：

  • 在 \(\exists x\in S_{i-1},x=a_i\) 时，让 \(a_i\) 与之进行操作，得到 \(a_i\gets a_{i+1}\)。

  这个操作方案会得到什么结果呢？

  • Ⅰ.（只加入 \([l_k,r_k]\)）\(a_i\) 不动，得到 \(a_i=l_k-1\)；
  • Ⅱ.（只加入 \([l_{k-1},r_{k-1}]\)） \(a_i\gets r_{k-1}+1\)；
  • Ⅲ.（合并两个连续段）\(a_i\) 仍然不动，\(a_i=l_k-1\)。

  综合以上三种情况的结果找出共性：

  • 通过该操作我们得到一个插入 \(a_i\) 后的数字互不相同的新连续段，该连续段与 \(S_{i-1}\) 包含着的 除了被 \(a_i\) 加入/合并的段 的其它连续段不接。

  在 \(S_{i-1}\) 的基础上删掉被 \(a_i\) 加入/合并的连续段后插入这个新连续段就得到了一种 \(S_i\)。为什么它是唯一确定的呢？

  因为任何一个操作都只能和同连续段的数字进行，进一步地，对一个数 \(x\) 进行一次操作不会使其脱离所在连续段，顶多就是让它挂在连续段两边而已（\(l-1\) 或 \(r+1\)）。特别地，对于一个数字互不相同的连续段，无论怎么操作 \(x\) 其值都会严格保持在连续段左右端点 \([l,r]\) 间。①（这个结论可以手动模拟，是比较易懂的）

  另外的一个点是，题设两个操作互为逆运算，也即，既然在加入 \(p_i\) 后 \(a_i=p_i\) 的状态可以导向如上操作方案得出的结果，那么这个结果也可以导回去。由 ① 对 按如上方案操作 \(a_i\) 后得到的新连续段 任意操作不会使这个连续段的值域发生改变，所以在初始 \(a_i=p_i\) 的状态下进行任何操作也都一定会导向这一个值域上的新连续段。

  值域确定下来后内部数字互不相同的连续段只有一个，所以这个新连续段是板上钉钉一定要加到 \(S_i\) 里面的，同时这个连续段把被 \(a_i\) 加入/合并的连续段（们）全部覆盖了，于是它（们）也一定会被删除。我们在定集合 \(S_{i-1}\) 的基础上改变的只有被 \(a_i\) 加入/合并的连续段以及插入后的新连续段，所以 \(S_i\) 被唯一确定。于是证完了。

以上所有讨论都是在忽略费用的情况下进行的，却能够使接下来的分析轻松许多。我们加进 \(b_i\) 的限制看看会发生什么。

上面我们分析了“可行性”，现在我们来谈“最优性”。我们已经把讨论范围缩减到了一个一个一个一个的连续段，连续段们的操作相互独立；由 Lemma2 我们完全不用管操作过程而只注重结果（@JustKevinXie(现名Destroyer_Garing)）；由 Lemma1 无论怎么操作得到的最终 \(a_{1,\cdots,i}\) 集合确定。这启发我们对每一个连续段进行乱搞（我们也只能对每个连续段分别乱搞），把它翻个底朝天都没问题，只需要达到最优费用即可。重新看向 Lemma2 的式子：

\[\sum_{j=1}^i a_jb_j-\sum_{j=1}^ip_jb_j \]

后面那项确定，我们只需最小化 \(\sum_{j=1}^i a_jb_j\)。对于每一个连续段我们可以随便镐镐鑐鑐，准确来说就是我们可以任意改变一个连续段中 \(a_i\) 的排列，即若一个连续段（其中数两两不同）是 \(a_{q_1},a_{q_2},\cdots,a_{q_s}\) 经操作得出的结果的集合，那么这个连续段中的数可以任意分配给 \(a_{q_1},\cdots,a_{q_s}\)。问题来了，如何分配才能使得 \(\sum a_jb_j\) 最小呢？

这是个经典问题，我们会发现重排后最小的 \(b_j\) 对应最大的 \(a_j\)、次小的 \(b_j\) 对应次大的 \(a_j\)、…… 、最大的 \(b_j\) 对应最小的 \(a_j\) 一定是最优方案。证明也很简单，随便交换两个 \(a_j\) 都只会使答案变劣。

于是这道题做完了。我们要做的便是维护每个连续段（可以用 std::set 或者各种奇怪的东西），对每个连续段分别开一个平衡树/动态开点线段树维护单调的 \(b_j\)，加入 \(p_i\) 时直接按照我们证明 Lemma1 时给出的操作方案不断让 \(a_i\gets a_i+1\) 然后分三种情况讨论、加上贡献即可，合并连续段时用启发式合并。总复杂度 \(O(n\log^2 n)\)。

参考实现：

#include <cstdio>
#include <random>
#include <vector>
#include <set>
#define ll long long

using namespace std;

namespace fIO{
    bool f;char c;void re(int &x){
        x=0;f=0;c=getchar();
        while(c<'0'||c>'9') f|=c=='-',c=getchar();
        while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
        if(f) x=-x;
    }
    void re(char &c){
        c=getchar();while(c==' '||c=='\n'||c=='\r') c=getchar();
    }
    template<class tp,class ...Tp>void re(tp &x,Tp &...y){re(x);re(y...);}
    char st[20];int tp;
    void wr(int n){
        if(!n) return putchar('0'),void();
        if(n<0) putchar('-'),n=-n;
        while(n) st[++tp]=n%10+48,n/=10;
        while(tp) putchar(st[tp--]);
    }
    inline void wr(char c){putchar(c);}
    template<class tp,class ...Tp>void wr(tp x,Tp ...y){wr(x);wr(y...);}
}using fIO::re;using fIO::wr;

mt19937 rnd;

const int N=4e5+5.14114;

int memo[N],tp;

struct info{
	int c;ll s;
	info operator+(const info &x)const{
		return (info){c+x.c,s+x.s};
	}
};

vector<int> vals;

namespace BLT{
	struct node{
		int v,ls,rs;unsigned int pr;info s;
		#define v(x) t[x].v
		#define ls(x) t[x].ls
		#define rs(x) t[x].rs
		#define pr(x) t[x].pr
		#define s(x) t[x].s
	}t[N];
	void updata(int x){s(x)=s(ls(x))+s(rs(x))+(info){1,v(x)};};
	void div(int now,int &x,int &y,int k){
		if(!now) return x=y=0,void();
		if(v(now)<=k) x=now,div(rs(now),rs(now),y,k);
		else y=now,div(ls(now),x,ls(now),k);
		updata(now);
	}
	int merge(int x,int y){
		if(!x||!y) return x|y;
		if(pr(x)<pr(y)){
			rs(x)=merge(rs(x),y);
			updata(x);return x;
		}else{
			ls(y)=merge(x,ls(y));
			updata(y);return y;
		}
	}
	int newnod(int k){
		int nwn=memo[tp--];t[nwn]=(node){k,0,0,rnd(),(info){1,k}};return nwn;
	}
	void ins(int &rt,int k){
		int x,y;div(rt,x,y,k);
		rt=merge(merge(x,newnod(k)),y);
	}
	info qryles(int &rt,int k){
		int x,y;div(rt,x,y,k-1);info res=s(x);
		rt=merge(x,y);return res;
	}
	info qrygrt(int &rt,int k){
		int x,y;div(rt,x,y,k);info res=s(y);
		rt=merge(x,y);return res;
	}
	void breakdown(int now){
		if(!now) return ;
		breakdown(rs(now));
		vals.push_back(v(now));
		breakdown(ls(now));
		memo[++tp]=now;
	}
}using namespace BLT;

struct itv{
	int l,r,rttr;
	bool operator<(const itv &x)const{
		return l<x.l;
	}
};

set<itv> sa;

ll saftz;

enum position{lft,rht};

set<itv>::iterator addtoitv(set<itv>::iterator p,int b,position po){
	int l=p->l,r=p->r,rttr=p->rttr;
	if(po==lft){
		--l;info x=BLT::qrygrt(rttr,b);
		saftz-=x.s-1ll*(l+x.c)*b;
	}else{
		++r;info x=BLT::qryles(rttr,b);
		saftz+=x.s+1ll*(r-x.c)*b;
	}
	BLT::ins(rttr,b);sa.erase(p);
	return sa.insert((itv){l,r,rttr}).first;
}

int main()
{
	while(tp<N) memo[tp]=N-tp,++tp;--tp;
	int n;re(n);ll sorgn=0;
	for(int i=1;i<=n;++i){
		int a,b,flg=0;re(a,b);sorgn+=1ll*a*b;
		auto py=sa.upper_bound((itv){a});
		auto px=py;if(px!=sa.begin()) --px;
		if(py!=sa.begin()&&px->r+1>=a) flg=1,a=px->r+1,px=addtoitv(px,b,rht);
		if(py!=sa.end()&&a==py->l-1){
			if(py!=sa.begin()&&a==px->r){
				vals.clear();
				int szx=px->r-px->l+1,szy=py->r-py->l+1,rttr;
				if(szx<szy){
					BLT::breakdown(px->rttr);
					int pl=px->l;sa.erase(px);
					for(int i=vals.size()-1;~i;--i) saftz-=1ll*vals[i]*(pl+i),
													py=addtoitv(py,vals[i],lft);
				}else{
					BLT::breakdown(py->rttr);
					int pl=py->l;sa.erase(py);
					for(int i=0;i<vals.size();++i) saftz-=1ll*vals[i]*(pl+i),
													px=addtoitv(px,vals[i],rht);
				}
			}
			else addtoitv(py,b,lft);
			flg=1;
		}
		if(!flg) sa.insert((itv){a,a,BLT::newnod(b)}),saftz+=1ll*a*b;
		printf("%lld\n",saftz-sorgn);
	}
}

所以说碰到这种题还是要提升观察高度、多从结果出发找共性，单单盯着样例看有时是不一定有结果的。

本题思维难度大码量也比较大（个人观点），反正我是不算快读写了130多行。很不理解同机房dalao是如何不压行的情况下写进60行以内的。

标签：rttr,int,题解,px,py,CF1051G,连续,操作
来源： https://www.cnblogs.com/vanspace/p/16547454.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。