⭐【贪心】LeetCode 659. Split Array into Consecutive Subsequences

题目描述

知识点

贪心算法

结果

实现

码前思考

1. 我的思路比较乱。。。但是也能出结果

代码实现

1. 下面的代码用了多余的堆，导致超时

   //递增的序列
   //能够分解为1个及1个以上的子序列，这些子序列由长度≥3的连续数字组成
   //使用堆来解决问题
   class Solution {
   public:
       bool isPossible(vector<int>& nums) {
           int size = nums.size();
   
           if(size == 0){
               return false;
           }
   
           //用来存储优先级队列的数组
           vector<priority_queue<int>> heaps;
   
           //初始化
           priority_queue<int> q;
           q.push(nums[0]);
           heaps.push_back(q);
           int heapsSize = 1;
   
           for(int i=1;i<size;i++){
               //当前读入的值
               int cur = nums[i];
   
               //表示当前读入的值得期望放置的位置
               int expected = -1;
               int curSize = size+1;
   
               for(int j=0;j<heapsSize;j++){
                   if(heaps[j].top()==cur-1 && heaps[j].size() < curSize){
                       expected = j;
                       curSize = heaps[j].size();
                   }
               }
               if(expected == -1){ //这时需要新建一个堆
                   priority_queue<int> q;
                   q.push(cur);
                   heaps.push_back(q);
                   heapsSize++;
               }else{//找到可以放置得地方
                   heaps[expected].push(cur);
               }
           }
   
           
           for(int i=0;i<heapsSize;i++){
               if(heaps[i].size() <3 ){
                   return false;
               }
           }
   
           return true;
       }
   };
   

2. 下面的代码省去了多余的堆，过题了，但是时间是1584ms，不太好！

   //递增的序列
   //能够分解为1个及1个以上的子序列，这些子序列由长度≥3的连续数字组成
   //使用堆来解决问题
   class Solution {
   public:
       bool isPossible(vector<int>& nums) {
           int size = nums.size();
   
           if(size == 0){
               return false;
           }
   
           //不使用优先队列，直接记录堆的最大值
           vector<int> heaps;
   
           //每个堆的大小
           vector<int> perHeapSize;
   
           //初始化
           heaps.push_back(nums[0]);
           perHeapSize.push_back(1);
           int heapsSize = 1;
   
           for(int i=1;i<size;i++){
               //当前读入的值
               int cur = nums[i];
   
               //表示当前读入的值得期望放置的位置
               int expected = -1;
               int curSize = size+1;
   
               for(int j=0;j<heapsSize;j++){
                   if(heaps[j]==cur-1 && perHeapSize[j] < curSize){
                       expected = j;
                       curSize = perHeapSize[j];
                   }
               }
               if(expected == -1){ //这时需要新建一个堆
                   heaps.push_back(cur);
                   perHeapSize.push_back(1);
                   heapsSize++;
               }else{//找到可以放置得地方
                   heaps[expected] = cur;
                   perHeapSize[expected]++;
               }
           }
   
           
           for(int i=0;i<heapsSize;i++){
               if(perHeapSize[i] <3 ){
                   return false;
               }
           }
   
           return true;
       }
   };
   

码后反思

1. 看网友说，这道题目就是我们扑克牌的顺子，是呀，确实是这样呢；
2. 看了这位网友的解答，他的优点在于能够提前终止，而不是遍历完所有的数。而且是贪心的算法，每一步只走当前最有利的，所以才能够提前终止！但是不知道为什么两个else if不能交换。。。
   

   class Solution {
   public:
       bool isPossible(vector<int>& nums) {
           unordered_map<int,int> nc,tail;
           for(auto num : nums){
               nc[num]++;
           }
   
           for(auto num:nums){
               if(nc[num] == 0){
                   continue;
               }else if(nc[num] >0 && tail[num-1]>0){ //前面可以接上
                   nc[num]--;
                   tail[num-1]--;
                   tail[num]++;
               }else if(nc[num]>0 && nc[num+1] > 0 && nc[num+2] > 0){
                   nc[num]--;
                   nc[num+1]--;
                   nc[num+2]--;
                   tail[num+2]++;
               }else{
                   return false;
               }
           }
   
           return true;
       }
   };
   

3. 上述代码我也知道了unordered_map，对于unordered_map中没有的key，进行查找时会自动返回0。