梦熊联盟1月普及组月赛游记

已于 2023-01-30 22:14:30 修改
阅读量410 收藏
点赞数 1
分类专栏： 比赛 文章标签： c++
于 2023-01-15 21:39:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73113801/article/details/128697679
版权

T1

给定 a 1 − n a_{1-n} a1−n​ 和 m m m , 要求 i ∗ p ∗ a i ≥ m i*p *a_i\ge m i∗p∗ai​≥m 且 i ∗ p ∗ ( a i − 1 ) < m i*p*(a_i-1)<m i∗p∗(ai​−1)<m 求整数 p p p 的可能个数

#include <bits/stdc++.h>
using namespace std;
const double inf = 1e18;
int n, m, cnt, a;
double l, r=inf;
int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++)
    {
        cin >> a;
        l = max( l, 1.0*m/(a*i) );
		if(a[i] != 1) 
			r = min( r, 1.0*m/((a-1)*i) );
    }
    if(r==inf) {puts("xiaogougege"); return 0;}
    int cnt = 0;
	for(int i=ceil(l);i<r;i++) cnt++;
    cout << cnt;
}

T2

给定序列 a n a_n an​ , 现有两个操作 :

  1. 删除 x x x , x x x 没有则输出 − 1 -1 −1 跳过
  2. 加入 x x x

对于每个操作 , 输出 ∣ a 1 − a 2 ∣ + ∣ a 2 − a 3 ∣ + . . . ∣ a n − a 1 ∣ |a_1-a_2|+|a_2-a_3|+...|a_n-a_1| ∣a1​−a2​∣+∣a2​−a3​∣+...∣an​−a1​∣ 的最小值

考虑 ∣ a 1 − a 2 ∣ + ∣ a 2 − a 3 ∣ + . . . ∣ a n − a 1 ∣ |a_1-a_2|+|a_2-a_3|+...|a_n-a_1| ∣a1​−a2​∣+∣a2​−a3​∣+...∣an​−a1​∣ 的几何意义 , 那么答案为 2 ∗ ( m a x ( a n ) − m i n ( a n ) ) 2*(max(a_n)-min(a_n)) 2∗(max(an​)−min(an​))

那么只有影响到最大最小值的操作才会影响答案 , 由于删除操作我们还需要维护次大次小值 , 考虑使用堆

数据较水 , 接近暴力的算法也能过

赛时代码 :

#include <iostream>
using namespace std;
const int MAXN = 1e6+5;
int n,q,mn=1e9,mx=-1,vis[MAXN];
int main()
{
    std::ios::sync_with_stdio(false);std::cin.tie(0);
    cin >> n >> q;
    for(int i=1;i<=n;i++)
    {
        int x; cin >> x; vis[x]++;
        mx = max(mx, x); mn = min(mn, x);
    }
    while(q--)
    {
        int opt,x;
        cin >> opt >> x;
        if(opt == 1)
        {
            if(!vis[x]) cout<<-1<<endl;
            else
            {
                vis[x]--;
                if(x == mx)
                    for(int i=mx;i>=mn;i--)
                        if(vis[i]) {mx = i; break;}
                if(x == mn)
                    for(int i=mn;i<=mx;i++)
                        if(vis[i]) {mn = i; break;}
                cout << 2*(mx-mn) << endl;
            }
        }
        if(opt==2)
        {
            vis[x]++;
            mn = min(mn, x); mx = max(mx, x);
            cout << 2*(mx-mn) << endl;
        }
    }
}

正解 (堆) :

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e6+5;
priority_queue <int> q1,q2; 
int n, q, vis[MAXN];
int main()
{
	cin >> n >> q;
	for(int i=1;i<=n;i++)
	{
		int x; cin >> x; vis[x] ++ ;
		q1.push(x); q2.push(-x);
	}
	while(q--)
	{
		int opt, x;
		cin >> opt >> x;
        if(opt == 1)
        {
            if(!vis[x]) cout<<-1<<endl;
            else
            {
                vis[x]--;
                while(!vis[q1.top()]) q1.pop();
                while(!vis[-q2.top()]) q2.pop();
                cout << 2*(q1.top()+q2.top()) << endl;
            }
        }
        if(opt==2)
        {
            vis[x]++;
            q1.push(x); q2.push(-x);
            cout << 2*(q1.top()+q2.top()) << endl;
        }
	}
	return 0;
}

T3

给定 a n a_n an​ 你可以花费 r − l + 1 + k r-l+1+k r−l+1+k 将区间 [ l , r ] [l,r] [l,r] 变为 g c d ( a l , a l + 1 . . . . , a r ) gcd(a_l,a_{l+1}....,a_r) gcd(al​,al+1​....,ar​) , 求将序列变相同的最小花费

容易想出最终的答案数列一定都为 G = g c d ( a 1 , a 2 . . . . a n ) G=gcd(a_1,a_2....a_n) G=gcd(a1​,a2​....an​)

我们令 f i f_i fi​ 表示将 a 1 − a i a_1-a_i a1​−ai​ 变成 G G G 的最小代价 , 那么有 f i = m i n { f j + i − j + k } ( 0 ≤ j < i ) f_i=min\lbrace f_j+i-j+k \rbrace(0\le j< i) fi​=min{fj​+i−j+k}(0≤j<i) ( 将 [ j + 1 , i ] [j+1,i] [j+1,i] 操作变为 G G G )

可以写出一个 O ( n 3 ) O(n^3) O(n3) 的朴素dp , 可以拿到 40 p t s 40pts 40pts

#include<bits/stdc++.h>
using namespace std;
const int MAXN=4e6+5;
const int inf = 1e9;
int n, k, a[MAXN], f[MAXN];
int calc(int l,int r)
{
	int res = a[l];
	for(int i=l+1;i<=r;i++) res = __gcd(res, a[i]);
	return res;
}
int main()
{
	cin >> n >> k;
	for(int i=1;i<=n;i++)  cin >> a[i];
 	int G = calc(1,n);
	for(int i=1;i<=n;i++)  f[i] = inf;
	for(int i=1;i<=n;i++)
	{
		if(a[i] == G) f[i] = f[i-1];
		for(int j=0;j<i;j++)
		{
			if(calc(j+1,i)==G)
				f[i] = min(f[i], f[j]+i-j+k);	
		}
	} 
	cout << f[n] <<endl;
	return 0;
}

在 n ≤ 1000 n\le 1000 n≤1000 时 , 我们可以 O ( n 2 ) O(n^2) O(n2) 预处理出 g c d ( a i . . . . a j ) gcd(a_i....a_j) gcd(ai​....aj​) , 可以拿到 60 p t s 60pts 60pts

for(int i=1;i<=n;i++)
{
	g[i][i] = a[i];
	for(int j=i+1;j<=n;j++)
	{
		g[i][j] = __gcd(g[i][j-1], a[j]);
	}
}
正解 :

每个数至多变一次 . 我们将数列划分成若干个连续为 G G G 的区间以及若干个其他区间 .

. . . . . . G G . . . . . . . . G G G G . . . . . . . . . . G G G . . . . . ......GG. .......GGGG..........GGG..... ......GG........GGGG..........GGG.....
[ 1 ] [   2   ] [ 3 ] [   4   ] [\enspace1\enspace]\quad[\enspace\space2\enspace\space]\qquad\quad[\quad3\quad]\quad\quad[\space4\space] [1][ 2 ][3][ 4 ]

记 f i f_i fi​ 为前 i i i 个其他区间变为 G G G 的最小花费

对于第 i i i 个区间 , 可选择将其变为连续 G G G 区间 , 代价为 r i − l i + 1 + k + ( g c d ( a l i . . . a r i )   ! = G ) r_i-l_i+1+k+(gcd(a_{l_i}...a_{r_i})\space!=G) ri​−li​+1+k+(gcd(ali​​...ari​​) !=G) ( 是否需要借助前面的一个 G G G )

也可选择将第 j + 1 j+1 j+1 到 i i i 个区间合并 ( 0 ≤ j < i − 1 ) (0\le j<i-1) (0≤j<i−1) 合并 , j + 1 , i j+1,i j+1,i 间必定跨过一段连续 G G G 的区间 , 因此代价即为 r i − l j + 1 + 1 + k r_i-l_{j+1}+1+k ri​−lj+1​+1+k

f i = m i n { f i − 1 + r i − l i + 1 + k + ( g c d ( a l i . . . a r i )   ! = G ) f j + r i − l j + 1 + 1 + k ( 0 ≤ j < i − 1 ) f_i=min\begin{cases} \small f_{i-1}+r_i-l_i+1+k+(gcd(a_{l_i}...a_{r_i})\space!=G)\\ f_j+r_i-l_{j+1}+1+k(0\le j<i-1) \end{cases} fi​=min{fi−1​+ri​−li​+1+k+(gcd(ali​​...ari​​) !=G)fj​+ri​−lj+1​+1+k(0≤j<i−1)​

这样做仍然是 O ( n 2 ) O(n^2) O(n2) 的 , m i n ( f j + r i − l j + 1 + 1 + k ) = m i n ( f j − l j + 1 ) + r i + k + 1 min(f_j+r_i-l_{j+1}+1+k)=min(f_j-l_{j+1})+r_i+k+1 min(fj​+ri​−lj+1​+1+k)=min(fj​−lj+1​)+ri​+k+1 动态维护 m i n ( f j − l j + 1 ) min(f_j-l_{j+1}) min(fj​−lj+1​) 即可

AC 代码

#include<bits/stdc++.h>
using namespace std;
const int MAXN=4e6+5;
const int inf = 1e9;
int n, k, a[MAXN], f[MAXN], l[MAXN], r[MAXN], tot=1;
int calc(int l,int r)
{
	int res = a[l];
	for(int i=l+1;i<=r;i++) res = __gcd(res, a[i]);
	return res;
}
int main()
{
	std::ios::sync_with_stdio(false);std::cin.tie(0);
	cin >> n >> k;
	for(int i=1;i<=n;i++) cin >> a[i];
	int G = calc(1,n);
	for(int i=1;i<=n;i++)
	{
		if(a[i]!=G && l[tot]==0) l[tot] = i;
		if(a[i]==G && l[tot]) r[tot++] = i-1;
	}
	if(l[tot]) r[tot]=n; else tot--;
	int mn = inf;
	for(int i=1;i<=tot;i++)
	{
		f[i] = f[i-1]+r[i]-l[i]+1+k+(calc(l[i],r[i])!=G);
		f[i] = min(f[i], mn+r[i]+k+1);
		mn = min(mn, f[i-1]-l[i]);
	} 
	cout << f[tot] <<endl;
	return 0;
}

T4

给定 n , k , p n,k,p n,k,p 要求序列 a 1 − p a_{1-p} a1−p​ 满足 :

  1. 1 ≤ a i ≤ n 1\le a_i \le n 1≤ai​≤n
  2. a i ∧ a i + 1 a_i \land a_{i+1} ai​∧ai+1​ 二进制 1 1 1 的个数为 k k k
  3. a p a_p ap​ 中两两互不相同

考虑到限制较多 , 经过一些预处理 , 暴力的复杂度并不会特别高 , 可以拿到 72 72 72 分

赛时代码:

#include <iostream>
#include <vector>
using namespace std;
const int mod = 998244353;
int n, k, p, vis[1005];
vector <int> G[1005];
int dfs(int i, int lst)
{
    if(i==p+1) return 1;
    int res = 0 ;
    for(auto d : G[lst])
    {
        if(vis[d]) continue;
        vis[d] = 1;
        res += dfs(i+1,d), res%=mod;
        vis[d] = 0;
    }
    return res;
}
int main()
{
    cin >> n >> k >> p;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(__builtin_popcount(i^j)==k)
                G[i].push_back(j);
    if(p==1) {cout<<n<<endl;return 0;}
    int res = 0;
    for(int i=1;i<=n;i++)
    {
        vis[i] = 1;
        res += dfs(2,i), res%=mod;
        vis[i] = 0;
    }
    cout << res;
}
正解 :

令 c n t [ i ] cnt[i] cnt[i] 表示满足 p o p c o u n t ( i ∧ x ) = k popcount(i\land x)=k popcount(i∧x)=k 的 x x x 个数

p = 1 p=1 p=1

if(p==1) {cout<<n<<endl;return 0;}

p = 2 p=2 p=2

枚举第一位为 i i i , 第二位有 c n t [ i ] cnt[i] cnt[i] 种填法

if(p==2) 
{
	int res= 0; 
	for(int i=1;i<=n;i++)	
		res+= G[i].size();
	cout << res<< endl;
}

p = 3 p=3 p=3

枚举第二位为 i i i , 第一位可以填 c n t [ i ] cnt[i] cnt[i] 种 , 由于不重复 , 最后一位可以填 c n t [ i ] − 1 cnt[i]-1 cnt[i]−1 种

if(p==3) 
{
	int ans = 0; 
	for(int i=1;i<=n;i++)	
		ans += G[i].size() * (G[i].size()-1);
	cout << ans << endl;
}

p = 4 p=4 p=4

枚举中间两位 : 则其余两位应该有 ( c n t [ i ] − 1 ) ∗ ( c n t [ j ] − 1 ) (cnt[i]-1)*(cnt[j]-1) (cnt[i]−1)∗(cnt[j]−1) (不与 i , j i,j i,j 重复) , 但需要减去左右两位重复的情况.

可以使用 bitset统计重复个数 :

(B[i]&B[j]).count()表示满足 p o p c o u n t ( i ∧ x ) = k popcount(i\land x)=k popcount(i∧x)=k 且 p o p c o u n t ( j ∧ x ) = k popcount(j\land x)=k popcount(j∧x)=k 的 x x x 的个数

if(p==4)
{
	for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(__builtin_popcount(i^j)==k)
				B[i].set(j), B[j].set(i);
			
	int ans = 0;
	for(int i=1;i<=n;i++)
	{
		for(auto j : G[i])
		{
			ans += (G[i].size()-1) * (G[j].size()-1) - (B[i]&B[j]).count(), ans%=mod
		}
	}
	cout << ans << endl;
}

p = 5 p=5 p=5

枚举 2 , 4 2,4 2,4 位为 i , j i,j i,j , 则第 3 3 3 位有(B[i]&B[j]).count()种填法 , 则若满足 p o p c o u n t ( i ∧ x ) = k popcount(i\land x)=k popcount(i∧x)=k 的 x x x 中包含 j j j , 那么第 1 1 1 位应该为 c n t [ i ] − 2 cnt[i]-2 cnt[i]−2 种 , 否则有 c n t [ i ] − 1 cnt[i]-1 cnt[i]−1 种 , 用 bitset表示即为 c n t [ i ] − 1 − B [ i ] [ j ] cnt[i]-1-B[i][j] cnt[i]−1−B[i][j] , 同理第 5 5 5 位有 c n t [ j ] − 1 − B [ j ] [ i ] cnt[j]-1-B[j][i] cnt[j]−1−B[j][i] 种 . 最终减去 1 , 5 1,5 1,5 重复的情况 , 因为 已经排除 1 , 5 1,5 1,5 与 3 3 3 重复的情况 , 因此 − 1 -1 −1 即为: (B[i]&B[j]).count()-1

if(p==5)
{
	int ans = 0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			if(i==j) continue;
			int x = (B[i]&B[j]).count();
			ans += x*((G[i].size()-1-B[i][j])*(G[j].size()-1-B[j][i])-(x-1)), ans%=mod;
		}
	}
	cout << ans << endl;
}

AC 代码：

#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, k, p, ans;
vector <int> G[1005];
bitset <1005> B[1005];
int main()
{
    cin >> n >> k >> p;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(__builtin_popcount(i^j)==k)
				G[i].push_back(j),B[i].set(j), B[j].set(i);
			
    if(p==1) {cout<<n<<endl;}
    if(p==2) 
	{
		for(int i=1;i<=n;i++) ans += G[i].size();
		cout << ans << endl;
	}
	if(p==3) 
	{
		for(int i=1;i<=n;i++)	
			ans += G[i].size() * (G[i].size()-1);
		cout << ans << endl;
	}
	if(p==4)
	{
		for(int i=1;i<=n;i++)
			for(auto j : G[i])
				ans += (G[i].size()-1) * (G[j].size()-1) - (B[i]&B[j]).count(), ans%=mod;
		cout << ans << endl;
	}
	if(p==5)
	{
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				if(i==j) continue;
				int x = (B[i]&B[j]).count();
				ans += x*((G[i].size()-1-B[i][j])*(G[j].size()-1-B[j][i])-(x-1)), ans%=mod;
			}
		}
		cout << ans << endl;
	}
}

总结 : 这场比赛拿到 100 + 100 + 60 + 72 100+100+60+72 100+100+60+72 还是不难的 , 但本人考场经验太少 , 经常犯蠢 , 所以多打月赛 / 模拟赛

零衣贰
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
游记分享-色块组合-PPT模板.pptx
01-24
游记分享-色块组合-PPT模板.pptx
蓝桥2024B省赛游记qwq
04-13
qwq
2021-2022收藏资料满井游记 Microsoft Word 文档 (3).doc
09-26
2021年09月16日
梦里江南游记作文.doc
01-25
梦里江南游记作文.doc
2024年图灵科技新书预告，技术人的必备技能，藏在每一本书里
图灵教育
01-18 346
翻过2023这一页，我们迎来了2024年。在过去的一年里，我们都有各自的收获。图灵去年出版了100+图书，有紧跟时代前沿的《这就是ChatGPT》，还有250万人都觉得好用的Python入门经典《Python编程从入门到实践（第3版）》，更有帮助百万大学生解决高数烦恼的《高等数学（上册）精选750题》。这里的每一个选题都是策划老师对图灵读者需求的反馈，每一本书也都是他们的诚意之作。2024年我们依...
LGR-128】梦熊信奥联盟 1 月普及组月赛
Dreams_shy的博客
01-14 522
【LGR-128】梦熊信奥联盟 1 月普及组月赛题解。
NOIP2020（退役）游记
qq_45516669的博客
01-01 490
as
月光下的凤尾竹—彩云之南西双版纳游记
weixin_30300225的博客
07-25 928
一、写在游记之前 　　今天距离汶川大地震已整整10年，依然记得10年之前，我刚下完课走回寝室的路上，一瞬间脚下的地面开始震动，骚动的叫声此起彼伏。地震，就这么毫无征兆地来了，距离我那么近。幸运的是，我没有受伤。不幸的是，汶川的人民们受伤了，他们失去了家园，也失去了部分亲人。2008年512大地震，总计造成约45万人伤亡，近2万人失踪，是建国以来破坏力最大的地震，也是唐山大地震后伤亡最严重的一次地...
精述字符编码（读这篇就够了）
Dablelv 的博客专栏。
01-31 8666
UCS（Universal Character Set，通用字符集）是由ISO制定的。
小学数学数学故事数学童话北游记17拔河比赛
09-09
小学数学数学故事数学童话北游记17拔河比赛
「程序设计思维与实践」 CSP-M1：取模+模拟+dfs
QER 的博客
03-18 274
文章目录A - 咕咕东的奇遇题目描述inputOutputSample InputSample Output题解代码B - 咕咕东想吃饭题目描述inputOutputSample Input1Sample Output1Sample Input2Sample Output2题解代码C - 可怕的宇宙射线题目描述inputOutputSample InputSample Output题解代码 A -...
【数学式子推导】梦熊[csp-noip十连测第六套] T2 距离
BCNT_BuCai的博客
11-01 61
用前缀和处理后面一个 sigma 即可，即。
C++中的智能指针类别
GOLOJO的博客
05-31 892
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
C++：round函数用法
Solititude的博客
05-28 378
C++：round函数用法
c++ string模拟实现
最新发布
2302_81705247的博客
06-01 625
模拟实现string类，里面包含四个成员变量，第一个是指向字符数组的指针，第二个变量是目前存放了多少个字符，第三个变量为这个字符数组的容量的大小。最后一个为静态成员变量npos。注意：一个修饰的成员变量可以在类里面初始化（三者缺一不可），而其他成员变量，要声明定义分离，类中声明，类外定义。char* _str;
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 847
string类各函数接口。
CF Round 368 (Div. 2) C. Pythagorean Triples【数学 构造】
2301_80089588的博客
05-30 404
数学 构造
【C++】问题及补充（2）
2301_80207207的博客
05-30 879
vector和list都是C++ STL中的容器，它们被定义在不同的头文件中。vector在中定义，而list在中定义。因此，如果要使用它们，需要包含相应的头文件。通常情况下，C++中的类定义需要包含在头文件中，而类的实现则包含在源文件中。这样做的目的是为了避免在多个源文件中重复定义同一个类，从而引发编译错误。因此，在C++ STL中，vector和list的定义也需要写在头文件中，以便在需要使用它们的源文件中包含相应的头文件即可。
python爬取携程游记
09-13
关于使用 Python 爬取携程游记的问题，我可以为您提供一些指导。使用 Python 进行网页爬取一般需要使用第三方库或框架，比如 requests 和 BeautifulSoup。 首先，您需要安装这两个库。可以通过以下命令在终端或命令...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值