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

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+7;
const ll mod=998244353;
using namespace std;
string s;
ll cc[N],b[N];
int ff[]={0,1,2,3};
map<char,int>mp;
ll cnt=0;
void unite(int l,int mid,int r){
	if(l>=r)return ;
    unite(l,(l+mid)>>1,mid);
    unite(mid+1,(mid+1+r)>>1,r);
    int i=l,j=mid+1;
    for(ll k=l;k<=r;++k){
        if(j>r||i<=mid&&cc[i]<=cc[j]) b[k]=cc[i++];
        else b[k]=cc[j++],cnt+=mid-i+1;
    }
    for(ll k=l;k<=r;++k) cc[k]=b[k]; 
}
ll cal(int *qq){
	int len=s.size();
	for(int i=0;i<len;++i){
		for(int j=0;j<4;++j){
			if(mp[s[i]]==qq[j]){
				cc[i]=j;
				break;
			}
		}
	}
	cnt=0;
	unite(0,(len-1)>>1,len-1);
	return cnt;
}
void solves(){
	cin>>s;
	string ans=s,a,n,t,o;
	ll sum=0;
	for(auto x:s){
		if(x=='A')a+='A';
		if(x=='N')n+='N';
		if(x=='T')t+='T';
		if(x=='O')o+='O';
	}
	do{
		ll re=cal(ff);
		if(re>sum){
			sum=re;
			ans.clear();
			for(int i=0;i<4;++i){
				if(ff[i]==0) ans+=a;
				if(ff[i]==1) ans+=n;
				if(ff[i]==2) ans+=t;
				if(ff[i]==3) ans+=o;
			}
		}
	} while(next_permutation(ff,ff+4));
	cout<<ans<<endl;
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	int OwO=1;
	cin>>OwO;
	mp['A']=0;
	mp['N']=1;
	mp['T']=2;
	mp['O']=3;
	while(OwO--){
		solves();
	}
}

昨天下午开始写到今天下午，从头证到尾的感觉真的爽炸了，呜呜。
致谢：诚挚感谢ginwAa的翻译，诚挚感谢张老师对本题证明过程中一些缺漏的指正。