专题十_穷举vs暴搜vs深搜vs回溯vs剪枝_二叉树的深度优先搜索_算法专题详细总结

目录

搜索 vs 深度优先遍历 vs 深度优先搜索 vs 宽度优先遍历 vs 宽度优先搜索 vs 暴搜

1.深度优先遍历 vs 深度优先搜索(dfs)

2.宽度优先遍历 vs 宽度优先搜索(bfs)

2.关系图暴力枚举一遍所有的情况

3.拓展搜索问题全排列

决策树

1. 计算布尔⼆叉树的值（medium）

解析：

1.函数头

2.函数体

3.函数出口

总结：

2. 求根节点到叶节点数字之和（medium）

解析：​编辑

总结：

3. ⼆叉树剪枝（medium）

总结：

4. 验证⼆叉搜索树（medium）

解析：

策略一：中序遍历，判断这个二叉树是否有序

策略二：剪枝

总结：

5. ⼆叉搜索树中第 k ⼩的元素（medium）

解析：

总结：

6. ⼆叉树的所有路径（easy）

解析：

总结：

穷举vs暴搜vs深搜vs回溯vs剪枝

什么是回溯算法

7. 全排列（medium）

解析：

1）暴力枚举：

2）递归优化：

2.设计代码：

全局变量

dfs函数

细节问题

总结：

8. ⼦集（medium）

解析：

解法一：

1.决策树

2.设计代码

全局变量

dfs

解法二：

1.画决策树

2.设计代码

总结：

搜索 vs 深度优先遍历 vs 深度优先搜索 vs 宽度优先遍历 vs 宽度优先搜索 vs 暴搜

1.深度优先遍历 vs 深度优先搜索(dfs)

2.宽度优先遍历 vs 宽度优先搜索(bfs)

那么遍历只是形式，目的是搜索

2.关系图
暴力枚举一遍所有的情况

搜索(暴搜) dfs

3.拓展搜索问题
全排列

决策树

废话不多说，直接进入例题：
 

1. 计算布尔⼆叉树的值（medium）

题目比较长，但是还是比较好理解的，0，1，2，3分别代表false，true,|,&
然后在这这个决策树上通过运算，算出最后这颗树的结果

解析：

递归函数的调用：

主要就是分三步，当主问题与子问题相同的时候：

1.函数头

2.函数体

3.函数出口

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool a[2]={false,true};
    bool evaluateTree(TreeNode* root) {
        if(root->left==nullptr||root->right==nullptr) return a[root->val];

        bool left=evaluateTree(root->left);
        bool right=evaluateTree(root->right);

        return root->val==2?left|right:left&right;
    }
};

总结：

只要能分析出当前问题的相同子函数，就可以得出函数体里面的内容，通过所有相同的子函数的内容进行一步步操作就能完成当前函数的任务。

2. 求根节点到叶节点数字之和（medium）

题意还是比较好理解的，就是对从根节点开始一直到叶子节点，计算每个节点当前值不断*10最后所有叶子节点的和

解析：

这种题目计算每个叶子节点的方法一眼就是dfs，先递归到叶子节点，然后就开始相加。

以下是同一种dfs的两种思想：

1.定义全局变量ret，然后每次递归到叶子节点的时候就开始进行相加，那么我就是用一个字符串s来保存每一层的临时变量，这样可以达到回溯的效果，起始不要字符串保存，只有用presum来存储临时变量也是ok的，都能存的下最终的和，然后每次到叶子节点ret就进行相加，知道加完所有叶子节点的值就完成，返回ret

唯一需要注意的就是，在传入dfs的时候就要立刻加上当前节点的值，这样就不会漏掉当前节点的某一位，因为只要到叶子节点就要开始返回上一层了，为了防止叶子节点的值给漏掉。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int ret=0;
    int sumNumbers(TreeNode* root) {
        string s;
        dfs(root,s);
        return ret;
    }

    void dfs(TreeNode* root,string s)
    {
        s+=to_string(root->val);

        if(root->left==nullptr&&root->right==nullptr)
        {
            ret+=stoi(s);
            return;
        }

        if(root->left) dfs(root->left,s);
        if(root->right) dfs(root->right,s);
    }
};

2.就是用presum来记录临时变量，不需要字符串到整形，整形到字符串的各种转换，因为最后的结果int也能存下。

看到上面的图，就能看出，如果我存临时变量presum，那么dfs返回的就是当前节点下所有叶子节点的和，那么整个二叉树就都变成了一个子问题，就是要求头节点下所有叶子节点的和。

函数头：int dfs(root,presum);

出口：就是当到达叶子节点的时候，那么就返回当前叶子节点的presum

函数体：用ret来记录当前节点下所有左右子树中，叶子节点的和，在当前节点左子树不为空下，传入dfs(root->left,presum);在当前节点右子树不为空下，传入dfs(root->right,presum);来求出当前节点下的左右子树的所有叶子节点的和

最后返回ret

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        return dfs(root,0);
    }

    int dfs(TreeNode* root,int presum)
    {
        presum=presum*10+root->val;

        if(root->left==nullptr&&root->right==nullptr) return presum;

        int ret=0;//记录当前节点下，所有叶子节点的值
        if(root->left) ret+=dfs(root->left,presum);
        if(root->right) ret+=dfs(root->right,presum);
        return ret; //返回给上一层
    }
};

总结：

像这种带有回溯类的问题，只需要考虑清楚带上的临时变量不会再中途被改变，并且再返回上一层稳定即可。

3. ⼆叉树剪枝（medium）

本题，题意比较绕，但是就是删掉所有子树全为0的节点

解析：

因为计算机不可能知道当前节点下左右子树的所有节点是否全为0，所以就要完全遍历到叶子节点在开始判断，判断叶子节点是否为0 如果是就直接置为空，并且返回空，否则就返回当前节点，不改变。

经过上面的思考，发现要先解决完所有的左子树和右子树，然后在考虑当前的节点是否为0，且左右子树是否为空，所以就完全是一个后序遍历。

1.函数头：再前面的分析里面要返回当前节点的情况，是否为空，否则就返回当前节点。说明函数头是带有返回值的。

Node* dfs(root);

2.函数体：

由于是后序遍历，先访问所有左子树，再访问右子树。然后进行判断当前节点

root->left=dfs(root->left);

root->right=dfs(root->right);

判断：如果当前节点的左右子树都为空，并且当前节点值为0，就说明这个节点也可以被删掉

if(root->left==nullptr&&root->right==nullptr&&root->val==0) root=nullptr；

return root;//将当前节点的值，返回给上一层

3.递归出口：当前节点为空的时候就返回空

if(root==nullptr) return nulltpr;

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* pruneTree(TreeNode* root) {
        if(root==nullptr) return nullptr;

        root->left=pruneTree(root->left);
        root->right=pruneTree(root->right);

        if(root->left==nullptr&&root->right==nullptr&&root->val==0) root=nullptr; 
        return root;//返回给上一层
    }
};

总结：

写的代码很简单，但是要想清楚每一步还是很不容易，多注意细节问题，多思考，一个题目要反复思考才能被吸收。

4. 验证⼆叉搜索树（medium）

题意很简单，只要证明该树是不是二叉搜索树

解析：

策略一：中序遍历，判断这个二叉树是否有序

用prev来记录二叉树的中序的根节点，就是当前节点左子树的最右边的一个节点

要保证该二叉树是平衡二叉树，就要一直保证prev < root->val 那么就能满足条件，一旦打破了就返回false

那么：

1.函数头：bool dfs(root)

2.函数体：

弄弄左子树：bool left=dfs(root->left);

中序判断：bool ret = false;

                  if(prev<root->val) ret=true;
                  prev = root->val;

弄弄右子树：bool right=dfs(root->right);

3.出口条件：

当节点访问到空的时候，证明没有问题，返回true

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    long prev=LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) return true;
        bool left=isValidBST(root->left);

        bool ret=false;
        if(root->val>prev) ret=true;
        prev=root->val;

        bool right=isValidBST(root->right);

        return left&&right&&ret;
    }
};

策略二：剪枝

上面策略一是访问了所有的节点，但是如果只要满足有一个节点不满足平衡二叉树的条件，不满足升序，那么就要返回false，不在往后遍历。

那么只需要再判断左子树的时候证明他是false 或者 再判断当前值不满足升序的时候都返回false就能完成剪枝操作，不在往后执行

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    long prev=LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) return true;
        bool left=isValidBST(root->left);
        if(left==false) return false;

        bool ret=false;
        if(root->val>prev) ret=true;
        prev=root->val;
        if(ret==false) return false;

        bool right=isValidBST(root->right);

        return left&&right&&ret;
    }
};

总结：

回溯、剪枝真的没有那么神秘，再递归里面百分之99都要用到回溯，剪枝只是再我们能完成条件之后再考虑优化，我们可以尝试以下剪枝。

5. ⼆叉搜索树中第 k ⼩的元素（medium）

题意很简单，中序遍历k次的值就是第k小的元素

解析：

设置两个全局变量，ret，count，那么当count==k的时候，说明dfs再中序遍历里面已经遇到了k次中序遍历的值，得到了第k小的值

1.函数头：

void dfs(root);

2.函数体：

中序遍历，遍历到第k次时找到第k小的值：

dfs(root->left);

++count; if(count==k) ret=root->val;

dfs(root->right);

3.出口条件：

知道root==nullptr || ret != -1 就return；只要ret被改变就可以进行剪枝 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int ret=-1;
    int _k;
    int count=0;
    int kthSmallest(TreeNode* root, int k) {
        _k=k;
        dfs(root);
        return ret;
    }

    void dfs(TreeNode* root)
    {
        if(root==nullptr||ret!=-1) return;
        dfs(root->left);
        if(++count==_k) ret=root->val;
        dfs(root->right);
    }
};

总结：

这题真的很简单，通过上面的练习，就只需要一次中序遍历就可以得到第k小的值。

6. ⼆叉树的所有路径（easy）

题意很简单，将从根节点到叶节点的所有路径放在字符串内进行返回。

解析：

虽然这题很简单，但只是有这个简单题来突破其他的难题，我们需要考虑到很多细节问题：

回溯     ->      恢复现场 的因果关系，是因为有了回溯才出现的恢复现场，不能本末倒置了。
只要有递归，那么就绝对伴随之回溯，只要有深度优先遍历，就会存在恢复现场。

为了回溯恢复现场的时候，那么就要考虑我们的参数就不能设置为全局变量，只需要把他设置为dfs的参数，那么就不需要对全局变量进行修改或删除。再每一层的临时变量都是存储当前位置的参数，不会被后面递归影响。

再考虑路径值的时候，就只需要考虑前序遍历然后添加到字符串内即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<string> ret;
    vector<string> binaryTreePaths(TreeNode* root) {
        string s;
        dfs(root,s);
        return ret;
    }

    void dfs(TreeNode* root,string s)
    {
        if(root==nullptr) return;

        s+=to_string(root->val);
        if(root->left==nullptr&&root->right==nullptr) ret.push_back(s);
        else s+="->";
        
        dfs(root->left,s);
        dfs(root->right,s);
    }
};

总结：

这里对于回溯和恢复现场真的有很强的表现，强烈建议深刻理解以下恢复现场时，把参数当作临时变量真的很方便，就不需要自己再进行操作。

穷举vs暴搜vs深搜vs回溯vs剪枝

什么是回溯算法

回溯算法是⼀种经典的递归算法，通常⽤于解决组合问题、排列问题和搜索问题等。
回溯算法的基本思想：从⼀个初始状态开始，按照⼀定的规则向前搜索，当搜索到某个状态⽆法前进时，回退到前⼀个状态，再按照其他的规则搜索。回溯算法在搜索过程中维护⼀个状态树，通过遍历状态树来实现对所有可能解的搜索。
回溯算法的核⼼思想：“试错”，即在搜索过程中不断地做出选择，如果选择正确，则继续向前搜
索；否则，回退到上⼀个状态，重新做出选择。回溯算法通常⽤于解决具有多个解，且每个解都需要搜索才能找到的问题。
回溯算法的模板 

void backtrack(vector<int>& path, vector<int>& choice, ...) {
 // 满⾜结束条件
 if (/* 满⾜结束条件 */) {
 // 将路径添加到结果集中
 res.push_back(path);
 return;
 }
 // 遍历所有选择
 for (int i = 0; i < choices.size(); i++) {
 // 做出选择
 path.push_back(choices[i]);
 // 做出当前选择后继续搜索
 backtrack(path, choices);
 // 撤销选择
 path.pop_back();
 }
}
其中， path 表⽰当前已经做出的选择， choices 表⽰当前可以做的选择。在回溯算法中，我们需要做出选择，然后递归地调⽤回溯函数。如果满⾜结束条件，则将当前路径添加到结果集中；否则，我们需要撤销选择，回到上⼀个状态，然后继续搜索其他的选择。
回溯算法的时间复杂度通常较⾼，因为它需要遍历所有可能的解。但是，回溯算法的空间复杂度较低，因为它只需要维护⼀个状态树。在实际应⽤中，回溯算法通常需要通过剪枝等⽅法进⾏优化，以减少搜索的次数，从⽽提⾼算法的效率。

7. 全排列（medium）

题意很简单，就是枚举所有可能的排列情况，那么废话不多说就是话决策树。

解析：

1）暴力枚举：

两层三层循环还可以枚举，如果要排列100层的数，那简直不可能，只能借助递归来思考。

2）递归优化：

1.画出决策树：越详细越好

2.设计代码：

全局变量

int [][] ret

int [] path

bool [] check 实现剪枝

dfs函数

就需要关系某一个节点在干什么事情

细节问题

回溯：

1.干掉path最后一个元素

2.修改check数组

剪枝

递归出口：遇到叶子节点就直接添加结果

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    bool check[7];
    vector<vector<int>> permute(vector<int>& nums) {
        dfs(nums);
        return ret;
    }

    void dfs(vector<int>& nums)
    {
        if(path.size()==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();i++)
        {
            if(check[i]==false)
            {
                path.push_back(nums[i]);
                check[i]=true;
                dfs(nums);
                path.pop_back();
                check[i]=false;
            }
        }
    }
};

总结：

最重要的就是画出决策树，越细致越好，然后通过决策树来观察代码该如何书写。

8. ⼦集（medium）

题意很简单，就是返回数组nums的所有子集。

解析：

解法一：

1.决策树

2.设计代码

全局变量

vector<vector<int>> ret; //来记录整体传入的子集
    vector<int> path;  //设置全局变量，来保证传参，然后进行手动删除

dfs

细节问题：剪枝，回溯，递归出口

传入nums后，要考虑当前位置是否选择，分为选择和不选择两种

如果选择，那么就是ret.push_back(path+nums[i])

不选择就是ret.push_back(path)

但是这里要注意的就是不选择要在选择前面，这样方便后面选择后的手动删除。再就是dfs传入后就是传入到下一层，i+1,表示的就是下一层的层数，此时回溯到这一层i也不会被改变。

递归出口：就是在i的层数在nums.size()的时候就进行最后的添加，然后进行返回。

、

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    
    int check[10];
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums,0);

        return ret;
    }

    void dfs(vector<int>& nums,int i)
    {
        if(nums.size()==i)
        {
            ret.push_back(path);
            return;
        }
        
        //不选
        dfs(nums,i+1);
        path.push_back(nums[i]);
        
        //选
        dfs(nums,i+1);
        path.pop_back();
    }
};

解法二：

1.画决策树

2.设计代码

全局变量

vector<vector<int>> ret; //来记录整体传入的子集
    vector<int> path;  //设置全局变量，来保证传参，然后进行手动删除

dfs

细节问题：回溯 剪枝 递归出口 

只用关心每层进去后当前nums下标值的后面的值，前面的值不用考虑

例如：在1中选2，1中选3不选2，就是在for循环内进行的，当进入下一层选2，回来这个数组就会删掉2，i++，再次进入下一层选3.

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int k)
    {
        ret.push_back(path);

        for(int i=k;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            dfs(nums,i+1);
            path.pop_back();
        }
    }
};

总结：

我觉得最关键的就是画出决策图然后再进行思考递归出口或者函数体里面的内容，像这一题就是跟上一题决策树完全不同，思考的方向就完全不同。

总结一下吧~这章对我的进步真的很大，希望对你也是！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/888550.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

yub‘s Algorithmic Adventures_Day7

yub‘s Algorithmic Adventures_Day7

环形链表 link&#xff1a;https://leetcode.cn/problems/linked-list-cycle-ii/description/ 思路分析 我只能说双指针yyds【刻板hh】 我们分两种情况来分析 起码在第二圈才会相遇 fast比slow多走环的整数倍 fast 走的步数是 slow 步数的 2 倍&#xff0c;即 f2s&#xff…
阅读更多...
计算机的错误计算（一百一十七）

计算机的错误计算（一百一十七）

摘要 算式“(5^25*(1/25)^(1/5)*3^25(1/25)^(1/5)*5^25*3^(251/5)-(9/25)^(1/5)*3^25*5^25-(1/25)^(1/5)*3^25*5.0^25*(13^(1/5)-3^(2/5.0)))” 的准确值是0. 但是&#xff0c;Python 与 Excel 均输出了错误结果&#xff1a;一个含有15位整数&#xff0c;一个含有14位整数。 …
阅读更多...
Python | Leetcode Python题解之第464题我能赢吗

Python | Leetcode Python题解之第464题我能赢吗

题目&#xff1a; 题解&#xff1a; class Solution:def canIWin(self, maxChoosableInteger: int, desiredTotal: int) -> bool:cachedef dfs(usedNumbers: int, currentTotal: int) -> bool:for i in range(maxChoosableInteger):if (usedNumbers >> i) & 1…
阅读更多...
初学者如何快速入门人工智能

初学者如何快速入门人工智能

一、引言 人工智能&#xff08;Artificial Intelligence&#xff0c;简称AI&#xff09;&#xff0c;作为当今科技领域极具前景与影响力的方向之一&#xff0c;吸引着众多人士投身其中。无论是对科技充满好奇的学生&#xff0c;还是意图拓展职业发展路径的职场人士&#xff0c…
阅读更多...
网络知识_001_浏览器输入域名

网络知识_001_浏览器输入域名

文章目录 网络模型IP地址&#xff0c;子网掩码&#xff0c;网关&#xff0c;网络地址&#xff0c;广播地址&#xff0c;NAT转换浏览器输入域名到网页打开发生了什么DNS获取顺序 网络模型 模型协议工具报文添加信息作用应用层http&#xff0c;https&#xff0c;ftp&#xff0c;…
阅读更多...
认识动态规划算法和实践（java）

认识动态规划算法和实践（java）

前言 动态规划算法里面最有意思的一个东西之一。动态规划初学肯定会有一定晦涩难懂。如果我们去网上搜索&#xff0c;动态规划的资料&#xff0c;它一开始都是将很多的理论&#xff0c;导致会认为很难&#xff0c;但是这个东西实际上是有套路的。 动态规划的英语是Dynamic Pr…
阅读更多...
Java爬虫技术：解锁1688商品搜索的新维度

Java爬虫技术：解锁1688商品搜索的新维度

Java爬虫技术简介 Java爬虫技术是指使用Java语言编写的程序&#xff0c;模拟浏览器行为&#xff0c;自动化地从互联网上获取信息。随着技术的发展&#xff0c;Java爬虫技术已经非常成熟&#xff0c;有多种框架和库可以使用&#xff0c;如Jsoup、HttpClient、WebMagic等。 1688…
阅读更多...
【操作系统】引导（Boot）电脑的奇妙开机过程

【操作系统】引导（Boot）电脑的奇妙开机过程

&#x1f339;&#x1f60a;&#x1f339;博客主页&#xff1a;【Hello_shuoCSDN博客】 ✨操作系统详见 【操作系统专项】 ✨C语言知识详见&#xff1a;【C语言专项】 目录 什么是操作系统的引导&#xff1f; 操作系统的引导&#xff08;开机过程&#xff09; Windows操作系…
阅读更多...
【2024最新】华为HCIE认证考试流程

【2024最新】华为HCIE认证考试流程

HCIE是华为认证体系中最高级别的ICT技术认证&#xff0c;表示通过认证的人具有ICT领域专业知识和丰富实践经验。 HCIE认证方向&#xff1a;最高认证级别HCIE的技术方向有13个 下面以HCIE-Datacom为例给大家介绍一下&#xff1a; HCIE-Datacom认证考试流程&#xff1a; 1.笔试…
阅读更多...
ecmascript标准

ecmascript标准

ECMAScript&#xff08;简称ES&#xff09;是由Ecma国际&#xff08;前身为欧洲计算机制造商协会&#xff0c;European Computer Manufacturers Association&#xff09;制定的一种标准化的脚本程序设计语言。它是JavaScript的核心&#xff0c;定义了语言的语法、类型、语句、关…
阅读更多...
Stable Diffusion最新版nowebui的api使用详解

Stable Diffusion最新版nowebui的api使用详解

最近在使用stable diffusion最新版的Stable Diffusion WebUI Forge进行api调用，下面来一步一步的进行展开吧！！！ 1、下载lllyasviel/stable-diffusion-webui-forge GitHub - lllyasviel/stable-diffusion-webui-forgeContribute to lllyasviel/stable-diffusion-webui-for…
阅读更多...
医院管理智能化：Spring Boot技术革新

医院管理智能化：Spring Boot技术革新

3系统分析 3.1可行性分析 通过对本医院管理系统实行的目的初步调查和分析&#xff0c;提出可行性方案并对其一一进行论证。我们在这里主要从技术可行性、经济可行性、操作可行性等方面进行分析。 3.1.1技术可行性 本医院管理系统采用JAVA作为开发语言&#xff0c;Spring Boot框…
阅读更多...
C++——类和对象（二）

C++——类和对象（二）

1. 类的默认成员函数 默认成员函数就是用户没有显式实现&#xff0c;编译器会自动生成的成员函数称为默认成员函数。⼀个类&#xff0c;我们不写的情况下编译器会默认生成以下6个默认成员函数&#xff0c;需要注意的是这6个中最重要的是前4个&#xff0c;最后两个取地址重载不…
阅读更多...
探索杨辉三角形的奥秘：C#实现

探索杨辉三角形的奥秘：C#实现

文章目录 杨辉三角形简介特点 C#实现杨辉三角形环境准备代码实现代码解释1. 用户输入2. 输入验证3. 初始化第一行4. 生成杨辉三角形5. 打印杨辉三角形 结论 杨辉三角形&#xff0c;也被称为帕斯卡三角形&#xff0c;是一个历史悠久且充满数学魅力的数字模式。它不仅在数学领域有…
阅读更多...
裸眼3D巨幕视频演示Pr城市广告显示屏样机模板

裸眼3D巨幕视频演示Pr城市广告显示屏样机模板

震撼大气超强视觉冲击力3D城市数字广告牌视频演示pr模板工程文件。 5个城市街景裸眼3D巨幕户外广告显示屏样机模板。每个场景提供2个不同的相机视图。 下载地址&#xff1a;https://prmuban.com/40595.html
阅读更多...
泡沫背后：人工智能的虚幻与现实

泡沫背后：人工智能的虚幻与现实

人工智能的盛世与泡沫 现今&#xff0c;人工智能热潮席卷科技行业&#xff0c;投资者、创业者和用户都被其光环吸引。然而&#xff0c;深入探讨这种现象&#xff0c;人工智能的泡沫正在形成&#xff0c;乃至具备崩溃的潜质。我们看到的&#xff0c;无非是一场由资本推动的狂欢…
阅读更多...
OCP迎来新版本，让OceanBase的运维管理更高效

OCP迎来新版本，让OceanBase的运维管理更高效

近期&#xff0c;OceanBase的OCP发布了新版本&#xff0c;全面支持 OceanBase 内核 4.3.2 及更低版本。新版本针对基础运维、性能监控、运维配置、外部集成等多个方面实现了 20余项的优化及强化措施&#xff0c;增强产品的易用性和稳定性&#xff0c;从而帮助用户更加高效地管理…
阅读更多...
第二期：第14节， beep 编程

第二期：第14节， beep 编程

首先是 硬件电路图&#xff1a; 然后是数据手册中 找到 相关的寄存器&#xff0c; 首先是 GPIO的复用寄存器&#xff0c; 然后是 PWM的寄存器。 首先是 关于GPIO的 复用 &#xff0c; 这里是 Tout&#xff0c; 也就是 定时器&#xff0c; pwm 通过 定时器 通过某种方式来控…
阅读更多...
【C++篇】继承之韵：解构编程奥义，领略面向对象的至高法则

【C++篇】继承之韵：解构编程奥义，领略面向对象的至高法则

文章目录 C 继承详解&#xff1a;初阶理解与实战应用前言第一章&#xff1a;继承的基本概念与定义1.1 继承的概念1.2 继承的定义 第二章&#xff1a;继承中的访问权限2.1 基类成员在派生类中的访问权限2.2 基类与派生类对象的赋值转换2.2.1 派生类对象赋值给基类对象2.2.2 基类…
阅读更多...
[Algorithm][贪心][可被三整除的最大和][距离相等的条形码][重构字符串]详细讲解

[Algorithm][贪心][可被三整除的最大和][距离相等的条形码][重构字符串]详细讲解

目录 1.可被三整除的最大和1.题目链接2.算法原理详解3.代码实现 2.距离相等的条形码1.题目链接2.算法原理详解3.代码实现 3.重构字符串1.题目链接2.算法原理详解3.代码实现 1.可被三整除的最大和 1.题目链接 可被三整除的最大和 2.算法原理详解 思路&#xff1a;正难则反 贪…
阅读更多...
最新文章

Copyright @ 2022~2023