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

Posted Zephyr丶J

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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;
    



以上是关于LeetCode 884. 两句话中的不常见单词 / 1342. 将数字变成 0 的操作次数(计算二进制长度统计1的个数) / 1763. 最长的美好子字符串(分治)的主要内容,如果未能解决你的问题,请参考以下文章

leetcode 884. 两句话中的不常见单词 (python)

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

LeetCode 884 两句话中的不常见单词[字符串] HERODING的LeetCode之路

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

快乐水题884. 两句话中的不常见单词

LeetCode刷题(134)~两句话中的不常见单词 istringstream 流操作