剑指offer学习记录2

class Solution {
    public int[] countBits(int n) {
        int[] arr = new int[n+1];
        for(int i = 0; i <= n; i++){
            int mid = i;、、记得有，不然直接操作i，循环操作会有问题。
            int j = 0;
            while(mid > 0){
            //在判断的时候记得加上括号，位操作的优先级低于==。
                if((mid & 1) == 1){
                    j++;
                }
                mid = mid >> 1;
            }
            arr[i] = j;
        }
        return arr;
    }
}

class Solution {
    public int singleNumber(int[] nums){
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++){
            map.put(nums[i],map.getOrDefault(nums[i],0) + 1);
        }
        for (int i:map.keySet()
             ) {
            if(map.get(i) == 1){
                return i;
            }
        }
        return -1;
    }
}

HashMap相关知识点：
（1）map.put(nums[i],map.getOrDefault(nums[i],0) + 1);—put()函数就是给map里面存值。而getOrDefault()的作用就是得到值，如果没有就存放设置的初始值。

方法2：

class Solution {
    public int singleNumber(int[] nums){
       int ans = 0;
       for(int i =0; i < 32; i++){
           int target = 0;
           for(int num:nums){
               target += (num >> i) & 1;
           }
           if(target % 3 != 0){
               ans |= (1 << i);
           } 
       }
       return ans;
    }
}

//暴力破解
class Solution{
    // 暴力解法
    // m 表示单词的平均长度，n 表示单词的个数
    // 时间复杂度：O(n^2 * m)
    // 空间复杂度：O(1)
    public int maxProduct(String[] words) {
        int ans = 0;
        for (int i = 0; i < words.length -1; i++) {
            String word1 = words[i];
            for (int j = i + 1; j < words.length; j++) {
                String word2 = words[j];
                // 每个单词的 bitMask 会重复计算很多次
                if (!hasSameChar(word1, word2)) {
                    ans = Math.max(ans, word1.length() * word2.length());
                }
            }
        }
        return ans;
    }
    // O(m^2)
    private boolean hasSameChar(String word1, String word2) {
        for (char c : word1.toCharArray()) {
            if (word2.indexOf(c) != -1) return true;
        }
        return false;
    }
}

方法二：

class Solution {
    public int maxProduct(String[] words) {
        //1、使用二进制的26位记录每个单词中26个字母的出现情况，1为出现
        int[] flags = new int[words.length];
        for (int i = 0; i < words.length; i++) {
            //关键一步，将1右移的位数，就证明有这个数。
            for (char ch: words[i].toCharArray()) {
                flags[i] |= 1 << (ch - 'a');
            }
        }
        //2、两个单词如果有相同字母，则对应的整数与运算后相同字母对应的数位为1,结果不为0；没有相同字母则结果为0
        int result = 0;
        for(int i = 0; i < words.length; i++){
            for (int j = i + 1; j < words.length; j++) {
                if((flags[i] & flags[j]) == 0) {
                    int prod = words[i].length() * words[j].length();
                    result = Math.max(result,prod);
                }
            }
        }
        return result;
    }
}