Codeforces Round #485 (Div. 2)

A. Infinity Gauntlet

模拟就行了（不过这个题面啊……）

#include<iostream>
#include<cstdio>
#include<map>
#include<string>
using namespace std;
int n;
string s[10];
map<string,string>has;
map<string,bool>v;
int main()
{
	has["purple"]="Power";
	has["green"]="Time";
	has["blue"]="Space";
	has["orange"]="Soul";
	has["red"]="Reality";
	has["yellow"]="Mind";
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		cin>>s[i];
		v[s[i]]=1;
	}
	printf("%d\n",6-n);
	if(!v["purple"])
		cout<<has["purple"]<<endl;
	if(!v["green"])
		cout<<has["green"]<<endl;
	if(!v["blue"])
		cout<<has["blue"]<<endl;
	if(!v["orange"])
		cout<<has["orange"]<<endl;
	if(!v["red"])
		cout<<has["red"]<<endl;
	if(!v["yellow"])
		cout<<has["yellow"]<<endl;
	return 0;
}

B. High School: Become Human

两边同时取对数即可，这个不卡精度

\[x^y?y^x \]

\[log_{10}x^y?log_{10}y^x \]

\[y*log_{10}x?x*log_{10}y \]

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int main()
{
	double x,y;
	scanf("%lf%lf",&x,&y);
	if(y*log(x)>x*log(y))
		puts(">");
	else if(y*log(x)<x*log(y))
		puts("<");
	else
		puts("=");
	return 0;
}

C. Three displays

首先向O(n^3)枚举三个点，这个显然会T；
预处理出每个点i后面的点中权值最小的记为权值记为mn[i]，然后枚举前两个点即可
注意判无解

#include<iostream>
#include<cstdio>
using namespace std;
const int N=3005,inf=1e9;
int n,a[N],c[N],mn[N],ans=inf;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	for(int i=1;i<=n;i++)
		scanf("%d",&c[i]);
	for(int i=1;i<=n;i++)
	{
		mn[i]=inf;
		for(int j=i+1;j<=n;j++)
			if(a[i]<a[j])
				mn[i]=min(mn[i],c[j]);
	}
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
			if(a[i]<a[j]&&mn[j]!=inf)
				ans=min(ans,c[i]+c[j]+mn[j]);
	printf("%d\n",ans==inf?-1:ans);
	return 0;
}

D. Fair

有趣的bfs，或者叫spfa更恰当？
预处理出dis[i][u]，表示到u点最近的i类点与u的距离，这个乍一看复杂度很高，实际上可以对于每个类单独处理，也就是进行k次spfa，每次都把当前枚举到的i类的点全部入队，然后再更新其他点，这样复杂度是O(nk)的

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<cstring>
using namespace std;
const int N=100005,K=105,inf=1e9;
int n,m,k,s,a[N],h[N],cnt,dis[K][N],c[K];
bool v[N];
vector<int>b[K];
queue<int>q;
struct qwe
{
	int ne,to;
}e[N<<1];
int read()
{
	int r=0,f=1;
	char p=getchar();
	while(p>'9'||p<'0')
	{
		if(p=='-')
			f=-1;
		p=getchar();
	}
	while(p>='0'&&p<='9')
	{
		r=r*10+p-48;
		p=getchar();
	}
	return r*f;
}
void add(int u,int v)
{
	cnt++;
	e[cnt].ne=h[u];
	e[cnt].to=v;
	h[u]=cnt;
}
void spfa(int nw)
{
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		v[u]=0;
		for(int i=h[u];i;i=e[i].ne)
			if(dis[nw][u]+1<dis[nw][e[i].to])
			{
				dis[nw][e[i].to]=dis[nw][u]+1;
				if(!v[e[i].to])
				{
					v[e[i].to]=1;
					q.push(e[i].to);
				}
			}
	}
}
int main()
{
	n=read(),m=read(),k=read(),s=read();
	for(int i=1;i<=n;i++)
	{
		int x=read();
		b[x].push_back(i);
	}
	for(int i=1;i<=m;i++)
	{
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	for(int i=1;i<=k;i++)
		for(int j=1;j<=n;j++)
			dis[i][j]=inf;
	for(int i=1;i<=k;i++)
	{
		memset(v,0,sizeof(v));
		for(int j=0,len=b[i].size();j<len;j++)
			q.push(b[i][j]),dis[i][b[i][j]]=0,v[b[i][j]]=1;
		spfa(i);
	}
	for(int i=1;i<=n;i++)
	{
		int ans=0;
		for(int j=1;j<=k;j++)
			c[j]=dis[j][i];
		sort(c+1,c+1+k);
		for(int j=1;j<=s;j++)
			ans+=c[j];
		printf("%d ",ans);
	}
	return 0;
}

E. Petr and Permutations

明明题面在疯狂暗示了……其实就是逆序对和n的奇偶性的关系，然后3n和7n+1一定是一奇一偶，求出逆序对数判断一下即可，n和逆序对数奇偶性相同则是Petr
求逆序对用树状数组

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1000005;
int n,c[N],h[N];
int read()
{
	int r=0,f=1;
	char p=getchar();
	while(p>'9'||p<'0')
	{
		if(p=='-')
			f=-1;
		p=getchar();
	}
	while(p>='0'&&p<='9')
	{
		r=r*10+p-48;
		p=getchar();
	}
	return r*f;
}
void update(int x)
{
	for(int i=x;i<=n;i+=(i&-i))
		c[i]+=1;
}
int ques(int x)
{
	int r=0;
	for(int i=x;i>0;i-=(i&-i))
		r+=c[i];
	return r;
}
int main()
{
	n=read();
	long long ans=0ll;
	for(int i=1;i<=n;i++)
	{
		int x=read();
		update(x);
		ans+=i-ques(x);
	}
	if(ans%2==n%2)
		puts("Petr");
	else
		puts("Um_nik");
	return 0;
}

F. AND Graph

很好的dfs
首先x&(~x)=0，然后把~x二进制下的任意为1的位换成0也满足要求
于是搜索，每个状态转移向 (x ^ (1<<w))，w是二进制下为1的位，这样一次dfs就可以遍历整个联通块，数一下dfs次数即可

#include<iostream>
#include<cstdio>
using namespace std;
const int N=5000005;
int n,m,a[N],ans,al,f[N];
bool v[N];
int read()
{
	int r=0,f=1;
	char p=getchar();
	while(p>'9'||p<'0')
	{
		if(p=='-')
			f=-1;
		p=getchar();
	}
	while(p>='0'&&p<='9')
	{
		r=r*10+p-48;
		p=getchar();
	}
	return r*f;
}
void dfs(int x)
{
	if(v[x])
		return;
	v[x]=1;
	if(f[x])
		dfs(al^x);
	for(int i=0;i<n;i++)
		if(x&(1<<i))
			dfs(x^(1<<i));
}
int main()
{
	n=read(),m=read(),al=(1<<n)-1;
	for(int i=1;i<=m;i++)
		a[i]=read(),f[a[i]]=1;
	for(int i=1;i<=m;i++)
		if(!v[a[i]])
			ans++,v[a[i]]=1,dfs(al^a[i]);
	printf("%d\n",ans);
	return 0;
}