LeetCode 458. 可怜的小猪（找毒药问题） / 700. 二叉搜索树中的搜索 / 519. 随机翻转矩阵（哈希表记录交换位置）

Posted 2021-12-23 Zephyr丶J

458. 可怜的小猪

2021.11.25 每日一题

题目描述

有 buckets 桶液体，其中 正好 有一桶含有毒药，其余装的都是水。它们从外观看起来都一样。为了弄清楚哪只水桶含有毒药，你可以喂一些猪喝，通过观察猪是否会死进行判断。不幸的是，你只有 minutesToTest 分钟时间来确定哪桶液体是有毒的。

喂猪的规则如下：

选择若干活猪进行喂养
可以允许小猪同时饮用任意数量的桶中的水，并且该过程不需要时间。
小猪喝完水后，必须有 minutesToDie 分钟的冷却时间。在这段时间里，你只能观察，而不允许继续喂猪。
过了 minutesToDie 分钟后，所有喝到毒药的猪都会死去，其他所有猪都会活下来。
重复这一过程，直到时间用完。
给你桶的数目 buckets ，minutesToDie 和 minutesToTest ，返回在规定时间内判断哪个桶有毒所需的 最小 猪数。

示例 1：

输入：buckets = 1000, minutesToDie = 15, minutesToTest = 60
输出：5

示例 2：

输入：buckets = 4, minutesToDie = 15, minutesToTest = 15
输出：2

示例 3：

输入：buckets = 4, minutesToDie = 15, minutesToTest = 30
输出：2

提示：

1 <= buckets <= 1000
1 <= minutesToDie <= minutesToTest <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/poor-pigs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

class Solution 
    public int poorPigs(int buckets, int minutesToDie, int minutesToTest) 
        //说真的，我都不知道第一个例子是怎么得到的，而且喝了毒水还要死
        //昨天看到这个题想到一个面试问的问题，就是怎么找一瓶毒药，用的是每一位表示的方法

        //第二个例子也想了一会才想明白，两个猪，一次验证四桶水，12 23 
        //然后看着第一个提示想呀想，终于想到了如果只有一轮的话，该怎么喝水验证
        //如果只有一轮，那么每个猪都有死或者不死两个状态，如果0是活着，1是死亡的话
        //如果有n头猪的话，那么就有2的n次方种情况，而每只小猪要喝的桶的号数就是对应的二进制中1的位数
        //例如8个桶，一轮要验证，那么就需要3只猪，abc
        //从000 - 111 共8种情况，000代表第8桶，
        //从001开始，表示c喝这桶水；010，b喝；011，bc喝；100，a喝；101，ac喝；110，ab喝；111，abc喝
        //那么如果对应的猪死了，立刻就能知道是第几桶水有毒，如果都没死，那就是第八桶

        //那么如果加上轮次呢，肯定不是简单的相乘
        //看了题解，想想，如果有四轮，那么一个小猪可以在任意一轮喝水，也可以不喝，也就是有5种状态，可以判断5桶水
        //如果有两只猪呢，那么也可以在任意一轮喝任意一桶水，a b
        //可以看成是五进制的数，0代表两个猪不喝水，1 2 3 4分别代表1 2 3 4轮b喝水1 2 3 4桶水，而a在第一轮不喝水
        //5 6 7 8 9 代表a在第一轮喝这5桶水的同时，b在0 1 2 3 4 轮分别喝对应的桶的水
        //然后就同理了，这样可以判断吗
        //相当于第一轮，a喝5 6 7 8 9桶水，但是b要喝1,6,11,16,21这几桶水
        //如果a死了，那么就是5 7 8 9桶，那么剩下几轮，b猪只要每轮验证一桶就可以了；b死了也同理
        //如果a和b同时死了，就是6，如果都没死那么就进行第二轮
        //a喝10 11 12 13 14，b喝2 7 12 17 22，同理，因为11和7上一轮验证过了，所以也可以得到答案或者继续
        //第三轮，a 15 16 17 18 19 ，b 3 8 13 18 23....
        //如果四轮过后，没有猪死亡，那么说明00位置的桶是有毒的

        //所以最后总结一个数学规律，如果有n轮，那么对于一只猪就有n + 1种情况
        //对于x只猪，那么就有(n + 1) ^ x种情况
        int n = minutesToTest / minutesToDie;
        int max = 1;
        int x = 0;
        while(max < buckets)
            x++;    //小猪数量加1
            max = (int)Math.pow(n + 1, x);
        
        return x;
    

700. 二叉搜索树中的搜索

2021.11.26 每日一题

题目描述

给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

例如，

给定二叉搜索树:

    4
   / \\
  2   7
 / \\
1   3
和值: 2

你应该返回如下子树:

  2     
 / \\   
1   3

在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-a-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

/**
 * Definition for a binary tree node.
 * public class TreeNode 
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x)  val = x; 
 * 
 */
class Solution 
    public TreeNode searchBST(TreeNode root, int val) 
        if(root == null)
            return root;
        if(val < root.val)
            return searchBST(root.left, val);
        else if(val > root.val)
            return searchBST(root.right, val);
        else
            return root;
    

519. 随机翻转矩阵

2021.11.27 每日一题

题目描述

给你一个 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 方法。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/random-flip-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

刚开始按照前几天随机数的题写了个这样的程序，结果超出内存限制了，10000*10000 确实不行

class Solution 
    //和那天那个随机的题差不多，只不过变成二维的了
    int m;
    int n;
    int sum;    //格子总数
    int idx;    //当前变化的格子下标
    int[] num;

    public Solution(int m, int n) 
        this.m = m;
        this.n = n;
        sum = m * n;    
        idx = 0;
        num = new int[sum];
        for(int i = 0; i < sum; i++)
            num[i] = i;
        
    
    
    public int[] flip() 
        Random rd = new Random();
        int ran = rd.nextInt(sum - idx);
        int temp = num[idx + ran];      //要交换位置的数
        num[idx + ran] = num[idx];      //和idx位置交换
        num[idx] = temp;                
        idx++;
        return new int[]num[idx - 1] / n, num[idx - 1] % n;
    
    
    public void reset() 
        Arrays.sort(num);
        idx = 0;
    


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

那么如何能不创建太大的空间而完成随机呢？
可以只记录交换的位置

class Solution 
    //用map存储出现过的值的位置，其实还是数组交换的方法
    // 0 1 2 3 4 5
    //第一次随机，如果出现2， 那么2要和5交换，也就是 0 1 5 3 4 2，所以哈希表记录2-5，也就是2的位置是5
    //然后第二次随机，如果出现的还是2，那么这次产生的数就是5，而要把5放到末尾，也就是0 1 4 3 5 2，所以还是要交换
    //也就是用哈希表记录2-4
    Map<Integer, Integer> map;
    int m;
    int n;
    int sum;
    Random rd = new Random();

    public Solution(int m, int n) 
        this.m = m;
        this.n = n;
        sum = m * n;
        map = new HashMap<>();
    
    
    public int[] flip() 
        //产生一个随机数，相当于产生一个位置
        int temp = rd.nextInt(sum);
        sum--;
        //获得这个位置的数字
        int idx = map.getOrDefault(temp, temp);
        //让这个位置temp存放末尾下标处的数，相当于把当前数字idx放到了sum位置
        map.put(temp, map.getOrDefault(sum, sum));
        return new int[]idx / n, idx % n;
    
    
    public void reset() 
        sum = m * n;
        map.clear();
    


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