2020.7.24 leetcode刷题 字节游戏，移掉k位数字

申请内存空间的系统调用是？

对小块内存（小于 128K），C 标准库使用 brk() 来分配，也就是通过移动堆顶的位置来分配内存。这些内存释放后并不会立刻归还系统，而是被缓存起来，这样就可以重复使用。

而大块内存（大于 128K），则直接使用内存映射 mmap() 来分配，也就是在文件映射段找一块空闲内存分配出去。
 

动态库和静态库的区别？

 

/*402.移掉k位数字

给定一个以字符串表示的非负整数 num，移除这个数中的 k 位数字，使得剩下的数字最小。

注意:

num 的长度小于 10002 且 ≥ k。
num 不会包含任何前导零。
示例 1 :

输入: num = "1432219", k = 3
输出: "1219"
解释: 移除掉三个数字 4, 3, 和 2 形成一个新的最小的数字 1219。
示例 2 :

输入: num = "10200", k = 1
输出: "200"
解释: 移掉首位的 1 剩下的数字为 200. 注意输出不能有任何前导零。
示例 3 :

输入: num = "10", k = 2
输出: "0"
解释: 从原数字移除所有的数字，剩余为空就是0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-k-digits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/


class Solution {
public:
    string removeKdigits(string num, int k) {
        string s;
        for(int i = 0;i<num.size();++i){
            while(s.size()&&k&&num[i]<s.back()){                  //如果是降序，表示可以删除上一个
                s.pop_back();
                k--;
            }
            if(s.size() == 0&&num[i] == '0') continue;           //如果前边为0，那就继续，不需要把前面的0加进结果
            s += num[i];
        }
        while(k>0&&!s.empty()){            //如果k过大并且结果不为空，退知道其中某个条件不满足
            s.pop_back();
            k--;
        }
        return s == "" ? "0":s;          //如果结果为空返回0，如果结果不为空（k变为0），返回结果
    }
};

/*95.不同的二叉搜索树II

给定一个整数 n，生成所有由 1 ... n 为节点所组成的 二叉搜索树 。

 

示例：

输入：3
输出：
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
解释：
以上的输出对应以下 5 种不同结构的二叉搜索树：

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3
 

提示：

0 <= n <= 8

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
*/




/**
 * 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<TreeNode*> generateTrees(int start,int end){
        if(start>end) return {nullptr};
        vector<TreeNode*> alltrees;
        for(int i = start;i<=end;++i){
            vector<TreeNode*> leftTrees = generateTrees(start,i-1);
            vector<TreeNode*> rightTrees = generateTrees(i+1,end);
            
            for(auto left:leftTrees){
                for(auto right:rightTrees){
                    TreeNode* curNode = new TreeNode(i);
                    curNode->left = left;
                    curNode->right = right;
                    alltrees.emplace_back(curNode);
                }
            }
        }
        return alltrees;
    }

    vector<TreeNode*> generateTrees(int n) {
        if(!n) return {};
        return generateTrees(1,n);
    }
};

 

/*386.字典序排数

给定一个整数 n, 返回从 1 到 n 的字典顺序。

例如，

给定 n =1 3，返回 [1,10,11,12,13,2,3,4,5,6,7,8,9] 。

请尽可能的优化算法的时间复杂度和空间复杂度。 输入的数据 n 小于等于 5,000,000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lexicographical-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/




class Solution {
public:
    void core(int k,int n,vector<int>& res){
        if(k>n) return;
        if(k != 0) res.push_back(k);
        for(int i = 0;i<=9;++i){
            if(k*10+i > 0) core(k*10+i,n,res);
        }
    }

    vector<int> lexicalOrder(int n) {
        vector<int> res;
        core(0,n,res);
        return res;
    }
};