leetcode刷题记录（三）

前K个高频元素

题目地址
知识点：堆排序，元素频数统计
解题思路：使用map统计元素出现频次，之后可以对词频排序，由于题目要求小于nlogn得时间复杂度，可以选择堆排序。排序也可以用lambda函数自定义

struct cmp
{
    bool operator()(pair<int, int> a, pair<int, int> b)
    {
        return a.second < b.second;
    }
};

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        map<int, pair<int, int>> freq;
        for (int num: nums)
        {
            if (!freq.count(num))
                freq[num] = {num, 0};
            freq[num].second++;
        }
        priority_queue<pair<int, int>, vector<pair<int,int>>, cmp> pq;
        for(auto& p: freq)
        {
            pq.push(p.second);
        }
        vector<int> res;
        for (int i = 0; i < k; i++)
        {
            res.push_back(pq.top().first);
            pq.pop();
        }
        return res;

    }
};

递增的三元子序列

题目地址
知识点：双指针法，没啥知识点，考察一眼洞悉问题本质的能力
解题思路：

1. 两个数组，分别前后扫描，保存当前位置i前面的最小值，和后面的最大值，之后再线性遍历，检查是否有一个位置i使得 forward[i] < nums[i] < backward[i]
2. 两个指针，small，middle，一遍扫描，如果小于small，更新small，else if小于middle，更新middle，如果大于middle，返回true

class Solution {
public:
    bool increasingTriplet(vector<int>& nums) {
        if (nums.size() < 3)
            return false;
        vector<int> forward(nums.size(), 0);
        vector<int> backward(nums.size(), 0);
        int min = nums[0];
        int max = nums[nums.size()-1];
        for (int i = 1; i < nums.size() - 1; i++)
        {//前序扫描，保存最小值
            forward[i] = min;
            if (nums[i] < min)
                min = nums[i];
        }
        for (int i = nums.size()-2; i >= 0; i--)
        {//倒序扫描，保存最大值
            backward[i] = max;
            if (nums[i] > max)
                max = nums[i];
        }
        for (int i = 1; i < nums.size()-1; i++)
            if (nums[i] > forward[i] && nums[i] < backward[i])
                return true;
        return false;
    }
};

和等于k的最长子数组长度

题目地址
知识点：map的使用
解题思路：求到当前位置累计和，以累计和为k记录最小的位置，到位置j时，累计和为sum，如果sum-k在map中存在，那么就存在和为k的子序列，为j-map[sum-k]+1；map[sum] = j + 1

class Solution {
public:
    int maxSubArrayLen(vector<int>& nums, int k) {
        std::map<int, int> preSum;
        int sum = 0;
        preSum[0] = 0;
        int res = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            sum += nums[i];
            if (!preSum.count(sum))
                preSum[sum] = i+1;
            if (preSum.count(sum - k))
                res = std::max(res, i - preSum[sum-k] + 1);
        }
        return res;
    }
};

验证二叉树的前序序列化

题目地址
知识点：树的前序遍历
解题思路：初始化一个栈，遍历树元素。遇到“#”，如果栈为空，那么返回false；如果栈顶为“#”，那么就要剪枝，如果pop出栈顶的“#”，后栈为空或者栈顶不是数字，返回false；如果是数字，和后面两个“#”，一起剪枝，并向栈中push一个“#”，如果此时栈顶是“#”返回一开始的逻辑处理，反之，遍历下一个元素。

class Solution {
public:
    bool isValidSerialization(string preorder) {
        vector<string> sq;
        vector<string> str;
        string tmp = "";
        for (int i = 0; i < preorder.size(); i++)
        {
            if (preorder[i] == ',')
            {
                if (preorder[i-1] == '#')
                    str.push_back("#");
                else
                {
                    str.push_back(tmp);
                    tmp = "";
                }
            }
            else if (preorder[i] == '#') {}
            else
                tmp += to_string(preorder[i]);
        }
        if (preorder[preorder.size()-1] == '#')
            str.push_back("#");
        else
            str.push_back(tmp);

        if (preorder == "#")
            return true;
        for (int i = 0; i < str.size(); i++)
        {
            if (str[i] == "#")
            {
                if (sq.size() < 1)
                    return false;
                while (sq.size() > 0 && sq[sq.size()-1] == "#")
                {
                    sq.pop_back();
                    if (sq.size() < 1 || sq[sq.size()-1] == "#")
                        return false;
                    sq.pop_back();
                }
                sq.push_back(str[i]);
            }
            else
                sq.push_back(str[i]);
        }
        return sq.size() == 1 && sq[0] == "#";
    }
};

整数拆分（剪绳子）

题目地址
知识点：找规律，动态规划
解题思路：
比较经典的一道题，剪绳子和这个是一个问题

1. 找规律，没太看明白，可以到题目地址的题解中看
2. 动态规划，dp[i]中存储了数字i的最大拆分乘积值。某一个数字可以选择拆分或者不拆分，位置i的值可以通过拆分成（m+n），拆分不拆分有四种组合，动态规划状态转移方程是dp[i] = max(dp[m] * n, dp[n] * m, dp[m] * dp[n], m * n)

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1, 0);
        dp[1] = 0;
        dp[2] = 1;
        for(int i = 3; i <= n; i++)
        {
            for (int j = 1; j <= i / 2; j++)
            {
                vector<int> poss = {j*(i-j), j*dp[i-j], dp[j]*(i-j), dp[j]*dp[i-j]}; //拆分不拆分的四种组合
                for (int pos: poss)
                    dp[i] = std::max(dp[i], pos); //求四种组合的最大值
            }
        }
        return dp[n];
    }
};