Leetcode 519.随机翻转矩阵

给你一个 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 <= 104
每次调用flip 时，矩阵中至少存在一个值为 0 的格子。
最多调用 1000 次 flip 和 reset 方法。

题解：最暴力的方法当然还是直接建立一个二维的数组，但是这样每次初始化的时候，时间复杂度比较大，而且浪费空间，所以在这里用一个HashSet存一下，每次随机数只生成一个就行，范围为0~m*n，即rand=i*n+j，然后再转换为对应的横纵坐标就行，每次查询一下是不是已经生成过了。reset的时候直接初始化HashSet就好了。

import java.util.HashSet;
import java.util.Set;

class Solution {
	
	Set<Integer> set;
	int m,n;
    public Solution(int m, int n) {
    	set=new HashSet<Integer>();
    	this.m=m;
    	this.n=n;
    }
    
    public int[] flip() {
    	int sum=m*n;
    	int rand=(int)(Math.random()*sum);
    	
    	while(set.contains(rand))
    	{
    		rand=(int)(Math.random()*sum);
    	}
    	System.out.println(rand);
    	set.add(rand);
    	int ans[]=new int[2];
    	ans[0]=rand/n;
    	ans[1]=rand%n;
    	return ans;
    }
    
    public void reset() {
    	set=new HashSet<Integer>();
    	
    }
}

/**
 * Your Solution object will be instantiated and called as such:
 * Solution obj = new Solution(m, n);
 * int[] param_1 = obj.flip();
 * obj.reset();
 */