2020 CCPC 威海站

最新推荐文章于 2024-05-16 12:51:38 发布
最新推荐文章于 2024-05-16 12:51:38 发布
阅读量701 收藏 1
点赞数 1
分类专栏： 思维 数论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43308078/article/details/109393949
版权

A.Golden Spirit

思路：
首先可知移动老人共需要4nt时间，讨论中间等待时间。
先在2nt时间内移动老人，使位置发生交换，
此时回到初始的位置，设为左侧。

(1).
若左侧的第一个老人已经休息完毕，则可知右边的第一个也休息完毕，用2t时间移动回这两个老人并回到左侧，由于同侧的老人移动时间相差2t，此时左侧的第二个也可移动，故总时间为4nt。
(2)
若左侧的第一个老人在休息中，右边的第一个老人休息完毕，此时可以先移动到右侧移动老人或者在左侧等待第一个老人休息完毕再移动，总时间为4nt+min(t, 2t+x-2n*t)
(3)
若左右侧的第一个老人都在休息中，讨论同(2)类似。

注意：各个移动的变量之间的差值分类讨论并取最小值

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long ll;

int main(){
	ll n,x,t;
	int T; scanf("%d",&T);
	while(T--){
		scanf("%lld%lld%lld",&n,&x,&t);
		if(2*n*t>=2*t+x) printf("%lld\n",4*n*t);
		else if(2*n*t>=t+x) printf("%lld\n",min(4*n*t+2*t+x-2*n*t,4*n*t+t) );
		else printf("%lld\n",min(4*n*t+max(t, (t+x-2*n*t)), 4*n*t+(2*t+x-2*n*t)));
	}
}

H.Message Bomb

思路：
差分+数据结构

首先朴素算法：
对于每一个学生,O(m)
遍历所有事件,O(s)
其中，每次退出一个讨论组则找到其加入时的时刻，统计区间内信息的条数，对每个group维护，O(1).

优化算法：
遍历所有事件，O(s)
若有一个学生i加入一个讨论组j，则对其接收消息数预先-sum[j],
若有一个学生i退出一个讨论组j，则对其接收消息数+sum[j]。从而实现区间内讨论组信息数的累积
若有一个学生i在讨论组j发言，则其接收消息数-1，讨论组j的消息数+1.

注意：由于最后存在学生未退出讨论组，需将未退出的讨论组退出并统计接收消息数，使用set数据结构存储 。

#include<cstdio>
#include<cmath> 
#include<set>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long ll;
const int maxn=2e5+10;

int sum[maxn];
int res[maxn];

set<int> S[maxn];

int main(){
	int n,m,s; scanf("%d%d%d",&n,&m,&s);
	int op,x,y;
	for(int i=1;i<=s;i++){
		scanf("%d%d%d",&op,&x,&y);
		if(op==1){
			res[x]-=sum[y];
			S[x].insert(y);
		}else if(op==2){
			res[x]+=sum[y];
			S[x].erase(y);
		}else{
			res[x]--;
			sum[y]++;
		}
	}
	set<int>::iterator iter;
	for(int i=1;i<=m;i++){
		
		for(iter=S[i].begin();iter!=S[i].end();iter++){
			res[i]+=sum[*iter];
		}
		printf("%d\n",res[i]);
	}
}

D.ABC Conjecture

D.题意 定义一种运算，rad(n)=n的质因子的乘积。问给出一个数c（c<=1e18）是否存在c=a+b且rad(abc)<c.

首先对c质因子分解，容易证明：
若所有因子的幂次小于等于1,则无论如何分解rad(abc)>=rad©>=c；
而对于其中幂次大于1的因子，总可以将其分解为几个素因子幂次的和，
且分解得因子的乘积小于被分解因子，将其分给a、b,其余因子不变，
可以证明rad(abc)<c。因此问题转换为求c是否有因子的幂>1,此处为本题关键

由于c范围极大（<=1e18），不能对其质因子分解。
参考网上的思路，合法的c可写作c=(y^2)*z，首先对1e6以内的素因子遍历，
判断是否存在p^2为c的因子，若是则输出“yes”,否则c除以1e6以内的因子。
剩余的c无小于1e6的因子，有两种情况，
(1)c=1此时无法继续分解,即无p^2为因子。
(2)c>1e6，此时若c包含某一因子的平方，该因子必然大于1e6,c必然大于1e12,
其除以该因子的平方后必然为1，符合则输出yes；
若不包含则为一个素因子,不存在质因子的幂次>1。

#include<cstdio>
#include<cstring>
#include<cmath> 
#include<set>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long ll;
const int maxn=1e6+10;

bool is_prime[maxn];
int prime[maxn];
int cnt=0;

int func(int N){
	memset(is_prime,true,sizeof(is_prime));
	is_prime[1]=false;
	
	for(int i=1;i<=N;i++){
		if(is_prime[i]) prime[++cnt]=i;
		for(int j=1;j<=cnt&&i*prime[j]<=N;j++){
			is_prime[i*prime[j]]=false;
			if(i%prime[j]==0) break;
		}
	}
} 

int main(){
	func(1000000);
	
	int T; scanf("%d",&T);
	ll x;
	while(T--){
		scanf("%lld",&x);
		
		bool flag=false;
		for(int i=1;i<=cnt&&prime[i]<=x&&!flag;i++){
//			printf("x=%lld, prime=%d\n",x,prime[i]);
			if(x%prime[i]==0){
				x/=prime[i];
				if(x%prime[i]==0){
					flag=true;
					break;
				}
			}
		}
		if(!flag&&x>1000000000000){
			ll y=sqrt(x);
			if(y*y==x) flag=true;
		}
		
		if(flag) printf("yes\n");
		else printf("no\n");
	}
}

L.Clock Master

(多重背包、分组背包)
题意：
对于n个指针t1~tn代表每个指针的齿轮数及价格，
每经过一周期，各个齿轮转动一齿，
经过k个周期后的指针指向（k%t1,t%t2,…,k%tn）.
问限定总共b元，如何构造多个齿轮，使不同指向的组合数最多？

由于(0,0,…,0)开始到(0,0,…,0)为一个完整周期，
则总数为lcm(t1,t2,…,tn),即求如何将b分解为多个数的和且lcm最大。

考虑分解后的两个数ti和tj，若两者有公共质因子p，
则在求lcm时仅有含p的幂最大的数对lcm有贡献，另一个数的p无贡献且占用b。
因此ti之间两两互素最优，即分解为多个质因子幂次的和。

因此按质因子分组，每一组内为质因子pi的幂次，进行多重(分组)背包dp.
由于数据范围b<=3e4，范围内的质因子及其幂次总数小，可直接朴素dp.

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;



const int maxn=3e4+10;

bool is_prime[maxn];
int prime[maxn];
int cnt=0; 

double ln[maxn];
double dp[maxn];

void func(int N){
	memset(is_prime,true,sizeof(is_prime));
	is_prime[1]=false;
	
	for(int i=2;i<=N;i++){
		if(is_prime[i]) prime[++cnt]=i;
		for(int j=1;j<=cnt&&i*prime[j]<=N;j++){
			is_prime[i*prime[j]]=false;
			if(i%prime[j]==0) break;
		}
	}
	printf("cnt: %d\n",cnt);
}

void init(int N){
	for(int i=1;i<=N;i++) ln[i]=log(i);
	 
	for(int i=1;i<=cnt;i++){
		for(int j=N;j>=1;j--){
			for(int k=prime[i];k<=j;k*=prime[i]){
				dp[j]=max(dp[j], dp[j-k]+ln[k]);
			}
		}
	}
}

int main(){
	func(30000);
	init(30000);
	int T,n; scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		printf("%.7lf\n",dp[n]);
	}
}

G.Gaesar Cipher(字符串哈希+线段树)

题意：给出一个数组，每个元素不超过65536，
有两种操作:
op1,x,y: 将区间[x,y]所有元素+1，大于65536则对其取模
op2,x,y,l:比较区间[x,x+l-1]和[y,y+l-1]区间内元素是否相同。

思路：
(1)首先看到比较区间内的元素是否相同，即类似字符串匹配，
由于数组长度大，考虑字符串哈希。
(2)对于数组中的元素区间+1的操作，相当于区间子串的哈希值加上sum{base^i|0<=i<(x-y+1)},可用前缀和维护。
区间操作考虑线段树。
而哈希值正好具有可加性(!)，即sum[l:r]=sum[l:mid]*base^(r-mid+1)+sum[mid+1:r],
可使用线段树维护。
(3)查询一个子串的哈希值，注意两部分哈希值相加左半部分需要乘一个base的幂次。

最后考虑如何处理区间内元素溢出即大于65536：
使用一个线段树维护区间内的最大值，若最大值小于65536则不操作；否则递归查询左右区间并修改大于65536的元素，并更新线段树内维护的值。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long ll;
const int Mod=1e9+7;
const int base=13331;
const int maxn=5e5+10;

ll p[maxn], pre[maxn];
int a[maxn];

void init(int N){
	p[1]=pre[1]=1;
	for(int i=2;i<=N;i++) p[i]=p[i-1]*base%Mod, pre[i]=pre[i-1]+p[i];
}

ll sum[maxn<<2],lazy[maxn<<2];
int tree_max[maxn<<2]; 


void pushup(int rt, int l, int mid, int r){
	sum[rt]= (sum[rt<<1]*p[r-mid+1]%Mod+sum[rt<<1|1])%Mod;
	tree_max[rt]=max(tree_max[rt<<1], tree_max[rt<<1|1]);
}
void build(int rt, int l, int r){
	if(l==r){
		sum[rt]=a[l];
		tree_max[rt]=a[l];
		return;
	}
	int mid=(l+r)/2;
	build(rt<<1,l,mid);
	build(rt<<1|1,mid+1,r);
	pushup(rt,l,mid,r);
}

void pushdown(int rt,int l, int mid, int r){
	sum[rt<<1]=(sum[rt<<1]+lazy[rt]*pre[mid-l+1]%Mod)%Mod;
	sum[rt<<1|1]=(sum[rt<<1|1]+lazy[rt]*pre[r-mid]%Mod)%Mod;
	
	tree_max[rt<<1]+=lazy[rt]; tree_max[rt<<1|1]+=lazy[rt];
	lazy[rt<<1]+=lazy[rt]; lazy[rt<<1|1]+=lazy[rt];
	
	lazy[rt]=0;
}

void update(int rt, int l, int r, int L, int R){
//	[l,r]为目标修改区间,[L,R]为当前结点对应区间 
	if(l>R||r<L) return;
	if(L>=l&&R<=r){
		sum[rt]=(sum[rt]+pre[R-L+1])%Mod;
		tree_max[rt]++;
		lazy[rt]++;
		return;
	}
	int Mid=(L+R)/2;
	if(lazy[rt]) pushdown(rt,L,Mid,R);
	update(rt<<1, l, r, L, Mid);
	update(rt<<1|1, l, r, Mid+1, R);
	pushup(rt,L,Mid,R);
}

ll query(int rt, int l, int r, int L, int R){
	if(l>R||r<L) return 0;
	if(l<=L&&R<=r){
		return sum[rt];
	} 
	int Mid=(L+R)/2; ll res=0;
	if(lazy[rt]) pushdown(rt, L, Mid, R);
	if(l<=Mid) res+=query(rt<<1,l,r,L,Mid);
	if(r>Mid) res=(res*p[min(r,R)-Mid+1]%Mod+query(rt<<1|1,l,r,Mid+1,R))%Mod;
	pushup(rt,L,Mid,R);
	return res;
	
}

void modify(int rt, int l, int r, int L, int R){
	if(tree_max[rt]<65536||l>R||r<L) return;
	if(L==R&&tree_max[rt]>=base){
		sum[rt]=tree_max[rt]=(tree_max[rt]%65536);
		return;
	}
	
	int Mid=(L+R)/2;
	pushdown(rt,L,Mid,R);
	
	modify(rt<<1,l,r,L,Mid);
	modify(rt<<1|1,l,r,Mid+1,R);
	pushup(rt,L,Mid,R);
}

int main(){
	init(500000);
	
	int n,q,op,x,y,l; scanf("%d%d",&n,&q);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	
	build(1,1,n);
//	printf("sum=%d\n",sum[1]);
	
	while(q--){
		scanf("%d",&op);
		if(op==1){
			scanf("%d%d",&x,&y);
			update(1,x,y,1,n); 
			
			if(tree_max[1]>=65536) modify(1,x,y,1,n);
		}else if(op==2){
			scanf("%d%d%d",&x,&y,&l);
			ll q1=query(1,x,x+l-1,1,n), q2=query(1,y,y+l-1,1,n);
//			printf("q1=%d, q2=%d\n",q1,q2);
			if(q1==q2) printf("yes\n");
			else printf("no\n");
		}
	}
}

C.Rencontre

(注意乘积溢出问题)
思路：
首先突破点在于分析3个hotel的位置关系，
讨论不同情况得出期望距离为0.5*(dis[v1][v2]+dis[v1][v3]+dis[v2][v3])
即求上式的期望。
可拆分为求0.5*sum{E(dis[vi][vj])|1<=i,j<=3且i!=j}

因此转换为，求树上两个点集内的点、两两之间的距离，
考虑每条边对于距离dis[vi][vj]总和的贡献为：
（该边一端vi的个数×另一端vj的个数+一端vj个数×另一端vi的个数）×e.w
最终E(dis[vi][vj])=sum{dis[vi][vj]}/(cnt[vi]*cnt[vj])

使用树形dp两次dfs即可解决。

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long ll;
const int maxn=2e5+10;
struct Edge{
	int to,nxt,w;
};
int head[maxn];
struct Edge edge[maxn<<1];
int cnt=1;
ll dis[5][5];

int k[5];
bool hotel[maxn][5];
int fa[maxn];


int dp[maxn][5];

void add(int u, int v, int w){
	edge[cnt].to=v; edge[cnt].nxt=head[u]; edge[cnt].w=w; head[u]=cnt++;
}

void dfs1(int u){
	for(int i=1;i<=3;i++){
		if(hotel[u][i]) dp[u][i]++;
	}
	for(int i=head[u];i;i=edge[i].nxt){
		struct Edge& e=edge[i];
		if(e.to==fa[u]) continue;
		fa[e.to]=u; dfs1(e.to);
		for(int j=1;j<=3;j++) dp[u][j]+=dp[e.to][j];
	}
}

void dfs2(int u){
	for(int i=head[u];i;i=edge[i].nxt){
		struct Edge &e=edge[i];
		if(e.to==fa[u]) continue;
		for(int j=1;j<3;j++){
			for(int l=j+1;l<=3;l++){
//			i号边的一端关于第j个点集，有dp[e.to][j]个点，则另一端有k[j]-dp[e.to][j]个点 
				dis[j][l]+=1LL*(k[j]-dp[e.to][j])*dp[e.to][l]*e.w + 1LL*(k[l]-dp[e.to][l])*dp[e.to][j]*e.w;
//				dis[j][l]+=1LL*(k[j]-dp[e.to][j])*dp[e.to][l]*e.w;
			}
		}
		dfs2(e.to);
	}
}
int main(){
	double res=0;
	int n,x,u,v,w; scanf("%d",&n);
	for(int i=1;i<n;i++){
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w); add(v,u,w);
	}
	memset(hotel,false,sizeof(hotel));
	memset(fa,0,sizeof(fa));
	
	for(int i=1;i<=3;i++){
		scanf("%d",&k[i]);
		for(int j=1;j<=k[i];j++){
			scanf("%d",&x);
			hotel[x][i]=true;
		}
	}
	
	dfs1(1);
	dfs2(1);
	for(int i=1;i<3;i++){
		for(int j=i+1;j<=3;j++){
			res+=1.0*dis[i][j]/(2.0*k[i]*k[j]); // sum{0.5*dis[i][j]|1<=i,j<=3且i!=j}
		}
	}
	
	printf("%.7f\n",res);
}
Psycho_w
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2018ccpc吉林站Wannflyak代码
09-24
【标题】"2018ccpc吉林站Wannflyak代码"涉及到的是2018年中国大学生程序设计竞赛（CCPC）吉林站的比赛，其中"Wannflyak"可能指的是参赛队伍名，尤其是那些成功解决所有问题的队伍，通常在编程竞赛中，"ak"代表全解...
2020CCPC河南省赛正式赛答案（官方版）.pdf
08-24
2020年河南省CCPC大赛是ACM竞赛的一个区域赛事，其答案提供了参赛队伍解题思路和算法解析。 1. **班委竞选**：这是一个关于最大票数的问题。题目中提到，需要从小到大枚举学号，如果当前学号的票数超过当前类别的...
2020CCPC威海站部分题解
Irving0323的博客
11-04 1047
2020CCPC威海站
2020CCPC威海 J - Steins；Game (sg函数、线性基)
moyangxian
08-06 470
题意：n堆石子，每堆石子有黑和白两种颜色，拿黑色堆石子的时候必须拿数量最少的（最少一个），白色没有限制可以任意拿（最少一个）。后手的人可以在游戏开始之前对所有石子堆染色，问后手能赢的染色方案数。 题解：首先可以将黑色和白色分成两个游戏，两个游戏的异或和为0即后手胜利。 白色游戏：相当于nim游戏 黑色游戏：通过sg打表能发现 SG值 = 最小堆石子数 − ( ( 最小堆数量 + [ 所有堆石子数相同 ] ) % 2 ) 能发现sg值只跟最小堆有关系，然后我们可以枚举最小堆。用一个pre维护异或前缀和，suf
2024CCPC郑州邀请赛暨河南省赛（A,B,C,D,F,G,H,J,K,L,M）
qq_45809243的博客
05-16 1267
2024CCPC郑州邀请赛暨河南省赛（A,B,C,D,F,G,H,J,K,L,M）
2020CCPC威海站(部分)
m0_50623076的博客
10-28 1453
目录 A Golden Spirit 思路： 代码： D ABC Conjecture 思路： 代码： H Message Bomb 思路： 代码： L Clock Master 思路： 代码： A Golden Spirit 思路： 两岸各n个老人，都想去对岸并且休息x分钟。你每次可以带一个老人过桥需要t分钟。问需要最少需要多长时间完成并且接老人回来。 分析：每次带一个老人，假设从左边开始，第一个休息的老人在右边，你最终肯定在左边。接送老人共需要2(往返)*2*n.
2020 ccpc 威海站（打铁感想）
yangzijiangac的博客
11-05 480
据离威海打铁已经过去一个多星期了，打铁带来的冲击感，目前才缓和了些许，但是回想起来，依然很难受。打铁后，整个人都不怎么自信了，心里生出过不想再打的念头，但是又有很多很多不甘，加入 ACM 工作室两年多了，打了两年多，今年疫情原因，形式不是很好，可能就这一场就结束整个 ACM 生涯了，我们又偏偏打了铁，内心极度的难受。 对于我们队的实力，虽然说打铜有点难，但又不是完全没有可能，要我说，我们队有%606060~%707070的可能性拿到铜牌。 比赛开始时，我们队是很顺利，率先一A掉 H题，然后当时过的人还是很少
2020 CCPC 威海 - A. Golden Spirit(思维)，D. ABC Conjecture(大数分解 / 思维)
Mr_dimple的博客
07-03 364
题意 一道河上有座桥，两岸分别有 nnn 个人。 现这 2n2n2n 个人都要到对岸去，游玩至少 xxx 分钟后回到原来的河岸。 要帮助这 2n2n2n 个人渡河。 每次渡河最多带一个人，时间为 ttt。 问，满足所有人的要求最少花多少时间？思路 在最理想的情况下，帮助者没有一点时间浪费，当他把所有人都运到其对应对岸后，立即可以将该河岸首次运过来的人运回去。 但是可能甚至首次运过来的人都没有到所需的游玩时间，所以帮助者可能需要等待。假设有河岸 A 和 B，起初帮助者在河岸 A，那么将所有人分别运到其对应河岸
2020CCPC河南省赛正式赛.pdf
08-24
2020年河南省CCPC大赛属于ACM竞赛的区域赛事，这类比赛通常包含多道编程题目，参赛队伍需要在限定时间内编写程序解决这些问题。 【Problem A - 班委竞选】是一道基于数据处理和排序的问题。题目要求根据学生的学号...
2020CCPC网络赛题解.pdf
07-12
2020CCPC网络赛题解
2020CCPC(威海) - Clock Master(数论+分组背包)
Falcon的博客
10-26 2687
题目大意：给出一个数字 n ，要求分解成：a[ 0 ] + a[ 1 ] + ... + a[ m ] = n，( m 没有约束 )，使得 lcm( a[ 0 ] , a[ 1 ] , ... a[ m ] ) 最大，输出这个最大值的对数 题目分析：看到 lcm 就可以去思考如何快速求出 n 个数的 lcm，比较简单的一种方法就是将每个数进行质因子分解，对于每个质因子 p 来说，取 n 个数中 p^k[ i ] 的最大值，就是质因子 p 的贡献了，所有质因子的贡献的乘积就是需要求的 lcm 所以这...
CCPC2020 威海C 树形dp
jkchen's Haven
10-25 2688
C Rencontre
2020CCPC（威海）
qq_38604065的博客
10-24 1497
奥里给
2020ccpc威海部分题解
代码笔记本
10-29 938
2020ccpc威海 A Golden Spirit(思维) 2020ccpc威海B Labyrinth(思维+bfs扣关键点最短路) 2020ccpc威海C Rencontre(树上各块中任意两点距离之和) 2020ccpc威海D题 ABC Conjecture(规律+pollard_rho大数质因数分解模板) 2020ccpc威海 H Message Bomb(思维+模拟) 2020ccpc 威海 Clock Master(多个数的lcm+分组背包) ...
备战ccpc分站赛：秦皇岛和威海站（数论模块和dp模块）
zeng_jun_yv的博客
10-05 492
挑战程序设计竞赛（第2版）练习题 1 . 记录结果再利用的“动态规划” 基础的动态规划算法： POJ 3176 POJ 2229 POJ 2385 POJ 3616 POJ 3280 优化递推关系式： POJ 1742 POJ 3046 POJ 3181 需要稍加思考的题目： POJ 1065 POJ 1631 POJ 3666 POJ 2392 POJ 2184 2. 数学问题的解题窍门 辗转相除法： Aizu 0005 POJ 2429 POJ 1930 素数： Aizu 0009 POJ 3126 P
2020 CCPC 威海（赛后重现）
bleak_dream的博客
02-10 566
文章目录比赛分析比赛题目部分题目思路及代码A题：老头过桥D题：ABC ConjectureB题：LabyrinthH题：Message Bomb 比赛分析 出题人的想法：（给一个链接自己看去） 本博主的看法（以下的就都是俺的想法了）：属于是为了签到签完而努力着！我们属于是赛后重现赛，自己拉一场打的。一场比赛就过两道题。哎～～。分析一下整场比赛（下面有部分题的分析）：牌线6/5/4，还在打铁的路上啊！什么时候能进入铜器时代呢？看了一下大佬们的过题时间，签到都挺快……大致上以B题、G题作为一个分界线。B题我.
2020ccpc威海D题 ABC Conjecture(规律+pollard_rho大数质因数分解模板)
代码笔记本
10-27 768
思路1：打表可得如果有两个以及以上的相同质因数，即可yes； /*来自：李双智学长模板*/ #include<iostream> #include<cmath> #include<cstring> #include<algorithm> #include<cstdio> #include<map> #include<stdlib.h> #include<time.h> #define times 20 us.
CCPC威海站
行走天涯的豆沙包的博客
10-27 560
这场整场都很迷，先是A题贡献6发罚时，然后L题读错题近1个小时。如果L题能读对的话说不定能节约很多时间想出分组背包，那么就可以解决时间给ar去过C题，说不定可以6题可以银的硬生生变成了铜尾。 L题解： 我们需要让分解出来的lcm最大那么就是一些互质的数或者是他们的次数幂，所以每一个幂次可以看成一组背包，那么我们就可以用分组背包。因为相同底数多选的话lcm就是计算最高的那个幂次，所以就是选不选，选的话就只选一组中的一个的分组背包问题。需要预处理log不然回T。 #include<bits/stdc++.
2020年，ICPC比赛、CCPC比赛、CCF-CSP考试、蓝桥杯比赛、天梯赛日程
热门推荐
海岛Blog
12-20 2万+
CCF-CSP考试日程： 第19次 6月28日（部分高校） 第20次 9月13日 第21次 12月13日 CCSP比赛： CCSP区域赛、总决赛 2020年10月17日 各个分赛场进行，赛点参赛人数30人以上 ICPC比赛日程： 银川 宁夏理工学院 11月中旬 北京 西北工业大学（牛客，邀请赛）11月21-22日 南京 南京航空航天大学 11月28-29日 沈阳 东北大学 12月5-6日 上海 上海大学 12月12-13日 昆明 昆明理工大学 12月19-20日 济南 齐鲁工业大学 12月26-27日 西杰
2024 长春 ccpc
最新发布
05-26
2024年的长春ACM程序设计竞赛（CCPC）是一个由ACM国际大学生程序设计竞赛组织（ICPC）认证的区域性比赛。该比赛通常会在10月或11月份举行，为期两天，参赛队伍来自于全球各地的大学和研究生院。比赛包括多个题目，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值