【Codeforces div3-498】题解

Codeforces div3-498题解

A. Adjacent Replacements

对于这道题目就比较简单了,如果该数N为奇数，那么经过变换之后不变，如果该数为偶数则变为N - 1

#include <stdio.h>

const int maxn=1005;
int a[maxn];
int n;
 
void work()
{
    scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		if(a[i]%2)
		{
			printf("%d ",a[i]);
		}
		else
			printf("%d ",a[i]-1);
	}
}
 
int main()
{
	work();
	return 0;
}

B. Polycarp’s Practice

首先根据题意我们可以确定的是，所挑选出来的数一定为输入的数中的最大的K个数，则我们所需要做的就是找出来这K个最大的数，并且记录下其位置，根据其位置来进行划分。自己这里使用的方法比较麻烦，另外使用了一个容器来存储位置，其实只要一个pair类型就可以解决的.

#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
using namespace std;

const int maxn = 2003;

map<int,queue<int> > pos;

bool cmp(int a,int b)
{
	return a > b;
}

int n,k;
vector<int> problems(maxn);

void input()
{
	scanf("%d%d",&n,&k);
	for(int i = 0;i < n;i++)
	{
		scanf("%d",&problems[i]);
		pos[problems[i]].push(i);
	}
}

void work()
{
	vector<int> opro = problems;
	vector<int> ans;
	sort(opro.begin(),opro.end(),cmp);
	int power = 0;
	int old = -1;
	for(int i = 0;i < k;i++)
	{
		power += opro[i];
		ans.push_back(pos[opro[i]].front());
		pos[opro[i]].pop();
	}
	printf("%d\n",power);
	sort(ans.begin(),ans.end());
	int left = 0;
	for(int i = 0;i < ans.size();i++)
	{
		if(i != ans.size() - 1)
		{
			printf("%d ",ans[i] - left + 1);
			left = ans[i] + 1;
		}else
		{
			printf("%d",n - left);
		}
	}
}

int main()
{
	input();
	work();
	return 0;
}

C. Three Parts of the Array

对于这道题目，首先第一部分一定在数组左侧，第二部分一定在数组右侧，同时中间的部分可以为空，则可以采用双指针的方法，一个指针在前，一个指针在后，相遇或者部分之和相同的时候停止。

#include <cstdio>
#include <vector>
using namespace std;

const int maxn = 2 * 1e5 + 3;

vector<int> nums(maxn);

int n;

void input()
{
	scanf("%d",&n);
	for(int i = 0;i < n;i++)
	{
		scanf("%d",&nums[i]);
	}
}

void work()
{
	int left = 0;
	int right = n - 1;
	long long int suml = nums[left];
	long long int sumr = nums[right];
	long long int max = 0;

	while(left < right)
	{
		if(suml > sumr)
		{
			right--;
			sumr += nums[right];
		}else if(suml < sumr)
		{
			left++;
			suml += nums[left];
		}else
		{
			if(suml > max)
			{
				max = suml;
			}
			left++;
			right--;
			sumr += nums[right];
			suml += nums[left];
		}
	}
	printf("%lld",max);
}

int main()
{
	input();
	work();
	return 0;
}

D. Two Strings Swaps

先要看懂题意,在每一次交换的时候，实际上只涉及到四个元素即a[i],a[n - i -1],b[i],b[n - i - 1]，在这之中又有着几种不同的情况

1.四个元素相同
2.四个元素均不相同
3.三个元素相同
4.两个元素分别相同
5.两个元素相同，另外两个元素不同
其中对于1和4来说，不需要进行预处理即可，对于3来说则只需要进行一次预处理即可，对于2则需要进行两次预处理，对于5我们还需要分情况讨论，当a[i] = a[n - i - 1]时，由于我们只能对a进行处理，所以这个时候需要进行两次预处理,a[i] != a[n - i - 1]时则只需要进行一次。

#include <cstdio>
#include <map>

using namespace std;

const int maxn = 1e5 + 7;

map<char,int> ans;

int n;
char a[maxn],b[maxn];

void input()
{
	scanf("%d",&n);
	getchar();
	scanf("%s",a);
	scanf("%s",b);
}

void work()
{
	int cnt = 0;
	int mid = 0;
	if(n % 2)
	{
		mid = n / 2 + 1;
	}else
	{
		mid = n / 2;
	}
	for(int i = 0;i < mid;i++)
	{
		ans[a[i]]++;
		ans[b[i]]++;
		if(n - i - 1 != i)
		{
			ans[a[n - i - 1]]++;
			ans[b[n - i - 1]]++;
		}
		else{
			if(ans[a[i]] % 2)
			{
				cnt++;
			}
			break;
		}
		int temp = ans[a[i]] | ans[a[n - i - 1]] | ans[b[i]] | ans[b[n - i -1]];
		if(ans[a[i]] == 3 || ans[a[n - i - 1]] == 3 || ans[b[i]] == 3 || ans[b[n - i - 1]] == 3)
		{
			cnt++;
		}else if(a[i] == a[n - i - 1] && b[i] != b[n - i - 1])
		{
			cnt += 2;
		}else if(b[i] == b[n - i - 1] && a[i] != a[n - i - 1])
		{
			cnt ++;
		}else if(ans[a[i]] == 1 && ans[a[n - i - 1]] == 1 && ans[b[i]] == 1 && ans[b[n - i - 1]] == 1)
		{
			cnt += 2;
		}else if(temp == 3)
		{
			cnt++;
		}	
		ans.clear();
	}
	printf("%d",cnt);
}

int main()
{
	input();
	work();
	return 0;
}	

E. Military Problem

题目中所要求的就是求出从第i个节点开始进行dfs之后的第k个节点。那么我们只需要在最开始的时候在源节点进行一次dfs，并记录下每一个节点在搜索中出现的出现的位次n_i，那么此时访问第i个节点后的第k个节点，即访问第 n_i + k节点即可。

#include <cstdio>
#include <vector>

using namespace std;

int n,k;
const int maxn = 2 * 1e5 + 7;
int currentOrder;

vector<vector<int> > officer(maxn);
vector<int> preorder(maxn);
vector<int> maxSize(maxn);
vector<int> preorder2Index(maxn);

void dfs(int index)
{
	preorder[index] = currentOrder;
	preorder2Index[currentOrder] = index;
	currentOrder++;	
	for(int i = 0;i < officer[index].size();i++)
	{
		dfs(officer[index][i]);
	}
	maxSize[index] = currentOrder - 1;
}

void input()
{
	scanf("%d%d",&n,&k);
	int temp = 0;
	currentOrder = 0;
	for(int i = 2;i <= n;i++)
	{
		scanf("%d",&temp);
		officer[temp].push_back(i);
	}
}

void work()
{
	int p,q;
	for(int i = 0;i < k;i++)
	{
		scanf("%d%d",&p,&q);	

		q += preorder[p] - 1;
		if(q > maxSize[p])
		{
			printf("-1\n");
		}else
		{
			printf("%d\n",preorder2Index[q]);
		}
	}
}

int main()
{
	input();
	dfs(1);
	work();
	return 0;
}

F. Xor-Paths

根据题意，我们每走一步就会有两种选择，从(1,1)到(n,m)最多可走n + m - 2步，即如果我们从头走到尾，共有2^(n + m - 2)种情况，显然是会超时。所以我们就需要转换思路，这里采用中途相遇的方法。从(1,1)节点以及(n,m)节点同时开始走。两边各走一半的路程即(n + m - 2) / 2，记录下到达(i,j)节点时的异或值，最后再进行异或操作与k比较即可。

#include <cstdio>
#include <vector>
#include <map>

using namespace std;

int n,m;
int half;
long long int ans;
long long int target;
long long int cnt = 0;
long long int maps[23][23];
map<long long int, int> v[23][23];

void input()
{
	scanf("%d%d%lld",&n,&m,&target);
	half = (n + m - 2) / 2;
	long long int temp;
	ans = 0;
	for(int i = 0;i < n;i++)
	{
		for(int j = 0;j < m;j++)
		{
			scanf("%lld",&maps[i][j]);
		}
	}
}

void calclf(int x, int y, long long int val, int cnt)
{
	val ^= maps[x][y];
	if(cnt == half)
	{
		v[x][y][val]++;
		return;
	}
	if(x + 1 < n)
	{
		calclf(x + 1, y, val, cnt + 1);
	}
	if(y + 1 < m)
	{
		calclf(x, y + 1, val, cnt + 1);
	}
}

void calcrg(int x, int y, long long int val, int cnt)
{
	if(cnt == n + m - 2 - half)
	{
		if(v[x][y].count(target ^ val))
		{
			ans += v[x][y][target ^ val];
		}
		return;
	}
	if(x > 0)
	{
		calcrg(x - 1, y, val ^ maps[x][y], cnt + 1);
	}
	if(y > 0)
	{	
		calcrg(x, y - 1, val ^ maps[x][y], cnt + 1);
	}
}


void work()
{
	calclf(0,0,0,0);	
	calcrg(n - 1, m - 1,0,0);
	printf("%lld",ans);
}

int main()
{
	input();
	work();
	return 0;
}