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(n−1)d
公差为1，Sn也已知。
又可以想到，合法数列的项数成对出现，且有取值在 [ 1 ， 2 ∗ N ] [1，2*N] [1，2∗N] 这个区间内，所以可以 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