2017 Multi-University Training Contest - Team 7

QuanQqqqq

于 2020-05-03 14:32:16 发布

阅读量264

点赞数

分类专栏：多校联合训练文章标签：多校联合训练

本文链接：https://blog.csdn.net/QuanQqqqq/article/details/77247289

版权

多校联合训练专栏收录该内容

9 篇文章 0 订阅

订阅专栏

神奇的数据。开机20分钟挂机4小时。

##Build a tree##

题意：
给一个完全k叉树，rootn个节点点，问整个树，每个节点的子节点数+1 异或出来的值是多少。

思路：
其实不难发现，当有n层时，子树里会有n-1层的满k叉树x棵，n-2层的满k叉树y棵，n-1层的完全k叉树z棵这三种情况。
如果k % 2 == 0，那么对于一个满k叉树，他所异或的值为整棵树的节点数
如果k % 2 == 1，那么多于一个满k叉树，他所异或的值为从1到n层(1 - k ^ i) / (1 - k)的异或值
这个可以打个表。
当x % 2 == 1， y % 2 == 1的时候可以取值，因为如果棵数成偶数的话就异或为0了。

我们可以打表算出，当层数为n时拥有的结点数。
那么我们可以通过剩下的rootn个结点，算出x，y，z。
然后递归直到为0或为1即可。
这里要注意(1 - k ^ i) / (1 - k)这个不能直接算，k ^ i可能会先爆long long。累加即可。

当k = 1时，树为链，求1-n的异或值，找规律发现4个出现一次0。那么每次最多只需要算4次即可。

/*
满足
n > (1 - k ^ a) / (1 - k)
有a + 1层，这层的总节点数为(1 - k ^ (a + 1)) / (1 - k) = n1个节点 
上一层总节点数为(1 - k ^ a) / (1 - k) = n2 个节点 
一棵满k叉子树需要(1 - k ^ a) / (1 - k) = n3个节点
一棵少一层的k叉子树需要(1 - k ^ (a - 1)) / (1 - k) = n4个节点
那么剩下的节点数为z = n - x * n3 - y * n4
那么可以算出
y有(n1 - n) / k ^ a个 
x有(n - n2) / k ^ a个
可得剩下的节点数

有前缀和
1 异或 (1 - k ^ 2) / (1 - k) 异或 ...

可知花费为 
^rootn
x % 2 == 1时 贡献 ^sum(a)
y % 2 == 1时 贡献 ^sum(a - 1)
继续递归可得 

这里n1可能已经爆long long了，所以可以通过其他方式计算到x,y
*/
#include <bits/stdc++.h>

#define ll long long
#define MAXN 200

using namespace std;

const ll MOD = 1e9;

ll f[MAXN], sum[MAXN];
ll mi[MAXN];
ll ans, k;

void dfs(ll rootn) {
	ans ^= rootn;
	if (rootn == 0 || rootn == 1) {
		return ;
	}
	ll a = 1;
	for (ll i = 1; i < MAXN; i++) {
		if (f[i] >= rootn || f[i] <= 0 || mi[i] <= 0) {
			break;
		}
		a = i;
	}
	ll n2 = f[a];
	ll n3 = n2;
	ll n4 = f[a - 1];
	ll y;
	ll x = (rootn - n2) / mi[a - 1];
	if ((n2 - x * mi[a - 1]) % mi[a - 1] == 0) {
		y = k - x;
	} else {
		y = k - x - 1;
		y = y < 0 ? 0 : y; 
	}
	if (x % 2) {
		ans ^= sum[a];
	}
	if (y % 2) {
		ans ^= sum[a - 1];
	}
	ll z = rootn - x * n3 - y * n4 - 1;
	dfs(z);
} 

void init() {
	f[0] = sum[0] = 0;
	mi[0] = 1;
	for (ll i = 1; i < MAXN; i++) {
		mi[i] = mi[i - 1] * k;
		f[i] = mi[i - 1] + f[i - 1];
		if (k & 1) {
			sum[i] = sum[i - 1] ^ f[i];
		} else {
			sum[i] = f[i];	
		}
	}
}

int main() {
	int T;
	ll n;
	scanf("%d", &T);
	while (T--) {
		scanf("%lld %lld", &n, &k);
		ans = 0;
		if (k == 1) {
			while (n && (n + 1) % 4) {
				ans ^= n;
				n--;
			}
		} else {
			init();
			dfs(n);
		}
		printf("%lld\n", ans);
	}
} 

/*
100
1000000000000000000 1000000000
*/

##Euler theorem##

签到题。
题意：有a % b，现在告诉你a，问a % b的值有多少种情况出现。
思路：不难发现，大于0，小于(a + 1) / 2的数都可以被取得，再加上本身可以%=0

#include <bits/stdc++.h>

#define ll long long

using namespace std;

int main() {
	int T;
	ll n;
	scanf("%d", &T);
	while (T--) {
		scanf("%lld", &n);
		printf("%lld\n" , (n + 1) / 2 + 1);
	}
}

##Free from square##

题意：
从1到n当中，每次选取不超过k次，问能取到没有平方因子的情况有多少种。

思路：
没有平方因子很容易能想到素数，也就是500以内的素数随机组合选取，但是又要不超过k次。那就有点难度了。。
500的平方根以内的素数一共有8个，我们只要保证这八个不重复即可（因为其他的只要重复了就超过了500了）。
先将1到n以内的数按照刨去这八个素数后所得的数分组。
每组里面有着对于这八个数的不同状态，状压一下。
将所有情况都分组后，就是分组背包问题了。
dp的时候要每次枚举不同的状态和当前可以选择的数目，从上一次的情况获取到。
然后滚动数组维护一下即可。

#include <bits/stdc++.h>

#define MAXN 505
#define ll long long
#define MOD 1000000007

using namespace std;

int p[] = {2, 3, 5, 7, 11, 13, 17, 19};
vector<int> v[MAXN];
int b[MAXN], bel[MAXN];
int n, k;
bool mark[MAXN][1 << 9];
ll dp[2][MAXN][1 << 9];

void add(int x, int y) {
	v[x].push_back(y);
}

void init() {
	for (int i = 0; i < MAXN; i++) {
		v[i].clear();
		b[i] = 0;
		bel[i] = i;
	}
	memset(dp, 0, sizeof(dp));
	memset(mark, false, sizeof(mark));
}

void div() {
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j < 8; j++) {
			if (b[i] != -1 && i % p[j] == 0 && i % (p[j] * p[j]) != 0) {
				b[i] |= (1 << j);
				bel[i] /= p[j];
			} else if (i % p[j] == 0 && i % (p[j] * p[j]) == 0) {
				b[i] = -1;
				break;
			}
		}
	}
	for (int i = 1; i <= n; i++) {
		if (b[i] != -1) {
			if (bel[i] == 1) {
				add(i, b[i]);
			} else {
				add(bel[i], b[i]);
			}
		}
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j < v[i].size(); j++) {
			mark[i][v[i][j]] = true;
		}
	}
}

void work() {
	for (int i = 1; i <= n; i++) {
		if (v[i].size() == 0) {
			continue;
		}
		for (int j = 0; j < (1 << 8); j++) {
			if (!mark[i][j]) {
				continue;
			}
			dp[i & 1][1][j] = (dp[(i & 1) ^ 1][1][j] + 1) % MOD;
			for (int l = 1; l <= k; l++) {
				for (int q = 0; q < (1 << 8); q++) {
					if (!(j & q)) {
						dp[i & 1][l][j | q] = (dp[(i & 1) ^ 1][l - 1][q] + dp[i & 1][l][j | q]) % MOD;
					}
				}
			}
		}
		for (int j = 1; j <= k; j++) {
			for (int l = 0; l < (1 << 8); l++) {
				dp[(i & 1) ^ 1][j][l] = dp[i & 1][j][l];
			}
		}
	}
}

ll cal() {
	ll ans = 0;
	for (int i = 1; i <= k; i++) {
		for (int j = 0; j < (1 << 8); j++) {
			ans += dp[k & 1][i][j];
			ans %= MOD;
		}
	}		
	return ans;
}

int main() {
	int T;
	scanf("%d", &T);
	while (T--) {
		init();
		scanf("%d %d", &n, &k);
		div();
		work();
		printf("%lld\n", cal());
	}
}

##Hard challenge##

题意：
给n个坐标点每个点的价值为val，两两点构成的线段的价值为val1 * val2，现在求一条经过(0,0)点的直线可以使它交到的线段价值最大。

思路：
把所有点都打成以角度排序，以某点转180°的点，都可以对该点造成价值。
用尺取法一段一段180°取就好了。
用x，y算它角度的 atan2(y, x) / PI * 180

#include <bits/stdc++.h>

#define ll long long
#define MAXN 100005

using namespace std;

const double PI = acos(-1.0);

struct point {
	ll x, y, val;
	double ang;
	point(ll _x, ll _y, ll _val) : x(_x), y(_y), val(_val) {
		ang = atan2(y, x) / PI * 180;
		if (ang < 0) {
			ang += 360;
		}
	}
	point() {}
} reg[MAXN];

int cmp(point a, point b) {
	return a.ang < b.ang;
}

int main() {
	ll T, x, y, val, n;
	scanf("%lld", &T);
	while (T--) {
		scanf("%lld", &n);
		for (int i = 0; i < n; i++) {
			scanf("%lld %lld %lld", &x, &y, &val);
			reg[i] = point(x, y, val);
			reg[i + n] = point(x, y, val);
			reg[i + n].ang += 360;
		}
		n *= 2;
		sort(reg, reg + n, cmp);
		ll l, r;
		l = 0, r = 0;
		ll lval = 0, rval = 0;
		while (r + 1 < n && reg[0].ang + 180 > reg[r + 1].ang) {
			rval += reg[++r].val;
		}
		ll ans = 0;
		if (r == 0) {
			rval += reg[++r].val;
		}
		for (ll i = 1; i < n; i++) {
			rval -= reg[i].val;
			lval += reg[i - 1].val;
			while (l < i && reg[i].ang - 180 >= reg[l].ang) {
				lval -= reg[l++].val;
			}
			while (r + 1 < n && reg[i].ang + 180 > reg[r + 1].ang) {
				rval += reg[++r].val;
			}
			ans = max(ans, (lval + reg[i].val) * rval);
			if (i == r && i + 1 < n) {
				rval +=  reg[++r].val;
			}
		}
		printf("%lld\n", ans);
	}
}

/*
3
3
1 1 1
1 -1 10
-1 0 100
*/

##Just do it##

题目：
给一个序列a，有一种操作，对于每一个下标i的数，他是 $[1, i] 之间的 a i 异或得到的$
现在进行m次操作，问最终序列的样子。

思路：
其实可以发现有dp[i][j]表示下标为i，已经操作了j次。
有 $d p [i] [j] = d p [i - 1] [j] x o r d p [i] [j - 1]$
再转化一下。有 $dp[i][j] = dp[i - 2^k] xor dp[i][j - 2^k]$
那可以发现，其实对于一个下标为i的，我们只需要做他j二进制化后，为1的位置（跟快速幂差不多）。
然后dp一下就好了。

#include<bits/stdc++.h>

#define MAXN 200005
#define ll long long

using namespace std;

ll a[MAXN];

int main(){
	ll T, n, m;
	scanf("%d", &T);
	while (T--) {
		scanf("%lld %lld", &n, &m);
		for (ll i = 0; i < n; i++) {
			scanf("%lld", &a[i]);
		}
		for (ll k = 0; 1 << k <= m; k++) {
			if (m >> k & 1) {
				for (ll i = 1 << k; i < n; i++) {
					a[i] ^= a[i - (1 << k)];
				}
			}
		}
		for (ll i = 0; i < n; i++) {
			if (i) {
				printf(" ");
			}
			printf("%lld", a[i]);
		}
		puts("");
	}
}

##Kolakosk##

题意：一个Kolakoski序列。。。。。。问你第n位是多少
什么是Kolakoski序列呢。百度去吧。。好难描述

思路：按照Kolakoski的描述打表即可。。
数据水到比赛的时候判奇偶都可以过。。

#include <bits/stdc++.h>

#define ll long long
#define MAXN 10000005

using namespace std;

int k[MAXN];

void init() {
	k[1] = 1;
	k[2] = 2;
	int cnt = 2;
	for (int i = 1; i < MAXN; i += k[cnt++]) {
		for (int j = 0; j < k[cnt]; j++) {
			k[i + j + 1] = k[i] ^ 3; 
		}
	}	
}

int main() {
	int T, n;
	init();
	scanf("%d", &T);
	while (T--) {
		scanf("%d", &n);
		printf("%d\n", k[n]);
	}	
}

QuanQqqqq

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2017 Multi-University Training Contest - Team 7

神奇的数据。开机20分钟挂机4小时。Build a tree 题意：给一个完全k叉树，rootn个节点点，问整个树，每个节点的子节点数+1 异或出来的值是多少。思路：其实不难发现，当有n层时，子树里会有n-1层的满k叉树x棵，n-2层的满k叉树y棵，n-1层的完全k叉树z棵这三种情况。如果k % 2 == 0，那么对于一个满k叉树，他所异或的值为整棵树的节点
复制链接

扫一扫