Binary Watch

A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes (0-59).

Each LED represents a zero or one, with the least significant bit on the right.

For example, the above binary watch reads "3:25".

Given a non-negative integer n which represents the number of LEDs that are currently on, return all possible times the watch could represent.

Example:

Input: n = 1
Return: ["1:00", "2:00", "4:00", "8:00", "0:01", "0:02", "0:04", "0:08", "0:16", "0:32"]

Note:

• The order of output does not matter.
• The hour must not contain a leading zero, for example "01:00" is not valid, it should be "1:00".

• The minute must be consist of two digits and may contain a leading zero, for example "10:2" is not valid, it should be "10:02".

思路：就是backtracking，难点在于有两个array，要联合起来进行backtracking。刚开始我的结果出现了12：00，发信去问了leetcode的admin，回信说题目要求hours只表示0-11点，也就是说这个电子表，4和8不能同时亮起来。确实比较恶心吧，为了test case来限定条件，我觉得现实生活中哪里有表不能表示12点多的？不管了，改进就是最后收集result的时候，要进行判断，hnum <=11, mnum <=59. 也就按照条件来了。

public class Solution {
    public List<String> readBinaryWatch(int num) {
        List<String> list = new ArrayList<String>();
        
        int[] hours = {1,2,4,8}; 
        boolean[] hvisited = new boolean[hours.length];
        
        int[] mins = {1,2,4,8,16,32};
        boolean[] mvisited = new boolean[mins.length];
        
        HashSet<String> hashset = new HashSet<String>();
        collect(list,
        hours, 0, 0, 0, hvisited,
        mins, 0, 0, 0, mvisited,
        num, hashset);
        return list;
    }
    
    public void collect(List<String> list,
                        int[] hours, int hindex, int hnum, int hcount, boolean[] hvisited,
                        int[] mins, int mindex, int mnum, int mcount, boolean[] mvisited,
                        int num, HashSet<String> hashset) {
        if(hcount + mcount == num) {
            StringBuilder sb = new StringBuilder();
            sb.append( hnum == 0 ? "0:" : hnum +":");
            sb.append(mnum == 0 ? "00" : mnum >=10 ? mnum : "0"+mnum);
            String res = sb.toString();
            if(!hashset.contains(res) && hnum <=11 && mnum <= 59){
                hashset.add(res);
                list.add(res);
            }
            return;
        }
        for(int i=hindex; i<hours.length; i++){
            for(int j=mindex; j<mins.length; j++){
                if(!hvisited[i] ){
                    hvisited[i] = true;
                    hnum += hours[i];
                    hcount++;
                    if(hcount + mcount <= num){
                        collect(list, hours, i, hnum, hcount, hvisited, mins, j, mnum,mcount, mvisited, num, hashset);
                    }
                    hcount--;
                    hnum -= hours[i];
                    hvisited[i] = false;
                }
                if(!mvisited[j]){
                    mvisited[j] = true;
                    mnum += mins[j];
                    mcount++;
                    if(hcount + mcount <= num){
                        collect(list, hours, i, hnum, hcount, hvisited, mins, j, mnum,mcount, mvisited, num, hashset);
                    }
                    mcount--;
                    mnum -= mins[j];
                    mvisited[j] = false;
                }
            }
        }
    }
}

网上搜了一下，更牛逼的解法，直接跪拜了。用bit来做，简直了。https://discuss.leetcode.com/topic/59374/simple-python-java

确实能想到1,2,4,8都是2的整数倍，每个数都只有1个bit，那么就是搜索所有的解空间，看那几个数的bit之和等于num，不过谁能想到Integer有bitCount这个method呢？不过这个人确实牛逼！ %02d，0表示数字前面补0.

public class Solution {
    public List<String> readBinaryWatch(int num) {
       List<String> list = new ArrayList<String>();
       if(num < 0) return list;
       for(int h=0; h<12; h++){
           for(int m=0; m<60; m++){
               if(Integer.bitCount(h) + Integer.bitCount(m) == num){
                   list.add(String.format("%d:%02d",h,m));
               }
           }
       }
       return list;
    }
}