[亚麻高频题] - 最大重复元素处理问题

题目描述

是一道OA时遇到的题目，给定一个数组，执行一下操作：

1. 找到数值最大重复元素的最小的两个index位置，删除最靠前的元素，保留第二个元素，并且将改元素 / 2。

2. 执行以上操作知道没有重复元素位置

3. 返回最后结果，并且保证元素相对位置不变

例子1 ：

Input: [4, 4, 2, 1] ; Output: [0]

解释：

最大重复元素 4，去掉第一个，第二个除以2，数组变为[2,2,1]

最大重复元素 2，去掉第一个，第二个除以2，数组变为[1,1]

最大重复元素 1，去掉第一个，第二个除以2，数组变为[0] 返回

例子2 ：

Input: [6,6,6,1,2,2]; Output: [3,6,0] 

解释：

最大重复元素 6，去掉第一个，第二个除以2，数组变为[3, 6, 1, 2, 2]

最大重复元素 3，去掉第一个，第二个除以2，数组变为[3, 6, 1, 1]

最大重复元素 1，去掉第一个，第二个除以2，数组变为[3, 6, 0] 返回

题目思路

这道题目属于一道模拟题，基本思路就是创建一个HashMap<Integer, LinkedList<Integer>> 来维护数组中数值以及元素对应的位置信息，然后可以创建一个大顶堆来维护重复元素，每一次循环，取出堆中最大元素，找到对应链表中最靠前的两个index，从链表中删除这两个位置，将第二个元素除以2后更新到对应链表中，注意每一个链表要保证有序，所以如果每一次插入链表时要逐个进行比较然后插入。

具体代码如下：

public class Test {

    public List<Integer> Solution(List<Integer> prio) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        HashMap<Integer, LinkedList<Integer>> loc = new HashMap<>();

        for (int i = 0; i < prio.size(); i++) {
            if (!loc.containsKey(prio.get(i))) loc.put(prio.get(i), new LinkedList<>());
            loc.get(prio.get(i)).addLast(i);
            if (loc.get(prio.get(i)).size()==2) pq.offer(prio.get(i));
        }

        while (!pq.isEmpty()) {
            int max = pq.poll();
            int first = loc.get(max).get(0);
            int second = loc.get(max).get(1);

            loc.get(max).removeFirst();
            loc.get(max).removeFirst();

            int cut = max/2;
            if (!loc.containsKey(cut)) loc.put(cut, new LinkedList<>());

            // find the right place to insert second index
            LinkedList<Integer> llist = loc.get(cut);
            if (llist.size()!=0 && llist.getLast()!=null) {
                if (llist.getLast() < second) llist.addLast(second);
                else {
                    for (int i=0; i<llist.size(); i++) {
                        if (llist.get(i) > second) {
                            llist.add(i, second);
                            break;
                        }
                    }
                }
            } else {
                loc.get(cut).addLast(second);
            }
            if (loc.get(cut).size()==2) pq.offer(cut);
        }

        // generate final result
        int[] res = new int[prio.size()];
        List<Integer> ans = new ArrayList<>();
        Arrays.fill(res, -1);

        for (int val: loc.keySet()) {
            for (int idx: loc.get(val)) {
                res[idx] = val;
            }
        }

        for (int i: res) {
            if (i!=-1) {
                ans.add(i);
                System.out.print(i + ",");
            }
        }
        return ans;
    }

    public static void main(String[] args) {
        Test obj = new Test();
        obj.Solution(Arrays.asList(4,4,2,1));
        obj.Solution(Arrays.asList(6,6,6,1,2,2));
        obj.Solution(Arrays.asList(2,1,5,10,10,1));
    }
}

时间复杂度了：,每一次操作中主要耗时的地方在将新值插入大顶堆，和将新值的index插入对应链表中，每一次操作的时间复杂度在于那个操作更慢；空间复杂度：。