主页有好看的🔞 🔞想打炮🔥，打飞机🔥，打手枪🔥 🔞血与肉的碰撞，深深入耳的叫声 🔞这是灵魂的对战，更是对自己意志的磨练🔞害羞，深夜寂寞，是时候来点热血的🔥 🔞体验真男人一样激烈的战斗 🔞点击此网站 🔞https://www.gfbzb.gov.cn/ 🔞未成年人无法参加🔞

大杰老师114514年1月9日去银趴198次被小新发现于是把小新卖到缅甸赚了十亿点了10个男模

🎉️ 好玩的 https://g.3699.co/

大主播挂我那我也要挂你😡↓

https://oj.0101jy.com/user/78

https://www.minesweeper.cn/ //扫雷

http://123.geiwosou.net/game/2048/ //2048

http://guozhivip.com/fun/els/ //俄罗斯方块

https://www.bilibili.com/video/BV1GJ411x7h7/ //好看的🔞未成年人🈲看🥵🥵

https://www.bilibili.com/video/BV1uuafe9Ek8/ //性感🥵🥵美女💃💃在线热舞🔞🔞

https://tiwb.github.io/catmario/ //猫里奥

vector是 C++ 标准模板库（STL）里极为实用的容器，它能当作动态数组使用，可依据运行时的需求灵活调整大小 1.一维vector

1. 头文件包含 使用vector前，要包含<vector>头文件： #include <vector>
2. 一维vector的创建与初始化 默认初始化：创建一个空的vector，之后可动态添加元素。

#include <iostream>
#include <vector>

int main() {
vector<int> v1;  // 创建一个空的存储int类型元素的vector
return 0;
}

指定大小初始化：创建时指定元素数量，元素默认初始化为对应类型的默认值（数值类型通常为 0）。

#include <iostream>
#include <vector>
int main() {
vector<int> v2(5);  // 创建包含5个元素的vector，元素初始值为0
for (int i = 0; i < v2.size(); ++i) {
cout << v2[i] << " ";
}
cout << endl;
return 0;
}

指定大小和初始值初始化：创建时指定元素数量和初始值。

#include <iostream>
#include <vector>

int main() {
    vector<int> v3(5, 10);  // 创建包含5个元素的vector，每个元素初始值为10
    for (int i = 0; i < v3.size(); ++i) {
       cout << v3[i] << " ";
    }
   cout << endl;
    return 0;
}

列表初始化：使用花括号{}直接给出初始元素。

#include <iostream>
#include <vector>

int main() {
    vector<int> v4 = {1, 2, 3, 4, 5};  // 使用列表初始化vector
    for (int i = 0; i < v4.size(); ++i) {
        cout << v4[i] << " ";
    }
   cout << endl;
    return 0;
}

3. 一维vector的常用操作 添加元素：用push_back()在vector末尾添加元素。

#include <iostream>
#include <vector>

int main() {
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    for (int i = 0; i < v.size(); ++i) {
        cout << v[i] << " ";
    }
    cout << endl;
    return 0;
}

任意进制转十进制

int a(const string&b, int c){
    int d=0;
    int e=0;
    for(int i=b.length()-1;i>=0;--i){
    	char f=b[i];
    	if(f>='0'&&f<='9'){
    		d+=(f-'0')*pow(c,e);
		}else{
			d+=(f-'A'+10)*pow(c,e);
		}
		++e;
	}
	return d;
}

dfs模板（往下滑有最新的

#include<bits/stdc++.h>
using namespace std;
递归模板：
void dfs(参数(地图，起点，终点)){
        处理节点
        dfs(地图，选择的节点);
        回溯,撤销处理结果
}
//dfs模板
void dfs(参数){
        if(终止条件){
                存放结果
                return;//终止当前的递归不是结束函数
        }
        for(选择;本连接所有的其他节点){
                处理节点
                dfs(地图，选择的节点);
                回溯，撤销处理结果
        }
}
int main(){
    return 0;
}

广度优先搜索（往下滑有最新打的

1地图
2队列
3状态数组
4结构体
5方向数组
 
struct node{
	int x;
	int y;
	int step;
};
int dir[4][2];//四个方向 
inr dir[8][2];//八个方向
int visited[][];//状态数组 
int dfs(参数(地图,起点,终点)){
	queue<node> q;//队列封装结构体
	q.push(起点);
	//起点的状态更新
	visited[起点][起点]=1;
	//预探索节点入队 
	while(!q.empty()){
		//获取头节点
		node head=q.front()//获取头节点
		//头节点出队
		q.pop();
		//判断是否为终点
		int x=head.x;
		int y=head.1y;
		if(x==终点&&y==终点){
			return 0;
		}
		//预探索方向
		for(int i=0;i<4/8;i++){
			int nx=x+dir[i][0];
			int ny=y+dir[i][1];
			if(int nx,ny地图内,visited没有被访问过,地图的当前坐标可以走){
				visited[nx][nx]=1;//当前坐标已经走过
				q.push({nx,ny,step+1}); 
			} 
		} 
	}
}

排序算法：

选择排序（不稳定排序，时间复杂度为O（n²））： 每一轮选择最小的元素和已排好的序列后一个进行交换

for(int i=0;i<n-1;i++){
    int minlndex=i;
    for(int j=i+1;j<n;j++){
        if(arr[j]<arr[minlndex]){
            minlndex=j;
        }
    }
    swap(arr[minldex],arr[i]);
}

冒泡排序：每一次如果前一个大于后一个进行交换选出最大值（O（n²），稳定排序）

for(int i=0;i<n-1;i++){
    for(int j=0;j<n-i;j++){
        if(arr[j]>arr[j+1]){
            //交换
            int temp=arr[i];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }
}

插入排序：当前i的值和前面进行比较，如果比前面小，不断的交换，直到不能交换为止（O（n²）稳定排序）

for(int i=2;i<=n;i++){
    int j,k=a[i];
    for(int j=i-1;j>0;j--){
        if(a[j]>k){
            a[j+1]=a[j];
        }else{
            break;
        }
    }
    a[j+1]=k;
}

计数排序：（不稳定）

for(i=1;i<=n;i++){
    cin>>k;
    a[k]++;
}
for(i=1;i<=2000;i++){
    while(a[i]){
        cout<<i<<" ";
        a[i]--;
    }
}

快速排序：找基准点（首位 or 末尾），每次执行比基准点小的放左边，大的放右边（O（log²n））

void quicksort(int arr[],int low,int high){
    if(low<high){
        //获取分区后的抠纽位置
        int pivot_index=partition(arr,low,high);
        //分别对抠纽左右两边的子数组进行递归排序
        quicksort(arr,low,pivot_index-1);
        quicksort(arr,pivot_index+1,high);
    }
}
int partition(int arr[],int low,int high){
    int pivot=arr[high];
    int i=(low-1);
    for(int j=low;j<=high-1;j++){
        if(arr[j]<pivot){
            i++;
            swap(arr[i],arr[j]);
        }
    }
    swap(arr[i+1],arr[high]);
    return i+1;
}

二叉树广搜模板

#include<bits/stdc++.h>
using namespace std;
struct node{
    int val;
    node*l;
    node*r;
}
void bfs(node*root){
    if(!root)return;
    queue<node*>q;
    q.push(root);
    while(!q.empty()){
        node*cur=q.front();
        q.pop();
        cout<<"value="<<cur->val<<endl;
        if(cur->l)q.push(cur->l);
        if(cur->r)q.push(cur->r);
    }
}
int main(){

}

广度优先搜索

#include<bits/stdc++.h>
using namespace std;
void bfs(){
    queue<point>q;
    begin.x=bex;
    begin.y=bey;
    begin.step=1;
    vis[begin.x][begin.y]=1;
    q,push(begin);
    while(!q.empty()){
        int x,y,step;
        x=q.front().x;
        y=q.front().y;
        step=q.front().step;
        break;
    }
    q.pop();
    int x1[4]={0,1,0,-1};
    int y2[4]={1,0,-1,0};
    struct point{
        int x,y,step;
    };
    for(int i=0;i<4;i++){
        int wx,wy;
        wx=x+x1[i];
        wy=y+y2[i];
        if(a[wx][wy]=='.'&&vis[wx][wy]==0){
            struct point ing;
            flag[wx][wy]=1;
            ing.x=wx;
            ing.y=wy;
            ing.step=q.front().step+1;
            q.push(ing);
        }
    }
}
int main(){

}

深度优先搜索

#include<bits/stdc++.h>
using namespace std;
//vector<vector<int>>result;//二维数组(保留结果集)
vector<int>path; //结果数组
int n; //题目中结果的目标长度
void dfs(int x){ //x起点
    if(path.size()==n){
        for(int x:path){//遍历path数组
        //for(int i=0;i<path.size();i++)
            cout<<x<<endl;
        }
        //result.push_back(path);二维数组保留一维数组
        return;//停止当前的递归
    }
    for(int i=x;i<=n;i++){//枚举可能向下递归结果
            if(条件不成立的时候){
                continue;
            }
            path[i]=true;//已经走过
            path.push_back(i);//保留结果 || 处理节点
            dfs(i+1);//开始向下递归
            //其他状态也要回溯
            path[i]=false;
            path.pop();//回溯
        }
}
int main(){
}

01背包问题描述：给定一组物品和一个背包，每个物品都有一个重量和一个价值 求如何选择物品放入背包使得背包物品的总价值最大（物品不重复

dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);

完全背包问题：给定一组物品和一个背包，每个物品都有一个重量和一个价值， 求如何选择物品放入背包使得背包内物品的总价最大（物品可以重复

dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight]-weights[i-1]+value[i-1]);

邻接矩阵：

#include<bits/stdc++.h>
using namespace std;
const int N = 205;
int g[N][N];
int n,m;
int main(){
	cin>>n>>m;
	for(int i = 1;i<=m;i++){
		int u,v;
		cin>>u>>v;
		g[u][v]= g[v][u]=1;
	}
	for(int i = 1;i<=n;i++){
		for(int j = 1;j<=n;j++){
			cout<<g[i][j]<<" ";
		}
		cout<<'\n';
	}
}

邻接表

#include
using namespace std;
const int N = 205;
vector<int> g[N]; // 邻接表
int n,m;
int main(){
cin>>n>>m;
for(int i = 1;i<=m;i++){
int u,v;
cin>>u>>v;
g[u].push_back(v);
}
for(int i = 1;i<=n;i++){
cout<<i<<":";
for(int j = 0;j<g[i].size();j++){
cout<<g[i][j]<<" ";
}
cout<<'\n';
}
}