LeetCode 598. 范围求和 II / 299. 猜数字游戏 / 488. 祖玛游戏

最新推荐文章于 2022-05-28 12:20:14 发布

Zephyr丶J

最新推荐文章于 2022-05-28 12:20:14 发布

阅读量236

点赞数

分类专栏： LeetCode 文章标签： leetcode java

本文链接：https://blog.csdn.net/windyjcy/article/details/121186891

版权

LeetCode 专栏收录该内容

198 篇文章 1 订阅

订阅专栏

598. 范围求和 II

2021.11.07 每日一题

题目描述

给定一个初始元素全部为 0，大小为 m*n 的矩阵 M 以及在 M 上的一系列更新操作。

操作用二维数组表示，其中的每个操作用一个含有两个正整数 a 和 b 的数组表示，含义是将所有符合 0 <= i < a 以及 0 <= j < b 的元素 M[i][j] 的值都增加 1。

在执行给定的一系列操作后，你需要返回矩阵中含有最大整数的元素个数。

示例 1:

输入:
m = 3, n = 3
operations = [[2,2],[3,3]]
输出: 4
解释:
初始状态, M =
[[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]
执行完操作 [2,2] 后, M =
[[1, 1, 0],
[1, 1, 0],
[0, 0, 0]]
执行完操作 [3,3] 后, M =
[[2, 2, 1],
[2, 2, 1],
[1, 1, 1]]
M 中最大的整数是 2, 而且 M 中有4个值为2的元素。因此返回 4。

注意:

m 和 n 的范围是 [1,40000]。
a 的范围是 [1,m]，b 的范围是 [1,n]。
操作数目不超过 10000。

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

思路

因为都是从0开始的更新，所以没啥问题，找最小值就可以了

class Solution {
    public int maxCount(int m, int n, int[][] ops) {
        int l = ops.length;
        int mm = m;
        int nn = n;
        for(int[] arr : ops){
            int x = arr[0];
            int y = arr[1];
            mm = Math.min(mm, x);
            nn = Math.min(nn, y);
        }
        return mm * nn;
    }
}

299. 猜数字游戏

2021.11.08 每日一题

题目描述

你在和朋友一起玩猜数字（Bulls and Cows）游戏，该游戏规则如下：

写出一个秘密数字，并请朋友猜这个数字是多少。朋友每猜测一次，你就会给他一个包含下述信息的提示：

猜测数字中有多少位属于数字和确切位置都猜对了（称为 “Bulls”, 公牛），
有多少位属于数字猜对了但是位置不对（称为 “Cows”, 奶牛）。也就是说，这次猜测中有多少位非公牛数字可以通过重新排列转换成公牛数字。
给你一个秘密数字 secret 和朋友猜测的数字 guess ，请你返回对朋友这次猜测的提示。

提示的格式为 “xAyB” ，x 是公牛个数， y 是奶牛个数，A 表示公牛，B 表示奶牛。

请注意秘密数字和朋友猜测的数字都可能含有重复数字。

示例 1:

输入: secret = “1807”, guess = “7810”
输出: “1A3B”
解释: 数字和位置都对（公牛）用 ‘|’ 连接，数字猜对位置不对（奶牛）的采用斜体加粗标识。
“1807”
|
“7810”

示例 2:

输入: secret = “1123”, guess = “0111”
输出: “1A1B”
解释: 数字和位置都对（公牛）用 ‘|’ 连接，数字猜对位置不对（奶牛）的采用斜体加粗标识。
“1123” “1123”
| or |
“0111” “0111”
注意，两个不匹配的 1 中，只有一个会算作奶牛（数字猜对位置不对）。通过重新排列非公牛数字，其中仅有一个 1 可以成为公牛数字。

示例 3：

输入：secret = “1”, guess = “0”
输出：“0A0B”

示例 4：

输入：secret = “1”, guess = “1”
输出：“1A0B”

提示：

1 <= secret.length, guess.length <= 1000
secret.length == guess.length
secret 和 guess 仅由数字组成

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

思路

很简单的思路，相同位置的先处理，不同位置的再遍历一遍

class Solution {
    public String getHint(String secret, String guess) {
        int l = secret.length();
        Map<Integer, Integer> m1 = new HashMap<>();
        Map<Integer, Integer> m2 = new HashMap<>();
        int same = 0;
        for(int i = 0; i < l; i++){
            int n1 = secret.charAt(i) - '0';
            int n2 = guess.charAt(i) - '0';
            if(n1 == n2)
                same++;
            else{
                m1.put(n1, m1.getOrDefault(n1, 0) + 1);
                m2.put(n2, m2.getOrDefault(n2, 0) + 1);
            }
        }
        int nosame = 0;
        for(Map.Entry<Integer, Integer> entry : m1.entrySet()){
            int key = entry.getKey();
            int value = entry.getValue();
            int v2 = m2.getOrDefault(key, 0);
            nosame += Math.min(value, v2);
        }
        return new String(same + "A" + nosame + "B");
    }
}

488. 祖玛游戏

2021.11.09 每日一题

题目描述

你正在参与祖玛游戏的一个变种。

在这个祖玛游戏变体中，桌面上有一排彩球，每个球的颜色可能是：红色 ‘R’、黄色 ‘Y’、蓝色 ‘B’、绿色 ‘G’ 或白色 ‘W’ 。你的手中也有一些彩球。

你的目标是清空桌面上所有的球。每一回合：

从你手上的彩球中选出任意一颗，然后将其插入桌面上那一排球中：两球之间或这一排球的任一端。
接着，如果有出现三个或者三个以上且颜色相同的球相连的话，就把它们移除掉。
如果这种移除操作同样导致出现三个或者三个以上且颜色相同的球相连，则可以继续移除这些球，直到不再满足移除条件。
如果桌面上所有球都被移除，则认为你赢得本场游戏。
重复这个过程，直到你赢了游戏或者手中没有更多的球。

给你一个字符串 board ，表示桌面上最开始的那排球。另给你一个字符串 hand ，表示手里的彩球。请你按上述操作步骤移除掉桌上所有球，计算并返回所需的最少球数。如果不能移除桌上所有的球，返回 -1 。

示例 1：

输入：board = “WRRBBW”, hand = “RB”
输出：-1
解释：无法移除桌面上的所有球。可以得到的最好局面是：
-插入一个 ‘R’ ，使桌面变为 WRRRBBW 。WRRRBBW -> WBBW
-插入一个 ‘B’ ，使桌面变为 WBBBW 。WBBBW -> WW
桌面上还剩着球，没有其他球可以插入。

示例 2：

输入：board = “WWRRBBWW”, hand = “WRBRW”
输出：2
解释：要想清空桌面上的球，可以按下述步骤：
-插入一个 ‘R’ ，使桌面变为 WWRRRBBWW 。WWRRRBBWW -> WWBBWW
-插入一个 ‘B’ ，使桌面变为 WWBBBWW 。WWBBBWW -> WWWW -> empty
只需从手中出 2 个球就可以清空桌面。

示例 3：

输入：board = “G”, hand = “GGGGG”
输出：2
解释：要想清空桌面上的球，可以按下述步骤：
-插入一个 ‘G’ ，使桌面变为 GG 。
-插入一个 ‘G’ ，使桌面变为 GGG 。GGG -> empty
只需从手中出 2 个球就可以清空桌面。

示例 4：

输入：board = “RBYYBBRRB”, hand = “YRBGB”
输出：3
解释：要想清空桌面上的球，可以按下述步骤：
-插入一个 ‘Y’ ，使桌面变为 RBYYYBBRRB 。RBYYYBBRRB -> RBBBRRB -> RRRB -> B
-插入一个 ‘B’ ，使桌面变为 BB 。
-插入一个 ‘B’ ，使桌面变为 BBB 。BBB -> empty
只需从手中出 3 个球就可以清空桌面。

提示：

1 <= board.length <= 16
1 <= hand.length <= 5
board 和 hand 由字符 ‘R’、‘Y’、‘B’、‘G’ 和 ‘W’ 组成
桌面上一开始的球中，不会有三个及三个以上颜色相同且连着的球

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

思路

按照我的思路回溯的，就是在每个相同字母的位置添加字母，如果添加以后，出现连续的，那么就消除，然后递归
但是写完以后，出现这么一个例子
“RRWWRRBBRR”
“WB”
这个例子按我的理解是不可能被消除的，但是答案给了个2
意思是消除一个以后，后面可以选择消除几个？？这太离谱了

看了官解，发现是这样操作的：
RRWWRRBBRR→RRWWRRBBR(W)R→RRWWRR(B)BBRWR→RRWWRRRWR→RRWWWR→RRR→""
所以还不能直接选择相同字母处插入

改了一下，然后剩一个例子没过
“RRYGGYYRRYYGGYRR”
“GGBBB”
没有的字母也能用到…
所以都把刚开始自以为的剪枝去掉以后，对是对了，但是超时了

不知道怎么剪枝了，是不是删除字符串的时候太麻烦了

class Solution {
    Map<Character, Integer> map;
    int min = 6;
    int n;
    char[] cc = {'R', 'Y', 'B', 'G', 'W'};
    public int findMinStep(String board, String hand) {
        //看到范围就感觉是回溯了
        //想想有什么可以优化的地方
        map = new HashMap<>();
        int l = board.length();
        n = hand.length();
        //Set<Character> set = new HashSet<>();
        //for(int i = 0; i < l; i++){
        //    set.add(board.charAt(i));
        //}
        for(int i = 0; i < n; i++){
            char c = hand.charAt(i);
            //if(!set.contains(c))
            //    continue;
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        StringBuffer sb = new StringBuffer(board);
        backtracking(sb, 0);
        return min == 6 ? -1 : min;
    }

    public void backtracking(StringBuffer sb, int ops){
        if(ops >= min)
            return;
        if(sb.length() == 0){
            min = Math.min(min, ops);
            return;
        }
        if(map.isEmpty())
            return;

        int l = sb.length();
        for(int i = 0; i < l; i++){
            char c = sb.charAt(i);
            //if(i > 0 && c == sb.charAt(i - 1))
            //   continue;
            for(int j = 0; j < 5; j++){
                char key = cc[j];
                if(!map.containsKey(key) || (i > 0 && c == sb.charAt(i - 1) && key == c))
                    continue;
                int v = map.get(key) - 1;
                map.put(key, v);
                if(v == 0)
                    map.remove(key);
                //插入这个元素
                sb.insert(i, key);
                //然后递归，创建一个临时变量用于递归删除
                String temp = sb.toString();
                sb = check(sb);
                backtracking(sb, ops + 1);
                //用原来的变量来回溯
                sb = new StringBuffer(temp);
                sb.deleteCharAt(i);
                map.put(key, v + 1);
            }
        }
    }

    public StringBuffer check(StringBuffer sb){
         boolean isdelete = true;
        while(isdelete){
            int l = sb.length();
            if(l == 0 || l == 1)
                break;
            int same = 1;
            char c = sb.charAt(0);
            for(int i = 1; i < l; i++){
                char temp = sb.charAt(i);
                if(temp == c){
                    same++;
                }
                else if(temp != c){
                    if(same >= 3){
                        sb.delete(i - same, i);
                        break;
                    }
                    same = 1;
                    c = temp;
                }
                if(i == l - 1 && same >= 3){
                    sb.delete(l - same, l);
                    break;
                }
                if(i == l - 1)
                    isdelete = false;
            }
        }
        return sb;
    }
}

加了个记忆化，终于ok了
可能还是麻烦，但是就这样吧，做不动了

class Solution {
    Map<Character, Integer> map;
    int n;
    char[] cc = {'R', 'Y', 'B', 'G', 'W'};
    Map<String, Integer> memo;
    public int findMinStep(String board, String hand) {
        //看到范围就感觉是回溯了
        //想想有什么可以优化的地方
        map = new HashMap<>();
        int l = board.length();
        n = hand.length();
        memo = new HashMap<>();
        //Set<Character> set = new HashSet<>();
        //for(int i = 0; i < l; i++){
        //    set.add(board.charAt(i));
        //}
        for(int i = 0; i < n; i++){
            char c = hand.charAt(i);
            //if(!set.contains(c))
            //    continue;
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        StringBuffer sb = new StringBuffer(board);
        int min = backtracking(sb, 0);
        return min == 6 ? -1 : min;
    }

    public int backtracking(StringBuffer sb, int ops){
        if(sb.length() == 0){
            return ops;
        }
        if(memo.containsKey(sb.toString()))
            return memo.get(sb.toString());
        int min = 6;
        if(map.isEmpty())
            return min;

        int l = sb.length();
        for(int i = 0; i < l; i++){
            char c = sb.charAt(i);
            //if(i > 0 && c == sb.charAt(i - 1))
            //   continue;
            for(int j = 0; j < 5; j++){
                char key = cc[j];
                if(!map.containsKey(key) || (i > 0 && c == sb.charAt(i - 1) && key == c))
                    continue;
                int v = map.get(key) - 1;
                map.put(key, v);
                if(v == 0)
                    map.remove(key);
                //插入这个元素
                sb.insert(i, key);
                //然后递归，创建一个临时变量用于递归删除
                String temp = sb.toString();
                sb = check(sb);
                int t = backtracking(sb, ops + 1);
                min = Math.min(min, t);  
                //用原来的变量来回溯
                sb = new StringBuffer(temp);
                sb.deleteCharAt(i);
                map.put(key, v + 1);
            }
        }
        memo.put(sb.toString(), min);
        return min;
    }

    public StringBuffer check(StringBuffer sb){
         boolean isdelete = true;
        while(isdelete){
            int l = sb.length();
            if(l == 0 || l == 1)
                break;
            int same = 1;
            char c = sb.charAt(0);
            for(int i = 1; i < l; i++){
                char temp = sb.charAt(i);
                if(temp == c){
                    same++;
                }
                else if(temp != c){
                    if(same >= 3){
                        sb.delete(i - same, i);
                        break;
                    }
                    same = 1;
                    c = temp;
                }
                if(i == l - 1 && same >= 3){
                    sb.delete(l - same, l);
                    break;
                }
                if(i == l - 1)
                    isdelete = false;
            }
        }
        return sb;
    }
}

Zephyr丶J

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
LeetCode 598. 范围求和 II / 299. 猜数字游戏 / 488. 祖玛游戏

598. 范围求和 II2021.11.07 每日一题题目描述给定一个初始元素全部为 0，大小为 m*n 的矩阵 M 以及在 M 上的一系列更新操作。操作用二维数组表示，其中的每个操作用一个含有两个正整数 a 和 b 的数组表示，含义是将所有符合 0 <= i < a 以及 0 <= j < b 的元素 M[i][j] 的值都增加 1。在执行给定的一系列操作后，你需要返回矩阵中含有最大整数的元素个数。示例 1:输入:m = 3, n = 3operations =
复制链接

扫一扫

专栏目录