Codeforces Round #588 (Div. 2)

Codeforces Round #588 (Div. 2)
AB略

C. Anadi and Domino
题意:

有如图所示的 21 个多米诺骨牌，给定一个无向图（无自环，无重边），一条边上可以放置一个多米诺骨牌。要求是如果两条边连接同一个顶点，那就必须使这两条边上的多米诺骨牌指向这个顶点的值相等，可以有不放的情况，问给定的图中最多可以放多少个多米诺骨牌。(n<=7)

思路: 假设ｎ<=6每条边都可以放满多米诺骨牌,当n=7时,必定有2个点对应的数字是相同的,那么怎么确定这2个点呢，我们可以假设点i和点j对应的数字相同,那么当i和j分别与点k有边的时候,我们只能选择在i与k(或j与k)之间放一个多米诺骨牌,相当于我们舍弃了其中一条边,所以我们可以找到需要舍弃的最少的边为cnt,答案就是m-cnt．

#include
using namespace std;
typedef long long ll;
int a[10][10];
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		a[u][v]=1;
		a[v][u]=1;
	}
	if(n<=6)
	{
		printf("%d\n",m);
		return 0;
	}
	int ans=0x3f3f3f3f;
	for(int i=1;i<=7;i++)
	{
		for(int j=1;j<=7;j++)
		{
			int cnt=0;
			for(int k=1;k<=7;k++)
			{
				if(a[i][k]&&a[j][k])
					cnt++;
			}
			ans=min(ans,cnt);
		}
	}
	printf("%d\n",m-ans);
	return 0;
}

D. Marcin and Training Camp
题意: 要组建一个小组，要求小组中每个人都不比所有人强，当一个人懂得一个算法但是另一个不懂那么前者认为他比后者强。所以这个小组要满足一个人懂得算法必定有另一个人全懂。每个人的技能是不同的，要求出这个小组能组成的技能最大值。
思路: 这个小组懂得最多算法的那个人必定有另一个人与他懂的算法一样。所以记录所有ai相同的人的ai。可以知道，当一个人比另一个人的ai小且他们的与运算等于小的那个人的ai那么可以知道大的那个人必定强于ai小的那个人。也就是ai小的那个人会的算法另一个人都会。知道了小组中必定有哪些人那么用其他人和这些人比较就可以得到最后小组有哪些人。
也就是说$a_i$ & $a_j=a_i$,此时$a_i$若是最大则需要一个与之一样大的$a_j$

#include 
#define ll long long
using namespace std;
 
const int maxn=7005;
struct stu{
    ll a,b;
    bool operator<(const stu &x)
    {
        return a<x.a;
    }
}s[maxn];
int vis[maxn];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin>>n;
    for(int i=1;i<=n;++i) cin>>s[i].a;
    for(int i=1;i<=n;++i) cin>>s[i].b;
    sort(s+1,s+n+1);
    for(int i=2;i<=n;++i)
    if(s[i].a==s[i-1].a)
        for(int j=1;j<=i;++j)
            if((s[i].a&s[j].a)==s[j].a) vis[j]=1;
    ll ans=0;
    for(int i=1;i<=n;++i)
        if(vis[i]) ans+=s[i].b;
    cout<<ans<<endl;
    return 0;
}

E. Kamil and Making a Stream
题意: 给你一颗树，每个结点都有一个权值x，现在定义$f(u,v)=gcd(x_u,\dots ,x_v)$,现计算${\sum }_{uisanancestorofv}f(u,v)$,注意本身也是本身的祖先
思路: 求一个连续区间的gcd种类不超过log(n)个,所以时间复杂度为O(n* logn*logn)，直接遍历即可，把每个结点到祖先的gcd都存起来，顶多有logn个

#include
using namespace std;
typedef long long ll;
const int N=1e5+5;
const int mod=1e9+7;
ll x[N],ans;
vector<int>G[N];
unordered_map<ll,int>a[N];
 
void add(int u,ll w,int p)
{
	ans=(ans+1ll*w*p%mod)%mod;
	a[u][w]+=p;
}
 
void dfs(int u,int fa)
{
	add(u,x[u],1);
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i];
		if(v==fa)
			continue;
		for(auto it: a[u])
		{
			add(v,1ll*__gcd(it.first,x[v]),it.second);
		}
		dfs(v,u);
	}
}
 
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%lld",&x[i]);
	for(int i=1;i<n;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		G[u].push_back(v);
		G[v].push_back(u);
	}
	dfs(1,0);
	printf("%lld\n",ans);
	return 0;
}

F. Konrad and Company Evaluation
题意:
有N个人在同一个公司上班，第i个人的薪水一开始为i，不过老板可以Q次指定员工编号$v_i$,第i次操作会将$v_i$ 的薪水提升至n+i
现在有M对仇恨关系。假如u,v有仇恨关系，那么当u薪水比v高（或v比u高）时，高的那个人就会向低的那个人炫耀,如果u向v炫耀,v向w炫耀，那么它们构成一个三元组
现在，需要在每次老板更改薪水之后，统计三元组的数量
思路: 首先我们需要转化一个，求三元组的数量其实就是求每个结点入度*出度的总和
复杂度O(n * sqrt(n))具体题解分析

#include
using namespace std;
const int N=1e5+5;
typedef long long ll;
vector<int>G[N];
int in[N],out[N];
ll ans;
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		if(u>v)
			swap(u,v);
		G[u].push_back(v);
		in[v]++;
		out[u]++;
	}
	for(int i=1;i<=n;i++)
		ans+=1ll*in[i]*out[i];
	printf("%lld\n",ans);
	int q;
	scanf("%d",&q);
	while(q--)
	{
		int v;
		scanf("%d",&v);
		ans-=1ll*in[v]*out[v];
		in[v]+=out[v];
		out[v]=0;
		for(auto it: G[v])
		{
			ans-=1ll*in[it]*out[it];
			in[it]--;
			out[it]++;
			ans+=1ll*in[it]*out[it];
			G[it].push_back(v);
		}
		G[v].clear();
		printf("%lld\n",ans);
	}
	return 0;
}