2021杭电多校赛2021“MINIEYE杯”中国大学生算法设计超级联赛签到题15869

Posted 2021-08-22 小哈里

2021“MINIEYE杯”中国大学生算法设计超级联赛（1）
Start Time : 2021-07-20 12:10:00 End Time : 2021-07-20 17:10:00
Contest Type : Private Contest Status : Ended

Current Server Time : 2021-07-21 14:52:47

Solved Pro.ID Title Ratio(Accepted / Submitted)
1001 Mod, Or and Everything 45.80%(986/2153)（位运算，数论，打表找规律）
1002 Rocket land 4.74%(10/211)
1003 Puzzle loop 40.00%(22/55)
1004 Another thief in a Shop 18.55%(23/124)
1005 Minimum spanning tree 48.20%(886/1838)（建图，线性筛，预处理）
1006 Xor sum 17.79%(305/1714)（异或前缀和，01字典树）
1007 Pass! 16.26%(146/898)
1008 Maximal submatrix 20.21%(610/3019)（递增子矩阵，最大子矩阵面积，单调栈）
1009 KD-Graph 23.32%(393/1685)（并查集）
1010 zoto 16.80%(172/1024)
1011 Necklace of Beads 35.21%(50/142)

1001 Mod, Or and Everything

题意

• 给出一个整数n（n<1e12），计算 (n mod 1) or (n mod 2) or … or (n mod (n - 1)) or (n mod n)的结果，or为位运算。

思路：

• 猜测：1-n的模数加起来会覆盖所有情况，所以左边第一个1后面都置为1，所以不断减lowbit只剩1个1，再减一就行。特判开始就只有1个1的情况，要将其右移1位。
• 打表可以发现规律

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
LL lowbit(LL x){ return x&-x; }
int main(){
	int T;  cin>>T;
	while(T--){
		LL n;  cin>>n;
		if(lowbit(n)==n){
			cout<<max(0ll, n/2-1)<<"\\n";
			continue;
		}
		while(lowbit(n)!=n)n -= lowbit(n);
		cout<<n-1<<"\\n";
	}
	return 0;
}

1005 Minimum spanning tree

题意：

• n-1个点，从2-n编号，两点间的边为lcm(a,b)，求最小生成树
• T<100, n < 1e7

思路：

• 要让lcm最小，容易想到一种是包含关系，即lcm(a, b)==a, 所以让每个数向其约数连边，比如9->3。对于没有约数的质数，将其与2相连是最优的，因为在不能包含的情况下，最小的倍数就是2倍。
• 总的边权和为（质数的和*2+合数的和），可以用筛法预处理出前缀和，复杂度O(n)。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 1e7+1;

LL v[maxn], p[maxn], cnt, s[maxn];
void init(){
	//线性筛
	for(int i = 2; i < maxn; i++){
		if(!v[i])p[++cnt] = i;
		for(int j = 1; j <= cnt; j++){
			if(i*p[j]>=maxn)break;
			v[i*p[j]] = 1;
			if(!(i%p[j]))break;
		}
	}
	//前缀和
	for(int i = 3; i < maxn; i++){
		if(!v[i])s[i] = s[i-1]+2*i;
		else s[i] = s[i-1]+i;
	}
}

int main(){
	ios::sync_with_stdio(false);
	init();
	int T;  cin>>T;
	while(T--){
		LL n;  cin>>n;
		cout<<s[n]<<"\\n";
	}
	return 0;
}

1008 Maximal submatrix

题意：

• 给出一个n*m的矩阵，求一个面积最大的子矩阵满足子矩阵的每一列都是单调不递减的

思路：

• 转化为01矩阵 每个位置1代表该位是否比上面一位小，然后用单调栈求最大01矩阵 复杂度O(n^2)

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 3e3+10;
int a[maxn][maxn], b[maxn][maxn], h[maxn];
int p, s[maxn], w[maxn];

int main(){
	ios::sync_with_stdio(false);
	int T;  cin>>T;
	while(T--){
		int n, m;  cin>>n>>m;
		for(int i = 1; i <= n; i++){
			for(int j = 1; j <= m; j++){
				cin>>a[i][j];
				if(i==1)continue;
				b[i][j] = (a[i][j]>=a[i-1][j]);
			}
		}
		int ans = 0;
		for(int i = 1; i <= n; i++){
			//统计高度
			for(int j = 1; j <= m; j++){
				if(b[i][j]==0)h[j] = 1;
				else h[j]++;
			}
			//单调栈
			p = 0;  h[m+1] = 0;
			for(int j = 1; j <= m+1; j++){
				if(h[j]>s[p])s[++p]=h[j], w[p] = 1;
				else{
					int width = 0;
					while(s[p]>h[j]){
						width += w[p];
						ans = max(ans, width*s[p]);
						p--;
					}
					s[++p] = h[j], w[p] = width+1;
				}
			}
		}
		cout<<ans<<"\\n";
	}
	return 0;
}

1006 Xor sum

题意：

• 给出一个长度为n的序列，求一个最短连续子序列满足异或和大于等于k。n<1e5。

思路：

• 参考CF665E，求序列a中有多少个异或和大于等于k的子序列，枚举所有的子序列，维护最小长度即可。
• 首先因为区间异或和，且异或满足性质a^b^a==b，所以可以想到异或前缀和，s[l~r] = s[r]^s[l-1]。
• 因为01字典树可以查找树中与x异或后最大的值，所以维护异或前缀和的01字典树。此时枚举靠右的那个数，字典树每次保存范围内最靠右的点的位置。
• 字典树每次查找的时候，由高位到低位考虑每位，令字典树的与R异或后的前 i-1 位与 k值相等（以此往下走），直到第i位往大于等于k的方向走，此时提取出每个大于等于k的存在的L，更新每个合法区间的最短即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 3e6+10;
int a[maxn], s[maxn];

int tot=1, tree[maxn][2], mx[maxn];
void init(){
	tot = 1;
	tree[1][0] = tree[1][1] = 0;
	mx[1] = -1;
}
void insert(int x, int l){ //插入节点
	int u=1;
	for(int i = 30; i >= 0; i--){
		int c1=(x>>i)&1;   //取出每一位
		if(!tree[u][c1]){  //新建节点
			tree[u][c1] = ++tot;
			tree[tot][0] = tree[tot][1] = 0;
			mx[tot] = -1;
		}
		u = tree[u][c1];
		mx[u] = max(mx[u], l);//维护到u为止最靠右的左端点
	}
}
int query(int x, int k){//查找对于给定r且满足sum[l,r]>=k的最大l
	int u = 1, tmpl = -1;
	for(int i = 30; i >= 0; i--){
		int c1=(x>>i)&1, c2=(k>>i)&1;
		if(c2==1)u = tree[u][c1^1];//因为必须大于等于k，k==1，所以树里的L走与R相反的，异或后等于1。
		else{
			if(tree[u][c1^1]){//k为0，如果异或后==1存在，那么更新该答案（更新后继续走相等的分支去统计其他答案）
				tmpl = max(tmpl, mx[tree[u][c1^1]]);
			}
			u = tree[u][c1];//否则继续按照和k相等的路走下去
		}
	}
	if(u)tmpl = max(tmpl, mx[u]);
	return tmpl;
}

int main(){
	//freopen("input.txt","r",stdin);
	ios::sync_with_stdio(false);
	int T;  cin>>T;
	while(T--){
		init();
		int n, k;  cin>>n>>k;
		int ansl=-1, ansr=n;
		for(int i = 1; i <= n; i++){
			cin>>a[i];  a[i] ^= a[i-1];
			int tmpl = query(a[i], k);
			if(tmpl>=0 &&i-tmpl<ansr-ansl)ansl=tmpl,ansr=i;
			insert(a[i], i);
		}
		if(ansl >= 0)cout<<ansl+1<<" "<<ansr<<"\\n";
		else cout<<"-1\\n";
	}
	return 0;
}

1009 KD-Graph

题意：

• 给出一张n个点m条边的加权无向图和一个整数K，求一个数字D可以将图分为K组，组内任意两点存在路径且小于等于D，组外不存在小于等于D的路径。不存在D输出-1。

思路：

• 将边按权值从小到大排序，每一阶段取出同权值的所有边，将这些边的端点用并查集两两合并，若某一阶段的全部边合并完，并查集数量为k，则当前阶段合并边的权值就是答案，否则输出-1。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 3e6+10;

struct Edge{int u,v,w;}e[maxn];
bool cmp(Edge a, Edge b){return a.w<b.w;}

int fa[maxn+10];
void init(int n){for(int i = 0; i <= n; i++)fa[i]=i;}
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
void merge(int x, int y){x=find(x);y=find(y);if(x!=y)fa[x]=y;}
int count(int n){int cnt=0; for(int i = 1; i <= n; i++)if(fa[i]==i)cnt++;return cnt;}

int main(){
	ios::sync_with_stdio(false);
	int T;  cin>>T;
	while(T--){
		int n, m, k;  cin>>n>>m>>k;
		for(int i = 1; i <= m; i++)
			cin>>e[i].u>>e[i].v>>e[i].w;
		init(n);
		sort(e+1,e+m+1,cmp);
		int now = n, ans = 0, ok = 0; //now表示刚开始有n组（当前并查集个数）
		for(int i = 1; i <= m; i++){
			if(e[i].w != e[i-1].w){
				if(now==k){//直到分成k组，此时的最大ans满足组外不存在小于等于它的路径
					cout<<ans<<"\\n";
					ok = 1;
					break;
				}
			}
			//如果两点间已经有更小的路径就不管
			if(find(e[i].u)==find(e[i].v))continue;
			//用这条边去合并，将合并的点放入同一组
			merge(e[i].u, e[i].v);
			now--;//组数-1(并查集个数-1)
			ans = e[i].w; //组内<=D（不断变大）
		}
		if(ok==0)cout<<(now==k?ans:-1)<<"\\n";
	}
	return 0;
}