Aprendizaje de algoritmos C ++ (método de bifurcación y enlace)

1. Objetivo

Encuentre la solución óptima bajo restricciones

2. Método

Busque en el árbol del espacio de la solución de una manera primero en amplitud o en primer lugar con el menor costo.

3. Realización concreta

En el método de ramificación y vinculación, cada nodo en vivo tiene la posibilidad de convertirse en un nodo extendido, generando todos sus nodos secundarios a la vez. Los nodos hijo inapropiados se eliminan, dejando solo los adecuados ingresando a la cola y los anteriores saliendo de la cola. Personalmente, creo que esto es BFS y hay otros entendimientos que se pueden discutir.

4. Preguntas de ejemplo:

Te sugiero que lo escribas a mano, aunque es una nota personal, espero que sea de utilidad para los internautas.

1. La base del recorrido en amplitud primero

(1) Botón Forzar: Sword se refiere a la Oferta 32-I. Imprime el árbol binario de arriba a abajo

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    vector<int> levelOrder(TreeNode* root) {
    
    
     if(!root) return {
    
    };
     queue<TreeNode *> mes;
     vector<int> answer;
     mes.push(root);
     while(!mes.empty()){
    
    
         TreeNode * node = mes.front();
         mes.pop();
         if(node->left) mes.push(node->left);
         if(node->right) mes.push(node->right);
         answer.push_back(node->val);
     }
     return answer;
    }
};

(2) Botón Forzar: Sword se refiere a la Oferta 32-II. Imprime el árbol binario de arriba a abajo II

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
    
    
    if(!root) return {
    
    };
    vector<vector<int>> a;
    queue<TreeNode*> data;
    data.push(root);
    while(data.size()){
    
    
        int num = data.size();
        vector<int> ai;
        for(int i = 0;i < num;i++){
    
    
            TreeNode * node = data.front();
            data.pop();
            if(!node) continue;
            if(node->left) data.push(node->left);
            if(node->right) data.push(node->right);
            ai.push_back(node->val);
        }
        if(ai.size() != 0) a.push_back(ai);
    }
    return a;
    }
};

(2) Botón Forzar: Sword se refiere a la Oferta 32-III. Imprime el árbol binario III de arriba a abajo

En realidad, es lo mismo que antes. Esta es una forma de presentarte:

v.insert(v.begin(),data);//把data插入到vector的最前面

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
    
    
    if(!root) return {
    
    };
    vector<vector<int>> a;
    queue<TreeNode*> data;
    data.push(root);
    int floor = 0;
    while(data.size()){
    
    
        floor++;
        int num = data.size();
        vector<int> ai;
        for(int i = 0;i < num;i++){
    
    
            TreeNode * node = data.front();
            data.pop();
            if(!node) continue;
            if(node->left) data.push(node->left);
            if(node->right) data.push(node->right);

            if(floor%2 == 0) ai.insert(ai.begin(),node->val);
            else ai.push_back(node->val);
        }
        if(ai.size() != 0) a.push_back(ai);
    }
    return a;
    }
};

2. Utilice un recorrido transversal en amplitud

(1) Botón de fuerza: matriz 542.01

class Solution {
    
    
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
    
    
        //准备工作
        queue<pair<int, int>> q;
        int row = matrix.size();
        int col = matrix[0].size();
        //开始第一步把0放入队列
        for(int i = 0;i < row;i++)
        for(int j = 0;j < col;j++){
    
    
            if(matrix[i][j] == 0)  q.push({
    
    i,j});
            else matrix[i][j] = -1;
        }
        //开始插入
        int a[] = {
    
    -1,1,0,0};
        int b[] = {
    
    0,0,1,-1};
        while(!q.empty()){
    
    
            pair<int,int> pair_data = q.front();
            q.pop();
            for(int i = 0;i <4;i++){
    
    
                int newX = pair_data.first + a[i];
                int newY = pair_data.second + b[i];
                if(newX >= 0 
                && newX < row 
                && newY >= 0
                && newY < col
                && matrix[newX][newY] == -1)
                {
    
    
                    matrix[newX][newY] = matrix[pair_data.first][pair_data.second] + 1;
                    q.push({
    
    newX,newY});
                }
                }
            }
        return matrix;
    }
};

Es un poco una nube y duele. Todavía no lo escribo. Lo actualizaré si encuentro límites de sucursales en el futuro. Se usa principalmente para notas personales. Espero que te ayude un poco.