1. 完全背包问题

和01背包唯一的区别是，每件物品都有无限个（也就是可以放入背包多次）

代码和01唯一的区别在于j的循环是从小到大，不是从大到小。ij谁在外谁在内层区别不大。

#include <bits/stdc++.h>
using namespace std;

int main(){
    int N,V;
    cin>>N>>V;
    vector<int> values(N), weights(N);
    for(int i =0;i<N;i++){
        cin>>weights[i]>>values[i];
    }
    vector<int> dp(V+1);
   for(int j=0;j<=V;j++ ){
    for(int i =0;i<N;i++)
        {
            if(j-weights[i]>=0)
            dp[j] = max(dp[j], dp[j-weights[i]]+values[i]);
        }
    }
    cout<<dp[V]<<endl;
    return 0;
}

2. 零钱兑换二

    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount+1,0);
        dp[0] = 1; // 当总金额为0时，有一种组合方法就是0
        int n = coins.size();
        for(int i=0;i<n;i++){
            for(int j =coins[i];j<=amount;j++){
                dp[j] += dp[j-coins[i]];
            }
        }
        for(int i = 0;i<amount+1;i++){
            cout<<dp[i]<<endl;
        }
        return dp[amount];
    }
};

组合数：要进行初始化，并且知道每一种组合等于把所有硬币遍历后的上一种组合加起来。（不用再加一）

时间复杂度：amount*coins的数量

j从coins[i]开始！其实从0开始也行，但是就要加个判断j大于coins[i]才能做呀，不然就是负数了

注意i，j的遍历顺序与求排列数还是组合数有关：

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

3. 零钱兑换

与上一题的区别在于dp不是表示组合数个数，而是表示凑足总额为j所需钱币的最少个数为

就是从+= 变成了min？

这里就要+1了，因为每次遍历多加了一个硬币，值就要+1

    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1,INT_MAX);
        dp[0] = 0; // 当总金额为0时，有一种组合方法就是0
        int n = coins.size();
        for(int i=0;i<n;i++){
            for(int j =coins[i];j<=amount;j++){
                if(dp[j-coins[i]] != INT_MAX)
                    dp[j] =min(dp[j], dp[j-coins[i]]+1);
            }
        }
        if(dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }

4. TOPK数的快排做法

注意这个topk指的是从大到小排序后的第k个！所以实际上并不是真正的想象中从小到大排序后的第k个！可以直接转换成第n-k+1大的数就行

    int quick_sort(vector<int>& nums,int left, int right,int k){
        if(left >= right) return nums[left];
        int i = left-1, j = right+1;
        int mid = (left+right)/2;
        int x = nums[mid];
        while(i <j){
            do i++; while(nums[i] < x);
            do j--; while(nums[j] > x);
            if(i<j) swap(nums[i],nums[j]);
        }
        if(j-left+1 >= k) return quick_sort(nums,left,j,k);
        else return quick_sort(nums,j+1,right,k-(j-left+1));
    }
    int findKthLargest(vector<int>& nums, int k) {
        int res =  quick_sort(nums,0,nums.size()-1, nums.size()-k+1);
        return res;
    }

代码和快排差不多，但是要想明白，每次是找哪边继续索引。如果排完序后的长度比k大，说明k在左边，就往左边回溯，如果比k小，就回溯右边，注意回溯右边的时候就不是找第k大了，而是k减去左边区间的长度

为什么时间复杂度是On啊？？

还是没懂，反正就是n，快速排序的复杂度是nlogn

4. SVM的核函数和高阶是具体如何实现的？

其中，线性核适合线性可分的数据，多项式核适合非线性模型，高斯核适合那种不清楚数据分布的非线性情况。

映射到高维空间不是说把每个样本做映射，而是在计算距离的时候，用高斯核计算两个x之间的距离。

5. GBDT树

梯度提升决策树。

树的流程从 决策树-》随机森林-》梯度提升决策树->Xgboost, 随机森林是bagging，GBDT和xgb都是boosting。

梯度提升是一种集成学习的一种方法，决策树是基学习器。为啥要这两个结合呢，是因为决策树是if，else的，速度快，适合非线性关系，不需要对输入数据做标准化，特征工程少，也可以处理特征缺失的情况。决策树能自动组合多个特征。

但是，决策树的缺点就是过拟合。抑制单颗树的复杂程度，再通过梯度提升方法继承多个决策树，就能达到平衡。

抑制复杂度的方法有：（1）树的最大深度（2）限制叶子结点的最少样本数量，有的特征缺失太多了就不放了（3）限制节点分裂时的最少样本数量（4）对训练样本采样，单个决策树学习时只使用一部分训练样本，这是bagging的思想（5）随机森林的思想，学习单颗决策树时只使用一部分特征（6）在目标函数中添加正则项惩罚

使用最小化损失函数（如均方误差或对数损失）来优化模型性能。每个弱学习器的训练都是在前一轮模型的残差（即预测值与真实值之间的差）基础上进行的。

具体优化方式: 前向分布算法

GBDT 算法可以看成是由 K 棵树组成的加法模型：

使用前向分布算法，每一步只学习一个基学习器，逐步逼近优化目标函数。

在第t步的目标函数为：

注意！每一颗树只拟合上一棵树的结果与目标之间的残差，不是去拟合目标

6. 数组中有个数的数量超过一半，如何最快找出这个数？

这是一种抵消的思路，就是如果两个数不同就会抵消为0，如果这个数超过了一半，说明它与其他数不同的时候被抵消完了以后，数量还是会>0，这样On就找出来了

或者是排序求中间值，这么看似乎是可以用快速选择的？只要找到一个数，刚好在中间位置，说明他就是众数。

还有一种方法，就是利用哈希map。

7. 每日温度

好难好难好难。。实际上是一种栈的方法，如果这个数比上一个数小就压栈，大就可以取出栈中的元素，并计算坐标之差

只要大，就把小的都取出来。我这里用了两个栈，分别存索引和值，实际上只存索引就行，值从数组里取。

    vector<int> dailyTemperatures(vector<int>& temperatures) {
        stack<int> idxs, values;
        int cur=0;
        vector<int> res(temperatures.size(),0);
        for(int i = 0;i<temperatures.size();i++){
            while (!idxs.empty() && values.top() < temperatures[i]){
                res[idxs.top()] = i-idxs.top();
                values.pop();
                idxs.pop();
            }
            idxs.push(i);
            values.push(temperatures[i]);

        }
        return res;
    }

8. 二叉树展开为链表

就是判断一下，没啥好说的 

    TreeNode * findr(TreeNode * cur){
        while(cur->right != nullptr){
            cur =  cur->right;
        }
        return cur;
    }
    void flatten(TreeNode* root) {
        TreeNode * cur = root;
        while(cur!= nullptr){
            if(cur->left != nullptr){
                TreeNode * r = cur->right;
                cur->right = cur->left;
                TreeNode * nextr = findr(cur);
                nextr->right = r;
                cur->left = nullptr;
            }
            cur = cur->right;
        }
        return ;
    }