codeforce Round#615 Div3.（ABCDEF）

戳我：比赛地址
A.Collecting Coins
题解：A题憨憨签到题，直接发代码辽，注意判一下大于小于。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
	ios::sync_with_stdio(false);
	int a,b,c,n;
	int t;
	cin>>t;
	while(t--)
	{
		cin>>a>>b>>c>>n;
		int mx=max(max(a,b),c);
		int mi=min(min(a,b),c);
		int z=a+b+c+n;
		if(z%3!=0)
		{
			cout<<"NO"<<endl;
			continue;
		}
		int zz=z/3;
		if(zz<mx)
		{
			cout<<"NO"<<endl;
			continue;
		}
		cout<<"YES"<<endl;
	}
	return 0;
}

B.Collecting Packages
题解：要求收集到所有的包裹并且只能向右（R）和向上走（U），显然要考虑两点，一是字典序最小，所以优先向右走，要拿包裹时再向上走；二是能否拿到所有包裹，模拟时发现只能向左或者向下走才能拿到包裹时就直接break输出NO就好。
AC代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node
{
	int x,y;
}arr[200005];
bool comp(node a,node b)
{
	if(a.x==b.x) return a.y<=b.y;
	else return a.x<b.x;
}
int main()
{
	ios::sync_with_stdio(false);
	int t;
	cin>>t;
	while(t--)
	{
		int n;
		cin>>n;
		string ans;
		for(int i=1;i<=n;i++)
		{
			cin>>arr[i].x>>arr[i].y;
		}
		int flag=1;
		sort(arr+1,arr+1+n,comp);
		int cx=0;int cy=0;
		int cnt=1;
		while(cnt<=n&&flag)
		{
			int xx=arr[cnt].x;
			int yy=arr[cnt].y;
			if(cx<xx)
			{
				cx++;
				ans+='R';
				continue;
			}
			if(cy>yy)
			{
				flag=0;continue;
			}
			if(cx==xx&&cy<yy)
			{
				cy++;
				ans+='U';
				continue;
			}
			if(cy==yy&&cx==xx)
			{
				cnt++;
			}
		}
		if(flag)
		{
			cout<<"YES"<<endl;
			cout<<ans<<endl;
		}
		else cout<<"NO"<<endl; 
	}
	return 0;
}

C. Product of Three Numbers
题解：这题要求判断一个数是否可以由三个大于2的不同的数字相乘得到，不可以输出NO，可以输出YES并且找到任意满足条件的一组三个数。
我的想法就是根号复杂度的筛一下，筛到因数时就放入一个vector中并且更新n值，当筛到第二个时看看能不能将新的n值加入到vector中，不行就继续筛，行就直接结束，复杂度是小于根号的，也算是一个模拟题吧。
AC代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<int> ans;
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		ll n;
		scanf("%lld",&n);
		ans.clear();
		for(int i=2;i*i<=n;i++)
		{
			if(n%i==0)
			{
				ans.push_back(i);
				n=n/i;
			}
			if(ans.size()==2&&n>i)
			{
				ans.push_back(n);
				break;
			}
		}
		if(ans.size()!=3)
		{
			printf("NO\n");
		}
		else
		{
			printf("YES\n");
			printf("%d %d %d\n",ans[0],ans[1],ans[2]);
		}
	}
	return 0;
}

D. MEX maximizing
题解：注意到这题给出的x是可以在每次询问后使用它加减无限次的，因此只需要记录下对x的余数就可以了，对x取余相同的数字在每一轮都可以相互转换。另外，注意到每次询问的答案一定是非递减的，因此不需要每一次都重新循环找一遍，观察ans是否可以变大即可。
AC代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=4e5+50;
int arr[maxn];
int main()
{
	int q,x;
	
	scanf("%d%d",&q,&x);
	int cnt=0;
	for(int i=1;i<=q;i++)
	{
		int a;
		scanf("%d",&a);
		arr[a%x]++;
		int flag=1;
		while(flag)
		{
			int zzz=cnt%x;
			if(arr[zzz]>0)
			{
				arr[zzz]--;
				cnt++;
			}
			else
			{
				flag=0;
			}
		}
		printf("%d\n",cnt);
	}
	return 0;
}

E. Obtain a Permutation
题解：这个题目，题意大家读完后很显然能发现每一列的处理都是单独的，最终求和即可，对于每一列，我们可以求解每个元素列移动几次可以移动到自己应该在的位置，注意有的元素怎么移动都不会在自己应该在的位置（这个时候就需要用一次变化将其换一个值），然后对于每一列都判断列移动（0~n-1）次时的ans，对这些ans维护一个最小值mi，就是这一列的答案，所有列的mi值的总和就是总的答案。
事先处理出每个元素移动几次后可以到自己应该在的位置使得每一次列移动不需要一个个去询问这一列的每一个元素，因此总的复杂度应该是O（nm）级别的。
但是这个题目写起来还是很容易出错，orz。
AC代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
typedef long long ll;
vector<int> arr[maxn];
int rec[maxn];//不用变得 
int cnt[maxn];//第几次需要变的
int ans[maxn]; 
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			int a;scanf("%d",&a);
			arr[i].push_back(a);
		}
	}
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			rec[j]=0;
			cnt[j]=j;
		}
		for(int j=0;j<n;j++)
		{
			int a=arr[j][i];
			if(a%m!=(i+1)%m) continue;
			int x=(a-1)/m;
			if(x<n) rec[(j-x+n)%n]++;
		}
		int mi=100000009;
		for(int j=0;j<n;j++)
		{
			cnt[j]=cnt[j]+n-rec[j];
			mi=min(mi,cnt[j]);
		}
		ans[i]=mi;
	}
	ll fin=0;
	for(int i=0;i<m;i++)
	fin+=ans[i];
	printf("%lld\n",fin);
	return 0;
 } 

F. Three Paths on a Tree
题解：这题的题意是给定一个树，然后在树上找到三个不相同的点，使得它们之间的边的并集内元素数目最大，输出这个最大值以及这三个点。三个点的选择方案数可以有很多种，输出一种即可。
根据观察，显然有两个点一定是树的直径的两个端点，再次观察发现并集内元素数量是这三个点之间的路径长度之和除以2，既然确定下来了两个点，找第三个点时就直接找到这两个点到剩余每个点的距离长度，最终找到到这两个点的距离和最大的点即可。
找树的直径端点跑两遍dfs即可。
AC代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+50;
struct node
{
	int to,next;
	int wei;
}edge[2*maxn];
int tot;
int head[maxn];
void edge_init()
{
	memset(head,0,sizeof(head));
	tot=0;
}
void add(int u,int v,int wei)
{
	edge[++tot].to=v;
	edge[tot].next=head[u];
	edge[tot].wei=wei;
	head[u]=tot;
}
int n;
int son[maxn];
int d[maxn];
int vis[maxn];
int tmp1[maxn];
int tmp2[maxn];
void dfs(int x,int fa)
{
	
	vis[x]=1;
	son[x]=x;
	for(int i=head[x];i;i=edge[i].next)
	{
		int y=edge[i].to;
		if(y==fa) continue;
		dfs(y,x);
		if(d[y]+edge[i].wei>d[x])
		{
			d[x]=d[y]+1;
			son[x]=son[y];
		}
	}
    return;
}
void bfs(int x)
{
	vis[x]=1;
	queue<int> que;
	d[x]=0;
	que.push(x);
	while(!que.empty())
	{
		int x=que.front();
		que.pop();
		for(int i=head[x];i;i=edge[i].next)
		{
			int y=edge[i].to;
			if(vis[y]) continue;
			vis[y]=1;
			d[y]=d[x]+1;
			que.push(y);
		}
	}
	return;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n-1;i++)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		add(a,b,1);
		add(b,a,1);
	}
	int beg,end;
	dfs(1,0);beg=son[1];
	for(int i=1;i<=n;i++)
	{
		vis[i]=d[i]=0;
	}
	dfs(beg,0);end=son[beg];
	for(int i=1;i<=n;i++)
	{
		vis[i]=d[i]=0;
	}
	bfs(beg);
	for(int i=1;i<=n;i++)
	{
		tmp1[i]=d[i];
	}
	for(int i=1;i<=n;i++)
	{
		vis[i]=d[i]=0;
	}
	bfs(end);
	for(int i=1;i<=n;i++)
	{
		tmp2[i]=d[i];
	}
	int pos=0;
	for(int i=1;i<=n;i++)
	{
		if(tmp1[i]+tmp2[i]>tmp1[pos]+tmp2[pos]&&i!=beg&&i!=end)
		pos=i;
	}
	int ans=(tmp1[end]+tmp1[pos]+tmp2[pos])/2;
	printf("%d\n%d %d %d\n",ans,beg,end,pos);
	return 0;
}