《LeetCode之每日一题》:220.随机翻转矩阵

题目链接： 随机翻转矩阵

有关题目

给你一个 m x n 的二元矩阵 matrix ，且所有值被初始化为 0 。
请你设计一个算法，随机选取一个满足 matrix[i][j] == 0 的下标 (i, j) ，并将它的值变为 1 。
所有满足 matrix[i][j] == 0 的下标 (i, j) 被选取的概率应当均等。

尽量最少调用内置的随机函数，并且优化时间和空间复杂度。

实现 Solution 类：

	Solution(int m, int n) 使用二元矩阵的大小 m 和 n 初始化该对象
	int[] flip() 返回一个满足 matrix[i][j] == 0 的随机下标 [i, j] ，并将其对应格子中的值变为 1
	void reset() 将矩阵中所有的值重置为 0

示例：

输入
["Solution", "flip", "flip", "flip", "reset", "flip"]
[[3, 1], [], [], [], [], []]
输出
[null, [1, 0], [2, 0], [0, 0], null, [2, 0]]

解释
Solution solution = new Solution(3, 1);
solution.flip();  // 返回 [1, 0]，此时返回 [0,0]、[1,0] 和 [2,0] 的概率应当相同
solution.flip();  // 返回 [2, 0]，因为 [1,0] 已经返回过了，此时返回 [2,0] 和 [0,0] 的概率应当相同
solution.flip();  // 返回 [0, 0]，根据前面已经返回过的下标，此时只能返回 [0,0]
solution.reset(); // 所有值都重置为 0 ，并可以再次选择下标返回
solution.flip();  // 返回 [2, 0]，此时返回 [0,0]、[1,0] 和 [2,0] 的概率应当相同

提示：

1 <= m, n <= 10^4
每次调用flip 时，矩阵中至少存在一个值为 0 的格子。
最多调用 1000 次 flip 和 reset 方法。

题解

法一：通过哈希表进行数组映射
参考官方题解

class Solution {
public:
    Solution(int m, int n) {
        this->m = m;
        this->n = n;
        this->total = m * n;
        srand(time(nullptr));
    }
    
    vector<int> flip() {
        int x = rand() % total;
        vector<int> ans;
        total--;
        
        //查找 x对应位置的映射
        if (mp.count(x))
        {
            ans = {mp[x] / n, mp[x] % n};
        }
        else 
        {
            ans = {x / n, x % n};
        }

        //改变x中对应的映射
        //将 x 对应的映射映射到total对应的映射中去
        if (mp.count(total))
        {
            mp[x] = mp[total];
        }
        else 
        {
            mp[x] = total;
        }

        return ans;
    }
    
    void reset() {
        total = m * n;
        mp.clear();
    }   
private:
    int m;
    int n;
    int total;

    //哈希表表示全下标x，存放的映射（即matrix[i][j] == 0的映射）
    //同时全下标 x 对应矩阵中的值已经发生变化
    unordered_map<int, int> mp;
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution* obj = new Solution(m, n);
 * vector<int> param_1 = obj->flip();
 * obj->reset();
 */