CCSU2023暑期结训测试赛

最新推荐文章于 2024-07-25 11:43:17 发布
最新推荐文章于 2024-07-25 11:43:17 发布
阅读量65 收藏
点赞数 1
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73951189/article/details/132457550
版权

A 666

将每个数组中的质因子分解，放到一个存质因子和每个质因子位置的二维数组中，每次查询在这个二维数组的质因子中查询最后和最前面的位置，相减即为答案

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 2e5 + 5;

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

void solve() {
	int n;
    cin >> n;
    vector<vector<int>> a(n + 1);
    
    for(int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        for(int j = 2; j * j <= x; j++) {
            if(x % j == 0) {
                while(x % j == 0) {
                    x /= j;
                }
                a[j].push_back(i);
            }
        }
        if(x > 1)    a[x].push_back(i);
    }
    
    int m;
    cin >> m;
    while(m--) {
        int l,r,x;
        cin >> l >> r >> x;
        int ans = upper_bound(a[x].begin(),a[x].end(),r) - lower_bound(a[x].begin(),a[x].end(),l);
        if(!ans)    cout << "666666!" << endl;
        else cout << ans << endl;
    }
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
//     cin >> t;
	t = 1;
    while(t--) {
    	solve();
    }
    	
    return 0;
}

B 求和

                                                                                 n                       n  
B:欧拉反演 n =  ∑   φ(n) ，对n属于N都成立.  那么 ∑   ⌊n|d⌋ φ(d) = ∑    ∑  φ(d)即对n求和
                        (d|n)                                                d=1                    i=1 d|i

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 2e5 + 5;
ll a[N];

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

int fact(int n) {
	int s = 0,j = 0;
	
	while(n) {
		s = s + j * (n % 2);
		n /= 2;
		j *= 10;
	}
	
	return s;
}

/*ll f(ll x)
{
    ll res = x;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0) {
            res = res / i * (i - 1);
            while (x % i == 0) x /= i;
        }
    if (x > 1) res = res / x * (x - 1);

    return res;
}*/

void solve() {
    ll n;
    cin >> n;
    ll sum = 0;
    for(int i = 1; i <= n; i++) {
        sum += i;
    }
    
    cout << sum << endl;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
    cin >> t;
// 	t = 1;
    while(t--) {
    	solve();
    }
    	
    return 0;
}

C 迷宫

将每个位置的数的位置坐标赋值到结构体中，循环每个位置的上下左右是否有比它权值小的数，若无则走不到终点

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 2e5 + 5;
// ll a[N];

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

void solve() {
	int n,m;
    cin >> n >> m;
    
    vector<vector<int>> a(n + 1,vector<int> (m + 1));
    vector<PII> q(n * m + 1);
    
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            cin >> a[i][j];
            q[a[i][j]] = {i,j};
        }
    }
    
    string ans = "YES";
    
    for(int i = 2; i <= n * m; i++) {
        bool f = 0;
        for(int j = 0; j < 4; j++) {
            int x = q[i].fi + dx[j];
            int y = q[i].se + dy[j];
            if(x < 1 || x > n || y < 1 || y > m)    continue;
            if(a[x][y] < i)    f = 1;
        }
        if(!f)    ans = "NO";
    }
    cout << ans << endl;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
    cin >> t;
	
    while(t--) {
    	solve();
    }
    	
    return 0;
}

D 操作序列1

先将每个算法的位置对应赋值，若已经学会就将其和下一个算法进行合并，直至都合并到一个未学习过的算法中

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 2e6 + 5;
ll a[N];

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

int find(int x) {
    return a[x] == x ? x : a[x] = find(a[x]);
}

void solve() {
	int n,m;
    cin >> n >> m;
    
    for(int i = 0; i <= n + 1; i++) {
        a[i] = i;
    }
    
    while(m--) {
        ll ans = 0;
        int l,r;
        cin >> l >> r;
        for(int i = find(l); i <= r; i = find(i + 1)) {
            ans++;
            a[i] = i + 1;
        }
        cout << ans << endl;
    }
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
//     cin >> t;
	t = 1;
    while(t--) {
    	solve();
    }
    	
    return 0;
}

F NB数

对操作次数进行二分，如果遇到不是NB数，操作次数减一将它变成0使它变成NB数，返回成立的操作次数，循环寻找最少的操作次数

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 1e5 + 5;
ll a[N],n,m;

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

bool check(int x) {
    int ans = 0;
    for(int i = 1; i <= n; i++) {
        if(ans >= a[i]) {
            ans++;
        } else if(x) {
            x--;
            ans++;
        }
    }
    return ans >= m;
}

void solve() {
	cin >> n >> m;
    for(int i = 1; i <= n; i++)    cin >> a[i];
    int l = 0,r = m;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(check(mid))    r = mid;
        else l = mid + 1;
    }
    cout << r << endl;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
//     cin >> t;
	t = 1;
    while(t--) {
    	solve();
    }
    	
    return 0;
}

G 跑步计划

求最多能删除的边，如果i，j两点之间存在一点k使得i可以通过k到达j的距离比i直接到j的距离更短，那么此时i到j的这条边可以删除，无向图最后要删除的边需要除2

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 305;
ll a[N],cnt[N][N];

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

int MIN(int a,int b) {
    return a < b ? a : b;
}

void solve() {
    memset(d,0x3f,sizeof d);
    int n,m;
    cin >> n >> m;
    for(int i = 1; i <= n; i++)    d[i][i] = 0;
    for(int i = 1; i <= m; i++) {
        int u,v,w;
        cin >> u >> v >> w;
        d[u][v] = MIN(d[u][v],w);
        d[v][u] = MIN(d[v][u],w);
        cnt[u][v] = 1;
        cnt[v][u] = 1;
    }
    for(int k = 1;  k <= n; k++) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
            }
        }
    }
    ll ans = 0;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            if(i == j)    continue;
            for(int k = 1; k <= n; k++) {
                if(k == i || k == j)    continue;
                if(cnt[i][j] && d[i][j] == d[i][k] + d[k][j]) {
                    ans++;
                    break;
                }
            }
        }
    }
    cout << ans / 2;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
//     cin >> t;
	t = 1;
    while(t--) {
    	solve();
    }
    	
    return 0;
}

H 中位数？中位序列！

通过枚举可以发现当k为偶数的情况下，中位序列都是k/2为开头，后面都是k的序列。k为奇数时，第一位一定是（k + 1） / 2（模拟就可得），后面需要进行1到n / 2次循环处理将（k + 1） / 2每次进行减一，当其本就是一时则将其删除（可以通过最简单的n为5 k为1样例模拟），而通过n为8，k为3的例子可得若最后一项删除并继续进行减一操作时，需要将其减一后在后一项添加一项赋值为k（不太懂啥原理只能模拟出来qwq）

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 2e5 + 5;
ll a[N];

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

void solve() {
	int n,k;
    cin >> n >> k;
    
    if(k % 2 == 0) {
        cout << k / 2 << ' ';
        for(int i = 2; i <= n; i++) {
            cout << k << ' ';
        }
    } else {
        for(int i = 1; i <= n; i++)    a[i] = (k + 1) / 2;
        int tt = n;
        for(int i = 1; i <= n / 2; i++) {
            if(a[tt] == 1) {
                tt--;
            } else {
                a[tt]--;
                while(tt < n)    a[++tt] = k;
            }
        }
        for(int i = 1; i <= tt; i++) {
            cout << a[i] << ' ';
        }
    }
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
//     cin >> t;
	t = 1;
    while(t--) {
    	solve();
    }
    	
    return 0;
}

I 仙跳墙

将xyz存入一个判断数组cnt中，xyz的位置cnt为1，在cnt为0时进行dp，因为编号小的都在编号大的之前，所以确定最大的i和j更新答案，此时的答案就是在没有连续使用编号为xyz下的答案

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define ll long long
#define fi first
#define se second

ll gcd(ll a,ll b) {
	return b ? gcd(b,a % b) : a;
}

ll power(ll a,ll b) {
	ll ans = 1;
	while(b) {
		if(b % 2 != 0)	ans *= a;
		a = a * a;
		b >>= 1;
	}
	return ans;
}

typedef pair<ll,ll> PII;
queue<PII> q;

const int N = 105;
ll val[N],time1[N],cnt[N][N][N],dp[N][N][N];

ll g[2010][2010],d[2010][2010];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

int max(int a,int b) {
    return a > b ? a : b;
}

void solve() {
	int n,T,m;
    cin >> n >> T >> m;
    for(int i = 2; i <= n + 1; i++) {
        cin >> val[i] >> time1[i];
    }
    for(int i = 1; i <= m; i++) {
        int x,y,z;
        cin >> x >> y >> z;
        x++;y++;z++;
        cnt[x][y][z] = 1;
    }
    
    ll ans = 0;
    
    for(int i = 2; i <= n + 1; i++) {
        for(int j = 0; j < i; j++) {
            for(int k = 0; k < j; k++) {
                if(!cnt[k][j][i]) {
                    for(int p = time1[i]; p <= T; p++) {
                        dp[i][j][p] = max(dp[i][j][p],dp[j][k][p - time1[i]] + val[i]);
                        ans = max(ans,dp[i][j][p]);
                    }
                }
            }
        }
    }
    
    cout << ans;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
    int t;
//     cin >> t;
	t = 1;
    while(t--) {
    	solve();
    }
    	
    return 0;
}

漏气的雪碧有点甜.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Javaweb图书借阅管理系统
10-29
功能描述： ... b) 分类展示图书信息：展示的方式有多种，可以按类别、按租赁数量、按上架时间等。 c) 书籍借阅查询：根据多种条件来查询，比如按照书籍名称，书籍价格，作者等特征信息。能进行模糊匹配。...
web应用开发教程PPT-长沙学院
02-21
【web应用开发教程PPT-长沙学院】是一个针对初学者设计的教学资料，旨在全面介绍Web应用的开发过程，包括基础理论、技术实践以及数据库连接等内容。这个教程可能涵盖了以下几个核心知识点： 1. **Web应用基础**：...
CCSU2023暑期结训测试赛(三)
yyh_rise的博客
08-21 63
文章目录前言G-跑步运动H-中位数？I-仙跳墙 前言 心态要好，不要急，毕竟急了也没用 G-跑步运动 #解题思路：暴力循环查找是否有边满足eij>=eik+ejk即说明可被替换,若满足则进行标记，最终标记的数量就是答案(当初写的时候一看见是图论就撒丫子跑路了，连数据范围都没看，还是不该太着急) #include<bits/stdc++.h> typedef long long ll; typedef unsigned long long ull; const ll Mod = 1e9 +
CCSU2023暑期结训测试赛之赛后题解
m0_72987224的博客
08-23 55
由题目可以得到，两种操作分别对应的是二进制下逐渐去掉第一位的1和逐步将二进制数进一位变成2的x次方，如果是一的情况，直接暴力维护即可，如果是2的情况，当对应的数字对应的二进制数全部只剩下1一个一的时候，便可以利用懒标记进行整体的数字大小的变化。可以观察到， 如果某个区间内的知识点Bruce小朋友全部学完了，那么在后面的计算中，就没有必要将这个范围内的知识点当作分开的多个部分，直接看成一部分即可，然后查找缩减后的区间，输出向对应的结果即可。#思路二（也是题解带来的思路。就是一个暴力图论的题目，
CCSU2023暑期结训测试赛(二)
yyh_rise的博客
08-21 45
题目目录前言D-操作序列1E-操作序列2F-NB数 前言 不能太重此轻彼，还是要平衡一些 D-操作序列1 #解题思路：利用并查集进行区间合并，每学习一种算法便将其并入位于find_set(r+1)的集合中，使得当之后再遇到此算法时，便可以直接判定此算法及直至r的算法，都已并入其他集合(数据结构类的题目的确是写少了，像靠并查集进行区间合并的做法都没有想到，还是要多写一些这类题目) #include<bits/stdc++.h> typedef long long ll; typedef uns
CCSU2023暑期结训测试赛(一)
yyh_rise的博客
08-21 55
题目目录前言A-666B-求和C-迷宫 前言 头脑清醒，实力才是硬道理 A-666 #解题思路：对每一个数进行质因数分解，得到每个质因数所有的下标索引，再进行二分查找，得到质因数x在范围[l,r]中的所占个数（不料这题是被自己害了，认错了原题，唉) #include<bits/stdc++.h> typedef long long ll; typedef unsigned long long ull; const ll Mod = 1e9 + 7; const ll mod9 = 99824
2021-2022年收藏的精品资料燃煤电厂CCSU子系统的设计.doc
09-17
【燃煤电厂CCSU子系统设计】是针对燃煤发电过程中产生的大量二氧化碳进行捕集、储存和利用（CCS：Carbon Capture and Storage，CCSU：Carbon Capture, Storage, and Utilization）的一项关键技术。燃煤电厂是全球...
ccsu-senior-project-spring-2021：与2021年Spring学期的中央康涅狄格州立大学高级项目相关的主题集合。 由@TheHartford赞助
02-11
CCSU高级项目（2021年Spring） 目录 背景资料 当由哈特福德（Hartford）投保的汽车发生重大损坏时，我们的保单持有人请我们赔偿这些损坏。 此过程要求Hartford获得大量与该事件有关的信息，以便成功并有效地处理我们...
科罗拉多州立大学
02-14
这个“CCSU-master”压缩包很可能是包含了上述两门课程的相关学习资料，比如课堂讲义、作业、实验指导、项目代码和测试案例等。在解压后，我们可以期待找到以下内容： 1. 讲义和笔记：PDF或Markdown格式的文档，...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 252
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 400
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
java算法原理
jylee的博客
07-25 833
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
数据结构的概念和术语
2303_78660417的博客
07-24 519
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
c语言（7.23）
fhgfyrsg的博客
07-23 712
【代码】c语言（7.23）
数据结构初阶(C语言)-二叉树-顺序表建堆
xiuwoaiailixiya的博客
07-23 1107
int size;}HP;由于堆在本质上是基于顺序表结构去实现的，所以接下来我们所介绍的实现内容重点介绍与顺序表的不同的地方，相同部分则直接给出代码。
【初阶数据结构篇】时间（空间）复杂度
2301_79849925的博客
07-23 1000
​ 在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运⾏时间。时间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运⾏时间呢？​ 1.因为程序运⾏时间和编译环境和运⾏机器的配置都有关系，⽐如同⼀个算法程序，⽤⼀个⽼编译器进⾏编译和新编译器编译，在同样机器下运⾏时间不同。​ 2.同⼀个算法程序，⽤⼀个⽼低配置机器和新⾼配置机器，运⾏时间也不同。​ 3.并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。
【JavaScript】`Map` 数据结构
lph159的博客
07-25 326
允许您使用各种类型的值作为键，不限于字符串或符号。按照插入顺序保留键值对，而对象的键的遍历顺序可能会根据不同的 JavaScript 引擎有所不同。的基本概念、用法、常见操作以及与对象的对比，帮助您全面掌握这一数据结构。与传统的对象（Object）不同，和对象在某些方面类似，但它们在使用场景和性能上有一些显著区别。保留了键值对的插入顺序，且键是唯一的，这意味着在同一个。对象适用于结构化的静态数据，而。是一种键值对集合，其中键和值都可以是任意类型。对象的键只能是字符串或符号，而。更适合需要动态操作的场景。
数据结构（3）（顺序栈）
qq_54094530的博客
07-25 554
栈是限定仅在栈顶进行插入和删除操作的线性表，在操作的时候，只允许栈顶改变不允许栈底改变，具有后进先出的特征。
碳捕获与封存技术在北美公用事业行业的应用洞察
CCSU是一种旨在减少温室气体排放的重要策略，通过捕捉工业和电力生产过程中产生的二氧化碳，防止其进入大气，然后进行安全储存或再利用。 1. 碳捕获：该技术涉及从化石燃料燃烧或工业过程中捕获二氧化碳。报告可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值