Note:

1. 1 <= w.length <= 10000
2. 1 <= w[i] <= 10^5
3. pickIndex will be called at most 10000 times.

Example 1:

Input: 
["Solution","pickIndex"]
[[[1]],[]]
Output: [null,0]

Example 2:

Input: 
["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
[[[1,3]],[],[],[],[],[]]
Output: [null,0,1,1,1,0]

Explanation of Input Syntax:

The input is two lists: the subroutines called and their arguments. Solution‘s constructor has one argument, the array w. pickIndex has no arguments. Arguments are always wrapped with a list, even if there aren’t any.

Solution: Binary Search

Crate a cumulative weight array, random sample a “weight”, do a binary search to see which bucket that weight falls in.
e.g. w = [2, 3, 1, 4], sum = [2, 5, 6, 10]
sample 3 => index = 1
sample 7 => index = 3

Time complexity: Init: O(n) Pick: O(logn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  Solution(vector<int> w): sums_(std::move(w)) {
    partial_sum(begin(sums_), end(sums_), begin(sums_));    
  }

  int pickIndex() {
    int s = rand() % sums_.back();
    return upper_bound(begin(sums_), end(sums_), s) - begin(sums_);
  }
private:  
  vector<int> sums_;
};

The post 花花酱 LeetCode 528. Random Pick with Weight appeared first on Huahua's Tech Road.

Return the element repeated N times.

Example 1:

Input: [1,2,3,3]
Output: 3

Example 2:

Input: [2,1,2,5,3,2]
Output: 2

Example 3:

Input: [5,1,5,2,5,3,5,4]
Output: 5

Note:

1. 4 <= A.length <= 10000
2. 0 <= A[i] < 10000
3. A.length is even

Solution: Randomization

Randomly pick two numbers in the array, if they are the same (25% probability) return the number, do it until the two numbers are the same.

Time complexity: O(1) expected 4
Space complexity: O(1)

// Author: Huahua, running time: 72 ms
class Solution {
public:
  int repeatedNTimes(vector<int>& A) {
    int i = 0;
    int j = 0;
    while (i == j || A[i] != A[j]) {
      i = rand() % A.size();
      j = rand() % A.size();
    }
    return A[i];
  }
};

The post 花花酱 LeetCode 961. N-Repeated Element in Size 2N Array appeared first on Huahua's Tech Road.

You are given the number of rows n_rows and number of columns n_cols of a 2D binary matrix where all values are initially 0. Write a function flip which chooses a 0 value uniformly at random, changes it to 1, and then returns the position [row.id, col.id] of that value. Also, write a function reset which sets all values back to 0. Try to minimize the number of calls to system’s Math.random() and optimize the time and space complexity.

Note:

1. 1 <= n_rows, n_cols <= 10000
2. 0 <= row.id < n_rows and 0 <= col.id < n_cols
3. flip will not be called when the matrix has no 0 values left.
4. the total number of calls to flip and reset will not exceed 1000.

Example 1:

Input: 
["Solution","flip","flip","flip","flip"]
[[2,3],[],[],[],[]]
Output: [null,[0,1],[1,2],[1,0],[1,1]]

Input: 
["Solution","flip","flip","reset","flip"]
[[1,2],[],[],[],[]]
Output: [null,[0,0],[0,1],null,[0,0]]

Explanation of Input Syntax:

The input is two lists: the subroutines called and their arguments. Solution‘s constructor has two arguments, n_rows and n_cols. flip and reset have no arguments. Arguments are always wrapped with a list, even if there aren’t any.

Solution 1: Hashtable + Resample

Time complexity: O(|flip|) = O(1000) = O(1)

Space complexity: O(|flip|) = O(1000) = O(1)

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
  Solution(int n_rows, int n_cols): 
    rows_(n_rows), cols_(n_cols), n_(rows_ * cols_) {}

  vector<int> flip() {
    int index = rand() % n_;
    while (m_.count(index))
      index = rand() % n_;    
    m_.insert(index);
    return {index / cols_, index % cols_};
  }

  void reset() {
    m_.clear();
    n_ = rows_ * cols_;
  }
private:
  const int rows_;
  const int cols_;
  int n_;
  unordered_set<int> m_;
};

Solution 2: Fisher–Yates shuffle

Generate a random shuffle of 0 to n – 1, one number at a time.

Time complexity: flip: O(1)

Space complexity: O(|flip|) = O(1000) = O(1)

C++

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
  Solution(int n_rows, int n_cols): 
    rows_(n_rows), cols_(n_cols), n_(rows_ * cols_) {}

  vector<int> flip() {
    int s = rand() % (n_--);
    int index = s;
    if (m_.count(s))
      index = m_[s];
    m_[s] = m_.count(n_) ? m_[n_] : n_;
    return {index / cols_, index % cols_};
  }

  void reset() {
    m_.clear();
    n_ = rows_ * cols_;
  }
private:
  const int rows_;
  const int cols_;
  int n_;
  unordered_map<int, int> m_;
};

The post 花花酱 LeetCode 881. Random Flip Matrix appeared first on Huahua's Tech Road.

Given a list of non-overlapping axis-aligned rectangles rects, write a function pick which randomly and uniformily picks an integer point in the space covered by the rectangles.

Note:

1. An integer point is a point that has integer coordinates.
2. A point on the perimeter of a rectangle is included in the space covered by the rectangles.
3. ith rectangle = rects[i] = [x1,y1,x2,y2], where [x1, y1] are the integer coordinates of the bottom-left corner, and [x2, y2] are the integer coordinates of the top-right corner.
4. length and width of each rectangle does not exceed 2000.
5. 1 <= rects.length <= 100
6. pick return a point as an array of integer coordinates [p_x, p_y]
7. pick is called at most 10000 times.

Input: 
["Solution","pick","pick","pick"]
[[[[1,1,5,5]]],[],[],[]]
Output: 
[null,[4,1],[4,1],[3,3]]

Input: 
["Solution","pick","pick","pick","pick","pick"]
[[[[-2,-2,-1,-1],[1,0,3,0]]],[],[],[],[],[]]
Output: 
[null,[-1,-2],[2,0],[-2,-1],[3,0],[-2,-2]]

// Author: Huahua
// Running time: 92 ms
class Solution {
public:
  Solution(vector<vector<int>> rects): rects_(std::move(rects)) {
    sums_ = vector<int>(rects_.size());
    for (int i = 0; i < rects_.size(); ++i) {
      sums_[i] = (rects_[i][2] - rects_[i][0] + 1) * (rects_[i][3] - rects_[i][1] + 1);
      if (i > 0) sums_[i] += sums_[i - 1];
    }
  }

  vector<int> pick() {
    const int s = nextInt(sums_.back()) + 1;
    int index = lower_bound(sums_.begin(), sums_.end(), s) - sums_.begin();
    const auto& rect = rects_[index];
    return {rect[0] + nextInt(rect[2] - rect[0] + 1),
            rect[1] + nextInt(rect[3] - rect[1] + 1)};
  }
    
private:  
  vector<int> sums_;
  vector<vector<int>> rects_;
  
  // Returns a random int in [0, n - 1]
  int nextInt(int n) {
    return rand() / static_cast<double>(RAND_MAX) * n;
  }
};

The post 花花酱 LeetCode 882. Random Point in Non-overlapping Rectangles appeared first on Huahua's Tech Road.

Given an array w of positive integers, where w[i] describes the weight of index i, write a function pickIndex which randomly picks an index in proportion to its weight.

Note:

1. 1 <= w.length <= 10000
2. 1 <= w[i] <= 10^5
3. pickIndex will be called at most 10000 times.

Example 1:

Input: 
["Solution","pickIndex"]
[[[1]],[]]
Output: [null,0]

Input: 
["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
[[[1,3]],[],[],[],[],[]]
Output: [null,0,1,1,1,0]

Explanation of Input Syntax:

The input is two lists: the subroutines called and their arguments. Solution‘s constructor has one argument, the array w. pickIndex has no arguments. Arguments are always wrapped with a list, even if there aren’t any.

Solution: Binary Search

1. Convert PDF to CDF
2. Uniformly sample a value s in [1, sum(weights)].
3. Use binary search to find first index such that PDF[index] >= s.

Time complexity: Init O(n), query O(logn)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 184 ms
class Solution {
public:
  Solution(vector<int> w) { 
    sums_ = std::move(w);
    for (int i = 1; i < sums_.size(); ++i)
      sums_[i] += sums_[i - 1];
  }

  int pickIndex() {
    int s = rand() / static_cast<double>(RAND_MAX) * sums_.back() + 1;
    return lower_bound(sums_.begin(), sums_.end(), s) - sums_.begin();
    // or
    // int l = 0;
    // int r = sums_.size();
    // while (l < r) {
    //   int m = (r - l) / 2 + l;
    //   if (sums_[m] < s)
    //     l = m + 1;
    //   else
    //     r = m;
    // }
    // return l;
  }
private:  
  vector<int> sums_;
};

Related Problems

• 花花酱 LeetCode 882. Random Point in Non-overlapping Rectangles

The post 花花酱 LeetCode 880. Random Pick with Weight appeared first on Huahua's Tech Road.

Given the radius and x-y positions of the center of a circle, write a function randPoint which generates a uniform random point in the circle.

Note:

1. input and output values are in floating-point.
2. radius and x-y position of the center of the circle is passed into the class constructor.
3. a point on the circumference of the circle is considered to be in the circle.
4. randPoint returns a size 2 array containing x-position and y-position of the random point, in that order.

Example 1:

Input: 
["Solution","randPoint","randPoint","randPoint"]
[[1,0,0],[],[],[]]
Output: [null,[-0.72939,-0.65505],[-0.78502,-0.28626],[-0.83119,-0.19803]]

Example 2:

Input: 
["Solution","randPoint","randPoint","randPoint"]
[[10,5,-7.5],[],[],[]]
Output: [null,[11.52438,-8.33273],[2.46992,-16.21705],[11.13430,-12.42337]]

Explanation of Input Syntax:

The input is two lists: the subroutines called and their arguments. Solution‘s constructor has three arguments, the radius, x-position of the center, and y-position of the center of the circle. randPoint has no arguments. Arguments are always wrapped with a list, even if there aren’t any.

Solution: Polar Coordinate

uniform sample an angle a: [0, 2*Pi)

uniform sample a radius r: [0, 1)

Number of random points in a cycle should be proportional to the square of distance to the center.

e.g. there are 4 times of points with distance d than points with distance d/2.

Thus sqrt(r) is uniformly distributed.

r’ = sqrt(r),

// Author: Huahua
// Running time: 116 ms
class Solution {
public:
  Solution(double radius, double x_center, double y_center)
    :r_(radius), x_(x_center), y_(y_center) {}

  vector<double> randPoint() {
    double a = rand() / static_cast<double>(RAND_MAX) * 2 * M_PI;
    double r = sqrt(rand() / static_cast<double>(RAND_MAX)) * r_;
    return {x_ + r * cos(a), y_ + r * sin(a)};
  }
private:
  double r_;
  double x_;
  double y_;
};

The post 花花酱 LeetCode 883. Generate Random Point in a Circle appeared first on Huahua's Tech Road.

Given a function rand7 which generates a uniform random integer in the range 1 to 7, write a function rand10 which generates a uniform random integer in the range 1 to 10.

Do NOT use system’s Math.random().

Input: 1
Output: [7]

Input: 2
Output: [8,4]

Input: 3
Output: [8,1,10]

// Author: Huahua
// Running time: 112 ms
class Solution {
public:
  int rand10() {
    int target = 40;
    while (target >= 40)
      target = 7 * (rand7() - 1) + (rand7() - 1);
    return target % 10 + 1;
  }
};

// Author: Huahua
// Running time: 112 ms
class Solution {
public:
  int rand10() {
    int i = INT_MAX;
    int j = INT_MAX;
    while (i > 6) i = rand7(); // i = [1, 2, 3, 4, 5, 6]
    while (j > 5) j = rand7(); // j = [1, 2, 3, 4, 5]
    return j + 5 * (i & 1);
  }
};

The post 花花酱 LeetCode 872. Implement Rand10() Using Rand7() appeared first on Huahua's Tech Road.

Problem:

https://leetcode.com/problems/linked-list-random-node/description/

Given a singly linked list, return a random node’s value from the linked list. Each node must have the same probability of being chosen.

Follow up:
What if the linked list is extremely large and its length is unknown to you? Could you solve this efficiently without using extra space?

Example:

// Init a singly linked list [1,2,3].
ListNode head = new ListNode(1);
head.next = new ListNode(2);
head.next.next = new ListNode(3);
Solution solution = new Solution(head);

// getRandom() should return either 1, 2, or 3 randomly. Each element should have equal probability of returning.
solution.getRandom();

Solution:

C++

Time Complexity: O(n)

Space Complexity: O(1)

// Author: Huahua
// Running time: 43 ms
class Solution {
public:
  /** @param head The linked list's head.
      Note that the head is guaranteed to be not null, so it contains at least one node. */
  Solution(ListNode* head) {
    head_ = head;
    
    n_ = 0;
    ListNode* curr = head;
    while (curr != nullptr) {
      curr = curr->next;
      ++n_;
    }
  }

  /** Returns a random node's value. */
  int getRandom() {
    int n = rand() % n_;
    ListNode* curr = head_;
    while (n-->0)
      curr = curr->next;      
    
    return curr->val;
  }
private:
  int n_;
  
   // Does not own the object
  ListNode* head_;
};

The post 花花酱 LeetCode 382. Linked List Random Node appeared first on Huahua's Tech Road.

https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/description/

Problem:

Design a data structure that supports all following operations in average O(1) time.

Note: Duplicate elements are allowed.

1. insert(val): Inserts an item val to the collection.
2. remove(val): Removes an item val from the collection if present.
3. 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.

Idea:

Hashtable + array

Solution:

// Author: Huahua
// Running time: 49 ms
class RandomizedCollection {
public:
    /** Initialize your data structure here. */
    RandomizedCollection() {}
    
    /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
    bool insert(int val) {        
        m_[val].push_back(vals_.size());
        vals_.emplace_back(val, m_[val].size() - 1);
        return m_[val].size() == 1u;
    }
    
    /** Removes a value from the collection. Returns true if the collection contained the specified element. */
    bool remove(int val) {
        if (!m_.count(val)) return false;
        int index_to_evict = m_[val].back();
        const auto& last_entry = vals_.back();
        
        // Update index
        m_[last_entry.first][last_entry.second] = index_to_evict;
        
        // Swap vals
        swap(vals_.back(), vals_[index_to_evict]);
        
        // Clenup
        vals_.pop_back();        
        m_[val].pop_back();
        if (m_[val].empty()) m_.erase(val);
        
        return true;
    }
    
    /** Get a random element from the collection. */
    int getRandom() {
        return vals_[rand() % vals_.size()].first;
    }
private:
    // val -> indices array: indices in vals_
    unordered_map<int, vector<int>> m_;
    // {val, index in the indices array}
    vector<pair<int,int>> vals_;
};

Java

// Author: Huahua
// Running time: 122 ms (<94.53%)
class RandomizedCollection {
  class Entry {
    public int value;
    public int index;
    public Entry(int val, int idx) {
      value = val;
      index = idx;
    }
  }
  
  private Map<Integer, List<Integer>> m;
  private List<Entry> vals;
  private Random rand;

  /** Initialize your data structure here. */
  public RandomizedCollection() {
    m = new HashMap<>();
    vals = new ArrayList<>();
    rand = new Random();
  }

  /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
  public boolean insert(int val) {    
    List<Integer> l = m.getOrDefault(val, new ArrayList<Integer>());
    l.add(vals.size());
    m.put(val, l);
    vals.add(new Entry(val, l.size() - 1));
    return l.size() == 1;
  }

  /** Removes a value from the collection. Returns true if the collection contained the specified element. */
  public boolean remove(int val) {    
    if (!m.containsKey(val)) return false;
    List<Integer> l = m.get(val);
    int index_to_evict = l.get(l.size() - 1);
    Entry last_entry = vals.get(vals.size() - 1);

    // Update index
    m.get(last_entry.value).set(last_entry.index, index_to_evict);

    // Swap vals
    vals.set(index_to_evict, last_entry);    

    // Cleanup
    vals.remove(vals.size() - 1);
    l.remove(l.size() - 1);
    if (l.size() == 0) m.remove(val);

    return true;
  }

  /** Get a random element from the collection. */
  public int getRandom() {    
    return vals.get(rand.nextInt(vals.size())).value;
  }
}

Related Problems:

• [解题报告] LeetCode 380. Insert Delete GetRandom O(1)
• [解题报告] LeetCode 460. LFU Cache O(1)
• [解题报告] LeetCode 146. LRU Cache O(1)
• [解题报告] LeetCode 295. Find Median from Data Stream O(logn) + O(1)

The post 花花酱 LeetCode 381. Insert Delete GetRandom O(1) – Duplicates allowed appeared first on Huahua's Tech Road.

Problem:

Design a data structure that supports all following operations in average O(1) time.

1. insert(val): Inserts an item val to the set if not already present.
2. remove(val): Removes an item val from the set if present.
3. getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.

Idea:

Hashtable + array

Time complexity:

O(1)

Solution:

// Author: Huahua
// Running time: 49 ms
class RandomizedSet {
public:
    /** Initialize your data structure here. */
    RandomizedSet() {}
    
    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
    bool insert(int val) {
        if(m_.count(val)) return false;
        m_[val] = vals_.size();
        vals_.push_back(val);
        return true;
    }
    
    /** Removes a value from the set. Returns true if the set contained the specified element. */
    bool remove(int val) {
        if(!m_.count(val)) return false;
        int index = m_[val];
        m_[vals_.back()] = index;
        m_.erase(val);
        std::swap(vals_[index], vals_.back());
        vals_.pop_back();
        return true;
    }
    
    /** Get a random element from the set. */
    int getRandom() {
        int index = rand() % vals_.size();
        return vals_[index];
    }
private:
    // val -> index in the array
    unordered_map<int, int> m_;
    vector<int> vals_;
};

Related Problems:

• LeetCode 381. Insert Delete GetRandom O(1) – Duplicates allowed
• [解题报告] LeetCode 460. LFU Cache O(1)
• [解题报告] LeetCode 146. LRU Cache O(1)
• [解题报告] LeetCode 295. Find Median from Data Stream O(logn) + O(1)

The post 花花酱 LeetCode 380. Insert Delete GetRandom O(1) appeared first on Huahua's Tech Road.