binflcy

蓝桥杯大赛决赛整理合集（B组C/C++）

根据大纲梳理一遍，也在全文最后补充了最几年的决赛真题，全文基于C++编写，希望对你有所帮助
关于省赛的反思：
1.我的Code::Block 20.03在机房的电脑调不出来（我决定还是用DEV）
2.暴力算法枚举不要指望学校机房的CPU
3.注意数据的规模，写完一部分代码块记得调试运行一下
ps:真题做下来不难发现小明是个究极强迫症QVQ，期末没有什么时间写，还要英语四级，提前cue借口，但还是加油！！
——以上是2021年的整理
经过寒假对考研数据结构的复习，对~~算法有了新的感悟~~）。
继续整理的栈队列树图排序

大纲要求

C/C++程序设计基础：包含使用 C/C++编写程序的能力。该部分不考查选手对某一语法的理解程度，选手可以使用自己喜欢的语句编写程序。选手可在 C 语言程序中使用标准 C 的库函数，在 C++语言程序中使用标准 C++的库函数（包括 C 库、STL 等）。
计算机算法：枚举、排序、搜索、计数、贪心、动态规划、图论、数论、博弈论*、概率论*、计算几何*、字符串算法等。
数据结构：数组、对象/结构、字符串、队列、栈、树、图、堆、平衡树/线段树、复杂数据结构*、嵌套数据结构*等。

一、STL

1.vector容器（单端数组）

vector容器可以动态地扩展（原数据拷贝新空间）

#include
#include
using namespace std;
int main(){
	vector<int> v1;//默认构造
	v1.push_back(1);//尾部插入 
	v1.pop_back();//尾部删除最后一个元素
	v1.insert(v1.begin(),100);//在迭代器指定位置插入数据
	v1.erase(v1.begin());//删除迭代器指定位置
	v1.clear();//清空 
	cout<<v1.capacity()<<endl;//输出容量	 
	cout<<v1.size()<<endl;//元素个数 
	v1.resize(15,100);//指定默认填充值拓展容量
	cout<<v1[0]<<" "<<v1[1]<<endl; //输出数据
	vector<int> v2(v1.begin(),v1.end());//区间方式构造
	vector<int> v3(10,100);//v3中有10个100
	vector<int> v4(v3);//拷贝构造
	if(v1.empty()){//判断是否为空 
		cout<<"空"<<endl;
	}
	v1.reserve(100);//预留空间，元素不可以访问 
	v1.swap(v2);//交换两个容器中的数据 
	vector<int>(v).swap(v)//巧用可以压缩空间
	return 0;
}

2.queue容器（队列——先进先出）

一般会结合bfs使用

#include
#include
using namespace std;
int main(){
	queue<int> q;
	q.push(1);//入队
	q.push(2); 
	cout<<"队列是否为空："<<q.empty()<<endl;
	cout<<"队头元素是："<<q.front()<<endl;
	cout<<"队尾元素是："<<q.back()<<endl;
	q.pop();//出队 
	cout<<"队列元素个数："<<q.size()<<endl;
	return 0; 
}

3.map/multimap容器（关联式——二叉树）

可以很方便地用Key值查找value值
map容器：不允许有重复key值
multimap容器：允许有重复key值

#include
#include
using namespace std;
class cmp{//指定降序插入 
	public:
		bool operator()(int v1,int v2){
			return v1>v2;
		}
}; 
int main(){
	map<int,int> m1;//创建map容器 
	map<int,int> m2(m1);//拷贝构造 
	map<int,int,cmp> m3;//按照指定规则排序 (默认按照key的升序插入)
	m1.insert(pair<int,int>(2,30));//插入数据 
	m1.insert(make_pair(1,10));//插入数据(这种方式不用写数据类型)
	m1.insert(make_pair(1,20));//不允许插入重复的key值（保留先插入的） 
	cout<<"容器是否为空："<<m1.empty()<<endl;
	cout<<"容器元素个数："<<m1.size()<<endl;
	cout<<"容器中有几个key为1的值：" <<m1.count(1)<<endl;
	map<int,int>::iterator pos = m1.find(2);//查找有没有key为2的元素，返回迭代器
	if(pos!=m1.end()){
		cout<<"找到了"<<endl;
	} 
	m1.swap(m2);//交换两个容器的元素 
	cout<<m2[1]<<endl;//利用key访问value值 
	m2.erase(m2.begin());//删除迭代器指定元素
	m2.erase(2);//根据指定的key值删除 
	m2.erase(m2.begin(),m2.end());//根据指定区间删除
	m2.clear();//清空容器 
	return 0; 
}

二、枚举

三、排序

试题历届试题字串排序

问题描述

小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。在冒泡排序中，每次只能交换相邻的两个元素。小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符，则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。例如，对于字符串 lan 排序，只需要 1次交换。对于字符串 qiao 排序，总共需要4次交换。小蓝的幸运数字是V，他想找到一个只包含小写英文字母的字符串，对这个串中的字符进行冒泡排序，正好需要V次交换。请帮助小蓝找一个这样的字符串。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。请注意字符串中可以包含相同的字符。
输入格式
输入一行包含一个整数，为小蓝的幸运数字。
输出格式
输出一个字符串，为所求的答案。
样例输入
4
样例输出
bbaa

四、搜索

一个很赞的BFS和DFS讲解

1.BFS（广度优先——队列）

引子：

试题1 历届试题九宫重排

问题描述
　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。

我们把第一个图的局面记为：12345678.把第二个图的局面记为：123.46758　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。
输入格式
　　输入第一行包含九宫的初态，第二行包含九宫的终态。
输出格式
　　输出最少的步数，如果不存在方案，则输出-1。
样例输入
12345678.
123.46758
样例输出 3
样例输入
13524678.
46758123.
样例输出 22

代码梳理

1.将九宫格的初始状态和目标状态以二维数组的形式存储，并标记初始空白格的位置
2.从初始状态的空白格开始广度优先遍历
->终止条件，达到目标状态，输出步骤/不存在方案 输出-1
->搜索：将当前状态入队，从队头开始，把空白格向四个方向挪动，如果可以挪动，判断是否满足目标九宫格，不满足再把当前状态入队。
  当无法再挪动时，在从队头寻找新的状态，直到队空。
3.剪枝：其中在bfs时，如果遇到之前已经出现的状态就不需要再遍历了。

实现代码

#include
#include
#include
#include
using namespace std;
char start[4][4];
char goal[4][4];
int df[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
map<string,int> vis;
struct Node{//结点结构体，存储当前坐标，步骤，九宫格状态 
	int x,y;
	long long step;
	char Map[4][4];
};
bool check_g(Node a){
	for(int i=1;i<=3;i++){
		for(int j=1;j<=3;j++){
			if(a.Map[i][j]!=goal[i][j])
			return false;//如果有一个位置不符合就返回false 
		}
	}
	return true;//全部符合就返回true 
}
bool check_cf(Node a){//判断剪枝 
	string s="";
	for(int i=1;i<=3;i++){
		for(int j=1;j<=3;j++){
			s+=a.Map[i][j];
		}
	}
	if(vis[s]>0)
	return false;
	vis[s]++;
	return true;
}
int bfs(int x1,int y1){//传入空白格的标记坐标 
	Node cur,next;//创立两个结点 （当前和下一个） 
	cur.x=x1;// 传入当前空白格的坐标 
	cur.y=y1;
	cur.step=0;//初始化步骤数 
	for(int i=1;i<=3;i++){
		for(int j=1;j<=3;j++){
			cur.Map[i][j]=start[i][j];//对当前九宫格初始化 
		}
	}
	queue<Node> Q;//创建一个队列 
	Q.push(cur);//将当前结点传入队列 
	if(check_g(cur)){//检查是否已经转化成目标九宫格 
		return cur.step;//已经是目标九宫格返回所需要的步骤 
	}
	while(!Q.empty()){//如果队列不为空 
		cur=Q.front();//取出队头元素 
		Q.pop();//出队 
		for(int i=0;i<4;i++){
			next.x=cur.x+df[i][0];//分别将空白格向四个方向移动 
			next.y=cur.y+df[i][1];
			for(int i1=1;i1<=3;i1++){
				for(int j=1;j<=3;j++){
					next.Map[i1][j]=cur.Map[i1][j];//存入下一个九宫格的状态			
			}
		}
		next.step=cur.step+1;//挪动的步骤+1 
		if(next.x>=1&&next.x<=3&&next.y>=1&&next.y<=3){//如果在边界内 
		swap(next.Map[next.x][next.y],next.Map[cur.x][cur.y]);//移动空白格 
		if(check_cf(next)){//检查是否重复 
			if(check_g(next)){//检查是否满足需求 
			return next.step;
			}
			Q.push(next);//把当前结点入队 
		}
	}
}
	}
	return -1;
}
int main(){
	int x1,y1;//空白格的位置 
	for(int i=1;i<=3;i++){
		for(int j=1;j<=3;j++){
			cin>>start[i][j];//输入起始九宫格状态 
			if(start[i][j]=='.'){
				x1=i; //遇到 。标记位置 
				y1=j;
			}
		}
	}
	for(int i=1;i<=3;i++){
		for(int j=1;j<=3;j++){
			cin>>goal[i][j];//输入目标九宫格的状态 
		}
	}
	cout<<bfs(x1,y1)<<endl;//bfs寻找最小步骤 
	return 0;
}

2.DFS（深度优先——栈）

引子：棋盘中的棋子摆放方法有几种

试题1 历届试题大臣的旅费

问题描述
很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？
输入格式
输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数城市从1开始依次编号，1号城市为首都。接下来n-1行，描述T国的高速路（T国的高速路一定是n-1条）每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。
输出格式
输出一个整数，表示大臣J最多花费的路费是多少。

#include
#include
#include
using namespace std;
struct road{
	int d,l;
};
vector<road> G[10000];
int visit[10000];
int totallen,maxlen,start;
void dfs(int s){
	if(maxlen<totallen){
		maxlen=totallen;
		start=s;
	}
	for(int i=0;i<G[s].size();i++){
		road k=G[s][i];
		if(!visit[k.d]&&k.l){
			visit[k.d]=1;
			totallen+=k.l;
			dfs(k.d);
			visit[k.d]=0;
			totallen-=k.l;
		}
	}
	return;
}
int main(){
	int n,a,s;
	cin>>n;
	road r;
	for(int i=0;i<n-1;i++){
		cin>>s>>r.d>>r.l;
		G[s].push_back(r);
		a=r.d;
		r.d=s;
		G[a].push_back(r); 
	}
	memset(visit,0,sizeof(visit));
	totallen=0;
	visit[1]=1;
	dfs(1);
	memset(visit,0,sizeof(visit));
	totallen=0;
	maxlen=-1;
	visit[start]=1;
	dfs(start);
	cout<<((11+10+maxlen)*maxlen)/2<<endl;
	return 0;
}

3.回溯算法总结

一个很好的回溯算法总结

题型：组合，切割，子集，排列，棋盘

回溯模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

（1）组合

#include
#include
using namespace std;
vector<int> path;
vector< vector<int> > result;//这里要注意<>中的空格不然会当>>报错
void backtracking(int n,int k,int starIndex){
	if(path.size()==k){
		result.push_back(path);
		for(int i=0;i<path.size();i++){
			cout<<path[i];
		}
		cout<<endl;
		return;
	}
	for(int i=starIndex;i<=n-(k-path.size())+1;i++){//优化剪枝
		path.push_back(i);
		backtracking(n,k,i+1);
		path.pop_back();
	}
}
int main(){
	int n,k;//返回 1 ... n 中所有可能的 k 个数的组合
	cin>>n>>k;
	backtracking(n,k,1); 
	return 0;
}

（2）组合总和

#include
#include
using namespace std;
vector<int> path;
vector< vector<int> > result;
int targetsum;
void backtracking(int n,int k,int sum,int starIndex){
	if(sum>targetsum){
		return;
	}
	if(path.size()==k){
		if(sum==targetsum){
			result.push_back(path);
			for(int i=0;i<path.size();i++){
				cout<<path[i];
			}
			cout<<endl;	
		}	
		return;
	}
	for(int i=starIndex;i<=n;i++){
		sum+=i;
		path.push_back(i);
		backtracking(n,k,sum,i+1);
		sum-=i; 
		path.pop_back();
	}
}
int main(){
	int n,k;//返回 1 ... n 中所有可能的 k 个数的组合使其达到目标值 
	cin>>n>>k>>targetsum;
	backtracking(n,k,0,1);
	cout<<"总共有："<<result.size()<<"取法"<<endl; 
	return 0;
}

（3）分割回文串

#include
#include
using namespace std;
vector<string> path;
vector< vector<string> > result;
bool isPalindrome(string s,int start,int end){
	for(int i=start,j=end;i<j;i++,j--){
		if(s[i]!=s[j]){
			return false;
		}
	}
	return true;
}
void backtracking(string s,int startIndex){
	if(startIndex>=s.size()){
		result.push_back(path);
		return;
	}
	for(int i=startIndex;i<=s.size();i++){
		if(isPalindrome(s,startIndex,i)){
			string str=s.substr(startIndex,i-startIndex+1);//获取分割子串 
			path.push_back(str);
		}
		else{
			continue;
		}
		backtracking(s,i+1);
		path.pop_back();
	}
}
int main(){
	string s;
	cin>>s;
	backtracking(s,0);
	cout<<"总共有："<<result.size()<<"取法"<<endl; 
	return 0;
}

（4）求子集

#include
#include
using namespace std;
vector<int> path;
vector< vector<int> > result;
vector<int> nums;
void backtracking(vector<int> nums,int startIndex){
	result.push_back(path);
	for(int i=0;i<path.size();i++){
		cout<<path[i];
	}
	cout<<endl;
	if(startIndex>=nums.size()){
		return;
	}
	for(int i=startIndex;i<nums.size();i++){
		path.push_back(nums[i]);
		backtracking(nums,i+1);
		path.pop_back();
	}
}
int main(){
	int n,num;
	cin>>n;//输入要求子集的集合 
	for(int i=1;i<=n;i++){
		cin>>num;
		nums.push_back(num);
	}
	backtracking(nums,0);
	cout<<"总共有："<<result.size()<<"子集"<<endl; 
	return 0;
}

五、计数

六、贪心

七、动态规划（本质递归）

引子：Fibonacci sequence
利用递推公式：Fib(n+2) = Fib(n+1) + Fib(n)，Fib(1) = Fib(2) = 1

利用递归的时间复杂度O(2^n)，想象成一棵二叉树，每次计算一个新的Fib(n)就要展开一次分支，效率很低。
但是如果把得出结果的Fib(n)、Fib(n-1)保存，Fib(n+1)用到的时候直接调用，是不是就把效率提高了。这就是动态规划的思想。下面利用动态规划解决一下Fibonacci sequence问题。

#include 
#define MAX 10000
using namespace std;
int Fib(int n){
    int F[MAX];//用数组存储结果
    F[1]=F[2]=1;
    for(int i=3;i<=n;i++)
        F[i]=F[i-1]+F[i-2];
    return F[n];//直接调用
}
int main()
{
    cout<<Fib(6)<<endl;
    return 0;
}

使用情形：
1、选择/不选择，求最优解（2维dp）以下试题按照难以程度升序排列

试题1 算法提高 01背包

问题描述
　　给定N个物品,每个物品有一个重量W和一个价值V.你有一个能装M重量的背包.问怎么装使得所装价值最大.每个物品只有一个.
输入格式
　　输入的第一行包含两个整数n, m，分别表示物品的个数和背包能装重量。
　　以后N行每行两个数Wi和Vi,表示物品的重量和价值
输出格式
　　输出1行，包含一个整数，表示最大价值。
样例输入
3 5
2 3
3 5
4 7
样例输出
8
数据规模和约定
1<=N<=200,M<=5000.

#include
using namespace std;
int W[5004];
int Vi[5004];
int dp[5004][5004];//动态规划 
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>W[i]>>Vi[i];
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			dp[i][j]=dp[i-1][j];
			if(j>=W[i]){
				dp[i][j]=max(dp[i][j],dp[i-1][j-W[i]]+Vi[i]);// 
			}
		}
	}
	cout<<dp[n][m];//最大价值 
	return 0;
}

试题2 试题算法提高秘密行动

问题描述
　　小D接到一项任务，要求他爬到一座n层大厦的顶端与神秘人物会面。这座大厦有一个神奇的特点，每层的高度都不一样，同时，小D也拥有一项特殊能力，可以一次向上跳跃一层或两层，但是这项能力无法连续使用。已知向上1高度消耗的时间为1，跳跃不消耗时间。由于事态紧急，小D想知道他最少需要多少时间到达顶层。
输入格式
　　第一行包含一个整数n，代表楼的高度。
　　接下来n行每行一个整数ai，代表i层的楼层高度（ai <= 100）。
输出格式
　　输出1行，包含一个整数，表示所需的最短时间。
样例输入
5
3
5
1
8
4
样例输出
1
数据规模和约定
　　对20%的数据,n<=10
　　对40%的数据,n<=100
　　对60%的数据,n<=5000
　　对100%的数据,n<=10000

#include
using namespace std;
int main(){
	int n;
	cin>>n;
	int ai[10005];
	for(int i=1;i<=n;i++){
		cin>>ai[i];
	}
	int dp[10005][2];//动态规划二维dp[每层楼][每层楼的选择0爬，1跳] 
	memset(dp,0,sizeof(dp));
	dp[1][0]=ai[1];//初始化，第一层选择爬的情况
	dp[1][1]=0;//第一层选择跳的情况
	for(int i=2;i<=n;i++){
		dp[i][0]=min(dp[i-1][0],dp[i-1][1])+ai[i];//如果选择爬的话，那么之前一层可以是爬，也可以是跳上来的
		dp[i][1]=min(dp[i-1][0],dp[i-2][0]);//如果是使用超能力，那么之前的一层/两层必须是爬上来的 
	} 
	cout<<min(dp[n][0],dp[n][1])<<endl;//选择最终耗时最短的方法 
	return 0;
}

试题3 算法提高第二点五个不高兴的小明

问题描述 　　有一条长为n的走廊，小明站在走廊的一端，每次可以跳过不超过p格，每格都有一个权值wi。　　小明要从一端跳到另一端，不能回跳，正好跳t次，请问他跳过的方格的权值和最大是多少？
输入格式 　　输入的第一行包含两个整数n, p, t，表示走廊的长度，小明每次跳跃的最长距离和小明跳的次数。　　接下来n个整数，表示走廊每个位置的权值。
输出格式 　　输出一个整数。表示小明跳过的方格的权值和的最大值。
样例输入 8 5 3 3 4 -1 -100 1 8 7 6
样例输出 12
数据规模和约定 　　1<=n, p, t<=1000, -1000<=wi<=1000。

#include
using namespace std;
const long long int inf=0x3f3f3f;
int main(){
	long long int n,p,t;
	cin>>n>>p>>t;
	long long int dp[1005][1005]; //当前格，当前跳的最大权值和
	long long int wi[1005];
	for(int i=1;i<=n;i++){//输入每一格距离的权值 
		cin>>wi[i];
	} 
	if(n>p*t){
		n=p*t;//划定距离，使其在跳跃能力范围内 
	}                      
	for(int i=n;i>=n-p&&i>=0;i--){//动态规划的初始化，我们从最后开始，定义最后一步。 
		dp[i][1]=wi[i];//最后一格的最后一跳 
	} 
	for(int i=n;i>=0;i--){
		for(int j=2;j<=t;j++){
			dp[i][j]=-inf;
			for(int k=1;k<=p&&i+k<=n;k++){
				dp[i][j]=max(dp[i+k][j-1],dp[i][j]);
			}
			if(dp[i][j]!=-inf){
				dp[i][j]+=wi[i];//如果找出步数内的最大值，那么加上自身的权值 
			}
		}
	} 
	cout<<dp[0][t]<<endl;
	return 0;
}

试题4 算法提高和谐宿舍2

问题描述
　　我的某室友学过素描，墙上有n张他的作品。这些作品都是宽度为1，高度不定的矩形，从左到右排成一排，且底边在同一水平线上。宿舍评比就要来了，为了及格，我们决定买不多于m块的矩形木板，把这些作品和谐掉。要求木板也从左到右排成一排，且底边与作品的底边在同一水平线上。在能够把所有作品和谐掉的前提下，我们希望这些木板的面积和最小，问最小面积和。
　　
输入格式
　　第一行两个数n和m，表示作品数和木板数；
　　第二行n个数Hi，表示从左到右第i个作品的高度。
输出格式
　　一行一个数ans，表示答案。
样例输入
5 2
4 2 3 5 4
样例输出
22
数据规模和约定
　　对于30%的数据：1<=n，m<=10；
　　对于100%的数据：1<=n，m<=100，1<=Hi<=10000。

#include
#define INF 0x3f3f3f3f
using namespace std;
int main(){
	int h[105];
	int hmax[105][105];
	int dp[105][105];
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>h[i];
	} 
	for(int i=1;i<=n;i++){ 
		for(int j=i;j<=n;j++){
			hmax[i][j]=max(hmax[i][j-1],h[j]);
		}
	}
	memset(dp,INF,sizeof(dp));
	for(int i=1;i<=n;i++){ 
		dp[i][1]=i*hmax[1][i];
		for(int j=2;j<=m;j++){
			for(int k=1;k<=i-j+1;k++){
				dp[i][j]=min(dp[i][j],dp[i-k][j-1]+k*hmax[i-k+1][i]);
			}
		}
	}
	cout<<dp[n][m]<<endl;
	return 0;
}

八、图论

dfs:

tarjan算法
lca算法

九、数论

十、博弈论

十一、概率论

十二、计算几何

十三、字符串算法

KMP（主要应用在字符串匹配上）

一个很好的KMP总结

前缀：不包含尾字母的所有子串
后缀：不包含首字母的所有子串
前缀表：相等前后缀的记录

匹配模型

构建前缀表

void getNext_1(int *next,string s){
	int j=0;
	next[j]=0;
	for(int i=1;i<s.size();i++){
		while(j>0&&s[i]!=s[j]){
			j=next[j-1];
		}
		if(s[i]==s[j]){
			j++;
		}
		next[i]=j;
	}
}

主函数调用

int main(){
	string s;//需要匹配的字符
	string s1;//被匹配的字符 
	cin>>s>>s1; 
	int next[s.size()];
	getNext(next,s);
	int j=0;
	for(int i=0;i<s1.size();i++){
		while(j>0&&s1[i]!=s[j]){
			j=next[j-1];
		}
		if(s1[i]==s[j]){
			j++;
		}
		if(j==s.size()){
			cout<<s1<<"可以匹配"<<endl;
			break;
		}
	}
	return 0;	
}

试题1：算法提高字符串匹配

问题描述
　　给出一个字符串和多行文字，在这些文字中找到字符串出现的那些行。你的程序还需支持大小写敏感选项：当选项打开时，表示同一个字母的大写和小写看作不同的字符；当选项关闭时，表示同一个字母的大写和小写看作相同的字符。
输入格式 　　
　　输入的第一行包含一个字符串S，由大小写英文字母组成。
　　第二行包含一个数字，表示大小写敏感的选项，当数字为0时表示大小写不敏感，当数字为1时表示大小写敏感。
　　第三行包含一个整数n，表示给出的文字的行数。　　
　　接下来n行，每行包含一个字符串，字符串由大小写英文字母组成，不含空格和其他字符。
输出格式 　　
　　输出多行，每行包含一个字符串，按出现的顺序依次给出那些包含了字符串S的行。
样例输入
Hello 1 5 HelloWorld
HiHiHelloHiHi
GrepIsAGreatTool HELLO
HELLOisNOTHello
样例输出
HelloWorld
HiHiHelloHiHi
HELLOisNOTHello
样例说明
　　在上面的样例中，第四个字符串虽然也是Hello，但是大小写不正确。如果将输入的第二行改为0，则第四个字符串应该输出。评测用例规模与约定
　　1<=n<=100，每个字符串的长度不超过100。

#include
using namespace std;
string s1[104];
string s;
void getNext_0(int *next,string s){
	int j=0;
	next[j]=0;
	for(int i=1;i<s.size();i++){
		char c1,c2;
		c1=s[i]-'A'+'a';
		c2=s[i]-'a'+'A';
		while(j>0&&c1!=s[j]&&c2!=s[j]&&s[i]!=s[j]){
			j=next[j-1];
		}
		if(s[i]==s[j]||c1==s[j]||c2==s[j]){
			j++;
		}
		next[i]=j;
	}
}
void getNext_1(int *next,string s){
	int j=0;
	next[j]=0;
	for(int i=1;i<s.size();i++){
		while(j>0&&s[i]!=s[j]){
			j=next[j-1];
		}
		if(s[i]==s[j]){
			j++;
		}
		next[i]=j;
	}
}
int main(){
	int num,n;
	cin>>s>>n>>num;
	for(int i=0;i<num;i++){
		cin>>s1[i]; 
	}
	if(s.size()==0){
		return 0;
	}
	int next[s.size()];
	for(int k=0;k<num;k++){
		string p=s1[k];
		if(p.size()<s.size()){
			continue;
		}
		if(n==0){//大小写不敏感 
			getNext_0(next,s);
			int j=0;
			for(int i=0;i<p.size();i++){
				char c1,c2;
				c1=p[i]-'A'+'a';
				c2=p[i]-'a'+'A';
				while(j>0&&p[i]!=s[j]&&c1!=s[j]&&c2!=s[j]){
					j=next[j-1];
				}
				if(p[i]==s[j]||c1==s[j]||c2==s[j]){
					j++;
				}
				if(j==s.size()){
					cout<<p<<endl;
					break;//这里加break很重要不然如果一个字符串中有其他匹配的就会一直输出。
				}
			}
		}
		if(n==1){//大小写敏感 
			getNext_1(next,s);
			int j=0;
			for(int i=0;i<p.size();i++){
				while(j>0&&p[i]!=s[j]){
					j=next[j-1];
				}
				if(p[i]==s[j]){
					j++;
				}
				if(j==s.size()){
					cout<<p<<endl;
					break;
				}
			}
		}
	}
	return 0;	
}

十四、数组

十五、对象/结构

十六、字符串

十七、队列

试题算法提高队列操作

【问题描述】
　　队列操作题。根据输入的操作命令，操作队列（1）入队、（2）出队并输出、（3）计算队中元素个数并输出。
输入格式
　　第一行一个数字N。
　　下面N行，每行第一个数字为操作命令（1）入队、（2）出队并输出、（3）计算队中元素个数并输出。
输出格式
　　若干行每行显示一个2或3命令的输出结果。注意：2.出队命令可能会出现空队出队（下溢），请输出“no”，并退出。
样例输入
7
1 19
1 56
2
3
2
3
2
样例输出
19
1
56
0
no
数据规模和约定
　　1<=N<=50

【思路】这里用到了queue（队列的STL容器）

定义一个queue的变量     queue<Type> Q
查看是否为空范例        Q.empty()    是的话返回1，不是返回0;
从已有元素后面增加元素   Q.push()
输出现有元素的个数      Q.size()
显示第一个元素          Q.front()
显示最后一个元素        Q.back()
清除第一个元素          Q.pop()

【注意】这里有个很顶的地方就是输出0后退出，就是漏了这个条件一直不能满分，这种编程题一定要看全！！！！

#include
#include
using namespace std;
queue<string> q;
int main(){
	stringstream ss;
	string s1;
	int N,op;
	string num;
	int k=0;
	cin>>N;
	string a[N];
	for(int i=0;i<N;i++){
		cin>>op;
		if(op==1){
			cin>>num;
			q.push(num);
		}
		if(op==2){
			if(!q.empty()){
				a[k++]=q.front();
				q.pop();
			}
			else{
			a[k++]="no";//请输出“no”，并退出。
			break;
			}
			
		}
		if(op==3){
			ss<<q.size();
			ss>>s1; 
			a[k++]=s1;
			ss.clear();
		}
	}
	for(int i=0;i<k;i++){
		cout<<a[i]<<endl;
	}
	return 0;
}

十八、栈

试题算法训练栈的研究

[问题描述]
宁宁考虑的是这样一个问题：一个操作数序列，从1，2，一直到n（图示为1到3的情况），栈A的深度大于n。
　　现在可以进行两种操作，
　　1.将一个数，从操作数序列的头端移到栈的头端（对应数据结构栈的push操作）
　　2. 将一个数，从栈的头端移到输出序列的尾端（对应数据结构栈的pop操作）
　　使用这两种操作，由一个操作数序列就可以得到一系列的输出序列，下图所示为由
　　1 2 3
　　生成序列
　　2 3 1
　　的过程。
　　
（原始状态如上图所示）
你的程序将对给定的n，计算并输出由操作数序列1，2，…，n经过操作可能得到的输出序列的总数。
输入格式
　　输入文件只含一个整数n（1≤n≤18）
输出格式
　　输出文件只有一行，即可能输出序列的总数目
样例输入
3
样例输出
5

【思路】这里我用到了卡特兰数，有兴趣的话你也可以用数学归纳推一下。
（n个不同的元素进栈，出栈不同序列个数有（1/1+n）*C（n,2n））

#include
using namespace std;
int main(){
	int n;
	long long count;
	cin>>n;
	long long a=1;//分子
	long long b=n+1;//分母 
	long long temp;
	for(int i=0;i<n;i++){
		 temp=2*n-i;
		 a*=temp;
		 temp=n-i;
		 b*=temp;
		 while(a%2==0&&b%2==0){//因为数字很大，只能时间换空间，除二收益很大，得不出答案再除以5，【7 9 11……以此类推】
		 	a/=2;
		 	b/=2;
		 }
		 while(a%3==0&&b%3==0){
		 	a/=3;
		 	b/=3;
		 }
	}
	count=a/b;
	cout<<count<<endl;
	return 0;
}

十九、图

二十、堆

二十一、平衡树/线段树

二十二、复杂数据结构

二十三、嵌套数据结构

第八届蓝桥杯大赛软件类决赛

试题A：36进制

[问题描述]
对于16进制，我们使用字母A-F来表示10及以上的数字。如法炮制，一直用到字母Z，就可以表示36进制。36进制中，A表示10，Z表示35，AA表示370你能算出
MANY 表示的数字用10进制表示是多少吗?
[答案提交]
1040254

#include
using namespace std;
int main(){
	int num;
	num=('m'-'a'+10)*pow(36,3)+
		('a'-'a'+10)*pow(36,2)+
		('n'-'a'+10)*36+
		('y'-'a'+10);
	cout<<num<<endl;
	return 0;
}

试题B：磁砖样式

[问题描述] 小明家的一面装饰墙原来是 310 的小方格。现在手头有一批刚好能盖住2个小方格的长方形瓷砖。瓷砖只有两种颜色：黄色和橙色。小明想知道，对于这么简陋的原料，可以贴出多少种不同的花样来。小明有个小小的强迫症：忍受不了任何22的小格子是同一种颜色。（瓷砖不能切割，不能重叠，也不能只铺一部分。另外，只考虑组合图案，请忽略瓷砖的拼缝）显然，对于 23 个小格子来说，口算都可以知道：一共10种贴法，如【p1.png所示】但对于 310 的格子呢？肯定是个不小的数目，请你利用计算机的威力算出该数字。

[答案提交]

在这里插入代码片

第九届蓝桥杯大赛软件类决赛

试题A：换零钞

[问题描述]
x星球的钞票的面额只有：100元，5元，2元，1元，共4种。小明去x星旅游，他手里只有2张100元的x星币，太不方便，恰好路过x星银行就去换零钱。小明有点强迫症，他坚持要求200元换出的零钞中2元的张数刚好是1元的张数的10倍，剩下的当然都是5元面额的。银行的工作人员有点为难，你能帮助算出：在满足小明要求的前提下，最少要换给他多少张钞票吗？（5元，2元，1元面额的必须都有，不能是0）
[答案提交]
74

#include
using namespace std;
int main(){
	for(int i=1;i<10;i++){
		int num,sum;
		num=200-21*i;
		num=num/5;
		if(num*5+21*i==200){
			sum=11*i+num;
			cout<<sum<<endl;
		}
	}
	return 0;
}

试题B：激光样式

[问题描述]
x星球的盛大节日为增加气氛，用30台机光器一字排开，向太空中打出光柱。安装调试的时候才发现，不知什么原因，相邻的两台激光器不能同时打开！国王很想知道，在目前这种bug存在的情况下，一共能打出多少种激光效果？显然，如果只有3台机器，一共可以成5种样式，即：
全都关上（sorry, 此时无声胜有声，这也算一种）开一台，共3种开两台，只1种， 30台就不好算了，国王只好请你帮忙了。要求提交一个整数，表示30台激光器能形成的样式种数。
[答案提交]
2178309

#include
using namespace std;
int main(){
	int dp[30][2];//30盏灯每盏都可以有两种状态选择 
	dp[0][0]=1;
	dp[0][1]=1;//为第一盏灯初始化
	for(int i=1;i<30;i++){
		dp[i][0]=dp[i-1][0]+dp[i-1][1];//如果当前灯是灭的它前一盏灯可以亮也可以不亮 
		dp[i][1]=dp[i-1][0];//当前灯如果要是亮的，前一盏灯就得是灭的 
	} 
	cout<<dp[29][0]+dp[29][1]<<endl; 
	return 0;
}

第十届蓝桥杯大赛软件类决赛（难度分水岭）

试题A:平方序列

[问题描述] 小明想找到两个正整数X和Y,满足 ●2019 [答案提交]
7020

#include
using namespace std;
int main(){
	bool flag=true;
	int x=2020;
	int num1,num2;
	while(flag){
		num1=2*x*x-2019*2019;
		num2=sqrt(num1);
		if(num2*num2==num1){
			cout<<num2+x<<endl;
			flag=false;
		}
		x++;
	}
}

试题B:质数拆分

[问题描述] 将2019拆分为若千个两两不同的质数之和，一共有多少种不同的方法?
注意交换顺序视为同一种方法，例如2+ 2017= 2019与2017 +2= 2019视为同一种方法。
[答案提交]
55965365465060

解析：
这是一个jave关于这道题的解析，里面的一张图示我觉得超赞就摘录了

#include
#include
using namespace std;

//找出2019中（2-2019每个数字中有几个质数,选择或者不选择） 
bool fun(int n){
	for(int i=2;i<=sqrt(n);i++){
		if(n%i==0){
			return false;
		}
	}
	return true;
}
int main(){
	vector<int> V;
	long long int dp[3000];
	for(int i=2;i<=2019;i++){
		if(fun(i)){
			V.push_back(i);
		}
	}
	memset(dp,0,sizeof(dp));
	dp[0]=1;
	for(int i=0;i<V.size();i++){
		for(int j=2019;j>=V[i];j--){
			dp[j]=dp[j]+dp[j-V[i]];
		}
	}
	cout<<dp[2019]<<endl;
	return 0;
}

第十一届蓝桥杯大赛软件类决赛

试题A:美丽的2

[问题描述] 小蓝特别喜欢2，今年是公元2020年，他特别高兴。他很好奇，在公元1年到公元2020年(包含)中，有多少个年份的数位中包含数字2?
[答案提交]
563

#include
using namespace std;
int main(){
	int q,b,s,g;
	int ans=0;
	for(int i=1;i<=2020;i++){
		q=i/1000;
		b=i%1000/100;
		s=i%100/10;
		g=i%10;
		if(q==2||b==2||s==2||g==2){
			ans++;
		}
	}
	cout<<ans<<endl;
	return 0;
}

试题B:扩散（BFS）

[问题描述] 小蓝在一张无限大的特殊画布上作画。这张画布可以看成一个方格图，每个格子可以用一个二维的整数坐标表示。小蓝在画布上首先点了一下几个点: (0,0), (2020, 11), (11, 14), (2000, 2000)。只有这几个格子上有黑色，其它位置都是白色的。每过一分钟，黑色就会扩散一点。具体的，如果一个格子里面是黑色，它就会扩散到上、下、左、右四个相邻的格子中，使得这四个格子也变成黑色 (如果原来就是黑色，则还是黑色)。请问，经过2020分钟后，画布上有多少个格子是黑色的。
[答案提交]
20312088

#include
#include
#include
using namespace std;
int m[6100][6100];
int ans;
const int a=2021;
int fx[4][2]={{1,0},{0,1},{0,-1},{-1,0}};
struct node{
	int x,y;
	int time;
};
void bfs(){
	queue<node> Q;
	m[0+a][0+a]=1;
	m[2020+a][11+a]=1;
	m[11+a][14+a]=1;
	m[2000+a][2000+a]=1;
	node n1,n2,n3,n4;
	n1.x=0+a;n1.y=0+a;n1.time=0;
	Q.push(n1);
	n2.x=2020+a;n2.y=11+a;n2.time=0;
	Q.push(n2);
	n3.x=11+a;n3.y=14+a;n3.time=0;
	Q.push(n3);
	n4.x=2000+a;n4.y=2000+a;n4.time=0;
	Q.push(n4);
	ans=4;
	node temp,next;
	while(!Q.empty()){
		temp=Q.front();
		Q.pop();
		if(temp.time==2020){
			cout<<ans<<endl;
			return;
		}
		for(int i=0;i<4;i++){
			next.x=temp.x+fx[i][0];
			next.y=temp.y+fx[i][1];
			if(!m[next.x][next.y]){
				ans++;
				next.time=temp.time+1;
				m[next.x][next.y]=1;
				Q.push(next);
			}
		}
	}
}
int main(){
	memset(m,0,sizeof(m));
	bfs();
	return 0;
}

试题C:阶乘约数

[问题描述] 定义阶乘n!= 1x2x3x…Xn。
请问100! (100 的阶乘)有多少个正约数。
[答案提交]
39001250856960000

#include
using namespace std;
int num_1[105];
int main(){
	long long int sum=1;
	memset(num_1,0,sizeof(num_1));
	for(int i=2;i<=100;i++){
		int num=i;
		for(int j=2;j<=sqrt(i);j++){
			while(num%j==0){
				num_1[j]++;
				num=num/j;
			}
		}
		if(num>1){
			num_1[num]++;
		}
	}
	for(int i=2;i<=100;i++){
		if(num_1[i]!=0){
			sum=sum*(num_1[i]+1);	
		}	
	}
	cout<<sum<<endl;
}

试题 D: 本质上升序列（与求子集问题相似）

【问题描述】
小蓝特别喜欢单调递增的事物。
在一个字符串中，如果取出若干个字符，将这些字符按照在字符串中的顺序排列后是单调递增的，则成为这个字符串中的一个单调递增子序列。
例如，在字符串 lanqiao 中，如果取出字符 n 和 q，则 nq 组成一个单调递增子序列。类似的单调递增子序列还有 lnq、i、ano 等等。
小蓝发现，有些子序列虽然位置不同，但是字符序列是一样的，例如取第二个字符和最后一个字符可以取到 ao，取最后两个字符也可以取到 ao。小蓝认为他们并没有本质不同。
对于一个字符串，小蓝想知道，本质不同的递增子序列有多少个？
例如，对于字符串 lanqiao，本质不同的递增子序列有 21 个。它们分别是 l、a、n、q、i、o、ln、an、lq、aq、nq、ai、lo、ao、no、io、lnq、anq、lno、ano、aio。
请问对于以下字符串（共 200 个小写英文字母，分四行显示）：
tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhf
iadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqij
gihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmad
vrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl
本质不同的递增子序列有多少个？
[答案提交]
3616159

#include
#include
#include
#include
using namespace std;
string s;
int main()
{
	cin>>s;
	int dp[220];
    for(int i=0;i<s.size();++i){
        dp[i] = 1;
    }
    for(int i=1;i<s.size();++i){
        for(int j=0;j<i;++j){
            if(s[i]==s[j]){
                dp[i]-=dp[j];
            }
            if(s[i]>s[j]){
                dp[i] += dp[j];
            }
        }
    }
     cout<<accumulate(dp,dp+s.size(),0);
	return 0;
}

你可能感兴趣的:(蓝桥杯,算法,数据结构,c++,stl,动态规划)

数字内容体验未来趋势：五大平台横向对比与深度解析清风徐徐de来其他
内容概要当前，企业数字化转型的核心战场正逐步向数字内容体验的精细化运营转移。随着用户行为碎片化与需求多元化趋势加剧，AI驱动的智能推荐系统、基于数据决策的动态优化能力，以及跨渠道的品牌一致性维护，已成为衡量内容平台竞争力的三大核心维度。本文将围绕这三大支柱，通过横向对比主流平台的技术架构与落地实践，揭示未来数字内容体验的演进方向。首先，AI驱动不仅改变了内容分发的效率，更通过深度学习算法实现用户行
共享内存的数据结构 ——循环队列+信息量 ——互斥锁、多进程的消费者模型源码模型测试代码 C++ sevenysq 数据结构 c++centos linux
前言：简单来说，共享内存不能自动扩展，申请多少就是多少，而且只能用C++内置的数据类型。也不能用STL容器，例如vector会自动扩展，容易造成内存泄漏，越界等问题。移动语义也不能用。要想实现多进程的生产/消费者模型只能采用循环队列。循环队列类值得一提的是这里面头尾指针的移动算法：（指针+1）取最大长度的余数。其他都很简单。#include#include#include#include#incl
众英达赏聘：人才与机会的完美交汇点 xjxijd 招聘
在信息化高速发展的今天，无论是企业还是求职者，都渴望能够在一个高效、便捷、精准的平台上找到彼此。众英达赏聘，正是这样一个致力于连接人才与机会的综合性招聘平台。众英达赏聘凭借其独特的算法和精准匹配技术，能够迅速分析用户的需求和特点，为企业和求职者提供个性化的推荐服务。无论是正在寻找优秀团队的企业，还是正在寻找理想工作岗位的求职者，都能在众英达赏聘上找到满意的选择。一个以企业招聘为主并融合本地生活出行
【Elasticsearch】`nested`字段和`join`字段的区别 risc123456 Elasticsearch elasticsearch
`nested`字段和`join`字段都是Elasticsearch中用于处理复杂数据结构的高级数据类型，但它们在设计目标、使用场景和实现方式上存在显著差异。以下是它们的主要区别：---1.设计目标•`nested`字段：•目标：用于处理单个文档中的嵌套数组，将数组中的每个对象独立索引，使其可以独立于其他对象进行查询。•场景：适用于需要在数组中独立查询每个对象的场景，例如博客文章中的评论、订单中的
算法刷题--哈希表--字母异位词和两个数组的交集 Bruce Jue LeetCode刷题算法散列表哈希算法
哈希表概念哈希表是根据关键码的值而直接进行访问的数据结构。直白来讲数组就是一种哈希表。那么哈希表能解决什么问题呢，一般哈希表都是用来快速判断一个元素是否出现集合里。那么一般都是将一个集合里面的元素映射为哈希表的索引。那么设计哈希表的时候需要考虑以下原则：均匀性，尽可能让不同key均匀分布到哈希表中；高效性；覆盖性，确保所有key都能映射到哈希表范围内。当多个元素映射到同一个索引时，这种现象叫做哈希
Py的Pandas：Python pandas库的详细介绍、安装和使用方法追逐程序梦想者 pandas python 数据分析
Py的Pandas：Pythonpandas库的详细介绍、安装和使用方法Pandas是一个Python的数据处理库，它提供了快速、灵活、易用且高效的数据结构来进行数据操作。在数据挖掘、数据分析等领域中，Pandas被广泛应用。本文主要介绍Pandas的安装、基本数据结构、数据读写、数据统计以及数据可视化等方面。安装在命令行中使用pip工具安装Pandas：pipinstallpandas基本数据结
【合集】Java进阶——Java深入学习的笔记汇总 & 再论面向对象、数据结构和算法、JVM底层、多线程、类加载、 web_15534274656 面试学习路线阿里巴巴 java 学习笔记
前言spring作为主流的JavaWeb开发的开源框架，是Java世界最为成功的框架，持续不断深入认识spring框架是Java程序员不变的追求；而spring的底层其实就是Java，因此，深入学习Spring和深入学习Java是硬币的正反面，两者相辅相成，相互促进。本篇博客是一篇不定期持续更新的博客，是一些Java深入学习的笔记汇总。目录前言面向对象专题再论面向对象封装和关键字private，t
深度优先搜索DFS 顾北辰20 Java数据结构算法数据结构 java
目录类`GraphDFS`的定义深度优先搜索方法`dfs`访问顺序的获取`order`深度优先搜索（DFS,Depth-FirstSearch）算法。深度优先搜索是一种用于遍历或搜索树或图的算法，其特点是从某个起始顶点出发，首先访问这个顶点，然后递归地访问与这个顶点直接相连的一个未访问过的顶点，再从这个顶点出发，继续访问它的未访问过的邻接顶点，如此重复，直到不能再深入为止，再回溯，直到所有能到达的
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【前缀和】2024E-分割数组的最大差值【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #前缀和 java c++c语言华为od javascript 算法 python
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例输入输出说明解题思路代码pythonjavaC++CNodejavaScriptGo时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024E+D卷最全真题【完全原创题解|详细考点分类|不断更新
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【排序】2024E-热点网站统计【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #模拟 java c++c语言华为od golang 算法 leetcode
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例一输入输出示例二输入输出解题思路代码pythonjavacppCNodejavaScriptGo时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024E+D卷最全真题【完全原创题解|详细考点分
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【前缀和】2024E-环中最长子串2【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #前缀和 #哈希表算法 java c++leetcode javascript c语言华为od
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例输入输出说明解题思路考虑非环字符串通过前缀确定任意连续字串的情况只考奇偶性而非具体数量三个差值均为偶数的情况将奇偶性状态压缩为数字状态压缩为后的前缀和数组的构建根据前缀和数组找到最长子字符串考虑环形字符串原字符串自身拼接储存下标
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【BFS】2024E-狼羊过河【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #BFS #模拟算法 java c++华为od c语言 javascript leetcode
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述补充说明示例输入输出说明解题思路转化为搜索状态树最小层数问题节点的设计以及更新重复状态的排除代入BFS代码框架代码pythonJavaC++CNodeJavaScriptGo时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【模拟】2024E-找终点【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #模拟 java c++c语言 leetcode golang 华为od
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例一输入输出说明示例二输入输出解题思路代码pythonjavaC++CNodejavaScriptGo时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024E+D卷最全真题【完全原创题解|详细考
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【DFS/BFS】2024E-战场索敌【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #BFS #DFS 算法 java c++c语言 leetcode 华为od javascript
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例输入输出解题思路代码解法一：BFSpythonjavacppCNodejavaScriptGo解法二：DFSpythonjavacppCNodejavaScriptGo时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【贪心】2024E-用户调度问题【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #贪心 java c++c语言 leetcode 华为od javascript python
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例输入输出说明解题思路代码pythonjavacppCNodejavaScriptGo时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024E+D卷最全真题【完全原创题解|详细考点分类|不断更新
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【贪心】2024E-静态代码扫描服务【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #贪心 java c++c语言华为od python 算法 javascript
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例一输入输出说明示例二输入输出解题思路题意理解贪心策略代码pythonjavacppCNodejavaScriptgo时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024E+D卷最全真题【完全
【Py/Java/C++/C/JS/Go六种语言OD独家2024E卷真题】20天拿下华为OD笔试之【二分查找】2024E-部门人力分配【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #二分查找 #贪心 java c++华为od leetcode 算法 python
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例输入输出说明解题思路代码pythonjavacppCNodejavaScriptgo时空复杂度本题易错点左指针初始化问题华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024E+D卷最全真题【完全原创题
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【二分查找】2024E-平均像素值【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #二分查找算法 java c++华为od leetcode python
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述补充说明示例一输入输出说明示例二输入输出解题思路代码pythonjavacpp时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024D+E卷最全真题【完全原创题解|详细考点分类|不断更新题目】【华
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【二分查找】2024E-孙悟空吃蟠桃【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #二分查找 java c++华为od python 算法 leetcode
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例一输入输出示例二输入输出解题思路代码pythonjavacpp时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024D+E卷最全真题【完全原创题解|详细考点分类|不断更新题目】【华为OD笔试】
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【模拟】2024E-多数组合并【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #模拟 java c++华为od leetcode 算法 python
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例输入输出解题思路代码pythonjavacpp时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024D+E卷最全真题【完全原创题解|详细考点分类|不断更新题目】【华为OD笔试】2024D+E卷
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【回溯】2024E-字符串拼接【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #回溯 #DFS java c++华为od leetcode 算法 python
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例一输入输出说明示例二输入输出说明解题思路代码pythonjavacpp时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024D+E卷最全真题【完全原创题解|详细考点分类|不断更新题目】【华为O
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【排序】2024E-预订酒店【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法最新华为OD真题 #模拟 java c++华为od 算法 leetcode python
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳oj1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读题目描述与示例题目描述输入描述输出描述示例一输入输出示例二输入输出示例三输入输出解题思路代码pythonjavacpp时空复杂度华为OD算法/大厂面试高频题算法练习冲刺训练相关推荐阅读【华为OD机考】2024D+E卷最全真题【完全原创题解|详细考点分类|不断更新题目】【
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【位运算】2024E-分苹果【欧弟算法】全网注释最详细分类最全的华为OD真题题解闭着眼睛学算法 #数学 #位运算最新华为OD真题算法 java c++python 华为od leetcode
可上欧弟OJ系统练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）文章目录相关推荐阅读2024年8月29日（2024E卷）题目描述与示例题目描述输入描述输出描述示例一输入输出示例二输入输出示例三输入输出说明解题思路题干阅读理解如何满足A的分配规则如何贪心地让B获利代码pythonjavacpp时空复杂度相同问题不同描述2023B-分积木题目描述输入描述输
Java的垃圾回收机制详解——从入门到出土，学不会接着来砍我！我心向阳iu #JVM Java面试知识点精讲 java jvm 算法
文章目录哪些内存需要回收回收堆：垃圾的定义引用计数算法：可达性分析算法：GCRoots的对象回收方法区：垃圾的定义如何回收垃圾垃圾回收算法总结标记—清除算法（适用老年代，但是基本废弃了）标记—复制算法（现在新生代普遍用的）标记—整理算法（现在老年代普遍用的）JVMGC的种类GC的触发机制年轻代GC(MinorGC)触发机制老年代GC(MajorGC/FullGC)触发机制FullGC触发机制为什么
简述java垃圾回收过程_浅析 java 垃圾回收（一）—— 以 HotSpot 为例 Patchouli Exarch 简述java垃圾回收过程
java的垃圾回收也就是我们常说的gc(garbagecollector)。这是一个老生常谈的问题。之所以这么经常被提及，是因为它对java性能有很大影响。在c/c++中考虑到效率，内存的分配和销毁是由程序员来控制的。程序员使用内存必须手动分配，在使用结束后，在手动释放掉已经不用的内存空间。如果忘记释放内存空间，那么这块内存区域就是一直被占用的状态。其他急需内存的程序将无法使用这块内存，导致内存泄
智能优化算法应用：基于群居蜘蛛算法与双伽马校正的图像自适应增强算法智能算法研学社（Jack旭）智能优化算法应用图像增强算法计算机视觉人工智能
智能优化算法应用：基于群居蜘蛛算法与双伽马校正的图像自适应增强算法-附代码文章目录智能优化算法应用：基于群居蜘蛛算法与双伽马校正的图像自适应增强算法-附代码1.全局双伽马校正2.群居蜘蛛算法3.适应度函数设计4.实验与算法结果5.参考文献6.Matlab代码摘要：本文主要介绍基于群居蜘蛛算法与双伽马校正的图像自适应增强算法。1.全局双伽马校正设图像的灰度值范围被归一化到[0,1]范围之内，基于全局
23行为型设计模式——迭代器模式凢曐设计模式迭代器模式 c++
一、迭代器模式介绍迭代器模式（IteratorPattern）是一种行为型设计模式，旨在提供一种方法来顺序访问集合对象中的元素，而无需暴露集合的内部表示。简单来说，它允许你遍历一个集合中的所有元素而无需直接访问集合内部的结构。例如STL中的容器存在输入输出迭代器，包括双向迭代器、随机访问迭代器等，算法通过迭代器就可以以某种权限去访问容器中的数据。GoF一书对迭代器模式的介绍迭代器（Iterator
蓝桥杯篇---IAP15F2K61S2串口 Ronin-Lotus 上位机知识篇嵌入式硬件篇蓝桥杯单片机职场和发展嵌入式硬件 c IAP15F2K61S2
文章目录前言简介串口通信的基本参数1.波特率2.数据位3.停止位4.校验位串口相关寄存器1.SCON2.SBUF3.PCON4.TMOD5.TH1/TL1串口使用步骤1.配置波特率2.配置串口模式3.使能串口中断4.发送数据5.接收数据6.处理中断示例代码：串口发送与接收示例代码：串口接收数据并回显注意事项1.波特率设置2.中断优先级3.数据缓冲区4.错误处理总结前言本文仅仅简单介绍了IAP15F
机器学习：k均值 golemon. ML 机器学习均值算法人工智能
所有代码和文档均在golitter/Decoding-ML-Top10:使用Python优雅地实现机器学习十大经典算法。(github.com)，欢迎查看。在“无监督学习”中，训练样本的标记信息是未知的，目标是通过对无标记训练样本的学习来揭示数据的内在性质及规律，为进一步的数据分析提供基础，较为经典的是聚类。**聚类试图将数据集中的样本划分为若干个通常是不相交的子集，每个子集称为一个“簇”。**聚
关于go-context包敖光 SRE go基础知识 golang 数据库开发语言
思维导图目的为了在不同的goroutine之间或跨API边界传递超时、取消信号和其他请求范围内的值（与该请求相关的值。这些值可能包括用户身份信息、请求处理日志、跟踪信息等等）。常用场景数据操作网络请求RPC操作context接口context包在提供了一个用于跨API边界传递超时、取消信号和其他请求范围值的通用数据结构。用于在多个Goroutine和函数之间传递请求范围内的信息。核心方法：Dead
对股票分析时要注意哪些主要因素？会飞的奇葩猪股票分析云掌股吧
　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。一、成交量　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
【Scala十八】视图界定与上下文界定 bit1129 scala
Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。隐式参数首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b } 因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
C语言的分支——Object-C程序设计阅读有感 darkblue086 apple c 框架 cocoa
自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
去除浏览器对表单值的记忆周凡杨 html 记忆 autocomplete form 浏览
&n
java的树形通讯录 g21121 java
最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
Nginx安装部署 510888780 nginx linux
Nginx ("engine x") 是一个高性能的 HTTP 和反向代理服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
java servelet异步处理请求墙头上一根草ｊａｖａ异步返回ｓｅｒｖｌｅｔ
servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能， final AsyncContext ac = request.startAsync(request, response); ac.s
我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。（有构造方法的下个文细说） 2、还
为Mysql创建最优的索引 annan211 mysql 索引
索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。索引经常会被误解甚至忽略，而且经常被糟糕的设计。索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
日期函数百合不是茶 oracle sql 日期函数查询
ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年显示值:07 yyy three digits 三位年显示值:007
线程优先级 bijian1013 java thread 多线程 java多线程
多线程运行时需要定义线程运行的先后顺序。线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
适配器模式和代理模式的区别 bijian1013 java 设计模式
一.简介适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。 &nbs
【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句，这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
oracle大数据表复制备份个人经验 bitcarter oracle 大表备份大表数据复制
前提：数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。
HTTP加速器varnish安装小记 ronin47 http varnish 加速
上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
学习编程的一点感想 Cb123456 编程感想 Gis
写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目. 本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
[能源与安全]美国与中国 comsci 能源
现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。在这个大
SEMI-JOIN执行计划突然变成HASH JOIN了的原因分析 cwqcwqmax9 oracle
甲说： A B两个表总数据量都很大，在百万以上。 idx1 idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn and exists (select 1 from B where B.idx2 =
SpringMVC-ajax返回值乱码解决方案 dashuaifu Ajax springMVC response 中文乱码
SpringMVC-ajax返回值乱码解决方案一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do") public @ResponseBody void getPunishReasonB
Linux系统中查看日志的常用命令 dcj3sjt126com OS
因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日志文件说明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
[应用结构]应用 dcj3sjt126com PHP yii2
应用主体应用主体是管理 Yii 应用系统整体结构和生命周期的对象。每个Yii应用系统只能包含一个应用主体，应用主体在入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
assertThat用法 eksliang JUnit assertThat
junit4.0 assertThat用法一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
android点滴2 gundumw100 应用服务器 android 网络应用 OS HTC
如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
超简洁的CSS下拉菜单 ini html Web 工作 html5 css
效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
kafka consumer防止数据丢失 kane_xie kafka offset commit
kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。考虑这样一个case，partiton_num=2
@Repository、@Service、@Controller 和 @Component mhtbbx DAO spring bean prototype
@Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
java 多线程高并发读写控制误区 qifeifei java thread
先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
mongodb replica set(副本集)设置步骤 tcrct java mongodb
网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下：首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
rust学习笔记 wudixiaotie 学习笔记
1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分

蓝桥杯大赛决赛整理合集（B组C/C++）

蓝桥杯大赛决赛整理合集（B组C/C++）

大纲要求

一、STL

1.vector容器（单端数组）

2.queue容器（队列——先进先出）

3.map/multimap容器（关联式——二叉树）

二、枚举

三、排序

试题 历届试题 字串排序

四、搜索

1.BFS（广度优先——队列）

试题1 历届试题 九宫重排

2.DFS（深度优先——栈）

试题1 历届试题 大臣的旅费

3.回溯算法总结

（1）组合

（2）组合总和

（3）分割回文串

（4）求子集

五、计数

六、贪心

七、动态规划（本质递归）

试题1 算法提高 01背包

试题2 试题 算法提高 秘密行动

试题3 算法提高 第二点五个不高兴的小明

试题4 算法提高 和谐宿舍2

八、图论

九、数论

十、博弈论

十一、概率论

十二、计算几何

十三、字符串算法

KMP（主要应用在字符串匹配上）

匹配模型

试题1：算法提高 字符串匹配

十四、数组

十五、对象/结构

十六、字符串

十七、队列

试题 算法提高 队列操作

十八、栈

试题 算法训练 栈的研究

十九、图

二十、堆

二十一、平衡树/线段树

二十二、复杂数据结构

二十三、嵌套数据结构

第八届蓝桥杯大赛软件类决赛

试题A：36进制

试题B：磁砖样式

第九届蓝桥杯大赛软件类决赛

试题A：换零钞

试题B：激光样式

第十届蓝桥杯大赛软件类决赛（难度分水岭）

试题A:平方序列

试题B:质数拆分

第十一届蓝桥杯大赛软件类决赛

试题A:美丽的2

试题B:扩散（BFS）

试题C:阶乘约数

试题 D: 本质上升序列（与求子集问题相似）

你可能感兴趣的:(蓝桥杯,算法,数据结构,c++,stl,动态规划)

试题历届试题字串排序

试题1 历届试题九宫重排

试题1 历届试题大臣的旅费

试题2 试题算法提高秘密行动

试题3 算法提高第二点五个不高兴的小明

试题4 算法提高和谐宿舍2

试题1：算法提高字符串匹配

试题算法提高队列操作

试题算法训练栈的研究