AtCoder Beginner Contest 190

A - Very Very Primitive Game

略

B - Magic 3

略

C - Bowls and Dishes

看数据范围发现 $K$ 比较小，可以进行搜索。对于每个人尝试将小球加入 Ci 或 Di 。完成一轮搜索后统计个数更新答案即可。

#include <cstdio>
int N, M, K, A[110], B[110], C[110], D[110], ans;
int flag[110];
void DFS(int k)
{
	if(k==K+1)
	{
		int cnt = 0;
		for(int i=1;i<=M;i++)
		{
			if(flag[A[i]]&&flag[B[i]])
			    cnt++;
		}
		if(cnt>ans)
		    ans = cnt;
		return;
	}
	flag[C[k]]++;
	DFS(k+1);
	flag[C[k]]--;
	flag[D[k]]++;
	DFS(k+1);
	flag[D[k]]--;
}
int main()
{
    scanf("%d%d", &N, &M);
    for(int i=1;i<=M;i++)
        scanf("%d%d", &A[i], &B[i]);
    scanf("%d", &K);
    for(int i=1;i<=K;i++)
        scanf("%d%d", &C[i], &D[i]);
    DFS(1);
    printf("%d\n", ans);
	return 0;
}

D - Staircase Sequences

给定 $N$ ，求公差为 1 且所有项和等于 $N$ 的数列的个数。
例如 N = 12，有四个合法数列：
[12]
[3,4,5]
[−2,−1,0,1,2,3,4,5]
[−11,−10,−9,…,10,11,12]

由等差数列求和公式：
$$S_n=n{a}_1+\frac{n(n-1)}{2}d$$
公差为1，Sn也已知。
又可以想到，合法数列的项数成对出现，且有取值在 $[1，2\ast N]$ 这个区间内，所以可以$O(\sqrt{n})$时间内枚举项数，计算出首项的值，判断是否合法（是否整数）。

#include <cstdio>
#include <cmath>
#define ll long long int
#define eps 1e-9
ll N;
int main()
{
	int ans = 0;
    scanf("%lld", &N);
    for(ll i=1;i*i<=N*2;i++)
    {
    	double tempa = N*1.0/i-(i-1)/2.0;
//    	printf("%.0lf\n", tempa);
    	if(fabs(tempa-(ll)tempa)<eps)
    	{
    	//	printf("%.0lf\n", tempa);
    		ans++;
		}
	}
	printf("%d\n", ans*2);
	return 0;
}

E - Magical Ornament

题意：有 $N$ 种宝石，宝石具有排斥性，只有某些宝石对能够放在一起，现在想要组成一条宝石链，使得相邻的宝石能够放在一起而且宝石链中含有指定的宝石，求可能的最短的宝石链长度。

能够相邻的宝石可以用一条无向边来表示，之后我们要组成一条宝石链，即遍历宝石链中存在的宝石。预处理出需要包含的宝石之间的最短距离，之后就是经典的旅行商问题，观察到 $K$ 范围较小，状压 DP即可。

#include <cstdio>
#include <cstring>
#include <queue>
#define ll long long int
#define inf 0x3f3f3f3f
#define MAXN 100010
using namespace std;
struct t_Edge {
	int next;
	int to;
};
t_Edge edge[2*MAXN];
int head[MAXN], num_edge;
int N, M, K, C[20], vis[MAXN];
ll dis[20][20];
ll d[MAXN];
ll dp[(1<<18)][20];
void add(int from, int to)
{
	edge[++num_edge].next = head[from];
	edge[num_edge].to = to;
	head[from] = num_edge; 
}
void bfs(int s)
{
	d[s] = 0;
	dis[vis[s]][vis[s]] = 0;
	queue<int> q;
	q.push(s);
	while(!q.empty())
	{
		int u = q.front();
		q.pop();
		for(int i=head[u];i;i=edge[i].next)
		{
			int v = edge[i].to;
			if(d[v]==inf)
			{
				d[v] = d[u]+1;
				q.push(v);
				if(vis[v])
				{
					dis[vis[s]][vis[v]] = d[v];
				}
			}
		}
	}
}
int main()
{
	memset(dis, inf, sizeof(dis));
	scanf("%d%d", &N, &M);
	for(int i=1;i<=M;i++)
	{
		int uu, vv;
		scanf("%d%d", &uu, &vv);
		add(uu, vv);
		add(vv, uu);
	}
	scanf("%d", &K);
	for(int i=1;i<=K;i++)
	{
		scanf("%d", &C[i]);
		vis[C[i]] = i;
	}
	for(int i=1;i<=K;i++)
	{
		for(int j=1;j<=N;j++)
			d[j] = inf;
	    bfs(C[i]);
	}
/*	for(int i=1;i<=K;i++)
	{
		for(int j=1;j<=K;j++)
		    printf("%d %d %d\n", C[i], C[j], dis[C[i][C[j]]]);
	}*/
	memset(dp, inf, sizeof(dp));
	for(int i=1;i<=K;i++)
	    dp[1<<(i-1)][i] = 1;
	for(int i=1;i<=(1<<K)-1;i++)
	{
		for(int j=1;j<=K;j++)
		{
			if(dp[i][j]==inf)
			    continue;
			for(int z=1;z<=K;z++)
			{
				if(z==j)
				    continue;
				if((1<<(z-1))&i)
				    continue;
				dp[i|(1<<(z-1))][z] = min(dp[i|(1<<(z-1))][z], dp[i][j]+dis[j][z]);
			}
		}
	}
	ll ans = inf;
	for(int i=1;i<=K;i++)
		ans = min(ans, dp[(1<<K)-1][i]);
	if(ans==inf)
	    printf("-1\n");
	else printf("%lld\n", ans);
	return 0;
}

F - Shift and Inversions

给出一个[0，n-1]的排列，分别求原数列和每一种循环同构数列的逆序对。

维护逆序对可以用线段树，当然我也看到了没有用线段树的思路。总体上比 E 题简单一些。

#include <cstdio>
#define ll long long int
struct t_Tree {
	int L, R;
	int num;
};
t_Tree tree[1200010];
int N, A[300010];
void Build(int n, int l, int r)
{
	tree[n].L = l;
	tree[n].R = r;
	if(l==r)
	{
		tree[n].num = 0;
		return;
	}
	int mid = (l+r)/2;
	Build(n*2, l, mid);
	Build(n*2+1, mid+1, r);
	tree[n].num = tree[n*2].num+tree[n*2+1].num;
}
void update(int n, int index, int k)
{
	if(tree[n].L==tree[n].R)
	{
		tree[n].num += k;
		return;
	}
	int mid = (tree[n].L+tree[n].R)/2;
	if(index<=mid)
	    update(n*2, index, k);
	else
	    update(n*2+1, index, k);
	tree[n].num = tree[n*2].num+tree[n*2+1].num;
}
ll query(int n, int l, int r)
{
	if(l<=tree[n].L&&r>=tree[n].R)
	    return tree[n].num;
	ll res = 0;
	int mid = (tree[n].L+tree[n].R)/2;
	if(l<=mid)
	    res += query(n*2, l, r);
	if(r>mid)
	    res += query(n*2+1, l, r);
	return res;
}
int main()
{
	scanf("%d", &N);
	Build(1, 0, N+1);
	ll inv = 0;
	for(int i=1;i<=N;i++)
	{
		scanf("%d", &A[i]);
		A[i]++;
		update(1, A[i], 1);
		inv += query(1, A[i]+1, N+1);
	}
	printf("%lld\n", inv);
	for(int i=1;i<N;i++)
	{
		update(1, A[i], 1);
	    inv += query(1, A[i]+1, N+1);
	    update(1, A[i], -1);
	    inv -= query(1, 0, A[i]-1);
	    printf("%lld\n", inv);
	}
	return 0;
}