AtCoder Beginner Contest 190

A - Very Very Primitive Game

B - Magic 3

C - Bowls and Dishes

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

#include 
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 N N ,求公差为 1 且所有项和等于 N N 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 + n ( n − 1 ) 2 d S_n = na_1+\frac{n(n-1)}{2}d Sn=na1+2n(n1)d
公差为1,Sn也已知。
又可以想到,合法数列的项数成对出现,且有取值在 [ 1 , 2 ∗ N ] [1,2*N] [12N] 这个区间内,所以可以 O ( n ) O(\sqrt{n}) O(n )时间内枚举项数,计算出首项的值,判断是否合法(是否整数)。

#include 
#include 
#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)

E - Magical Ornament

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

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

#include 
#include 
#include 
#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 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<

F - Shift and Inversions

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

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

#include 
#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

你可能感兴趣的:(Atcoder)