Gray Code

Question: https://leetcode.com/problems/gray-code/

题目：

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.

For example, given n = 2, return [0,1,3,2]. Its gray code sequence is:

00 - 0
01 - 1
11 - 3
10 - 2

Note:
For a given n, a gray code sequence is not uniquely defined.

For example, [0,2,3,1] is also a valid gray code sequence according to the above definition.

For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.

---

 分析：

这里采用了比较经典的 Backtracking。

这里 Assume 当 n 为 0 时，返回的是[0]. 

因为题目中只要求找出一个满足要求的序列就 OK，所以这个题目的题解找寻Solution 数字之间的规律更为 efficient。但是，如果是要求输出全部满足条件的序列 List<List<Integer>>, BackingTrachking 就是正解，只需将 helper 的返回类型变为 void，delete 原 return false/true 处即可。 

public class Solution {
    public List<Integer> grayCode(int n) {
        LinkedList<Integer> res = new LinkedList<>();
        if(n < 0) {
            return res;
        } 
        
        int[] buff = new int[n];
        Set<Integer> set = new HashSet<>();
        set.add(0);
        res.add(0);
        helper(buff, set, res);
        
        return res;
    }
    
    private boolean helper(int[] buff, Set<Integer> set, LinkedList<Integer> res) {
        if(set.size() == (1 << buff.length)) {
            return true;
        }
        
        // for(int i = 0; i < buff.length; i++) {           
        // Both work, but different integer order
        for(int i = buff.length - 1; i >= 0; i--) {
            buff[i] ^= 1;
            int val = toIntVal(buff);
            if(set.contains(val)) {
                buff[i] ^= 1;
                continue;
            }
            
            set.add(val);
            res.add(val);
            
            if(helper(buff, set, res)) {
                return true;
            }
            
            buff[i] ^= 1;
            set.remove(val);
            res.removeLast();
        }
        
        return false;
    }
    
    private int toIntVal(int[] array) {
        int res = 0;
        for(int i : array) {
            res = (res << 1) + i;
        }
        return res;
    }
}    

Solution 2: Referred from Code Ganker.

思路为，假设我们已经找到 f(n) 对应的序列，那么 f(n+1) 对应的序列，the first half 就是 f(n) 对应的序列，即最高位为0；而 second half 是 f(n) 的对应序列的反向，最高位为1. 如此就有了相应的递推关系。

Code并不难写：这里的 Recursion 是可以采用 Iteration 来实现的。

public class Solution {
    public List<Integer> grayCode(int n) {
        ArrayList<Integer> res = new ArrayList<>();
        if(n < 0) {
            return res;
        } else if(n == 0) {
            res.add(0);
            return res;
        } 
        
        res.add(0);
        res.add(1);
        helper(1, n, res);

        return res;
    }
    
    private void helper(int i, int n, ArrayList<Integer> res) {
        if(i == n) {
            return;
        }
        
        int index = (1 << i ) - 1;
        int mask = 1 << i;
        while(index >= 0) {
            res.add(res.get(index) ^ mask);
            index--;
        }
        helper(i+1, n, res);
    }
}