Codeforces Round 922 (Div. 2)

A. Brick Wall

题目链接

题意

给定一个n x m的矩阵，每个单元格都可以横放或竖放一个1 x k的砖块，k至少为2，且每块砖的k不一定相同，必须用砖块将矩阵填满。现定义稳定值为水平放置砖块与垂直放置砖块的个数之差，求最小的稳定值是多少。

分析

要使稳定值最小，即水平放置砖块与垂直放置砖块个数之差最小，那我们应该尽可能多的水平放置砖块，由于k的值可变且最少为2，那么其实我们可以选择全部水平放置砖块，这样也一定可以将矩阵填满，那么答案就是每行最多可以水平放置的砖块数 x 行数

为使得每行水平放置砖块最多，我们应该尽可能多的选择k=2的砖块，当剩下的列不足够2时，我们选择k=3的砖块，可以发现列数除以2即为每行最多可以水平放置的砖块

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
//#include<queue>
//#include<map>
//#include<vector>
//#include<set>
//#include<deque>
//#include<bitset>
//#include<functional>

#define ll long long
#define inf 0x3f3f3f3f
using namespace std;

typedef pair<int,int>PII;

	
	
int main()
{
	int t;cin>>t;
	while(t--)
	{
		int n,m;
		cin>>n>>m;
		cout<<n*(m/2)<<endl;
	}
	return 0;
}

B. Minimize Inversions

题目链接

题意

给定包含n个元素的数组a和b，可以交换无限次，每次交换必须将a和b相同位置上的元素一起交换，比如选择i，j，那么ai和aj交换，bi和bj交换，输出交换过后的a和b，使得两个数组之中的逆序对数量之和最少

分析

关于操作次数无限时，一定要想到排序，因为可以交换无限次，那么我们一定可以将a交换成升序状态，此时a中逆序对数量为0，可以发现如果我们在这个基础上再进行交换，那么b中逆序对数量最多减少1，而a中逆序对数量一定会至少增加1，那么我们将a变成升序状态之后，再进行操作，一定会产生负贡献或不产生贡献，由此可见将a变成升序后已经是最优状态了。那么我们输出将a升序之后已经b交换相应位置后的数组即可

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
//#include<queue>
//#include<map>
//#include<vector>
//#include<set>
//#include<deque>
//#include<bitset>
//#include<functional>

#define ll long long
#define inf 0x3f3f3f3f
using namespace std;

typedef pair<int,int>PII;
const int N=2e5+10;
PII a[N];
int b[N];

	
int main()
{
	int t;cin>>t;
	while(t--)
	{
		int n;cin>>n;
		for(int i=1;i<=n;i++)
		{
			cin>>a[i].first;
			a[i].second=i;
		}
		for(int i=1;i<=n;i++) cin>>b[i];
		sort(a+1,a+1+n);
		for(int i=1;i<=n;i++) cout<<a[i].first<<" ";
		cout<<endl;
		for(int i=1;i<=n;i++) cout<<b[a[i].second]<<" ";
		cout<<endl;
	}
	
	
	return 0;
}

C. XOR-distance

题目链接

题意

给定整数 a ， b ， r 。在所有 0≤x≤r 中找出 |(a⊕x)−(b⊕x)| 的最小值。

⊕ 是按位XOR的运算， |y| 是 y 的绝对值

分析

要使得a异或x与b异或x最接近，我们先从每一位考虑

1.当a和b的某一位相同时，即都为1或都为0，那么对于x的这一位不论是1还是0，其与a，b异或之后再相减所产生的贡献一定为0，所以对于a，b某一位上的数相同时，不会产生贡献，我们直接跳过

2.当a和b的某一位不同时，

如 a=101

     b=001

此时若x第3位为0，第3位产生的结果为100-0=100；

此时若x第三位为1，第3位产生的结果为0-100=-100；

可以发现，如果a和b某一位不同时，我们选择x对应位上的数如果与a该位数相同则会产生负数，如果与a该位数相同，则会产生正数

3.为使a异或x减b异或x的绝对值最小，那么我们应该选择从第一个不相同的高位开始，对于后面不同的位，我们选择将其变成符号与第一个不相同位产生的贡献相反的符号，不断减少第一个不相同位产生的贡献，使得最后的绝对值更小，可以证明，就算后面的数全部与第一个不相同位的符号相反，结果也一定是大于0的，因为高位的数至少是低位数的二倍

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
//#include<queue>
//#include<map>
//#include<vector>
//#include<set>
//#include<deque>
//#include<bitset>
//#include<functional>

#define ll long long
#define inf 0x3f3f3f3f
using namespace std;

typedef pair<int,int>PII;

void solve()
{
	ll a,b,r;
	ll sum=0;
	cin>>a>>b>>r;
	bool is_high=true;//ab两者第一次出现不同位的标记
	for(int i=60;i>=0;i--)
	{
		bool x=(1ll<<i) & a;//a b第x位的值
		bool y=(1ll<<i) & b;
		if(x==y) continue;//如果相同则不需要处理
		if(is_high) 
		{
			sum=(1ll<<i) *(x-y);//将第一个不同位的贡献直接加入答案
		    is_high=false;
		}
		else//已经不是第一次出现位不同
		{
			if(r>=(1ll<<i) && (x-y)*sum>0)//r足够并且当前位产生的贡献与sum同号
			{
				//同号需要将x这一位填1取反
				r-=(1ll<<i);//r减去x这位变1的消耗
				sum-=(x-y) * (1ll<<i);
			}
			else//r不够或者当前位与sum异号
			{
				//直接加，x这一位填0即可
				sum+=(x-y)*(1ll<<i);
			}
			
		}  
	}
	
	if(sum>0) cout<<sum<<endl;
	else cout<<-sum<<endl;
	return;
}
	
	
int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	int t;cin>>t;
	while(t--) solve();
	
	return 0;
}

D. Blocking Elements

题目链接

题意

给定包含n个元素的数组a，你可以阻塞一些元素，那么数组的成本为以下两部分的最大值

1.阻塞元素的总和

2.删除阻塞元素和，所形成的各区间元素之和的最大值

输出阻塞元素之后的最小成本

分析

求最小值应最先想到二分答案，但是试过几个样例后发现单纯的贪心二分是不可行的，故又考虑dp，设dp[i]表示阻塞第i个元素后，前i个元素的最小成本,可以发现dp[i]由i之前最小的dp[]值加a[i]转移过来，所以可以使用单调队列维护，每次留下最优的值，并且转移

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
//#include<queue>
//#include<map>
//#include<vector>
//#include<set>
#include<deque>
//#include<bitset>
//#include<functional>

#define ll long long
#define inf 0x3f3f3f3f
using namespace std;

typedef pair<int,int>PII;
const int N=1e5+10;
ll s[N],a[N];
ll n;

bool check(ll x)
{
	deque<int>q;
	vector<ll>dp(n+1);
	dp[0]=0;
	q.push_back(0);
	for(int i=1;i<=n;i++)
	{
		while(!q.empty() && s[i-1]-s[q.front()] > x) q.pop_front();//将不符合的头元素全部弹出
		dp[i]=dp[q.front()]+a[i];
		if(dp[i]<=x && s[n]-s[i]<=x) return true;//当前dp值符合且其之后的元素和也符合直接返回true
		while(!q.empty() && dp[q.back()]>=dp[i]) q.pop_back();//将末尾更不符合的元素全部弹出，留下更优的
		q.push_back(i);
	}
	return false;
	
}

void solve()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
		s[i]=s[i-1]+a[i];
	}
	
	ll l=1,r=1e15;
	while(l+1<r)
	{
		ll mid=l+r>>1;
		if(check(mid)) r=mid;
		else l=mid;
	}
	if(check(l)) cout<<l<<endl;
	else cout<<r<<endl;
	
}
	
	
int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	int t;cin>>t;
	while(t--) solve();
	
	
	return 0;
}