Codeforces Round #723 (Div. 2)Codeforces-1526ABCD

Posted 2023-02-16 JophieQu

A. Mean Inequality

void solves()
	int n;cin>>n;
	n*=2;
	for(int i=1;i<=n;++i) cin>>a[i];
	sort(a+1,a+1+n);
	int tot=0;
	for(int i=1;i<=n;i+=2)
		b[i]=a[++tot];
	
	for(int i=2;i<=n;i+=2)
		b[i]=a[++tot];
	
	for(int i=1;i<=n;++i) cout<<b[i]<<" ";cout<<endl;

B. I Hate 1111

void solves()
	ll x;cin>>x;
	if(x<=100)
		if(x%11==0)
			cout<<"YES\\n";return ;
		
		if(x<11)
			cout<<"NO\\n";return ;
		
	
	x*=9;
	int n=x%99,m=x/99/10;
	if(n<=9*m)cout<<"YES\\n";
	else cout<<"NO\\n";

C1. Potions (Easy Version)

C2. Potions (Hard Version)

带悔贪心，dp应该也能做

void solves()
	priority_queue<int> q;
	int n;cin>>n;
	ll sum=0,now=0,ans=0;
	for(int i=0;i<n;++i)
		cin>>now;
		sum+=now;
		if(now>=0) ++ans;
		else q.push(-now);
		while(q.size()&&sum<0)
			sum+=q.top();
			q.pop();
		
	
	cout<<ans+q.size()<<endl;

D. Kill Anton

前置知识：1.没有学过线性代数的同学需要百度一下逆序对/逆序数的定义 2.树状数组or归并排序求逆序数 3.全排列函数next_permutation的用法

我和张老师口胡出来的引理：给定无序排列通过交换相邻两个元素后变为升序排列(∀i>j，ai≥aj)，其最小交换次数为最初无序排列的逆序数。
引理的简单证明：显然，最小交换次数具体实现就是保证每一次交换都使得逆序数减小。而交换两个相邻且不同的元素只会使逆序数+1或-1。我们只需要做使逆序数不断-1的交换即可。

在探究一个无序排列1通过交换相邻元素变为另一个无序排列2的最小交换次数时，我们不妨重新给无序排列2进行人为的权重赋值，使其重新构成升序排列，再将无序排列2重新赋值后的权重一一对应回无序排列1。由此可以将问题抽象成引理的条件。
上面这段话说的可能有点抽象，我们用样例来举个栗子：
要从NNOTA变为ANTON，我们先人为给ANTON进行权重赋值
$ANTON$$⟸$ $NNOTA$
$1234525431$
显然【25431】的逆序数为7。
需要注意的是，由于我们需要求的是最小移动次数。所以在对NNOTA进行权重排列的时候，应该让相同的字母是按升序排序（为了让逆序数尽可能更小）（${}^{(1)}$）。所以NNOTA的权重排列应该是【25431】而不是【52431】。

结论：存在一个最佳答案，在该答案中相同类型的元素将连续出现。
该结论的证明思路和官方题解大致相同。其实证明思路不难，只是官方的证明写得抽象，这里我们会讲得相对具体一些。
我们设一段排列为：$XXAA...AA[A_i]XX...XX[A_j]AA...AAXX$ ，其中X是与A不同的元素。每一个元素都有一个权值$C_k$，但相同的元素的权值是升序的，这一点我们在（${}^{(1)}$） 中阐述过。我们分别设两个[A]的下标为i和j，即$C_i<C_j$${(}^{(2)})$
我们再记$D_1={\sum }_{k=i+1}^{j-1}sgn(C_k-C_i)，D2={\sum }_{k=i+1}^{j-1}sgn(C_j-C_k)$
显然$D_1+D_2\ge 0$。因为假设$D_1+D_2<0$，那么存在$k$使得$sgn(C_k-C_i)+sgn(C_j-C_k)<0$，即$C_j<C_i$，与${(}^{(2)})$矛盾。
我们由$D_1+D_2\ge 0$可推出$D_1\ge 0$或$D_2\ge 0$。不失一般性，我们假设$D_1\ge 0$。
当$D_1\ge 0$时，意味着$[A_i]$和$[A_j]$之间的（j-i-1）个元素中，与$[A_i]$构成逆序对的个数≥与$[A_j]$构成逆序对的个数，此时我们将$[A_j]$移动到i+1的位置上，只会使总的逆序数可能增大（$D_1=0$时逆序数不变，>0时逆序数增大），而不会使得总的逆序数减小。为了使得排列的逆序数更大且方便解题，我们尽可能地将相同的元素排列在一起。

当相同的元素排列在一起时，由于最多只有4个不同的元素，所以最多有4!=24种排列方式，可以直接枚举。我们通过枚举最多24种排列的逆序数来确定最大的那个解，复杂度应该可能是O(24*nlogn)

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ll long long
#define endl '\\n'
const int N=2e5+7Codeforces Round #723 (Div. 2)Codeforces-1526ABCD

 Codeforces Round #723 (Div. 2)Codeforces-1526ABCD
 Codeforces Round #723 (Div. 2)
 Codeforces Round #723 (Div. 2)， A. Mean Inequality
 Codeforces Round #723 (Div. 2)B. I Hate 1111
 Codeforces Round #723 (Div. 2)