Codeforces Round #797 (Div. 3)

A. Print a Pedestal (Codeforces logo?)

题目链接：Problem - A - Codeforces

样例输入： 

6
11
6
10
100000
7
8

样例输出：

4 5 2
2 3 1
4 5 1
33334 33335 33331
2 4 1
3 4 1

题意：给定一个n，找出来所有满足h1+h2+h3=n且(0<h3<h2<h1)的三元组(h1,h2,h3)，输出h1最小的三元组，输出任意一个答案即可。

分析：贪心来看，让h1,h2,h3三个值尽可能接近，直接对n取余3的情况分类讨论一下即可。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n;
		scanf("%d",&n);
		if(n%3==0) printf("%d %d %d\n",n/3,n/3+1,n/3-1);
		else if(n%3==1) printf("%d %d %d\n",n/3,n/3+2,n/3-1);
		else printf("%d %d %d\n",n/3+1,n/3+2,n/3-1);
	}
	return 0;
}

B. Array Decrements

题目链接：Problem - B - Codeforces

样例输入：

6
4
3 5 4 1
1 3 2 0
3
1 2 1
0 1 0
4
5 3 7 2
1 1 1 1
5
1 2 3 4 5
1 2 3 4 6
1
8
0
1
4
6

样例输出：

YES
YES
NO
NO
YES
NO

题意：给定一个长度为n的数组a和数组b，我们可以对a数组进行操作，每次操作把a中所有的非0元素的值减1，问能否通过操作将数组a变至数组b。

分析：我们遍历一边数组可以知道理论上应该操作多少次，就是找一个i，求max(a[i]-b[i])，然后我们对于每个数都进行这么多次操作，最后直接比较a数组和b数组是否相同即可。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
int a[N],b[N];
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n;
		scanf("%d",&n);
		int mx=0;
		for(int i=1;i<=n;i++)
			scanf("%d",&a[i]);
		for(int i=1;i<=n;i++)
			scanf("%d",&b[i]),mx=max(mx,a[i]-b[i]);
		for(int i=1;i<=n;i++)
			a[i]=max(0,a[i]-mx);
		bool flag=true;
		for(int i=1;i<=n;i++)
			if(a[i]!=b[i])
			{
				flag=false;
				break;
			}
		if(flag) puts("YES");
		else puts("NO");
	}
	return 0;
}

C. Restoring the Duration of Tasks

题目链接：Problem - C - Codeforces

样例输入：

4
3
0 3 7
2 10 11
2
10 15
11 16
9
12 16 90 195 1456 1569 3001 5237 19275
13 199 200 260 9100 10000 10914 91066 5735533
1
0
1000000000

样例输出：

2 7 1 
1 1 
1 183 1 60 7644 900 914 80152 5644467 
1000000000 

题意：给定n个进程的到达时间和离开时间，让我们模拟每个进程运行了多长时间。一个进程能够运行当且仅当在他之前到达的进程都已经离开。

思路：直接模拟即可

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
int s[N],f[N];
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
			scanf("%d",&s[i]);
		for(int i=1;i<=n;i++)
			scanf("%d",&f[i]);
		int now=0;
		for(int i=1;i<=n;i++)
		{
			if(s[i]>=now)
			{
				now=f[i];
				printf("%d ",f[i]-s[i]);
			}
			else if(f[i]>=now)
			{
				printf("%d ",f[i]-now);
				now=f[i];
			}
			else
				printf("0 ");
		}
		puts("");
	}
	return 0;
}

D. Black and White Stripe

题目链接：Problem - D - Codeforces

样例输入： 

4
5 3
BBWBW
5 5
BBWBW
5 1
BBWBW
1 1
W

样例输出：

1
2
0
1

题意：给定一个长度为n的字符串，每个字符为‘W’或者‘B’，每次操作我们可以把一个‘W’变为‘B’，问至少操作多少次能够使得字符串中出现一个长度大于等于k的全‘B’字符串。

分析：我们直接用前缀和记录一下‘W’的数目，然后我们统计一下每个长度为k的区间里面有多少个W，这就是我们需要的操作次数，只需要O(n)统计一下最小值即可。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
int s[N];
char ss[N];
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n,k;
		scanf("%d%d",&n,&k);
		scanf("%s",ss+1);
		for(int i=1;i<=n;i++)
		if(ss[i]=='W') s[i]=s[i-1]+1;
		else s[i]=s[i-1];
		int ans=n;
		for(int i=k;i<=n;i++)
			ans=min(ans,s[i]-s[i-k]);
		printf("%d\n",ans);
	}
	return 0;
}

E. Price Maximization

题目链接：Problem - E - Codeforces

题意：给定一个长度为n的数组和一个k，n是一个偶数，我们将这n个数分成n/2组，每组2个数，这一组的贡献就是(a[i]+a[j])/k，求最大贡献值。

分析：对于一个a[i]，首先其对结果的贡献至少为a[i]/k，我们可以先记录下这个贡献，然后令a[i]=a[i]%k，最后我们就得到了一个值在0~k-1之间的数组，这个时候我们贪心来选择，优先令i和k-i分到一组，这个我们可以直接通过双指针实现

具体实现见代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
int a[N];
int cnt[N];
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		long long ans=0;
		int n,k;
		scanf("%d%d",&n,&k);
		for(int i=0;i<k;i++) cnt[i]=0;
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
			ans+=a[i]/k;
			cnt[a[i]%k]++;
			
		}
		int l=1,r=k-1;
		while(l<=r)
		{
			while(l+r<k) l++;
			if(l<r)
			{
				if(cnt[l]<cnt[r]) ans+=cnt[l],cnt[r]-=cnt[l++];
				else if(cnt[l]>cnt[r]) ans+=cnt[r],cnt[l]-=cnt[r--];
				else ans+=cnt[l],l++,r--;
			}
			else if(l==r)
			{
				ans+=cnt[l]/2;
				break;
			}
			else break;
		}
		
		printf("%lld\n",ans);
	}
	return 0;
}

F. Shifting String

题目链接：Problem - F - Codeforces

样例输入：

3
5
ababa
3 4 5 2 1
5
ababa
2 1 4 5 3
10
codeforces
8 6 1 7 5 2 9 3 10 4

样例输出：

1
6
12

题意：给定一个长度为n的字符串，字符串是由小写字母组成，接下来给定一个1~n的排列a[i]，代表我一次操作后第a[i]个字符将会放置在第i个字符，每次操作都是在之前已经操作过的字符串上进行，问至少需要多少次操作能还原字符串。

分析：这种题目还是比较常见的，我们能够发现字符的变换是有规律的。就是说这n个数可以看成若干个环，对于每个环之间都是独立的，我们只需要找到每个环的最少还原次数，最后直接取一个最小公倍数即可。

以第一个样例进行分析：第一个样例中有3->1->5->3,这个环的长度为3，这个环对应的字符串是aaa，那么最少还原次数就是1。而剩余的2和4在一个环中，最少还原次数也是1。所以两个环的最小公倍数就是1。

细节见代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
char s[N];
bool vis[N];
int a[N],mp[N];
long long f(string t)
{
	int l=t.size();
	for(int i=1;i<=l;i++)
	{
		bool flag=true;
		for(int j=0;j<l;j++)
			if(t[j]!=t[(j+i)%l])
			{
				flag=false;
				break;
			}
		if(flag) return 1ll*i;
	}
}
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n;
		scanf("%d",&n);
		for(int i=1;i<=n;i++) vis[i]=false;
		scanf("%s",s+1);
		for(int i=1;i<=n;i++) scanf("%d",&a[i]),mp[a[i]]=i;
		long long ans=1;
		for(int i=1;i<=n;i++)
		{
			if(vis[i]) continue;
			vis[i]=true;
			string ss="";
			ss+=s[i];
			int t=i;
			while(mp[t]!=i)
			{
				t=mp[t];
				ss+=s[t];
				vis[t]=true;
			}
			long long tt=f(ss);
			ans=ans/__gcd(ans,tt)*tt;
		}
		printf("%lld\n",ans);
	}
	return 0;
}