LeetCode 884. 两句话中的不常见单词 / 1342. 将数字变成 0 的操作次数(计算二进制长度、统计1的个数) / 1763. 最长的美好子字符串（分治）

884. 两句话中的不常见单词

2022.1.30 每日一题

题目描述

句子 是一串由空格分隔的单词。每个 单词 仅由小写字母组成。

如果某个单词在其中一个句子中恰好出现一次，在另一个句子中却 没有出现 ，那么这个单词就是 不常见的 。

给你两个 句子 s1 和 s2 ，返回所有 不常用单词 的列表。返回列表中单词可以按 任意顺序 组织。

示例 1：

输入：s1 = “this apple is sweet”, s2 = “this apple is sour”
输出：[“sweet”,“sour”]

示例 2：

输入：s1 = “apple apple”, s2 = “banana”
输出：[“banana”]

提示：

1 <= s1.length, s2.length <= 200
s1 和 s2 由小写英文字母和空格组成
s1 和 s2 都不含前导或尾随空格
s1 和 s2 中的所有单词间均由单个空格分隔

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

思路

class Solution {
    public String[] uncommonFromSentences(String s1, String s2) {
        String[] ss1 = s1.split(" ");
        String[] ss2 = s2.split(" ");
        Map<String, Integer> m1 = new HashMap<>();
        Map<String, Integer> m2 = new HashMap<>();
        for(String s : ss1){
            m1.put(s, m1.getOrDefault(s, 0) + 1);
        }
        for(String s : ss2){
            m2.put(s, m2.getOrDefault(s, 0) + 1);
        }
        List<String> list = new ArrayList<>();

        for(String s : m1.keySet()){
            if(m1.get(s) == 1 && !m2.containsKey(s)){
                list.add(s);
            }
        }

        for(String s : m2.keySet()){
            if(m2.get(s) == 1 && !m1.containsKey(s)){
                list.add(s);
            }
        }
        return list.toArray(new String[0]);
    }
}

1342. 将数字变成 0 的操作次数

2022.1.31 每日一题，除夕快乐啊！！！！！

题目描述

给你一个非负整数 num ，请你返回将它变成 0 所需要的步数。 如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。

示例 1：

输入：num = 14
输出：6
解释：
步骤 1) 14 是偶数，除以 2 得到 7 。
步骤 2） 7 是奇数，减 1 得到 6 。
步骤 3） 6 是偶数，除以 2 得到 3 。
步骤 4） 3 是奇数，减 1 得到 2 。
步骤 5） 2 是偶数，除以 2 得到 1 。
步骤 6） 1 是奇数，减 1 得到 0 。

示例 2：

输入：num = 8
输出：4
解释：
步骤 1） 8 是偶数，除以 2 得到 4 。
步骤 2） 4 是偶数，除以 2 得到 2 。
步骤 3） 2 是偶数，除以 2 得到 1 。
步骤 4） 1 是奇数，减 1 得到 0 。

示例 3：

输入：num = 123
输出：12

提示：

0 <= num <= 10^6

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

思路

很简单，主要是学统计二进制长度和1个数的方法

class Solution {
    public int numberOfSteps(int num) {
        //当然可以简单模拟
        //但是可以从二进制角度来考虑，比如14，二进制就是 1 1 1 0，要变成0，就是需要向右移位
        //如果是0就向右移1位，如果是1，就减去1
        //所以需要4-1+3等于6次
        
        //那么现在的问题就是怎么统计二进制的长度和其中1的个数
        //统计1的个数之前做过，例如统计11这个数中的1的个数，就是11 & 01 + 01 & 01，两个
        //什么意思呢，就是先统计个位的1，再向右移动1位然后统计十位的1
        //所以对于任意一个数，32位，先与0x55555555相与，再向右移动1位，与0x55555555相与
        //这样就将32位分成了两个一组，统计了16组
        //然后现在4个一组，相当于将之前的两组，再两组两组的分，也就是与0x33333333相与
        //这样，4个一组的1的个数就被统计到了每组
        //然后继续，8个一组1的个数，每8个需要与00001111，总体也就是0x0F0F0F0F相与
        //后面以此类推

        return num == 0 ? 0 : length(num) - 1 + bitCount(num);
    }
    //统计长度，运用二分的思想，先将32位分成前后各16位
    //然后如果前面16位为0，就计算后面的，如果不为0，就计算前面的
    //然后再分成8位
    public int length(int num){
        int len = 0;
        //如果等于0，那么处理后16位，将后16位移动到前面
        if((num >> 16) == 0){
            len += 16;
            num <<= 16;
        }

        if((num >> 24) == 0){
            len += 8;
            num <<= 8;
        }

        if((num >> 28) == 0){
            len += 4;
            num <<= 4;
        }

        if((num >> 30) == 0){
            len += 2;
            num <<= 2;
        }

        if((num >> 31) == 0){
            len += 1;
        }
        
        return 32 - len;
    }
    

    public int bitCount(int num){
        num = (num & 0x55555555) + ((num >> 1) & 0x55555555);
        num = (num & 0x33333333) + ((num >> 2) & 0x33333333);
        num = (num & 0x0f0f0f0f) + ((num >> 4) & 0x0f0f0f0f);
        num = (num & 0x00ff00ff) + ((num >> 8) & 0x00ff00ff);
        num = (num & 0x0000ffff) + ((num >> 16) & 0x0000ffff);
        return num;
    }
}

1763. 最长的美好子字符串

2021.2.1 每日一题，初一，新年快乐哈哈哈

题目描述

当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。比方说，“abABB” 是美好字符串，因为 ‘A’ 和 ‘a’ 同时出现了，且 ‘B’ 和 ‘b’ 也同时出现了。然而，“abA” 不是美好字符串因为 ‘b’ 出现了，而 ‘B’ 没有出现。

给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。

示例 1：

输入：s = “YazaAay”
输出：“aAa”
解释：“aAa” 是一个美好字符串，因为这个子串中仅含一种字母，其小写形式 ‘a’ 和大写形式 ‘A’ 也同时出现了。
“aAa” 是最长的美好子字符串。

示例 2：

输入：s = “Bb”
输出：“Bb”
解释：“Bb” 是美好字符串，因为 ‘B’ 和 ‘b’ 都出现了。整个字符串也是原字符串的子字符串。

示例 3：

输入：s = “c”
输出：""
解释：没有美好子字符串。

示例 4：

输入：s = “dDzeE”
输出：“dD”
解释：“dD” 和 “eE” 都是最长美好子字符串。
由于有多个美好子字符串，返回 “dD” ，因为它出现得最早。

提示：

1 <= s.length <= 100
s 只包含大写和小写英文字母。

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

思路

我的思路，先遍历长度，检查每个长度是否有满足条件的子字符串，如果发现，那么就返回该长度的字符串
检查用的是滑动窗口的方法

class Solution {
    public String longestNiceSubstring(String s) {
        //这题也算简单题吗，我想到的思路是，因为字符串长度不大
        //所以先二分长度，然后用滑动窗口判断是否满足条件
        //二分有问题，只能遍历长度

        int l = s.length();
        int ll = 0;
        int rr = 0;
        for(int i = l; i >= 2; i--){
            int[] res = check(i, s);
            if(res[0] == 0){
                continue;
            }else{
                ll = res[1];
                rr = res[2];
                break;
            }
        }
            
        return ll + rr == 0 ? "" : s.substring(ll, rr + 1);
    }

    public int[] check(int len, String s){
        int left = 0;
        int right = 0;
        int[] small = new int[26];
        int[] big = new int[26];

        while(right < s.length()){
            char c = s.charAt(right);
            if(right < len - 1){
                if(Character.isLowerCase(c)){
                    small[c - 'a']++;
                }else{
                    big[c - 'A']++;
                }
                right++;
            }else{
                if(Character.isLowerCase(c)){
                    small[c - 'a']++;
                }else{
                    big[c - 'A']++;
                }
                for(int i = 0; i < 26; i++){
                    if((small[i] == 0 && big[i] != 0) || (small[i] != 0 && big[i] == 0))
                        break;
                    if(i == 25)
                        return new int[]{1, left, right};
                }
                char t = s.charAt(left);
                if(Character.isLowerCase(t)){
                    small[t - 'a']--;
                }else{
                    big[t - 'A']--;
                }
                right++;
                left++;
            }
        }
        return new int[3];
    }
}

第二个方法，可以将数组换成一个二进制数，因为只需要知道这个字符是否存在，而不需要知道有几个
这里直接遍历所有子字符串，记录最长的满足条件的子字符串

class Solution {
    public String longestNiceSubstring(String s) {
        int n = s.length();
        int maxPos = 0;
        int maxLen = 0;
        for (int i = 0; i < n; ++i) {
            int lower = 0;
            int upper = 0;
            for (int j = i; j < n; ++j) {
                if (Character.isLowerCase(s.charAt(j))) {
                    lower |= 1 << (s.charAt(j) - 'a');
                } else {
                    upper |= 1 << (s.charAt(j) - 'A');
                }
                if (lower == upper && j - i + 1 > maxLen) {
                    maxPos = i;
                    maxLen = j - i + 1;
                }
            }
        }
        return s.substring(maxPos, maxPos + maxLen);
    }
}

官解所给的分治思想意思就是：
先统计字符串中大小字母，如果是一对存在的，就不管，如果不是一对存在的，说明满足条件的子字符串肯定不会经过这个字符，所以将字符串按照这些字符分开，再递归处理子字符串

class Solution {
    public String longestNiceSubstring(String s) {
        if (s.length() < 2) {
            return "";
        }
        Set<Character> cache = new HashSet<>();
        for (char ch : s.toCharArray()) {
            cache.add(ch);
        }

        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            //如果同时存在大小写字母，那么继续遍历
            if (cache.contains(Character.toUpperCase(ch)) 
                && cache.contains(Character.toLowerCase(ch))) {
                continue;
            }
            //如果不存在，那么就分治
            String s1 = longestNiceSubstring(s.substring(0, i));
            String s2 = longestNiceSubstring(s.substring(i + 1));
            //长度相同，取前面的
            return s1.length() >= s2.length() ? s1 : s2;
        }
        //如果没有单个字符，那么返回整个字符串
        return s;
    }
}