基础算法与数据结构板子

最新推荐文章于 2021-12-11 11:38:34 发布
最新推荐文章于 2021-12-11 11:38:34 发布
阅读量145 收藏 2
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49786613/article/details/116070466
版权

1.排序算法

快速排序

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int Arr[N]; 
void qsort(int l,int r){
	int t = Arr[l];
	int i = l;
	int j = r;
	while(i<j){
		while(Arr[j]>=t&&i<j) j--;
		while(Arr[i]<=t&&i<j) i++;
		swap(Arr[i],Arr[j]);
	}
	swap(Arr[l],Arr[i]);
	if(i<r) qsort(i+1,r);
	if(j>l) qsort(l,j-1);
}
int main(){
	int n;
	cin>>n;
	for(int i=0;i<n;i++) cin>>Arr[i];
	qsort(0,n-1);
	for(int i=0;i<n;i++) cout<<Arr[i]<<" ";
	return 0;
}

归并排序

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int Arr[N],temp[N];
void merge_sort(int l,int r){
	if(l>=r) return ;
	int mid = l + r >> 1;
	int i = l;
	int j = mid + 1;
	int k = 0;
	merge_sort(l,mid);
	merge_sort(mid+1,r);
	while(i<=mid&&j<=r){
		if(Arr[i]<=Arr[j]) temp[k++] = Arr[i++];
		else temp[k++] = Arr[j++];
	}
	while(i<=mid) temp[k++] = Arr[i++];
	while(j<=r) temp[k++] = Arr[j++];
	for(i=0;i<k;i++) Arr[l+i] = temp[i];
}
int main(){
	int n;
	cin>>n;
	for(int i=0;i<n;i++) cin>>Arr[i];
	merge_sort(0,n-1);
	for(int i=0;i<n;i++) cout<<Arr[i]<<" ";
	return 0;
}

堆排序

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int heap[N];
int n,k;
void down_adjust(int pos){
	int i = pos;
	int j = i * 2;
	while(j<=n){
		if(j+1<=n&&heap[j]>heap[j+1]) j = j + 1;
		if(heap[i]>heap[j]) {
			swap(heap[i],heap[j]);
			i = j;
			j = i * 2;
		}
		else break;
	}
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>heap[i];
	for(int i=n/2;i>=1;i--) down_adjust(i);
	while(n){
		cout<<heap[1]<<" ";
		heap[1] = heap[n--];
		down_adjust(1);
	}
	return 0;
}

2.高精度

加法高精度

#include<bits/stdc++.h>
using namespace std;
void add(vector<int>&A,vector<int>&B){
	vector<int> C;
	int t = 0;
	for(int i=0;i<A.size()||i<B.size();i++){
		if(i<A.size()) t+=A[i];
		if(i<B.size()) t+=B[i];
		C.push_back(t%10);
		t/=10;
	}
	if(t) C.push_back(1);
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];
}
int main(){
	string a,b;
	vector<int> A,B;
	cin>>a>>b;
	for(int i=a.length()-1;i>=0;i--) A.push_back(a[i]-'0');
	for(int i=b.length()-1;i>=0;i--) B.push_back(b[i]-'0');
	add(A,B);
	return 0;
}

减法高精度

#include<bits/stdc++.h>
using namespace std;
bool cmp(string a,string b){
	if(a.length()<b.length()) return false;
	for(int i=0;i<a.length();i++){
		if(a[i]<b[i]) return false;
	} 
	return true;
}
void minu(vector<int>&A,vector<int>&B){
	int t = 0;
	vector<int> C;
	for(int i=0;i<A.size();i++){
		t = A[i] - t;
		if(i<B.size()) t -= B[i];
		C.push_back((t+10)%10);
		if(t<0) t = 1;
		else t = 0;
	}
	while(C.size()>1&&C.back()==0) C.pop_back();
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];
}
int main(){
	string a,b;
	vector<int> A,B;
	cin>>a>>b;
	if(cmp(a,b)==false) {
		swap(a,b);
		cout<<"-";
	}
	for(int i=a.length()-1;i>=0;i--) A.push_back(a[i]-'0');
	for(int i=b.length()-1;i>=0;i--) B.push_back(b[i]-'0');
	minu(A,B);
	return 0;
}

乘法高精度

#include<bits/stdc++.h>
using namespace std;
void multi(vector<int>&A,int b){
	vector<int> C;
	int t = 0;
	for(int i=0;i<A.size()||t;i++){
		if(i<A.size()) t+=A[i]*b;
		C.push_back(t%10);
		t/=10;
	}
	while(C.size()>1&&C.back()==0) C.pop_back();
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];
}
int main(){
	string a;
	int b;
	vector<int> A;
	cin>>a>>b;
	for(int i=a.length()-1;i>=0;i--) A.push_back(a[i]-'0');
	multi(A,b);
	return 0;
}

除法高精度

#include<bits/stdc++.h>
using namespace std;
void div(vector<int>&A,int b,int &r){
	vector<int> C;
	r = 0;
	for(int i=A.size()-1;i>=0;i--){
		r = r * 10 + A[i];
		C.push_back(r/b);
		r%=b;
	}
	reverse(C.begin(),C.end());
	while(C.size()>1&&C.back()==0) C.pop_back();
	for(int i=C.size()-1;i>=0;i--) cout<<C[i];
	cout<<endl;
	cout<<r;
}
int main(){
	string a;
	int b,r;
	vector<int> A;
	cin>>a>>b;
	for(int i=a.length()-1;i>=0;i--) A.push_back(a[i]-'0');
	div(A,b,r);
	return 0;
}

3.二分查找

lower_bound && upper_bound

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int Arr[N],m,n,temp;
int lower_bound(int data){
    int left = 0;
    int right = n-1;
    int mid;
    while(left<right){
        mid = (left+right) / 2;
        if(Arr[mid]>=data) right = mid;
        else left = mid + 1;
    }
    if(Arr[left]!=data) return -1;
    else return left;
}
int upper_bound(int data){
    int left = 0;
    int right = n-1;
    int mid;
    while(left<right){
        mid = (left+right+1)/2;
        if(Arr[mid]<=data) left = mid;
        else right = mid - 1;
    }
    if(left+1>n-1) return -1;
    else return left + 1;
}
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++) cin>>Arr[i];
    while(m--){
        cin>>temp;
        if(lower_bound(temp)==-1) cout<<"-1 -1"<<endl;
        else cout<<lower_bound(temp)<<" "<<upper_bound(temp)<<endl;
    }
    return 0;
}

4.树

已知前序和中序还原树

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n,in[N],pre[N];
struct node{
	int data;
	node *lchild;
	node *rchild;
};
node *build_tree(int prel,int prer,int inl,int inr){
	if(prel>prer) return NULL;
	node *root = new node;
	root->data = pre[prel];
	int k,num;
	for(k=inl;k<=inr;k++) if(in[k]==pre[prel]) break;
	num = k - inl;
	root->lchild = build_tree(prel+1,prel+num,inl,k-1);
	root->rchild = build_tree(prel+num+1,prer,k+1,inr);
	return root;
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++) cin>>pre[i];
	for(int i=0;i<n;i++) cin>>in[i];
	node *root = build_tree(0,n-1,0,n-1);
	return 0;
}

已知后序和中序还原树

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n,in[N],post[N];
struct node{
	int data;
	node *lchild;
	node *rchild;
}; 
node *build_tree(int inl,int inr,int posl,int posr){
	if(posl>posr) return NULL;
	node *root = new node;
	root->data = post[posr];
	int k,num;
	for(k=inl;k<=inr;k++){
		if(in[k]==post[posr]) break;
	}
	num = k - inl;
	root->lchild = build_tree(inl,k-1,posl,posl+num-1);
	root->rchild = build_tree(k+1,inr,posl+num,posr-1);
}
void pre(node *root){
	if(root==NULL) return ;
	cout<<root->data<<" ";
	pre(root->lchild);
	pre(root->rchild);
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++) cin>>in[i];
	for(int i=0;i<n;i++) cin>>post[i];
	node *root = build_tree(0,n-1,0,n-1);
	pre(root);
	return 0;
}

二叉搜索树(BST)

#include<bits/stdc++.h>
using namespace std;
struct node{
	int data;
	node *lchild;
	node *rchild;
};
void build_BST(node *&root,int v){
	if(root==NULL){
		root = new node;
		root->data = v;
		root->lchild = root->rchild = NULL;
		return ;
	}
	else if(root->data<v) build_BST(root->rchild,v);
	else build_BST(root->lchild,v);
}
int main(){
	node *root = NULL;
	int n,temp;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>temp;
		build_BST(root,temp);
	}
	return 0;
}

并查集(路径压缩)

#include<bits/stdc++.h>
using namespace std;
int father[10001];
void init(int n){
	for(int i=0;i<n;i++) father[i] = i;
}
int find_father(int x){
	if(x==father[x]) return x;
	return father[x] = find_father(father[x]);
}
void Union(int u,int v){
	int fu = find_father(u);
	int fv = find_father(v);
	if(fu!=fv) father[fu] = fv;
}
int main(){
	int n,m,u,v,w;
	cin>>n>>m;
	init(n);
	for(int i=0;i<n;i++){
		cin>>u>>v;
		Union(u,v);
	}
	while(m--){
		cin>>u>>v;
		if(find_father(u)==find_father(v)) cout<<"Yes"<<endl;
		else cout<<"No"<<endl;
	}
	return 0; 
}

二叉堆(down_adjust)

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int heap[N],n;
void down_adjust(int low,int high){
	int i = low;
	int j = i * 2;
	while(j<=high){
		if(j+1<=high&&heap[j+1]<heap[j]) j = j + 1;
		if(heap[i]>heap[j]){
			swap(heap[i],heap[j]);
			i = j;
			j = i * 2;
		}
		else break;
	}
}
void create_heap(){
	for(int i=n/2;i>=1;i--) down_adjust(i,n);
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>heap[i];
	create_heap();
	for(int i=1;i<=n;i++) cout<<heap[i]<<" ";
	return 0;
}

二叉堆(up_adjust)

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int heap[N],t,n,idx;
void up_adjust(int high){
	int i = high;
	int j = i / 2;
	while(j>=1){
		if(heap[j]>heap[i]){
			swap(heap[i],heap[j]);
			i = j;
			j = i / 2;
		}
		else break;
	}
}
void insert(int x){
	heap[++idx] = x;
	up_adjust(idx);
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>t;
		insert(t);
	}
	for(int i=1;i<=n;i++) cout<<heap[i]<<" ";
	return 0;
}

5.图

Dijkstra求单源最短路(堆优化+链式前向星)

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000001;
int vis[maxn],dis[maxn],first[maxn],pre[maxn];
int cnt;
struct node{
	int to;
	int weight;
	bool operator < (const node &temp) const{
		return weight > temp.weight;
	}
};
struct Graph{
	int to;
	int weight;
	int next;
}G[maxn];
void add(int u,int v,int w){
	G[++cnt].to = v;
	G[cnt].weight = w;
	G[cnt].next = first[u];
	first[u] = cnt;
}
priority_queue<node> q;
void Dijkstra(int s){
	fill(dis,dis+maxn,INT_MAX);
	dis[s] = 0; 
	pre[s] = s;
	q.push((node){s,0});
	while(!q.empty()){
		node temp = q.top();
		q.pop();
		if(vis[temp.to]) continue;
		vis[temp.to] = 1;
		for(int i=first[temp.to];i!=-1;i=G[i].next){
			int end = G[i].to;
			if(dis[end] > dis[temp.to] + G[i].weight){
			    dis[end] = dis[temp.to] + G[i].weight;
			    pre[end]  = temp.to;
			    if(!vis[end]) q.push((node){end,dis[end]});
		    } 
		} 
	}
}
void find_path(int start,int end){
	if(start==end){
		cout<<start;
		return ;
	}
	else find_path(start,pre[end]);
	cout<<"-->"<<end;
}
int main(){
	fill(first,first+maxn,-1);
	int m,n,u,v,w,start,end;
	cin>>n>>m;
	for(int i=0;i<m/2;i++){
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	cin>>start>>end;
	Dijkstra(start);
	find_path(start,end); 
	cout<<endl;
	cout<<dis[end];
	return 0;
}

SPFA求单源最短路(图中含负环)(链式前向星+堆优化)

#include<bits/stdc++.h>
using namespace std;
const int N = 10010;
int dis[N],vis[N],first[N],de[N],cnt,m,n,u,v,w;
struct Graphy{
	int v;
	int w;
	int next;
}G[N];
void add(int u,int v,int w){
	G[++cnt].v = v;
	G[cnt].w = w;
	G[cnt].next = first[u];
	first[u] = cnt;
}
struct node{
	int v;
	int w;
	bool operator < (const node&temp) const{
		return temp.w < w;
	}
};
bool SPFA(int s){
	de[s]++;
	dis[s] = 0;
	vis[s] = 1;
	priority_queue<node> q;
	q.push(node{s,0});
	while(!q.empty()){
		node top = q.top();
		q.pop();
		vis[top.v] = 0;
		for(int i=first[top.v];i;i=G[i].next){
			int e = G[i].v;
			if(dis[e]>dis[top.v]+G[i].w){
				dis[e] = dis[top.v] + G[i].w;
				if(!vis[e]) {
					q.push(node{e,dis[e]});
					de[e]++;
					vis[e] = 1;
					if(de[e]>=n) return true;
				}
			}
		} 
	}
	return false;
}
int main(){
	fill(dis,dis+N,INT_MAX); 
	cin>>n>>m;
	for(int i=0;i<m;i++){
		cin>>u>>v>>w;
		add(u,v,w);
	}
	for(int i=1;i<=n;i++){
		if(dis[i]!=INT_MAX) continue;
		if(SPFA(i)==true) {
			cout<<"Yes";
			return 0;
		}                                                                                                   
	}
	cout<<"No";
	return 0;
}

Floyd求多源最短路径

#include<bits/stdc++.h>
using namespace std;
const int maxn = 101;
int dis[maxn][maxn],path[maxn][maxn];
void Floyd(int n){
	for(int k=0;k<n;k++){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(dis[i][k]!=INT_MAX&&dis[k][j]!=INT_MAX&&dis[i][j]>dis[i][k]+dis[k][j]) {
					dis[i][j] = dis[i][k]+dis[k][j];
					path[i][j] = path[i][k];
				}
			}
		}
	}
}
void find_path(int x,int y){
	int v = path[x][y];
	cout<<x;
	while(v!=y){
		cout<<"->"<<v;
		v = path[v][y];
	}
	cout<<"->"<<y;
}
int main(){
	int n,m,u,v,w,start,end;
	cin>>n>>m>>start>>end;
	fill(dis[0],dis[0]+maxn*maxn,INT_MAX);
	for(int i=0;i<n;i++) dis[i][i] = 0;
	for(int i=0;i<m;i++){
		cin>>u>>v>>w;
		dis[u][v] = w;
		path[u][v] = v;
	}
	Floyd(n);
	if(start==end) cout<<start<<"->"<<end<<":0";
	else find_path(start,end);
	return 0;
}

求最小生成树—Kruskal算法

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000001;
int father[maxn];
struct Edge{
	int u;
	int v;
	int dis;
}ed[maxn];
bool cmp(Edge a,Edge b){
	return a.dis < b.dis;
}
void init(int n){
	for(int i=1;i<=n;i++) father[i] = i;
}
int find_father(int x){
	if(x==father[x]) return x;
	int temp = find_father(father[x]);
	return temp;
}
int Kruskal(int n,int m){
	int ans = 0;
	int num_Edge = 0;
	for(int i=0;i<m;i++){
		int fu = find_father(ed[i].u);
		int fv = find_father(ed[i].v);
		if(fu!=fv){
			father[fu] = fv;
			ans+=ed[i].dis;
			num_Edge++;
			if(num_Edge==n-1) break;
		}
	}
	if(num_Edge!=n-1) return -1;
	else return ans;
}
int main(){
	int n,m;
	cin>>n>>m;
	init(n);
	for(int i=0;i<m;i++) cin>>ed[i].u>>ed[i].v>>ed[i].dis;
	sort(ed,ed+m,cmp);
	cout<<Kruskal(n,m);
	return 0;
}

求最小生成树—Prime算法

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000001;
int dis[maxn],vis[maxn],first[maxn],cnt;
struct Graph{
	int to;
	int weight;
	int next;
}G[maxn];
void add(int u,int v,int w){
	G[++cnt].to = v;
	G[cnt].weight = w;
	G[cnt].next = first[u];
	first[u] = cnt;
}
int prime(int n){
	fill(dis,dis+maxn,INT_MAX);
	dis[1] = 0;
	int minn,u,ans=0;
	for(int i=1;i<=n;i++){
		minn = INT_MAX;
		u = -1; 
		for(int j=1;j<=n;j++){
			if(vis[j]==0&&dis[j]<minn){
				minn = dis[j];
				u = j;
			}
		}
		if(u==-1) return -1;
		vis[u] = 1;
		ans+=dis[u];
		for(int k=first[u];k;k=G[k].next){
			int end = G[k].to;
			if(vis[end]==0&&dis[end]>G[k].weight) dis[end] = G[k].weight;
		}
	} 
	return ans;
}
int main(){
	int n,m,u,v,w;
	cin>>n>>m;
	for(int i=0;i<m;i++){
		cin>>u>>v>>w;	
		add(u,v,w);
		add(v,u,w);
	}
	int ans = prime(n);
	if(ans==-1) cout<<"orz";
	else cout<<ans;
	return 0;
}

拓扑排序

#include<bits/stdc++.h>
using namespace std;
const int maxn = 10001;
vector<int> vi[maxn];
priority_queue<int,vector<int>,greater<int> > q;
int dis[maxn];
int main(){
	int n,m,u,v,num=0;
	cin>>n>>m;
	for(int i=0;i<m;i++){
		cin>>u>>v;
		vi[u].push_back(v);
		dis[v]++;
	}
	for(int i=1;i<=n;i++){
		if(dis[i]==0) q.push(i);
	}
	while(!q.empty()){
		int top = q.top();
		cout<<top<<" ";
		q.pop();
		for(int i=0;i<vi[top].size();i++){
			int end = vi[top][i];
			dis[end]--;
			if(dis[end]==0) q.push(end);
		}
		vi[top].clear();
		num++;
	}
	return 0;
}
独钓烟云
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构与算法C++模板实现在vs环境下
08-30
C++模板类的形式实现了基本的数据结构和算法：交换算法、快排序、选择排序、归并排序、二叉树、AVL树、2-3树、双向链表、队列等。红黑树还没完成。
数据结构与算法模板
darknight
09-15 1343
经常打codeforce，比赛，给学生讲算法那的啥啊的都需要模板 那么也把我整理的这些基础数据结构与算法的模板分享给大家 可能有一点点小错误，可以在评论区留言哈~ namespace I_love_xinxin{ /* 名称定义： n: 数据规模 m: 表示边数等数据规模 v: vertex 图中的顶点 fa: father 一般用来指代父亲 r......
算法与数据结构模版题
weixin_44520881的博客
03-09 181
P5788 【模板】单调栈
算法与数据结构（十四）：IO 模板总结(C++ & Python)
Dby_freedom的博客
08-02 1024
不少网络笔试不像 LeetCode 帮你完成 I/O，需要手动完成；个人深受其痛，现将常用的 IO 模板总结与此，分别总结了 C/C++ 和 Python 代码。
《数据结构与算法》模板大全（数千行代码）
Keep studying
12-11 284
千行数据结构和算法代码+详细注释。
算法与数据结构入门的基础算法，必须熟练写出，是一些竞赛常考的模板
02-18
算法与数据结构入门的基础算法，必须熟练写出，是一些竞赛常考的模板。打比赛用的所有板子，数据结构与算法中常用的核心算法，大家在拿到之后使用最好加以理解，这样才能真正内化到自己的知识库里，量多且实惠，背住...
c++板子、算法、题解
07-19
可能包含各种数据结构的实现（如链表、树、图、队列、栈）和复杂算法的实例化。 - 通过实例，学习者可以更好地掌握如何在特定场景下选择合适的算法，并进行有效的代码实现。 4. **题解**： - 题解通常是针对编程...
给线下 ACM 比赛准备的板子。.zip
最新发布
09-30
这些源代码可能包括了常用的算法实现、数据结构、模板函数或者解决特定问题的代码片段，旨在提高团队的编程效率和解决问题的能力。 标签“比赛项目源码”是对压缩包内容的概括，表明它包含了用于参赛的编程项目代码...
吉林大学算法模板
04-08
1. **基础算法**：ACM算法模板通常会涵盖基础数据结构，如数组、链表、栈、队列、树、图等，以及对应的操作方法，如查找、排序、遍历等。此外，还包括经典的排序算法，如快速排序、归并排序、堆排序，以及搜索算法，...
ARM9和ARMLinux下利用QT编写的实时数据采集，数据曲线动态显示
04-02
4. **数据处理**：设计合适的算法和数据结构来存储和处理大量实时数据，避免内存溢出和性能瓶颈。 5. **实时性优化**：在有限的硬件资源下，通过优化代码、合理分配内存、使用异步处理等方式保证系统的实时响应。 ...
基本数据结构模板
a765528534的博客
08-13 284
单链表 // head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点 int head, e[N], ne[N], idx; // 初始化 void init() { head = -1; idx = 0; } // 在链表头插入一个数a void insert(int a) { e[idx] = a, ne[idx] = ...
C语言数据结构之二叉树部分（2）
qq_43437044的博客
03-10 114
二叉树的应用 #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node *left,*right; }BTNode; BTNode *CreateBTree(int a[],int n);//创建 int LeafCount(BTNode *roo...
数据结构（七）——查找之平衡二叉树
Double___H的博客
07-12 418
代码中所用到的结构体 typedef struct node { int key;//关键字 struct node*left; struct node*right; int height;//当前结点所在的高度 }BTNode; 构造平衡二叉树算法的主要思想 为了提高查找的效率，于是在二叉排序树的基础上，有了二叉平衡树的诞生。其中，先介绍几个重要的概念： 平衡...
数据结构 链式线性表的构建（C语言）
櫆溟的博客
04-07 628
//线性链表结构 typedef struct Node { int data; struct Node *next; }Node; typedef struct LinkedList { Node* head_node; Node* current_node; }LinkedList; //初始化 LinkedList* Init_Linked() { LinkedList *ll = malloc(sizeof(LinkedList)); Node *head_node=malloc(s
01背包问题分支限界java_【在线等】分支限界法01背包问题C语言
weixin_36469247的博客
02-22 531
满意答案#include#includeusing namespace std;#define N 100classHeapNode{public:double upper,price,weight;int level,x[N];};double MaxBound(int i);double Knap();void AddLiveNode(double up,double cp,double ...
计算机三级正确答案报错,2012年全国计算机等级考试二级C++模拟试题及答案（4）...
weixin_42151036的博客
07-20 1293
n&&mB.switch语句结构中必须有default语句C.if语句结构中必须有else语句D.如果至少有一个操作数为true,则包含“||”运算符的表达式为true【参考答案】 D13.下面关于break语句的描述中，不正确的是( )A.break可以用于循环体内B.break语句可以在for循环语句中出现多次C.break语句可以在switch语句中出现多次D.break语句...
用分支限界法求解01背包
热门推荐
One of thre_tigers的博客
06-01 1万+
问题描述 0-1背包问题:给定n种物品和一背包。物品i的重量是wi， 其价值为Vi， 背包的容量为C。问应如何选择装入背包中的物品，使得装入背包中物品的总价值最大?在选择装入背包的物品时，对每种物品i可以选择这个物品的一部分。 输入： 通过文件读入，第一行包括两个整数n和c，代表物品数和背包容量，接下来的n行每行包括两个整数，w[i]和v[i]代表物品的重量和价值。 输出： 将计算结果输出到文件，包括最优价值和选取方案包括2行，第一行一个整数，表示计算结果，第二行包括一组序列，表示选取方案，按照T={1，0
slam算法可以在什么板子上跑
07-12
SLAM（Simultaneous Localization and Mapping）算法可以在多种硬件平台上运行，包括但不限于以下几种： 1. 通用计算平台：SLAM算法可以在通用计算平台上运行，如个人电脑、笔记本电脑或者工作站。这些平台通常具有...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值