（CCF CAT 训练二）2023-2024年中国计算机应用技术大赛- 全国算法精英大赛

已于 2024-01-26 17:06:56 修改
阅读量3.4k 收藏 62
点赞数 31
文章标签： 算法 数据结构
于 2024-01-25 23:04:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43983809/article/details/135855273
版权

Flower
在这里插入图片描述

反悔贪心，按照时间对花朵进行排序，从0到n-1遍历花朵，如果当前堆中元素小于当前花朵的绽放时间t，直接放入堆中，否则花朵金币数放入堆中并弹出堆中金币数最小值，最后如果堆中元素个数大于k，一直弹出堆中最小金币数直到元素个数等于k

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
const int N=1e5+5;
int t[N], w[N];

int main()
{
  int n, k;
  cin>>n>>k;
  for(int i=0;i<n;i++){
    cin>>t[i];
  }
  for(int i=0;i<n;i++){
    cin>>w[i];
  }
  vector<pair<int,int>> v;
  for(int i=0;i<n;i++){
      v.push_back({t[i], w[i]});
  }
  priority_queue<int, vector<int>, greater<int>> pq;
  sort(v.begin(), v.end(), [](const pair<int,int>& p1, const pair<int,int>&p2){
      return p1.first < p2.first;
  });
  int ans = 0;
  for(int i=0;i<n;i++){
      if(v[i].first > int(pq.size())){
          pq.push(v[i].second);
          ans+=v[i].second;
      }else{
          ans+=v[i].second - pq.top();
          pq.push(v[i].second);
          pq.pop();
      }
    //   if(pq.size())
  }
//   cout<<pq.size()<<" ";
  while(int(pq.size()) > k){
      ans-=pq.top();
      pq.pop();
  }
  cout<<ans;
}

Tree
在这里插入图片描述

先构造二叉搜索树，询问的时候再进行递归求节点深度

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;

struct node{
  node* l = nullptr,*r = nullptr;
  int v;
  node(int v1):v(v1){}
};
node* root = nullptr;
void insert(int i){
    if(root==nullptr){
        root = new node(i);
    }else{
        node* pre = root;
        node* tmp = root->v>i? root->l:root->r;
        while(tmp!=nullptr){
            pre = tmp;
            tmp = tmp->v>i? tmp->l:tmp->r;
        }
        tmp = new node(i);
        if(pre->v > i){
            pre->l = tmp;
        }else{
            pre->r = tmp;
        }
    }
}
int find(int i){
    node* tmp = root;
    int deep = 1;
    while(tmp!=nullptr){
        tmp = tmp->v>i? tmp->l:tmp->r;
        deep++;
    }
    return deep;
}
int main()
{
  int n;
  cin>>n;
  for(int i=0;i<n;i++){
      int a;
      cin>>a;
      insert(a);
  }
  for(int i=0;i<n;i++){
      int a;
      cin>>a;
      cout<<find(a)<<endl;
  }

}


Best Travel Plans
在这里插入图片描述

使用动态规划， 遍历1到n座城市，dp[i][j]表示到达第i座城市且花费j时间的最大旅行活动数
转移方程 d p [ i ] [ j ] = m a x ( d p [ i ] [ j ] , d p [ i − 1 ] [ k ] + 在第 i 座城市花费 j − k − t [ i ] 获得旅行活动数 ) dp[i][j] = max(dp[i][j], dp[i-1][k] +在第i座城市花费j-k-t[i]获得旅行活动数) dp[i][j]=max(dp[i][j],dp[i−1][k]+在第i座城市花费j−k−t[i]获得旅行活动数)
这里代码超时了，还没想好优化思路，后面有时间再补上
用枚举加贪心，枚举前 i i i个城市, 除去旅行时间，剩下remain时间，遍历前 i i i个城市，每次选择最大活动数量，时间复杂度 O ( n 2 m ) O(n^2m) O(n2m) 代码如下

//动态规划超时
#include <iostream>
#include <queue>
#include <vector>
#include<cstring>
#include <algorithm>
using namespace std;
const int N = 1e2+5;
const int M = 2e4+5;
int e[N], d[N], t[N];
long long dp[N][M];
int main()
{
  int n, m;
  cin>>n>>m;
  for(int i=2;i<=n;i++){
      cin>>t[i];
  }
  for(int i=1;i<=n;i++){
      cin>>e[i];
  }
  for(int i=1;i <= n;i++){
      cin>>d[i];
  }
  memset(dp, -1, sizeof dp);
  dp[1][0]  = 0;
  for(int i=1;i<=m;i++){
      if(e[1] - d[1]*(i-1) >=0 )
        dp[1][i] = dp[1][i-1] + e[1] - d[1]*(i-1);
      else{
          dp[1][i] = dp[1][i-1];
      }
    //   cout<<i<<" "<<dp[1][i]<<endl;
  }
  long long ans = 0;
  for(int i=2;i<=n;i++){
    //   dp[i]
      for(int j=0; j<=m;j++){
        //   dp[i][j] = dp[i-1][j];
          for(int k=0;k<=j-t[i]; k++){
              if(dp[i-1][k]!=-1)
              dp[i][j] = max(dp[i][j], dp[i-1][k] + (long long)e[i]*(j-k-t[i]) - (long long)(j-k-t[i])*(j-k-t[i] -1)*d[i]/ 2);
            //   cout<<i<<" "<<j<<" "<<k<<" "<<dp[i][j]<<endl;
          }
          ans=max(ans, dp[i][j]);
        //   cout<<i<<" "<<j<<" "<<dp[i][j]<<endl;
      }
    //   cout<<
  }
  cout<<ans;

}

//枚举和贪心
#include<iostream>
#include<cstring>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
const int N = 1e2 + 5;
const int M = 2e4 + 5;
int t[N], e[N], d[N];
int pos[N];
int main()
{
	// ios_base::sync_with_stdio(false);
	// cin.tie(NULL);
	int n, m;
	// 	cin>>n>>m;
	scanf("%d%d", &n, &m);
	t[1] = 0;
	for (int i = 2; i <= n; i++) {
		// cin>>t[i];
		scanf("%d", &t[i]);
	}
	for (int i = 1; i <= n; i++) {
		// cin>>e[i];
		scanf("%d", &e[i]);
	}
	for (int i = 1; i <= n; i++) {
		// cin>>d[i];
		scanf("%d", &d[i]);
	}
	std::vector<std::vector<int>> p(n + 1);

	for (int i = 1; i <= n; ++i) {
		for (int j = 0; e[i] - j * d[i] > 0 && j <= m; ++j) {
			p[i].emplace_back(e[i] - j * d[i]);
		}
	}

	int ans = 0;
	int travel = 0;
	for (int i = 1; i <= n; i++) {
		travel += t[i];
		memset(pos, 0, sizeof pos);
		int remain = m - travel;
    	if(remain <= 0)break; //这里一定要加上判断
		int tmp_ans = 0;
		while (remain) { //否则remain为负数会进入循环，一直没找到这个错误
			int id = -1, mx = 0;
			for (int j = 1; j <= i; j++) {
				if(pos[j] == p[j].size())continue;
				if (p[j][pos[j]] > mx) {
					id = j;
					mx = p[j][pos[j]];
				}
			}
			if (id != -1) {
				tmp_ans += p[id][pos[id]];
				pos[id] ++;
				remain--;
			}
			else {
				break;
			}
		}
		ans = max(ans, tmp_ans);
	}
	printf("%d", ans);
}


Hearthstone
在这里插入图片描述

思路动态规划，有点麻烦的是需要连接成环，这里就是分三种情况，分别是第1次分别选择1，2，3所对应的卡片，再取三种情况的最大值，中间的转移方程比较简单，就是要枚举满足条件（任何一个位置的卡牌都要比相邻的两张卡牌的法力消耗值都高或都低）的状态就ok了

#include <iostream>
#include <queue>
#include <vector>
#include<cstring>
#include <algorithm>
using namespace std;
const int N = 1e5+5;
long long dp[N][4][4];
int arr[N][4];
int main()
{
  int n;
  cin>>n;
  for(int i=1;i<=n;i++){
      cin>>arr[i][1] >> arr[i][2]>> arr[i][3];
  }
  memset(dp, -1, sizeof dp);
//   dp[2][1][2] = arr[2][1] + arr[1][2];
//   dp[2][1][3] = arr[2][1] + arr[1][3];
  dp[2][2][1] = arr[2][2] + arr[1][1];
//   dp[2][2][3] = arr[2][2] + arr[1][3];
  dp[2][3][1] = arr[2][3] + arr[1][1];
//   cout<<dp[2][3][1]<<" ";
//   dp[2][3][2] = arr[2][3] + arr[1][2];
  for(int i=3;i<=n;i++){
      dp[i][1][2] = dp[i-1][2][1] + arr[i][1];
      dp[i][1][3] = max(dp[i-1][3][1], dp[i-1][3][2]) + arr[i][1];
      dp[i][2][1] = max(dp[i-1][1][2], dp[i-1][1][3]) + arr[i][2];
      dp[i][2][3] = max(dp[i-1][3][1], dp[i-1][3][2]) + arr[i][2];
    //   cout<<i<<" "<<dp[i][2][3]<<" "<<endl;
      dp[i][3][1] = max(dp[i-1][1][3], dp[i-1][1][2]) + arr[i][3];
      dp[i][3][2] = dp[i-1][2][3] + arr[i][3];
  } 
  long long ans = max(max(dp[n][2][1], dp[n][3][2]), dp[n][3][1]);
//   cout<<ans<<" ";
  memset(dp, -1, sizeof dp);
  dp[2][1][2] = arr[2][1] + arr[1][2];
//   dp[2][1][3] = arr[2][1] + arr[1][3];
//   dp[2][2][1] = arr[2][2] + arr[1][1];
//   dp[2][2][3] = arr[2][2] + arr[1][3];
//   dp[2][3][1] = arr[2][3] + arr[1][1];
  dp[2][3][2] = arr[2][3] + arr[1][2];
  for(int i=3;i<=n;i++){
      dp[i][1][2] = dp[i-1][2][1] + arr[i][1];
      dp[i][1][3] = max(dp[i-1][3][1], dp[i-1][3][2]) + arr[i][1];
      dp[i][2][1] = max(dp[i-1][1][2], dp[i-1][1][3]) + arr[i][2];
      dp[i][2][3] = max(dp[i-1][3][1], dp[i-1][3][2]) + arr[i][2];
      dp[i][3][1] = max(dp[i-1][1][3], dp[i-1][1][2]) + arr[i][3];
      dp[i][3][2] = dp[i-1][2][3] + arr[i][3];
  } 
  ans = max(ans, max(max(max(dp[n][3][1], dp[n][3][2]), dp[n][1][2]), dp[n][1][3]));
//   cout<<ans<<" ";
    memset(dp, -1, sizeof dp);
//   dp[2][1][2] = arr[2][1] + arr[1][2];
  dp[2][1][3] = arr[2][1] + arr[1][3];
//   dp[2][2][1] = arr[2][2] + arr[1][1];
  dp[2][2][3] = arr[2][2] + arr[1][3];
//   dp[2][3][1] = arr[2][3] + arr[1][1];
//   dp[2][3][2] = arr[2][3] + arr[1][2];
  for(int i=3;i<=n;i++){
      dp[i][1][2] = dp[i-1][2][1] + arr[i][1];
      dp[i][1][3] = max(dp[i-1][3][1], dp[i-1][3][2]) + arr[i][1];
      dp[i][2][1] = max(dp[i-1][1][2], dp[i-1][1][3]) + arr[i][2];
      dp[i][2][3] = max(dp[i-1][3][1], dp[i-1][3][2]) + arr[i][2];
      dp[i][3][1] = max(dp[i-1][1][3], dp[i-1][1][2]) + arr[i][3];
      dp[i][3][2] = dp[i-1][2][3] + arr[i][3];
  } 
  ans = max(ans,max(max(dp[n][1][2], dp[n][1][3]), dp[n][2][3]));
  cout<<ans;
 
}


Hotpot

在这里插入图片描述

这里只需要求出一边的方案数目，总方案数目是两者乘积，如何求一边的方案数呢，可以想象位置有人状态设置，没人设置0，整个就是二进制串，需要求的是合法的二进制串数目，要求不能存在两个1相邻的情况，这不就是数位dp吗，使用dfs求

#include <iostream>
#include <queue>
#include <vector>
#include<cstring>
#include <algorithm>
using namespace std;
int mod=1e9+7;
const int N=1e4+5;
long long dp[N][2];
// string str;
int n;
long long dfs(int i, int mask){
    if(dp[i][mask]!=-1)return dp[i][mask];
    if(i==n)return 1LL;
    long long ans = 0;
    ans = (ans+dfs(i+1, 0))%mod;
    if(mask!=1)
        ans = (ans + dfs(i+1, 1))%mod;
    dp[i][mask] = ans;
    return ans;
}
int main()
{
//   int n;
  cin>>n;
  memset(dp, -1, sizeof dp);
  long long ans = dfs(0,0);
  cout<<(ans*ans)%mod;

}

补充两道(CCF CAT训练一）题目


Card
在这里插入图片描述

当存在 i , j i,j i,j，其中 1 ≤ i ≤ n , 1 ≤ j ≤ n 1 \le i \le n, 1 \le j \le n 1≤i≤n,1≤j≤n，且 x i , x j x_i, x_j xi​,xj​最大公因数为1，则是满足要求的两种地铁票，还存在特殊情况是当出现 x i = 1 x_i=1 xi​=1，也是满足要求的，取所有满足要求的最小值即可

#include <iostream>
#include <queue>
#include <vector>
#include<cstring>
#include <algorithm>
using namespace std;
int x[105], v[105];
int main()
{
  int n;
  cin>>n;
  for(int i=0;i<n;i++){
      cin>>x[i];
  }
  for(int i=0;i<n;i++){
      cin>>v[i];
  }
  int ans = 0x3f3f3f3f;
  for(int i=0;i<n;i++){
      if(x[i]==1){
          ans=min(ans, v[i]);
      }
  }
  for(int i=0;i<n;i++){
      for(int j=0;j<n;j++){
          if(i!=j && __gcd(x[i], x[j])==1){
              ans=min(ans, v[i]+v[j]);
          }
      }
  }
  cout<<(ans==0x3f3f3f3f?-1:ans);
}


The diameter of a rectangle

在这里插入图片描述

比较经典的单调栈的题目，先使用单调栈找到每个矩形 i i i最靠近它且矩形长小于它的长位置下标，比如左边为 j j j，右边为 k k k，则可以找到一个大矩形长宽分别为 a i a_i ai​, b j + 1 + b j + 2 + . . . + b i + . . . + b k − 2 + b k − 1 b_{j+1} + b_{j+2}+...+b_i+...+b_{k-2}+b_{k-1} bj+1​+bj+2​+...+bi​+...+bk−2​+bk−1​，两个取最小值作为正方形的边长，遍历1到n取面积最大值，宽的计算可以使用前缀和

#include <iostream>
#include <queue>
#include <vector>
#include<cstring>
#include <algorithm>
#include <stack>
using namespace std;
const int N=1e6+5;
int arr[N][2];
int left1[N], right1[N];
long long pre[N];
int main()
{
  int n;
  cin>>n;
  for(int i=0;i<n;i++){
      cin>>arr[i][0]>>arr[i][1];
      pre[i+1] = pre[i] + arr[i][1];
      right1[i] = n;
  }
  memset(left1, -1, sizeof left1);
//   memset(right1, )
  stack<int> l, r;
  for(int i=0;i<n;i++){
      while(!l.empty() && arr[l.top()][0] > arr[i][0]){
          right1[l.top()] = i;
          l.pop();
      }
      l.push(i);
  }
  for(int i=n-1;i>=0;i--){
      while(!r.empty() && arr[r.top()][0] > arr[i][0]){
          left1[r.top()] = i;
          r.pop();
      }
      r.push(i);
  }
  long long ans=0;
  for(int i=0;i<n;i++){
    //   cout<<i<<" "<<left1[i]<<" "<<right1[i]<<endl;
      long long lo = min(pre[right1[i]] - pre[left1[i] + 1], (long long)arr[i][0]);
      ans=max(ans, lo*lo);
  }
  cout<<ans;
}
qq_43983809
关注
2024年06月CCF-GESP编程能力等级认证C++编程二级真题解析
人生就是一个不断学习的过程
07-10 1744
小杨认为自己的幸运数是正整数 （注：保证 ）。小杨想知道，对于从 到 的所有正整数中， 出现了多少次。
CCF CAT- 全国算法精英大赛（2024第二场）往届真题练习 3 | 珂学家
m0_66102593的博客
05-22 1077
这是2024年第一场CCF初赛的题， 其实整场比赛，感觉不是特别难，就是码量大，偏模拟和数学。对于A题，摩斯密码，很容易抄错，我一直在想有什么好办法可以规避它，是真的苦涩。
计算机竞赛 题目：基于深度学习的中文对话问答机器人
Mr.D学长
10-08 402
🔥 优质竞赛项目系列，今天要分享的是基于深度学习的中文对话问答机器人该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！🧿🧿。
黑龙江日报报道第5届中国计算机应用技术大赛，赛氪提供赛事支持
最新发布
2301_78353591的博客
08-13 242
此次大赛与中国计算机应用大会的主题“数字经济赋能向北开放新高地，助推产研应用厚植新质生产力”相呼应，旨在全面贯彻国家关于加快发展新质生产力、推动高质量发展的重要指示精神。中国计算机学会计算机应用专委会荣誉主任许斌表示，每年大概都有10万人会参加这个比赛，它不仅能够激发学生更好地研究计算机中的算法，同时也助力国家在拔尖创新人才的培养方面做出积极贡献。此次大赛的成功举办，不仅展示了我国在计算机应用技术领域的雄厚实力，也为广大青年学子提供了一个展示才华、交流学习的宝贵平台。同时，全国智能无人车大赛也备受关注。
赛氪OJ评测 | CCF CAT- 全国算法精英大赛（2024第二场）往届真题练习 1 | 珂学家
m0_66102593的博客
05-19 2216
在赛氪OJ打过不少比赛，包括计算机挑战赛春季赛/秋季赛，大学生算法赛（清华社杯），CCF-CAT，智星算法赛等。我感觉需要对这个平台，做一下评测，以帮助新生避下坑。
23中国计算机应用技术大赛全国算法精英大赛，赛氪全程协同
2301_78353591的博客
06-25 417
拓宽视野：参加计算机竞赛能够接触到各种优秀的解决方案和创新思路，了解行业内的最新技术动态和发展趋势，从而拓宽自己的视野，提高对计算机科学的理解和认知。建立人脉关系：参加计算机竞赛可以结识同行业的优秀人才、专家学者和企业代表，通过交流和互动建立起宝贵的人脉关系，这对个人的职业发展和学术研究都非常有帮助。CCF是国内首个实现理事会、监事会、下属专业委员会负责人公开差额选举的全国性学会，建立了现代学术社团的治理架构和制度体系，学会事务严格按照程序决策和执行，财务向会员公开，接受会员监督。
2023中国计算机应用技术大赛全国算法精英大赛，赛氪全程协同
2301_78353591的博客
06-13 2110
大学生参加计算机大赛有以下几个方面的帮助：1. 提升技术能力：参加计算机大赛可以让大学生接触到前沿的技术和应用，通过实践掌握更多的技能，提高技术水平和解决问题的能力。”为推动人工智能应用落地，2017年国务院印发《新一代人工智能发展规划》，2022年召开的党的二十大，党中央从突出创新在我国现代化建设全局中的核心地位出发，将科技、教育、人才放在二十大报告第五部分进行统筹部署，科教兴国战略、人才强国战略、创新驱动发展战略都是党中央提出的需要长期坚持的国家重大战略。建成后，将是世界上最大的计算机博物馆。
2023中国商超自有品牌案例报告-CCFA-2024-45页.pdf
01-11
2023中国商超自有品牌案例报告-CCFA-2024-45页.pdf
《学科前沿专题》学习2018-2019中国计算机科学技术发展报告（CCF）.rar
07-02
《学科前沿专题》学习2018-2019中国计算机科学技术发展报告（CCF）是一份重要的行业研究报告，由计算机学会（CCF）发布，旨在深入剖析和总结我国在计算机科学和技术领域的最新进展、趋势和挑战。这份报告对于产品...
基于python的CCF-BDCI大数据与计算智能大赛-互联网金融新实体发现算法源码+项目说明（9th）.zip
01-16
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的...基于python的CCF-BDCI大数据与计算智能大赛-互联网金融新实体发现算法源码+项目说明（9th）.zip
计算机 竞赛题目详解
09-01
竞赛题目详解
全国计算机计算机竞赛试题
04-21
全国技能大赛计算机竞赛企业网搭建,交换机和路由器配置等.................................................................................
2017年华为算法比赛题目
11-29
华为2017年算法比赛题目全套，包括中文版和英文版，编译器有gcc和java
CCF-BDCI大赛 OCR赛题第一名 天晨破晓团队 文字识别模型baseline.zip
08-20
CCF-BDCI大赛 OCR赛题第一名 天晨破晓团队 文字识别模型baseline.zip CCF-BDCI大赛 OCR赛题第一名 天晨破晓团队 文字识别模型baseline.zip CCF-BDCI大赛 OCR赛题第一名 天晨破晓团队 文字识别模型baseline.zip
CCF-CSP真题训练第二题-《202303垦田计划》-python
weixin_44302779的博客
01-01 613
在pycharm中能够正常运行，两个案例的测试也是正确的，然而在系统上测试是有问题的，时间使用也超时了。还未找出什么原因，明天继续做这个题目，尝试找找B站上的解说。大家有晓得咋搞的欢迎在评论区提出建议哈~不断对开垦耗时最大的田，投入资源，缩短天数，直至无资源投入或缩减天数到达阈值k。
CCF CAT- 全国算法精英大赛（2024第二场）往届真题练习 2 | 珂学家
m0_66102593的博客
05-20 953
这是第二场CCF的练习赛，找找手感，顺便熟悉下赛氪OJ平台。当前就做了5题，感觉还可以，部分题目质量蛮高的，但是易错。第1题dp入门题， 第5属于诈骗题，第2和第3挺有难度的，第四题感觉放水了。
2023CCF CAT- 全国算法精英大赛
死也不承认自己笨的博客
07-02 4670
目录A FlowerB TreeC Best Travel PlansD HearthstoneE HotpotF Mystery Sailing ChallengeG CardH The diameter of a rectangleI TouristJ Mysterious Rune String
计算机竞赛 题目：基于深度学习的图像风格迁移 - [ 卷积神经网络 机器视觉 ]
Mr.D学长
10-09 229
🔥 优质竞赛项目系列，今天要分享的是基于深度学习卷积神经网络的花卉识别该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！🧿图片风格迁移指的是将一个图片的风格转换到另一个图片中，如图所示：原图片经过一系列的特征变换，具有了新的纹理特征，这就叫做风格迁移。🧿。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_43983809

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值