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.

https://leetcode.com/problems/random-pick-index/description/

Given an array of integers with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.

Note:
The array size can be very large. Solution that uses too much extra space will not pass the judge.

Example:

int[] nums = new int[] {1,2,3,3,3};
Solution solution = new Solution(nums);

// pick(3) should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
solution.pick(3);

// pick(1) should return 0. Since in the array only nums[0] is equal to 1.
solution.pick(1);

Solution: Reservoir sampling

https://en.wikipedia.org/wiki/Reservoir_sampling

Time complexity: O(query * n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 92 ms
class Solution {
public:
  Solution(vector<int> nums) {
    nums_ = std::move(nums);
  }

  int pick(int target) {
    int n = 0;    
    int index = -1;
    for (int i = 0; i < nums_.size(); ++i) {
      if (nums_[i] != target) continue;
      ++n;
      if (rand() % n == 0) index = i;
    }
    return index;
  }
private:
  vector<int> nums_;
};

The post 花花酱 LeetCode 398. Random Pick Index appeared first on Huahua's Tech Road.