CSP-M1-C可怕的宇宙射线

最新推荐文章于 2024-06-11 09:47:47 发布
最新推荐文章于 2024-06-11 09:47:47 发布
阅读量200 收藏
点赞数
文章标签： 剪枝 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43717026/article/details/104855052
版权

目录

1.题意

宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的左右45°方向分裂出两条宇宙射线，同时威力不变！宇宙射线会分裂 次，每次分裂后会在分裂方向前进a[i] 个单位长度。求出所经过的位置总数。
在这里插入图片描述

2.解题思路

  1. 用BFS暴力方法结果在第五个点超时
    思路：如图有8个方向，依次对这8个方向写分裂函数方向1的分裂方向为2和3以此类推，写出8个分裂函数，每分裂一次将同一层的分裂点压到队列中，按层取出分裂点进行分裂
    在这里插入图片描述
  2. 用BFS进行剪枝优化
    　　观察其分裂以及前进过程可知若以原点为起始位置，则前进过程中整个前进图关于y轴对称，所以只需考虑右半部分在每次count++时判断该点关于y轴对称的点是否被标记过
    　　通过两个结构体pi,point定义map<pi,int>m来记录该点是否被标记过，map<point,int>m1来标记在该点该方向该分裂次数是否分裂过，因为若分裂过再进行一次得到的结果不变且浪费时间，所以优化每层不重复地到下一层分裂点
    　　通过这两次优化解决TLE问题
  3. 用DFS更为凝练的分裂
    　　同理的剪枝优化不重复地分裂，结构体仍相同，优先向右分裂则可得到一个正八边形，以此为规律，则定义两个长度为8的数组dx,dy存储相应的向右分裂x,y的变化点,先向右再向左，该点该方向该分裂次数对应的map为0时分裂，当点未到达时count++，当分裂次数大于n时溯回。
    在这里插入图片描述

4.总结

  1. 剪枝优化真的非常有用，但是要思考全面真的很难
  2. BFS关于y轴对称优化时，关于判断y轴对称的点是否到达过时，与该点判断是否到达过时，是并行的关系，不能套用
  3. 关于BFS/DFS用map与结构体并用来判断该点的该方向该分裂次数是否分裂过时，结构体的重载函数要写全，如果写一半则只要写的相同会认为这两个结构体相同
bool operator<(const point &p) const{
		if(x==p.x)
		{
			if(y==p.y)
			{
				if(z==p.z)
				{
					if(w!=p.w) return w<p.w;
				}
				return z<p.z;
			}
			return y<p.y;
		}
		return x<p.x;
	}
	//而非仅写x,y
		bool operator<(const pi &p) const{
		return x !=p.x ? x<p.x : y<p.y;
	}

5.BFS AC代码

#include<iostream>
#include<map>
#include<vector>
#include<queue>
using namespace std;
struct point{
	int x;
	int y; 
	int z;
	int w;
	bool operator<(const point &p) const{
		if(x==p.x)
		{
			if(y==p.y)
			{
				if(z==p.z)
				{
					if(w!=p.w) return w<p.w;
				}
				return z<p.z;
			}
			return y<p.y;
		}
		return x<p.x;
	}
};
struct pi{
	int x;
	int y; 
	bool operator<(const pi &p) const{
		return x !=p.x ? x<p.x : y<p.y;
	}
};
queue<point> q;
map<point,int>m1;
map<pi,int>m;
int count=0;
void c1(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.x++;
		p.y++;
		p1.x--;
		p1.y++;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
			
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=3;
	p1.z=2;
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c2(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.y++;
		p1.x--;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
			
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=1;
//	q.push(p);
	p1.z=5;
	//q.push(p1);
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c3(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.y++;
		p1.x++;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=1;
//	q.push(p);
	p1.z=4;
//	q.push(p1);
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c4(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.x++;
		p.y++;
		p1.x++;
		p1.y--;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
			
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=3;
	//q.push(p);
	p1.z=7;
//	q.push(p1);
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c5(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.x--;
		p.y++;
		p1.x--;
		p1.y--;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
			
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=2;
//	q.push(p);
	p1.z=6;
	//q.push(p1);
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c6(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.x--;
		p1.y--;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
			
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=5;
//	q.push(p);
	p1.z=8;
//	q.push(p1);
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c7(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.x++;
		p1.y--;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=4;
//	q.push(p);
	p1.z=8;
	//q.push(p1);
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c8(point &p,int k,int fc)
{
	point p1;
	p1.x=p.x;
	p1.y=p.y;
	for(int i=0;i<k;i++)
	{
		p.x++;
		p.y--;
		p1.x--;
		p1.y--;
		pi p5,p6;
		p5.x=p.x;
		p5.y=p.y;
		p6.x=p1.x;
		p6.y=p1.y;
		if(m[p5]==0) 
		{
			m[p5]=1;
			count++; 
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		}
		if(m[p6]==0) 
		{
			m[p6]=1;
			count++;	
		} 
		pi p4;
		p4.x=-p1.x;
		p4.y=p1.y;
		if(m[p4]==0)
		{
			m[p4]=1;
			count++;
		} 
	}
	p.z=7;
//	q.push(p);
	p1.z=6;
//	q.push(p1);
	p.w=fc+1;
	p1.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
	if(m1[p1]==0)
	{
		q.push(p1);
		m1[p1]=1;
	}
}
void c9(point &p,int k,int fc)
{
	for(int i=0;i<k;i++)
	{
		p.x++;
		p.y++;
		pi p4;
		p4.x=p.x;
		p4.y=p.y;
		if(m[p4]==0) 
		{
			m[p4]=1;
			count++; 
		} 
		pi p3;
		p3.x=-p.x;
		p3.y=p.y;
		if(m[p3]==0)
		{
			m[p3]=1;
			count++;
		} 
	}
	p.z=3;
	//q.push(p);
	p.w=fc+1;
	if(m1[p]==0)
	{
		q.push(p);
		m1[p]=1;
	}
}
void dy(point &p,int k2,int k3)
{
	switch(p.z)
	{
		case 1:
			c1(p,k2,k3);
			break;
		case 2:
			c2(p,k2,k3);
			break;
		case 3:
			c3(p,k2,k3);
			break;
		case 4:
			c4(p,k2,k3);
			break;
		case 5:
			c5(p,k2,k3);
			break;
		case 6:
			c6(p,k2,k3);
			break;
		case 7:
			c7(p,k2,k3);
			break;
		case 8:
			c8(p,k2,k3);
			break;
		case 9:
			c9(p,k2,k3);
			break;
	}
}
int main()
{
	int n;
	scanf("%d",&n);
	point t;
	int *a=new int[n+1];
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(int i=0;i<n;i++)
	{
		if(i==0)
		{
			for(int m1=1;m1<=a[0];m1++)
			{
				t.x=0;
				t.y=m1;
				t.z=0;
				pi t1;
				t1.x=t.x;
				t1.y=t.y;
				m[t1]=1;
				count++;
				if(m1==a[0])
				{
					t.z=9;
					t.w=i;
					q.push(t);
				}
			}
		}
		else
		{
			int m2=q.size();
			for(int m3=0;m3<m2;m3++)
			{
				point p2=q.front();
				q.pop();
				p2.w=i;
				//cout<<p.x<<p.y<<endl;
				//int k=a[i];
				dy(p2,a[i],i);
		
			}	
		}		
	}
	cout<<count<<endl;
	count=0;
	while(!q.empty())
	{
		q.pop();
	}
	return 0;
}

6.DFS AC代码

#include<iostream>
#include<map>
#include<vector>
#include<queue>
using namespace std;
struct point{
	int x;
	int y; 
	int num;
	int dire;
	point(){
	}
	point(int a,int b,int c,int d){
		x=a;
		y=b;
		num=c;
		dire=d;
	}
	bool operator<(const point &p) const{
		if(x==p.x)
		{
			if(y==p.y)
			{
				if(num==p.num)
				{
					if(dire!=p.dire) return dire<p.dire;
				}
				return num<p.num;
			}
			return y<p.y;
		}
		return x<p.x;
	}

};
struct pi{
	int x;
	int y; 
	bool operator<(const pi &p) const{
		return x !=p.x ? x<p.x : y<p.y;
	}
};
map<pi,int>m1; //到达 
map<point,bool>m2;//分裂 
int count=0,n;
point np,nnp;
int dx[8]={0,1,1,1,0,-1,-1,-1};
int dy[8]={1,1,0,-1,-1,-1,0,1};
int fc[30]={0};
void dfs(point &p)
{
	if(p.num==n)
	{
		return;
	 }
	if(m2[p]==false)
	{
		m2[p]=true;
		for(int i=1;i<=fc[p.num];i++)
		{
			pi p1;
			p1.x=p.x+dx[p.dire]*i;
			p1.y=p.y+dy[p.dire]*i;
			if(m1[p1]==0)
			{
				m1[p1]=1;
				count++;
			}
		}
		int k1=p.x+dx[p.dire]*fc[p.num];
		int k2=p.y+dy[p.dire]*fc[p.num];
		int k3=(p.dire+1)%8;
		int k4=p.num+1;
		point np(k1,k2,k4,k3);
		dfs(np);
		int k5=p.x+dx[p.dire]*fc[p.num];
		int k6=p.y+dy[p.dire]*fc[p.num];
		int k7=(p.dire+7)%8;
		int k8=p.num+1;
		point nnp(k5,k6,k8,k7);
		dfs(nnp);
	}
} 
int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>fc[i];
	}
	point p(0,0,0,0);
	dfs(p);
	cout<<count<<endl;
	return 0;
}
陌浮生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C 可怕的宇宙射线（Week4CSP模拟）
小小根堆的博客
03-13 498
题目描述 众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁人的智商，进行降智打击！ 宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该...
可怕的宇宙射线
Tony Yang的博客
03-12 542
题意： 宇宙射线会在无限的二维平面上传播(可以看做一个二维网格图)，初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的左右45°方向分裂出两条宇宙射线，同时威力不变。宇宙射线会分裂n次，每次分裂后会在分裂方向前进ai 个单位长度。计算出共有多少个位置会被打击。 输入： 输入第一行包含一个正整数n(n <= 30)，表示宇宙射线会分裂n次，第二行包含n个正整数a1,a2…an，第i...
C-可怕的宇宙射线
chihiro的博客
03-15 474
题目： 众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁人的智商，进行降智打击！ 宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方...
可怕的宇宙射线（dfs/bfs+剪枝）
龙征天的博客
03-14 568
文章目录问题描述InputOutputSample inputSample output数据范围样例解释解题思路完整代码关于此题的优秀博客链接 问题描述 \hspace{17pt}众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发...
程序设计思维（CSP模拟题） 可怕的宇宙射线（宽度优先搜索+剪枝）
weixin_43826681的博客
03-20 214
题目 众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁人的智商，进行降智打击！ 宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方...
2022 CSP-J1 CSP-S1 初赛 资料集（2022.07.08).pdf
07-08
本资源是关于 2022 年 CSP-J1 CSP-S1 初赛的资料集，包含了报名通知、成绩及分数线汇总、相关书籍、培训计划、学习要点、复习方法、知识汇总、模拟题、答案解析、视频等内容。本资源主要面向青少年趣味编程和 C++ ...
2019-2021 CSP-J CSP-S 第一轮成绩及分数线汇总.pdf
05-17
CSP-J和CSP-S认证考试科目详解 CSP-J和CSP-S认证考试是中国计算机学会（CCF）举办的计算机等级考试，旨在考察考生的计算机基础知识和编程能力。下面是对CSP-J和CSP-S认证考试科目的详细解释： 一、CSP-J认证考试...
2020 CSP-J1 CSP-S1答案解析及总结(C)-2021.08.23(B)--56页.pdf
08-24
* 备战CSP2020，初赛讲解，NOIP CSP-J CSP-S CSP-J/S * 信奥CSP入门级2019年初赛试题精讲 * 备战CSP2020，初赛讲解，NOIP CSP-J CSP-S CSP-J/S * 2011-2020NOIP/CSP普及组初赛真题解析 * 2019CSP提高初赛 * CSP2019-...
CSP-J模拟赛：真题复现
08-02
考试试卷
CSP-J CSP-S 初赛模拟题_(C)-2021.09.01(H)--18页.pdf
09-01
CSP-J CSP-S 初赛模拟题汇总 本资源汇总了CSP-J和CSP-S的初赛模拟题，涵盖了2019年和2020年的初赛试题，以及相关的评级分数线和模拟试题分析。这些资源对于参加CSP-J和CSP-S比赛的学生和教师具有重要的参考价值。 ...
【Week4 CSP C】可怕的宇宙射线【dfs剪枝】
xKuro的博客
03-15 216
题意： 宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的左右45度方向分裂出两条宇宙射线，同时威力不变。宇宙射线会分裂n次(n<=30)，每次分裂后会在分裂方向上前进ai个单位长度(ai<=5)。请输出有多少个位置会被宇宙射线影响到。 思路： 整体思路为dfs剪枝。 首先二维平面使用pointpm类型,记录是否...
可怕的宇宙射线-bfs
weixin_44203022的博客
03-17 128
宇宙射线 问题分析 题干说明是每条射线都会分成两条射线，一条顺时针转45度，一条逆时针转45度。即每条路径都会另分出两条路径，我们要做的是遍历每条路径并计算走的不同位置。使用bfs或dfs都可达成目的，此处采用dfs思想。 首先需要解决不同方向的表示问题，一开始直接枚举了八种方向分别判断，但是写出代码后发现过于冗杂，代码重复度很高，于是总结在不同方向前进时，x,y的变化规律，写入数组。 首先对各个...
可怕的宇宙射线(dfs+剪枝)
zhL816的博客
03-15 385
写在前面： 对于这个问题，首先我们可以采用暴力bfs或者dfs，但是这种算法的复杂度是指数级的，如果考虑分裂30次，那么它的循环次数是2302^{30}230，如果在正规比赛中肯定会超时，在询问了大佬之后，这个问题可以采用dfs加上剪枝来解决，这里和大家分享一下 问题描述： 在浩瀚的宇宙中，存在着1种生物， 这种生物可以发出宇宙射线!宇宙射线可以摧毁人的智商，进行降智打击! 宇宙射线会在无限的...
ｃｓｐ补题—Ｃ—可怕的宇宙射线
XiaoAnn的博客
03-21 233
题目描述： 众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天 生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁人的智商，进行降智打击！ 宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后...
2022CSP游记
Evan_song1234的博客
09-11 856
CSP2022RP++
宇宙射线：它们对程序产生影响的概率是多少？
asdfgh0077的博客
01-13 1485
我再一次进行了设计评审，并且遇到了一个声称，即某个特定场景的概率“低于宇宙射线的风险”影响了该程序，而且我发现我没有最清楚的想法是什么概率是。 “因为2 -128是34028236692
【递归、搜索与回溯】穷举vs暴搜vs深搜vs回溯vs剪枝
fight_p的博客
06-11 1216
管他什么深搜、回溯还是剪枝，画出决策树就完事了~~~
国内移动端APP月活跃（MAU）Top5000 数据整理
06-16
国内移动端APP月活跃（MAU）Top5000 时间范围：2020年-2022年 具有一定参考价值 csv格式
和平巨魔跨进成免费.ipa
最新发布
06-16
和平巨魔跨进成免费.ipa
csp-j+csp-s新题型初赛模拟试题附答案
08-01
csp-j 和 csp-s 是中国计算机学会（Chinese Computer Federation）举办的一系列计算机科学竞赛。这些竞赛旨在提高学生的计算机科学能力和解决实际问题的能力。 这个问题中提到的是 csp-j csp-s 新题型初赛模拟试题附答案。具体的试题内容我无法提供，因为每届竞赛的试题都是新的，为了保证公平性，试题一般不会提前公布。也就是说，我无法提供 csp-j csp-s 新题型初赛模拟试题的真实试题内容。 但是，可以给你一些关于 csp-j csp-s 新题型初赛模拟试题的一般性信息。这些试题可能涉及到各种算法和数据结构的应用，如图论、动态规划、贪心算法等。题目可能会要求解决实际问题，例如最短路径、最小生成树、网络流等。此外，还可能包含简单的编程任务，例如编写一个算法来解决某个特定问题。 如果你需要真实的题目及其答案，我建议你去中国计算机学会官方网站或相关竞赛官方网站查询。那里会提供最新的试题和答案。希望这些信息对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值