算法框架

递归：

void recursion(level,param1,param2....){
    //递归基，终止条件
    if（level>Max_level）{
        porcess_result //打出相应的结果
        return         //返回
    }
    //处理当前层的逻辑
    process（level data） 
    //下探到下一层
    self recursion(level+1,p1,p2....);
    //有必要的话清理当前层的数据
}

回溯法：

void check(){//一些约束条件的判断，如边界，总和不超多少，矩阵的各种要求

}
void DFS(vector<int> nums,
        vector<string>&res, //这个需要引用，因为我们要改变里面的值，添加符合要求的数据进去
        vector<int> &visied,//这个也要用引用，因为递归的时候每一层都会访问改状态，访问后要修改状态
        string track，      //每一层的路径，这里没有用引用，因为每一层都有属于自己的一个状态，用了引用相当于全局了
        ){
    //递归基，找出符合条件的要求并且保存返回
    if（符合要求的条件）{
        保存数据
        返回
    }

    //选择列表
    for(int i=0;i<n;i++){
       //剪枝，根据题目不同的要求来剪
        if(visied(是否访问过))continue;
        if(i>0&&visied[i-1]&&nums[i-1]==nums[i]);
        if(check()条件不成立)continue;
        //做选择
        visied[i]=true;
        track.push_back(nums[i]);
        //进入下一层
         DFS(nums,res,visied,track)；
        //撤销选择，恢复现场
        visied[i]=false;
        track.pop_back();
    }
}
int main()
{
    vector<int> nums//输入的数据
    vector<string>res;//保存输出的数据
    vector<int> visied（n,false）;//记录是否访问过，相当于备忘录
    string track;    //实时路径，轨迹
    DFS(nums,res,visied,track)   //带备忘录的深度优先搜索
    return res;     //输出全部符合要求的数据
}

BFS广度优先遍历（队列）

vector<vector<int>> LevelOrder(TreeNode* root)
{
    queue<TreeNode*> que;
    if(root!=nullptr)
        que.push(root);
    vector<vector<int>> result;
    while(!que.empty()){                  //这里实现的层序遍历，记录树的每一层数据
        int size=que.size();              //获取当层的数据长度
        vector<int> vec;
        for(int i=0;i<size;i++){          //这里一定要固定每一层的数据长度
            TreeNode* node=que.front();
            que.pop();
            vec.push_back(node->val);     //节点处理逻辑
            if(node->left)queue.push(node->left);
            if(node->right)queue.push(node->right);
        }
        result.push_back(vsc);
    }
    return result;
}
/*优先队列+bfs解决从[0][0]到[M][N]路径上的和为最小*/
#include<bits/stdc++.h>
using namespace std;

struct node{
    int x,y,step;
    friend bool operator<(node a,node b){//重载函数，结构体需要在优先队列里面排序的时候要重载
        return a.step>b.step;
    }
};
priority_queue<node> qu;
int xx[]={0,-1,0,1};  //移动方向矩阵
int yy[]={-1,0,1,0};
int a[105][105],vis[105][105];
int main(){
    node tmp;
    int n,i,j,_x,_y;
    while(cin>>n){
        while(qu.size())
        qu.pop();
        for(i=1;i<=n;i++){
            for(j=1;j<=n;j++)
            cin>>a[i][j];
        }
        memset(vis,0,sizeof(vis));
        qu.push((node){1,1,0});
        while(qu.size()){
            tmp=qu.top();
            qu.pop();
            vis[tmp.x][tmp.y]=1;
            if(tmp.x==n&&tmp.y==n){
                cout<<tmp.step<<endl;
                break;
            }
            for(i=0;i<4;i++){
                _x=tmp.x+xx[i];
                _y=tmp.y+yy[i];
                if(_x<1||_x>n||_y<1||_y>n||vis[_x][_y]==1)
                continue;
                qu.push((node){_x,_y,tmp.step+abs(a[_x][_y]-a[tmp.x][tmp.y])});//操作真6
            }
        }
    }
    return 0;
}