【Lintcode】1877. Longest Super Sequence

题目地址：

https://www.lintcode.com/problem/longest-super-sequence/description

给定一个长$n$数组$A$，要求找到其最长子数组，删掉其一个元素之后别的元素出现次数都一样。返回这个子数组。题目保证$A$里只含$0\sim 3000$。

思路是枚举“别的元素出现次数都一样”这个出现次数$x$。先统计一下每个数字的出现次数，接着开个最小堆，将出现了的数入堆，出现次数小的优先级高，并且存一下出现次数最多的那个数是谁。我们的目的是，每次从堆中弹出一个数$a$的时候，如果其出现次数是$c$，那么我们枚举$x=c-1$和$x=c$的情况。假设poll出$a$之后堆的size是$s$。$x=c-1$的情况是指，$a$以及堆里的数都重复$c-1$次，另外再加上$a$自己，此时整个LSS的长度是$(c-1)(s+1)+1$；$x=c$的情况是，$a$以及堆里的数都重复$c$次，再加上一个堆里的某个数多一次，此时整个LSS的长度是$c(s+1)+1$，这里有个必要条件是$A$里存在某个数出现次数超过$c$，否则无法存在这个数，例如$A$里每个数都出现了$2$次，则$c$是无法枚举为$2$的，因为没有数次数比$2$多。但是此时$c$仍然可以枚举为$1$。这里还需要注意$A$里所有数都只出现了$1$次的情况，这个情况不含在上面的讨论中，此时直接返回$A$自己。代码如下：

import java.util.Arrays;
import java.util.PriorityQueue;

public class Solution {
     
    /**
     * @param nums: the input array
     * @return: return the longest super sequence
     */
    public int[] longestSuperSequence(int[] nums) {
     
        // write your code here
        int[] count = new int[3001];
        int maxCount = 0, maxCountNum = 0;
        // 统计一下每个数出现次数，以及出现次数最多的数是几，及其出现次数
        for (int num : nums) {
     
            count[num]++;
            if (count[num] > maxCount) {
     
                maxCount = count[num];
                maxCountNum = num;
            }
        }
        
        // 特判一下出现次数最多的元素只出现一次的情况
        if (maxCount == 1) {
     
            return nums;
        }
        
        // 建堆，把出现过的数入堆，出现次数少的数优先
        PriorityQueue<Integer> minHeap = new PriorityQueue<>((x, y) -> Integer.compare(count[x], count[y]));
        for (int i = 0; i < count.length; i++) {
     
            if (count[i] > 0) {
     
                minHeap.offer(i);
            }
        }
        
        // maxLen是可以达到的最长LSS的长度，mostCount是这个LSS去掉一个数后别的数出现次数一样了，这个出现次数
        int maxLen = 0, mostCount = 0;
        while (!minHeap.isEmpty()) {
     
            int cur = minHeap.poll(), curCount = count[cur];
            if ((count[cur] - 1) * (minHeap.size() + 1) + 1 > maxLen) {
     
                maxLen = (count[cur] - 1) * (minHeap.size() + 1) + 1;
                mostCount = count[cur] - 1;
            }
            
            if (count[cur] * (minHeap.size() + 1) + 1 > maxLen && maxCount > count[cur]) {
     
                maxLen = count[cur] * (minHeap.size() + 1) + 1;
                mostCount = count[cur];
            }
            
            // 这里可以做个优化，一旦枚举完这个curCount，就把所有出现次数也是curCount的数全poll出来
            while (!minHeap.isEmpty() && count[minHeap.peek()] == curCount) {
     
                minHeap.poll();
            }
        }
        
        int[] res = new int[maxLen], resCount = new int[3001];
        int idx = 0;
        for (int i = 0; i < nums.length; i++) {
     
            if (nums[i] == maxCountNum && resCount[maxCountNum] < mostCount + 1) {
     
                res[idx++] = nums[i];
                resCount[nums[i]]++;
            } else if (nums[i] != maxCountNum && count[nums[i]] >= mostCount && resCount[nums[i]] < mostCount) {
     
                res[idx++] = nums[i];
                resCount[nums[i]]++;
            }
        }
        
        return res;
    }
}

时间复杂度$O(n\log n)$，空间$O(n)$。