算法036（必备）二叉树高频题目——上

于 2024-08-13 14:54:33 发布
阅读量530 收藏 6
点赞数 19
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x_2023_713/article/details/141091375
版权

二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

思路：

接受二叉树每层的节点：

  • 利用queue先进先出的性质，保证各个node的进入顺序与层序遍历顺序保持一致

确定节点的层数：

  • 利用map接受节点并记录对应层数，弹出时根据层数放置到答案中

大体流程（循环）：

  • cycle：记录que的头节点，并将其val插入到对应的vector中后pop；按照先左后右的顺序，将tmp的非空子节点push到que中并用map记录子节点的层数；最后删除tmp在map中的记录；直到que为空（全部node都已遍历完）

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>>vec;
        map<TreeNode*,int> Node_lel;
        if(root==nullptr)return vec;
        vec.resize(2000);
        que.push(root);
        Node_lel[root]=0;       
        TreeNode* tmp;
        while(que.size()){
            tmp=que.front();
            vec[Node_lel[tmp]].push_back(tmp->val);
            que.pop();           
            if(tmp->left){
                que.push(tmp->left);
                Node_lel[tmp->left]=Node_lel[tmp]+1;
            }
            if(tmp->right){
                que.push(tmp->right);
                Node_lel[tmp->right]=Node_lel[tmp]+1;
            }
            if(que.size()==0){
                vec.resize(Node_lel[tmp]+1);
            }
            Node_lel.erase(tmp+1);
        }
        return vec;
    }
};

优化思路：

优化queue的性能：

  • 利用静态数组模拟queue，提升进出效率

优化map：

分析queue不同元素的层数发现，元素的层数之差不超过一且具有相同层数的元素紧挨在一起，如此只需记录queue头的层数（level）并记录同一层数的node个数（cnt）即可替代map

  • 初始的level已知：0；初始的cnt已知：1
  • 遍历完level层的node：流程与之前类似，每遍历一个node，--cnt。
  • level和cnt的更新：当cnt为0时，level和cnt同步更新。此时queue中原属于level层的node已全部弹出，只剩下他们的子节点，由此更新cnt和level

优化代码：

class Solution {
public:

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>vec;
        if(root==nullptr)return vec;
        vec.resize(2000);
        int l=0,r=0;
        que[r++]=root;
        int cnt=1,level=0;
        TreeNode* tmp;
        while(cnt--){
            tmp=que[l++];
            vec[level].push_back(tmp->val);           
            if(tmp->left){
                que[r++]=tmp->left;
            }
            if(tmp->right){
                que[r++]=tmp->right;
            }
            if(cnt==0){
                ++level;
                cnt=r-l;
            }
        }
        vec.resize(level);
        return vec;
    }
    static TreeNode** que;
};
TreeNode** Solution::que=new TreeNode*[2001];

 二、二叉树的锯齿形层序遍历

思路：

大体流程与层序遍历一致，在最后将vec对应的vec进行反转

代码：

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>>vec;
        if(root==nullptr)return vec;
        vec.resize(2000);
        que.push(root);
        int cnt=1,level=0;
        TreeNode* tmp;
        while(cnt--){
            tmp=que.front();
            vec[level].push_back(tmp->val);
            que.pop();           
            if(tmp->left){
                que.push(tmp->left);
            }
            if(tmp->right){
                que.push(tmp->right);
            }
            if(cnt==0){
                ++level;
                cnt=que.size();
            }
        }
        vec.resize(level);
        for(int i=1;i<level;i+=2){
            reverse(vec[i].begin(),vec[i].end());
        }
        return vec;
    }
};

优化思路：

优化queue：

  • 利用静态数组模仿queue，优化pop和push；

优化反转：

  • 利用静态数组在每次要进入下一层时，将全部ele整体压进vec中；同时设置变量flag，适时反向压入

优化代码：

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>>vec;
        if(root==nullptr)return vec;
        vec.resize(2000);
        int l=0,r=0;
        que[r++]=root;
        int cnt=1,level=0;
        bool flag=0;
        TreeNode* tmp=root;
        vec[level].push_back(tmp->val);
        while(cnt--){
            tmp=que[l++];          
            if(tmp->left){
                que[r++]=tmp->left;
            }
            if(tmp->right){
                que[r++]=tmp->right;
            }
            if(cnt==0){
                flag=!flag;
                ++level;
                vec[level].resize(r-l);
                if(flag){
                    for(int i=r-1,k=0;i>=l;--i,++k){
                        vec[level][k]=que[i]->val;
                    }
                }else{
                    for(int i=l,k=0;i<r;++i,++k){
                        vec[level][k]=que[i]->val;
                    }
                }             
                cnt=r-l;
            }
        }
        vec.resize(level);
        return vec;
    }
    static TreeNode** que;
};
TreeNode** Solution::que=new TreeNode*[2001];

三、二叉树最大宽度 

给你一棵二叉树的根节点 root ，返回树的 最大宽度 。

树的 最大宽度 是所有层中最大的 宽度 。

每一层的 宽度 被定义为该层最左和最右的非空节点（即，两个端点）之间的长度。将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 null 节点，这些 null 节点也计入长度。

题目数据保证答案将会在  32 位 带符号整数范围内 

思路：

大体流程与层序遍历一致，但在过程中需要给各个node进行编号，queue的模版参数也改为pair<Node*,int>。在每层开始时统计尾到头的编号差值。

代码：

class Solution {
public:
    int widthOfBinaryTree(TreeNode* root) {
        queue<pair<TreeNode*,unsigned>> que;
        if(root==nullptr)return 0;
        que.push({root,1});
        unsigned cnt=1,ret=1;
        pair<TreeNode*,unsigned> tmp;
        while(cnt--){
            tmp=que.front();  
            que.pop();           
            if(tmp.first->left){
                que.push({tmp.first->left,2*tmp.second});
            }
            if(tmp.first->right){
                que.push({tmp.first->right,2*tmp.second+1});
            }
            if(cnt==0&&que.size()){
                ret=max(ret,que.back().second-que.front().second+1);
                cnt=que.size();
            }
        }
        return ret;
    }
};

注：

  • 由于数据量过大使用int存储编号会溢出，而利用unsigned的性质（溢出后从零开始计数）和题目提示答案大小在32位内，可知需要用unsigned存储编号 

优化思路：

优化queue：

  • 利用两个静态数组分别存储节点和编号或一个静态数组模仿queue，优化pop和push；


优化代码： 

与之前类似不再重复

四、二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

思路：

basecase（基础条件）：若root为空，return 0；

recur（递归）：return max(root->left的最大深度,root->right的最大深度)+1;

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(!root)return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

五、二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点

思路：

basecase（基础条件）：

  • 若root为空，return 0；
  • 若root左空右不空，return root->right的最小深度+1；
  • 若root右空左不空，return root->left的最小深度+1；
  • 若root左右皆空，return 1；

recur（递归）：

return min(root->right的最小深度,root->left的最小深度)+1;

代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root)return 0;
        if(!root->left&&!root->right)return 1;
        if(!root->left&&root->right)return minDepth(root->right)+1;
        if(!root->right&&root->left)return minDepth(root->left)+1;
        return min(minDepth(root->right),minDepth(root->left))+1;
    }
};

六、序列化与反序列化二叉树 （先序实现）

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

思路：

序列化：

  • 流程与先序遍历大体先一致，在node压入时将其加入string，并添加“，”以分割不同节点，遇到空node可用字符“#”标识

反序列化：

  • 整体流程与先序遍历一致，在开始前需将string以分隔符“，”分割成vector<string>（C++中无split函数）。遍历vector，在进queue时利用stoi确定各个node的val

代码：

class Codec {
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        // return "1,2,#,#,3,4,#,#,5,#,#,";
        string str;
        if (!root)
            return "#,";
        stack<TreeNode*> stacks;
        TreeNode* cur = root;
        while (cur||stacks.size()) {
            while (cur) {
                stacks.push(cur);
                str += to_string(cur->val);
                str += ",";
                cur = cur->left;
            }        
            str += "#,";
            if (stacks.size() == 0)
                break;
            cur = stacks.top();
            stacks.pop();
            cur = cur->right;   
        }
        return str;
    }
    void split(const string& str, vector<string>& vec, const string& delim) {
        if (str == "")
            return;
        int spos = 0;
        int pos = str.find(delim);
        int epos = str.size();
        while (pos != string::npos) {
            vec.push_back(str.substr(spos, pos - spos));
            spos = pos + delim.size();
            pos = str.find(delim, spos);
        }
        if (spos != epos) {
            vec.push_back(str.substr(spos));
        }
    }
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if (data == "#,")
            return nullptr;
        vector<string> vec;
        split(data, vec, ",");
        int i = 1, len = vec.size();
        TreeNode* root = new TreeNode(stoi(vec[0]));
        TreeNode* cur = root;
        stack<TreeNode*> stacks;
        stacks.push(root);
        while (i < len) {
            while (i < len && vec[i++] != "#") {
                TreeNode* tmp = new TreeNode(stoi(vec[i - 1]));
                cur->left = tmp;
                cur = tmp;
                stacks.push(tmp);
            }
            while (i < len) {
                if (stacks.size()) {
                    cur = stacks.top();
                    stacks.pop();
                }
                if (i < len && vec[i++] != "#") {
                    TreeNode* tmp = new TreeNode(stoi(vec[i - 1]));
                    cur->right = tmp;
                    cur = cur->right;
                    stacks.push(tmp);
                    break;
                }
            }
        }
        return root;
    }
};

注：

可以通过先序或后序反序列化，而中序的序列化不具有唯一性，无法反序列化

七、序列化与反序列化二叉树 （层序实现）

思路：

序列化：

  • 流程与层序遍历大体一致，在node弹出时将其压入string，并添加“，”以分割不同节点，遇到空可用字符“#”标识

反序列化：

  • 整体流程与层序遍历一致，在开始前需将string以分隔符“，”分割成vector<string>（C++中无split函数）。遍历vector，在进queue时利用stoi确定各个node的val

代码：

class Codec {
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string str;
        if (!root)
            return "#";
        queue<TreeNode*> que;
        TreeNode* cur = root;
        str += to_string(root->val);
        str += ',';
        que.push(root);
        while (que.size()) {
            cur = que.front();
            que.pop();
            if (cur->left) {
                str += to_string(cur->left->val);
                que.push(cur->left);
            } else {
                str += '#';
            }
            str += ',';
            if (cur->right) {
                str += to_string(cur->right->val);
                que.push(cur->right);
            } else {
                str += '#';
            }
            str += ',';
        }
        return str;
    }
    void split(const string& str,vector<string>& vec, const string& delim) {
        if(str=="")return;
        int spos=0;
        int pos=str.find(delim);
        int epos=str.size();
        while(pos!=string::npos){
            vec.push_back(str.substr(spos,pos-spos));
            spos=pos+delim.size();
            pos=str.find(delim,spos);
        }
        if(spos!=epos){
            vec.push_back(str.substr(spos));
        }
        
    }
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if (data==""||data == "#")
            return nullptr;
        vector<string> vec;
        split(data,vec,",");
        int i = 1, len = vec.size();
        TreeNode* root = new TreeNode(stoi(vec[0]));
        queue<TreeNode*> que;
        que.push(root);
        TreeNode* cur;
        while (i < len) {
            cur = que.front();
            que.pop();
            if (i < len && vec[i++] != "#") {
                cur->left = new TreeNode(stoi(vec[i - 1]));
                que.push(cur->left);
            }
            if (i < len && vec[i++] != "#") {
                cur->right = new TreeNode(stoi(vec[i - 1]));
                que.push(cur->right);
            }
        }
        return root;
    }
};

八、从前序与中序遍历序列构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

思路：

分析前序和中序遍历序列的特征：

  • 前序：序列的开头一定是整颗二叉树的根节点，且任何一颗子树的root都在整颗子树序列范围的开头
  • 中序：整颗二叉树的根节点将序列分为左右子树的序列，且任何一颗子树的root都将整颗子树序列分为左右子树的序列：左部分为左子树的序列，右部分为右子树的序列

大体流程（递归）：

递归函数的返回值：

  • 根据给定的前序序列范围和中序序列范围，构造二叉树并返回root

basecase：

  • 范围违规（l>r），返回空节点

recur：

  • 构造头结点：根据规定的前序范围的左端点
  • 划分左右：根据题目提示无重复元素，对中序序列使用查找函数找到root，并以此确定左右范围
  • 构造左右：递归构造

代码：

class Solution {
public:

    TreeNode* build(vector<int>& preorder,int l1,int r1, vector<int>& inorder,int l2,int r2){
        if(l1>r1)return nullptr;
        TreeNode* root=new TreeNode(preorder[l1]);
        vector<int>::iterator tmp=find(inorder.begin()+l2,inorder.begin()+r2,preorder[l1]);
        int len1=tmp-inorder.begin()-l2;
        //int len2=r
        root->left=build(preorder,l1+1,l1+len1,inorder,l2,l2+len1-1);
        root->right=build(preorder,l1+len1+1,r1,inorder,l2+len1+1,r2);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0)return nullptr;
        return build(preorder,0,preorder.size()-1,inorder,0,preorder.size()-1);
    }
};

九、二叉树的完全性检验

给你一棵二叉树的根节点 root ，请你判断这棵树是否是一棵 完全二叉树 。

在一棵 完全二叉树 中，除了最后一层外，所有层都被完全填满，并且最后一层中的所有节点都尽可能靠左。最后一层（第 h 层）中可以包含 1 到 2h 个节点。

思路：

大体流程与层序遍历一致，过程中对每个节点验证两个完全二叉树的特性：

  • 节点不存在有右无左
  • 若出现节点的子不全，则后续节点都为叶子结点（子全无）

代码：

class Solution {
public:
    bool isCompleteTree(TreeNode* root) {
        if(root==nullptr)return true;
        int l=0,r=0;
        que[r++]=root;
        TreeNode* cur=root;
        bool flag=false;
        while(l<r){
            cur=que[l++];
            if(cur->left){
                if(flag)return false;
                que[r++]=cur->left;
            }
            if(cur->right){
                if(flag||!cur->left)return false;
                que[r++]=cur->right;
            }
            if(!cur->left||!cur->right){
                flag=true;
            }
        }
        return true;
    }
    static TreeNode** que;
};
TreeNode** Solution::que=new TreeNode*[110];

十、完全二叉树的节点个数 

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

思路：

利用完全二叉树的特性，不断递归求子树的节点个数：

  • 若root到其右树最左node的高度小于其到左树最左node，则总node数为右树+root的节点数（2^（H-1））和左树的节点数
  • 若root到其右树最左node的高度等于其到左树最左node，则总node数为左树+root的节点数（2^H）和右树的节点数

 代码：

class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root==nullptr)return 0;
        int h1=Height(root->left);
        int h2=Height(root->right);
        int ans=0;
        if(h1>h2){
            ans+=pow(2,h2);
            return ans+countNodes(root->left);
        }
        ans+=pow(2,h1);
        return ans+countNodes(root->right);
    }
    int Height(TreeNode* root){
        if(root==nullptr)return 0;
        int cnt=0;
        while(root){
            ++cnt;
            root=root->left;
        }
        return cnt;
    }
};

CS_浮鱼
关注
  • 19
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
这个题目考察的是对二叉树遍历的理解以及如何用编程语言（这里可能是Python）来实现这个操作。 首先，我们来看第一种解题方法，即递归解法。递归是解决此类问题的常见策略，因为二叉树遍历的自然顺序与递归调用的...
二叉树高频考题完整源码（包含测试树）
05-03
二叉树高频考题，完整，包含测试树，求二叉树深度
算法037（必备）二叉树高频题目——下
x_2023_713的博客
08-11 457
中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（若左的最大值≥root的值和右的最小值≤root的值，则返回false；改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。所以结果应当返回修剪好的二叉搜索树的新的根节点。
7 道高频面试算法题，你都会了吗？「矩阵 + 位运算 + LRU」
圆号本号
10-21 768
矩阵 螺旋矩阵 给定一个包含 m x n 个要素的矩阵，（m 行, n 列），按照螺旋顺序，返回该矩阵中的所有要素。 public List<Integer> spiralOrder(int[][] matrix) { ArrayList<Integer> rst = new ArrayList<Integer>(); if(matrix...
Leetcode Top100题目和答案（Java完整版 面试必备）
热门推荐
lx_lollipop的博客
03-26 8万+
最近忙着准备春招，复习完这个又复习那个。不过还是忙里偷闲，把剑指Offer这66道题目重新刷了一遍，收获还是很大的，下面贴出答案，又不懂的可以给我留言，博主会及时解答。 我的github 准备把春招复习的知识都整理到github上，一边是自己做个总结，一边也能供大家参考 ——leetcode数据库 19道题 ——剑指Offer 66道题 以下摘自leetcode Top100精选题目 文章目录1....
【高频算法题】这28道题本周被50家公司问了128次
程序员面试精选【codeoffer】
08-28 217
大家都知道现在各大互联网公司的招聘面试已经越来越注重算法了，除了校招要笔试之后，校招社招的面试过程中都会手撕算法题。 尤其是字节跳动，动不动就给甩给你一个medium甚至hard。但是大家的时间可能没那么多，无法刷完所有题甚至一些准备不充分的同学很多类型的题都没见过。 这里有网上总结的大厂超高频算法题，面试的时候其实面试官也就爱问这几类题，真搞懂了这些题面试的时候遇到原题或类似的题目可能性还是非常大的。 哪28道题在本周被这么多公司考察呢？ 比如说LR...
java多线程面试算法，开发人员必学
2401_84413599的博客
04-23 435
OSI七层模型都是什么举例网络协议，都在哪个层TCP UDP区别TCP如何实现可靠连接Time_Wait中2*msl 为什么如果TCP突然接收方故障 会发生什么HTTP状态码 含义，503 504,200GET POST区别一个url从输入到访问经过了哪些过程说一说TCP三次握手和四次挥手。
「面试高频」二叉搜索树+双指针+贪心 算法题指北
圆号本号
10-16 485
二叉搜索树 验证二叉搜索树 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 : 输入: 5 / \ 1 4 / \ 3 6 输出: false 解释: 输入为: [5,1,4,null,...
大厂必备！阿里、字节跳动、京东、腾讯、小米等名企高频面试
m0_57081562的博客
06-23 137
一、前言 k8s全称kubernetes，是目前大热的一个可移植容器的编排管理工具，像AWS、Azure、Google、阿里云、腾讯云等主流的公有云提供的都是基于k8s的容器服务，很多其他厂商也在努力跟进中，所以说“kubernetes”是目前容器行业中最为热门的也毫不为过！ 但是大家都是知道的，kubernetes虽然比较热门，但是学习的门槛相对来说也是比较高的，所以这份笔记也是因此而生的，一经发布，瞬间上了周榜双Top1，已评钻级！ 这份笔记有着以下两个重要的特点： 系统的讲解当前最流行的容器编排引
如何系统地学习数据结构与算法？
程序员吴师兄的博客
04-28 1997
不 BB，直接上干货，非科班出生，毕业工作后才开始学算法，到目前学了 4 年 ！！！ 为了让你对数据结构和算法能有个全面的认识，我画了一张图，里面几乎涵盖了所有数据结构和算法书籍中都会讲到的知识点。 这里面有10个数据结构：数组、链表、栈、队列...
java面试大厂必备的学习资料
m0_67537062的博客
03-30 1234
最近系统的整理了下java面试相关的学习资料，包含了java核心知识点、数据结构和算法、计算机基础、版本控制工具和面试经验分享等知识
高频算法题目总结1
08-04
本文将围绕给定的标题和描述，对其中涉及的高频算法题目进行详细的总结和解析。 1. **删除链表的倒数第n个节点**： 这个问题要求我们找到链表的倒数第n个节点并将其删除。可以通过双指针技术解决，一个快指针先...
题目：编写递归算法，将二叉树中所有结点的左右子树相互交换 - READ.doc
05-31
二叉树中结点左右子树的递归交换算法设计 一、知识点总览 本文主要讨论二叉树的递归交换算法的设计和实现。该算法的核心是使用递归函数来交换二叉树中所有结点的左右子树，从而实现树形结构中结点的交换。该算法的...
day 9 回溯算法
m0_73924943的博客
08-08 313
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 928
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-09 311
其中a和b是用户传入的参数，函数返回的是两者中较大的数。
算法学习day32
最新发布
2301_78191305的博客
08-12 813
2.如果遍历到的数字可以和放一个数字构成一个有效的大写字母的ASCII值，是对dp[i+1]有用的，(这个有用是指多了dp[i-1]种分割方法）那么dp[i+1]+=dp[i-1];现在1有与3，5相乘的资格，2有与2，3，5相乘的资格，但是2×3和2×5是没必要比较的，因为有比它更小的1可以同3，5相乘，所以我们只需要比较1×3，1×5，2×2。即n=2*x+3*y+5*z。如果nums[i]==nums[i-1]&&nums[i-1]==nums[i-2] 那么dp[i]+=dp[i-1]+1;
算法日记day 33（动归之斐波那契数|爬楼梯）
m0_74980681的博客
08-08 364
要求每次可以爬1阶或者2阶，逆向思维可以理解为，当我们上到最后一阶楼梯时，可以迈一阶楼梯dp[n-1]，或者迈两阶楼梯上dp[n-2]，因此可得最终爬上去n阶台阶的方法共有dp[n-1]+dp[n-2]种方法，dp的方法是爬到第n阶台阶总共有多少种方法，而不是走了几步，因此递推关系仍是斐波那契数列。已知斐波那契数列递推式为dp[i]=dp[i-1]+dp[i-2]，因此求第n个数只需要逐渐相加获得。1. 1 阶 + 1 阶 + 1 阶。1. 1 阶 + 1 阶。2. 1 阶 + 2 阶。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值