Leetcode 381. Insert Delete GetRandom O(1) - Duplicates allowed 可重复常数增删改系统 解题报告

1 解题思想

这道题是380的进化版，其实也就是在插入的时候允许了重复的值，变的更加复杂了一些。

这道题是基于这题来的，所以请先看下这题，我只说下如何从380过渡到381

Leetcode 380. Insert Delete GetRandom O(1) 常数增删改系统 解题报告

因为一个值要多个位置，所以原来的那个HashMap肯定要从<值-位置>，改成<值-位置的集合>

那么查询还是直接操作ArrayList没有难度

而插入的时候，是插入到位置集合也没有难度

问题在于删除。

删除的时候，idea和之前380一样，同样是将ArrayList的最后一个交换到前面，但是现在一个值有多个位置，所以我们要交换对位置，不能和原来一样直接替换。

所以根据值的集合选的不同，有所不同：

如你可以使用：

ArrayList来存储集合，那么你替换的时候需要遍历一下位置替换

我选择了Stack，那么就需要保证出栈的顺序有保障

或者其他更高级的快速的结构，随你，只要方便就好。。思想就是380的拓展，懂了380这个自然能变

2 原题

Design a data structure that supports all following operations in average O(1) time.
Note: Duplicate elements are allowed.

insert(val): Inserts an item val to the collection.
remove(val): Removes an item val from the collection if present.
getRandom: Returns a random element from current collection of elements. The probability of each element being returned is linearly related to the number of same value the collection contains.

Example:
// Init an empty collection.
RandomizedCollection collection = new RandomizedCollection();

// Inserts 1 to the collection. Returns true as the collection did not contain 1.
collection.insert(1);

// Inserts another 1 to the collection. Returns false as the collection contained 1. Collection now contains [1,1].
collection.insert(1);

// Inserts 2 to the collection, returns true. Collection now contains [1,1,2].
collection.insert(2);

// getRandom should return 1 with the probability 2/3, and returns 2 with the probability 1/3.
collection.getRandom();

// Removes 1 from the collection, returns true. Collection now contains [1,2].
collection.remove(1);

// getRandom should return 1 and 2 both equally likely.
collection.getRandom();

3 AC解

public class RandomizedCollection {
//用来索引下在ArrayList中的关系，做到快速定位
private HashMap<Integer,Stack<Integer>> locations;
//存储原始数据
private ArrayList<Integer> list;
private Random random;
//为了排序，控制栈的
ArrayList<Integer> tmpForStack;

/** Initialize your data structure here. */
public RandomizedCollection() {
this.locations = new HashMap<Integer,Stack<Integer>>();
this.list = new ArrayList<Integer>();
this.random = new Random();
this.tmpForStack = new ArrayList<Integer>();
}

/**
* 直接插入
* */
public boolean insert(int val) {
boolean flag = false;
if( locations.containsKey(val) == false ){
locations.put(val,new Stack<Integer>());
}
if(locations.get(val).isEmpty())
flag = true;
locations.get(val).push(list.size());
list.add(val);
return flag;
}

/** Removes a value from the set. Returns true if the set contained the specified element. */
/**
* 核心思想在于：把删除的元素交换到ArrayList最后一位上，这样就可以O1完成了,
*
* 唯一的一点不同是，要保证在每一个元素对应的位置的栈，要保证其顺序是从小到大，每次出栈的一定是最大的，所以我这里交换List后，更新那个元素的栈时需要先把比他大的弹出来，再放回去
* */
public boolean remove(int val) {
if( locations.containsKey(val) == false || locations.get(val).isEmpty() ) return false;
int tmpLocation = locations.get(val).pop();
if(tmpLocation != list.size() - 1){
int lastVal = list.get(list.size() -1 );
list.set(tmpLocation,lastVal);
locations.get(lastVal).pop();
tmpForStack.clear();
while(locations.get(lastVal).isEmpty() == false && locations.get(lastVal).peek() > tmpLocation){
tmpForStack.add(locations.get(lastVal).pop());
}
locations.get(lastVal).push(tmpLocation);
for(int tval:tmpForStack)
locations.get(lastVal).push(tval);
}
list.remove(list.size() - 1);
return true;
}

/** Get a random element from the set. */
public int getRandom() {
return list.get(random.nextInt(list.size()));
}
}

/**
* Your RandomizedCollection object will be instantiated and called as such:
* RandomizedCollection obj = new RandomizedCollection();
* boolean param_1 = obj.insert(val);
* boolean param_2 = obj.remove(val);
* int param_3 = obj.getRandom();
*/