Leetcode 318. 最大单词长度乘积

最新推荐文章于 2022-04-15 14:22:49 发布

coder_xiaoyou

最新推荐文章于 2022-04-15 14:22:49 发布

阅读量161

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/Loser_you/article/details/113732867

版权

LeetCode 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

这篇博客探讨了如何使用位运算来优化LeetCode318题目的解决方案，分别展示了三种不同的实现方式：原始的双层循环检查，位运算结合数组，以及位运算结合HashMap。每种方法都通过位运算来判断两个单词是否有相同的字符，从而提高查找效率。最终，通过位运算和HashMap的解决方案在时间和空间复杂度上取得了更好的平衡。

摘要由CSDN通过智能技术生成

Leetcode 318. 最大单词长度乘积

原题链接

class Solution {
    public int maxProduct(String[] words) {
        int length = words.length;
        if (length == 1) {
            return 0;
        }
        int result = 0;
        for (int i = 0; i < words.length; i++) {
            for (int j = i + 1; j < words.length; j++) {
                if (check(words[i], words[j])) {
                    result = Math.max(result, words[i].length() * words[j].length());
                }
            }
        }
        return result;
    }

    private boolean check(String word1, String word2) {
        Set<Character> set = new HashSet<>();
        for (char c : word1.toCharArray()) {
            set.add(c);
        }
        for (char c : word2.toCharArray()) {
            if (set.contains(c)) {
                return false;
            }
        }
        return true;
    }
}

位运算+数组

class Solution {
    public int maxProduct(String[] words) {
        int n = words.length;
        // bitmasks 记录每个单词的位掩码值
        int[] bitmasks = new int[n];
        // len 记录每个单词的长度
        int[] len = new int[n];
        for (int i = 0; i < n; i++) {
            // 计算每一个单词的位掩码
            // bitmask中记录了每个单词所拥有的字母
            int bitmask = 0;
            for (char c : words[i].toCharArray()) {
                // bitmask的第i位如果为1，说明这个单词中出现了 ('a' + i) 这个字母
                bitmask |= 1 << bitIndex(c);
            }
            bitmasks[i] = bitmask;
            len[i] = words[i].length();
        }
        int result = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if ((bitmasks[i] & bitmasks[j]) == 0) {
                    result = Math.max(result, len[i] * len[j]);
                }
            }
        }
        return result;
    }

    private int bitIndex(char ch) {
        return (int) ch - (int) 'a';
    }


}

位运算+HashMap

class Solution {
    public int maxProduct(String[] words) {
        Map<Integer, Integer> map = new HashMap<>();
        for (String word : words) {
            int bitmask = 0;
            for (char c : word.toCharArray()) {
                bitmask |= 1 << bitIndex(c);
            }
            // 将单词的掩码值，相同掩码值中，长度最长的单词length存储到map中
            // 如果多个单词中，每个单词所拥有的字母都相同，则存储最长的那个单词长度
            map.put(bitmask, Math.max(map.getOrDefault(bitmask, 0), word.length()));
        }
        int result = 0;
        for (Integer k1 : map.keySet()) {
            for (Integer k2 : map.keySet()) {
                if ((k1 & k2) == 0) {
                    result = Math.max(result, map.get(k1) * map.get(k2));
                }
            }
        }
        return result;
    }

    private int bitIndex(char ch) {
        return (int) ch - (int) 'a';
    }
}