LeetCode---Bit Manipulation && Design

**401. Binary Watch

思路：产生两个list分别代表小时和分钟，然后遍历

public List<String> readBinaryWatch(int num) {
    List<String> res = new ArrayList<String>();
    int[] hour = {8,4,2,1};
    int[] minute = {32,16,8,4,2,1};
    
    for(int i = 0; i <= num; i++){
        //i表示时和分各有几个灯亮，产生所有可能的值
        List<Integer> list1 = generateDigit(hour,i);
        List<Integer> list2 = generateDigit(minute,num - i);
        
        for(Integer num1 : list1){
            if(num1 >= 12) continue;
            for(Integer num2 : list2){
                if(num2 >= 60) continue;
                res.add(num1 + ":" + (num2 < 10 ? "0" + num2 : num2));
            }
        }
    }
    return res;
}

public List<Integer> generateDigit(int[] nums,int count){
    List<Integer> res = new ArrayList<Integer>();
    getResult(res,nums,count,0,0);
    return res;
}

public void getResult(List<Integer> res,int[] nums,int count,int start,int sum){
    if(count == 0){
        res.add(sum);
        return;
    }
    
    for(int i = start; i < nums.length; i++){
        getResult(res,nums,count - 1,i + 1,sum + nums[i]);
    }
}

**393. UTF-8 Validation

思路：判断每个UTF-8首Byte，看后面应该接几个Byte，再依次判断后面Byte的合法性，循环

public boolean validUtf8(int[] data) {
    if(data == null || data.length == 0) return false;
    for(int i = 0; i < data.length; i++){
        int numOfBytes = 0;
        if(data[i] > 255) return false;
        else if((data[i] & 128) == 0) {//0xxxxxxx
            numOfBytes = 1;
        }
        else if((data[i] & 224) == 192){//110xxxxx 
            numOfBytes = 2;
        }
        else if((data[i] & 240) == 224){//1110xxxx 
            numOfBytes = 3;
        }
        else if((data[i] & 248) == 240){//11110xxx 
            numOfBytes = 4;
        }
        else return false;
        
        for(int j = 1; j < numOfBytes; j++){
            if(i + j >= data.length) return false;
            if((data[i + j] & 192) != 128) return false;
        }
        //-1是因为上面的循环要+1
        i = i + numOfBytes - 1;
    }
    return true;
}

**211. Add and Search Word - Data structure design

思路：利用TrieTree,回溯
class TrieNode{
	TrieNode[] children = new TrieNode[26];
	String val = "";
}

public class WordDictionary {
TrieNode root = new TrieNode();

// Adds a word into the data structure.
public void addWord(String word) {
    TrieNode head = root;
    for(int i = 0; i < word.length(); i++){
        char c = word.charAt(i);
        if(head.children[c - 'a'] == null){
            head.children[c - 'a'] = new TrieNode();
        }
        head = head.children[c - 'a'];
    }
    head.val = word;
}

// Returns if the word is in the data structure. A word could
// contain the dot character '.' to represent any one letter.
public boolean search(String word) {
    return match(word,0,root);
}

public boolean match(String word,int k,TrieNode root){
    if(k == word.length()) return !root.val.equals("");
    
    if(word.charAt(k) != '.'){
        int idx = word.charAt(k) - 'a';
        return root.children[idx] != null && match(word,k + 1,root.children[idx]);
    }
    else{
        for(int i = 0; i < 26; i++){
            if(root.children[i] != null && match(word,k + 1,root.children[i])) return true;
        }
        return false;
    }
}
}

总结

191. Number of 1 Bits：两种方法：1、每次和1作逻辑与，右移统计个数；2、n = n & (n - 1)每次消除一个1
342. Power of Four：两种方法：1、循环判断能不能被4整除，更新直到为1；2、大于0且是2的幂乘且排除是2的幂乘不是4的幂乘的数（(num & 0x55555555) != 0）后者不需要循环求解
231. Power of Two：同上，1、循环判断能不能被2整除，更新直到为1；2、return n > 0 && (n & (n - 1)) == 0;或统计1的个数只有1个
371. Sum of Two Integers：return b == 0 ? a : getSum(a ^ b,(a & b) << 1);异或相当于不进位的加法，后面的左移相当于加上进位
461. Hamming Distance：依次比较每一位，不相同则加1
201. Bitwise AND of Numbers Range：m、n同时右移直到相等，然后当前m左移同样的位数
284. Peeking Iterator:利用优先队列，将元素添加进去以后直接求解

训练

**190. Reverse Bits：结果先左移，n再右移
**405. Convert a Number to Hexadecimal：类比二进制，每4位是一个字符，循环拼接后翻转
**338. Counting Bits：动态规划：res[i]表示数字i有几个1bit，res[i] = res[i >>> 1] + (i & 1)
**477. Total Hamming Distance：统计每一位上有几个1，几个0，乘积即为这一位上的距离
397. Integer Replacement：两种方法：1、若是偶数则除2，是奇数则取n - 1和n + 1中bit1少的那个，若是3只能取2；2、递归求解，注意考虑负数和越界。前者效率高
318. Maximum Product of Word Lengths：两种方法：1、利用抽屉法判断两个字符串是否有相同字符，依次更新最大值；2、构造数组存每个字符串对应的整型值，判断整型值作与运算是否为0，更新最大值，后者效率高很多
208. Implement Trie (Prefix Tree)：利用字典树，下次训练尝试将类成员变成string

提示

1、统计bits中1的个数：n = n & (n - 1)
2、==的优先级高于逻辑运算
3、当出现一组数思考能不能通过全局观察得到解决方法
4、利用bit manipulation将字符串转化成整型判断有没有相同的字符：val[i] |= (1 << (words[i].charAt(j) - 'a'));