『蓝桥杯』 面对蓝桥杯的基础算法复习快速总结

搜索：

1.DFS(八皇后迭代)

#include <bits/stdc++.h>
using namespace std;
int n,tot = 0;
int a[20];
bool is_ok(int row){
	for(int i = 1; i < row; i++){
		if(a[row] == a[i] || row - a[row] == i - a[i]|| a[i] + i == a[row] + row)
			return false;	
	}
	return true;
}
void dfs(int row) {
	if(row == n + 1){
		if(tot < 3){
		for(int i = 1; i <= n; i++){
			cout<<a[i]<<" ";
		}
		cout<<"\n";			
		}
		tot++;
		return ;
	}else{
		for(int i = 1; i <= n; i++){
			a[row] = i;
			if(is_ok(row)){
				dfs(row + 1);
			}
		}
	}
}
	int main() {
		ios::sync_with_stdio(false);
		cin>>n;
		dfs(1);
		cout<<tot;
		return 0;
	}

2.BFS

/*
队列_1330：【例8.3】最少步数
*/
#include <bits/stdc++.h>
using namespace std;
int dir[][2] = {{1,2},{2,2},{2,1},{2,-1},{2,-2},{1,-2},{-1,-2},{-2,-2},{-2,-1},{-2,1},{-2,2},{-1,2}};
int bk[105][105] = {0};
struct Node{
	int x,y,step;
}node,p;
queue<Node> que;
vector<int> ans;
void bfs(){
	while(!que.empty()){
		p = que.front();
		if(p.x == 1 && p.y == 1){
			//cout<<p.step;
			ans.push_back(p.step);
			return;
		}
		que.pop();
		for(int i = 0 ; i < 12; i++){
			int xt = p.x + dir[i][0] ,yt = p.y + dir[i][1];
			if(xt < 1 || yt < 1 || xt > 100 || yt > 100) 
				continue;
			if(!bk[xt][yt]){
				bk[xt][yt] = 1;
				node.x = xt;
				node.y = yt;
				node.step = p.step+1;
				que.push(node);
			}
		}
	}
}
int main(){
	int ax,ay,bx,by;
	cin>>ax>>ay>>bx>>by;
	node.x = ax;
	node.y = ay;
	node.step = 0; 
	bk[ax][ay] = 1;
	que.push(node);
	bfs();
	memset(bk,0,sizeof(bk));
	while(!que.empty())
		que.pop();
	node.x = bx;
	node.y = by;
	node.step = 0; 
	bk[bx][by] = 1;
	que.push(node);
	bfs();
	if(ans[0] < ans[1])
		cout<<"Alice";
	else
		cout<<"Bob";
	return 0;
}

3.记忆化搜索

基础图论：

1.图的遍历(欧拉回路)

/*
欧拉通路_1375：骑马修栅栏(fence)
*/
#include <bits/stdc++.h>
#include <sstream>
using namespace std;
const int Max = 505;
int maxx = -1,minx = 2e9;
int maze[Max][Max],cnt = 1;
int dot[Max];
vector<int> path;
int f,x,y;
void dfs(int cur) {
	if(cnt == f+2) {
		return ;
	}
	for(int i = 1 ; i <= maxx; i++) {
		if(maze[cur][i]) {
			maze[cur][i]--;
			maze[i][cur]--;
			cnt++;
			dfs(i);
		}
	}
	//cout<<cur<<"\n";
	path.push_back(cur);
}
int main() {
	ios::sync_with_stdio(false);
	cin>>f;
	for(int i = 0 ; i < f; i++) {
		cin>>x>>y;
		dot[x]++;
		dot[y]++;
		maze[x][y]++;
		maze[y][x]++;
		minx = min(minx,min(y,x));
		maxx = max(maxx,max(y,x));
	}
	//cout<<"maxx = "<<maxx<<"\n";
	int k = minx;
	for(int i = minx ; i <= maxx; i++) {
		if(dot[i]%2) {
			k = i;
			break;
		}
	}
	dfs(k);
	//cout<<"cnt = "<<cnt<<"\n";
	int size = path.size();
	for(int i = size-1 ; i >= 0; i--) {
		cout<<path[i]<<"\n";
	}
	return 0;
}

2.最短路算法 Dijistra，Bellman-Ford，SPFA

/*
dij
*/
#include <bits/stdc++.h>
using namespace std;
int n,m,a,b,bk[105] = {0},s,e,cnt = 1;
double dis[105],ans = 0;
struct Node {
	int x,y;
} node[105];
struct Eage {
	int v;
	double w;
} eage;
//priority_queue<Eage> pq;
//bool operator < (const Eage &a,const Eage &b) {
//	return a.w > b.w;
//}
vector<vector<Eage> > G;
void init() {
	for(int i = 1 ; i <= n; i++) {
		dis[i] = 2e9;
	}
	int size_s = G[s].size();
	//cout<<"size_s = "<<size_s<<"\n";
	for(int i = 0 ; i < size_s; i++) {
		dis[G[s][i].v] = G[s][i].w;
	}
	dis[s] = 0;
	bk[s] = 1;
}
double cal(int x1,int y1,int x2,int y2) {
	return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
}

//void print() {
//	for(int i = 1 ; i <= n; i++) {
//		cout<<i<<" : ";
//		int len_ = G[i].size();
//		for(int j = 0;  j < len_; j++) {
//			cout<<G[i][j].v<<" ";
//		}
//		cout<<"\n";
//	}
//}
void print_dis() {
	for(int i = 1; i <= n; i++) {
		cout<<dis[i]<<" ";
	}
	cout<<"\n";
}
void dij() {
	while(cnt < n) {
		int minx = 2e9;
		int cur;
		for(int i = 1; i <= n; i++) {
				if(!bk[i] && minx > dis[i]) {
					minx = dis[i];
					cur = i;
				}
		}
		cnt++;
		bk[cur] = 1;
		int size_cur = G[cur].size();
		for(int i = 0; i < size_cur; i++){
			if(G[cur][i].w < 2e9 && dis[G[cur][i].v] > dis[cur] + G[cur][i].w){
				dis[G[cur][i].v] = dis[cur] + G[cur][i].w;
			}
		}
	}
}
int main() {
	cin>>n;
	for(int i = 1; i <= n; i++) {
		cin>>node[i].x>>node[i].y;
	}
	cin>>m;
	G.clear();
	G.resize(105);
	for(int i = 0 ; i <m ; i++) {
		cin>>a>>b;
		eage.w = cal(node[a].x,node[a].y,node[b].x,node[b].y);
		eage.v = b;
		G[a].push_back(eage);
		eage.v = a;
		G[b].push_back(eage);
	}
	cin>>s>>e;
	init();
	//print_dis();
	dij();
	//print_dis();
	printf("%.2f",dis[e]);
	return 0;
}

/*
5
0 0
2 0
2 2
0 2
3 1
5
1 2
1 3
1 4
2 5
3 5
1 5
*/

/*spfa*/
#include<bits/stdc++.h>
using namespace std;
const int Max = 100010,inf = 2e8;
struct Eage {
	int v,w;
} eage;
vector<vector<Eage> > G;
queue<Eage> que;
int n,m,x,y,z;
int bk[Max] = {0},dis[Max];
void init() {
	for(int i=1; i <= n; i++) {
		dis[i] = inf;
	}
	dis[1]=0;

}
void spfa() {
	init();
	eage.v = 1;
	eage.w = 0;
	que.push(eage);
	while(!que.empty()) {
		int q = que.front().v;
		que.pop();
		bk[q] = 0;
		int size = G[q].size();
		for(int i = 0; i < size; i++) {
			if(dis[G[q][i].v] > dis[q] + G[q][i].w) {
				dis[G[q][i].v] = dis[q] + G[q][i].w;
				if(!bk[G[q][i].v]) {
					eage.v = G[q][i].v;
					eage.w = G[q][i].w;
					que.push(eage);
					bk[G[q][i].v] = 1;
				}
			}
		}
	}
}
int main() {
	scanf("%d%d",&n,&m);
	G.resize(Max);
	G.clear();
	for(int i = 0 ; i < m; i++) {
		scanf("%d%d%d",&x,&y,&z);
		eage.v = y;
		eage.w = z;
		G[x].push_back(eage);
		eage.v = x;
		G[y].push_back(eage);
	}
	// for(int i = 1; i <= n; i++){
	//     int size = G[i].size();
	//     cout<<i<<" : ";
	//     for(int j = 0; j < size; j++){
	//         cout<<G[i][j].v<<" ";
	//     }
	//     cout<<"\n";
	// }
	spfa();
	printf("%d",dis[n]);


	return 0;
}

 

3.并查集

4.最小生成树算法 Prim,Kruskal

//kruskal算法——最小生成树
#include <bits/stdc++.h>
using namespace std;
const int Max = 5000;
int n,e,x,y,z,cnt = 0,ans = 0;
int pre[Max];
struct Eage{
    int u,v,w;
}eage[Max];
bool cmp(const Eage &a,const Eage &b){
    return a.w < b.w;
}
void init(){
    for(int i = 1; i <= n; i++)
        pre[i] = i;
}
int find_pre(int v){
    if(pre[v] == v)
        return v;
    pre[v] = find_pre(pre[v]);
    return pre[v];
}
bool merge(int u,int v){
    int t1 = find_pre(u),t2 = find_pre(v);
    if(t1 != t2){
        pre[t1] = t2;
        return true;
    }
    return false;
}
int main(){
    cin>>n>>e;
    init();
    for(int i = 1; i <= e; i++){
        cin>>x>>y>>z;
        eage[i].u = x;
        eage[i].v = y;
        eage[i].w = z;
    }
    sort(eage+1,eage+e+1,cmp);
    for(int i = 1 ; i <= e; i++){
        if(merge(eage[i].u,eage[i].v)){
            cnt++;
            ans += eage[i].w;
            cout<<eage[i].u<<" "<<eage[i].v<<"\n";
        }
        if(cnt > n-1)
            break;
    }

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int Max = 110,inf= 2e8;
int n,e,x,y,z,cnt = 1,bk[Max] = {0};
struct Node {
	int v,u,w;
} node;
vector<vector<Node> > G;
priority_queue<Node> que;
bool operator < (const Node &a,const Node &b) {
	return a.w > b.w;
}
void Prim() {
	int cur = 1;
	bk[1] = 1;
	while(cnt < n) {
		int size = G[cur].size();
		for(int i = 0 ; i < size; i++) {
			if(!bk[G[cur][i].v]) 
				que.push(G[cur][i]);
		}
		int q = que.top().v;
		//cout<<"q = "<<q<<" w = "<<que.top().w<<"\n";
		cout<<que.top().u<<" "<<q<<"\n";
		bk[q] = 1;
		cur = q;
		que.pop();
		cnt++;
	}
}
int main() {
	cin>>n>>e;
	G.resize(Max);
	G.clear();
	for(int i =1 ; i <= e; i++) {
		cin>>x>>y>>z;
		node.u = x;
		node.v = y;
		node.w = z;
		G[x].push_back(node);
		node.u = y;
		node.v = x;
		G[y].push_back(node);
	}
	Prim();
	return 0;
}

 

5.LCA

6.求割点

7.树的直径

基础DP模板：

1.最长上升子序列LIS

#include <bits/stdc++.h>
using namespace std;
int dp[105] = {0};//保存
int ans = -1;
int main(){
    string a = "8126490";
    int len_a = a.length();

    for(int i = 0 ; i < len_a; i++){
        dp[i+1] = 1;
        for(int j = 0 ; j <i; j++){
            if(a[i] > a[j])
                dp[i+1] = max(dp[i+1],dp[j+1]+1);
           ans =  max(dp[i+1],ans);
        }

    }
    cout<<"ans = "<<ans<<"\n";
    return 0;
}

2.最长公共子序列LCS

/*
LCS
*/
#include <bits/stdc++.h>
using namespace std;
int dp[105][105] = {0};
int main(){
     string a = "AEDDG",b = "AEDEG";
    int len_a = a.length(),len_b = b.length();
    int len = max(len_a,len_b);
    for(int i = 0 ; i < len; i++){
        dp[i][0] = dp[0][i] = 0;
    }
    for(int i = 0 ; i < len_a; i++){
        for(int j = 0 ; j < len_b; j++){
            if(a[i] == b[j]){
                dp[i+1][j+1] = dp[i][j]+1;
            }else{
                dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1]);
            }
        }
    }
    cout<<"ans = "<<dp[len_a][len_b];
    return 0;
}

 

其他：

树的建立

/*前中求后*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
struct BiTree {
	char data;
	BiTree *lc = NULL,*rc = NULL;
	int len_;
};
string per,in;
int flag = 0;
BiTree* Build(int l,int r,int s,int e) {
	if(l > r)
		return NULL;
	int k ;
	BiTree *root;
	if(!(root= (BiTree*)malloc(sizeof(BiTree))))
		exit(-1);
	root->data = per[s];
	for(int i = l ; i <= r; i++) {
		if(per[s] == in[i]) {
			k = i;
			break;
		}
	}
	root->lc = Build(l,k-1,s+1,s+k-l);
	root->rc = Build(k+1,r,s+k-l+1,e);
	if(l == r)
		root->len_ = 1;
	else
		root->len_ = root->rc->len_ + root->lc->len_;
	return root;
}
void postorder(BiTree* root) {
	if(root == NULL)
		return ;
	
//	for(int i = 0 ; i < root->len_; i++)
//	cout<<root->data;
//	cout<<"\n";	
	postorder(root->lc);
	postorder(root->rc);
	cout<<root->data;
}
int main() {
	BiTree *root = (BiTree*)malloc(sizeof(BiTree));
	int n; 
	cin>>per;
	cin>>in;
	n = per.length();
	root = Build(0,n-1,0,n-1);
	postorder(root);
	return 0;
}

线段树模板

/*2.例1最大最小值的差*/
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
int value[N],maxx = -1,minx = 2e8;
struct Node{
    int l,r,minx,maxx;
}st[4*N];
void creat_st(int xl,int xr,int root){
    st[root].l = xl;
    st[root].r = xr;
    if(xl == xr){
        st[root].maxx = st[root].minx = value[xl];//到叶子节点
        return ;
    }
    //开始递归
    int mid = (xl + xr)/2;
    creat_st(xl,mid,2*root);
    creat_st(mid+1,xr,2*root+1);
    //开始回溯
    st[root].maxx = max(st[2*root].maxx,st[2*root+1].maxx);
    st[root].minx = min(st[2*root].minx,st[2*root+1].minx);
}
void print_st(int xl,int xr,int root){
    cout<<root<<" "<<st[root].l<<" "<<st[root].r<<" "<<st[root].maxx<<" "<<st[root].minx<<"\n";
    if(xl == xr)
        return ;
    int mid = (xl+xr)/2;
    print_st(xl,mid,root*2);
    print_st(mid+1,xr,2*root+1);
}
void print_st1(int root){
    cout<<root<<" "<<st[root].l<<" "<<st[root].r<<" "<<st[root].maxx<<" "<<st[root].minx<<"\n";
    if(st[root].l == st[root].r) return ;
    print_st1(root*2);
    print_st1(2*root+1);
}
void update(int q,int u,int xl,int xr,int root){
    if(xl == xr){
        value[xl] = u;
        st[root].maxx = st[root].minx = u;
        return ;
    }
    int mid = (xl + xr)/2;
    if(q <= mid) 
        update(q,u,xl,mid,2*root);
    else
        update(q,u,mid+1,xr,2*root+1);
    st[root].maxx = max(st[2*root].maxx,st[2*root+1].maxx);
    st[root].minx = max(st[2*root].minx,st[2*root+1].minx);
}
//查询 ----xl，xr为查询的区间
void query(int xl,int xr,int root){
    if(xl == st[root].l && xr == st[root].r){
        minx = min(st[root].minx,minx);
        maxx = max(st[root].maxx,maxx);
        return ;
    }else {
        int mid = (st[root].l + st[root].r)/2;
        if(mid >= xr){
            query(xl,xr,2*root);
        }else if(xl > mid){
            query(xl,xr,2*root+1);
        }else{
            query(xl,mid,2*root);
            query(mid+1,xr,2*root+1);
        }
    }
    

}
int main(){
    int n;
    cin>>n;
    for(int i =1; i <= n; i++){
        cin>>value[i];
    }
    creat_st(1,n,1);
    update(4,10,1,n,1);
    //print_st1(1);
    query(1,4,1);
    cout<<"maxx = "<<maxx<<" minx = "<<minx<<"\n";
    return 0;
}