leetcode 1121. 将数组分成几个递增序列（C++）

给你一个 非递减 的正整数数组 nums 和整数 K，判断该数组是否可以被分成一个或几个 长度至少 为 K 的 不相交的递增子序列。

 

示例 1：

输入：nums = [1,2,2,3,3,4,4], K = 3
输出：true
解释：
该数组可以分成两个子序列 [1,2,3,4] 和 [2,3,4]，每个子序列的长度都至少是 3。

示例 2：

输入：nums = [5,6,6,7,8], K = 3
输出：false
解释：
没有办法根据条件来划分数组。

 

提示：

1. 1 <= nums.length <= 10^5
2. 1 <= K <= nums.length
3. 1 <= nums[i] <= 10^5

C++

class Solution {
public:
    bool canDivideIntoSubsequences(vector<int>& nums, int K) 
    {
        int n=nums.size();
        map<int,int> tmp;
        for(int i=0;i<n;i++)
        {
            tmp[nums[i]]++;
        }
        priority_queue<int> que;
        int one=0;
        for(auto it:tmp)
        {
            if(it.second==1)
            {
                one++;
            }
            else
            {
                que.push(it.second);
            }
        }
        while(que.size() && one>=0)
        {
            if(que.size()>=K)
            {
                int count=0;
                vector<int> vec;
                while(count<K)
                {
                    int num=que.top()-1;
                    que.pop();
                    if(num>0)
                    {
                        vec.push_back(num);
                    }
                    count++;
                }
                for(auto it:vec)
                {
                    que.push(it);
                }
            }
            else
            {
                int first=que.size();
                int count=0;
                vector<int> vec;
                while(count<first)
                {
                    int num=que.top()-1;
                    que.pop();
                    if(num>0)
                    {
                        vec.push_back(num);
                    }
                    count++;
                }
                for(auto it:vec)
                {
                    que.push(it);
                }
                one-=(K-first);
            }
        }
        if(one>=0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

方法2思路：先求出重复最多的次数val，问题转变为nums中的所有数能否将val行，K列的容器塞满；

代码如下：

class Solution {
public:
    bool canDivideIntoSubsequences(vector<int>& nums, int K) 
    {
        int n=nums.size();
        map<int,int> tmp;
        for(int i=0;i<n;i++)
        {
            tmp[nums[i]]++;
        }
        int val=0;
        for(auto it:tmp)
        {
            val=max(val,it.second);
        }
        if(n<val*K)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
};