LeetCode - Single Number II

题注

这开学以后，论文阅读和撰写的压力就慢慢上来了。确实，既能够保证编程水平不下降（或者提升），又能够保证理论上的深入性，是一件非常困难的事情啊。我的偶像Dan Boneh，实际上是一个完全不会代码的人… 他的一个准学生Brent Waters也是不懂代码（Waters好多论文的运行时间是从理论时间估计出来的，或者是别人帮他实现的）。Graig Gentry算是Boneh学生里面理论最厉害的了，论文一大堆！但是他也是一点代码都不懂…

我短期的理想是将把在论文中的密码学应用到实际中，所以两手抓两手都要硬，真是困难啊… 以后争取每天回家花点时间哪怕做一道LeetCode的题呢，虽然工程类的编程能力肯定会下降（因为OO的概念快被磨没了嘛，而且一些库函数也快不会用了…），但是代码本身的感觉还在，而且提高算法能力也对看论文有好处吧！

题目

Given an array of integers, every element appears three times except for one. Find that single one.

Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

分析和代码

解法一：HashMap

这道题，一种非常直观的办法是用Hash Map或者Map来做。Map中的Key用数组中各个元素值来表示，Map中的Value表示每个数字出现的次数。也就是说，我们构造了一个O(n)空间复杂度的计数器，分别记录每一个元素出现的次数，最后用一次O(n)的检索，来看计数器中哪一个是1即可。

这种方法很直观，时间复杂度和空间复杂度都为O(n)，但是这是一个通用解法，可以应用在所有这类问题中。举个例子：如果题目变为，给定一个整数数组，每一个元素出现了m次，只有一个元素出现过n次，找到这一个元素。那么这种Map的方法也可以使用。因此，我个人认为在实际应用中，我们应该考虑这种通用的解决方法，虽然效率不会达到最高，但是很具有代表性。

解法一代码

public class Solution {
    public int singleNumber(int[] A) {
    	int result;
        //check the validity of input array
        if(A.length < 1 || A.length % 3 != 1){
            return -1;
        }
        HashMap<Integer,Integer> countMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < A.length; i++){
        	// if countMap does not contain value with key i, add a new element
        	if (!countMap.containsKey(A[i])){
        		countMap.put(A[i], 1);
        	} else {
        		countMap.put(A[i], countMap.get(A[i]) + 1);
        	}
        }
        
        //finding values with count number equals 1
        Iterator<Map.Entry<Integer, Integer>> iterator = countMap.entrySet().iterator();  
        while (iterator.hasNext()) {  
            Map.Entry<Integer, Integer> entry = iterator.next();  
            if (entry.getValue() != 3) {  
                result = entry.getKey();  
                return result;
            }  
        }
        return -1;
    }
}

解法二：按位记录

既然我们可以构造一个O(n)长的计数器，我们能不能取而代之，弄一个O(1)长的计数器呢？当然可以。思路是：我们把每一个数看成二进制的，分别考虑二进制数的每一位。假定我们现在考虑第i位，如果一个数出现过3次，那么无论这个数第i位为0还是为1，出现0和1的次数都为3；但是，如果一个数只出现过1次，且这个数第i位为1，那么1只能出现1次。因此，我们分别考察每一位数中，1出现的次数是否能被3整除。

（1）如果不能整除，那么只出现1次的这个数第i位必定为1。

（2）如果能整除，那么只出现1次的这个数第i位必定为0。

这样，我们循环32次（因为Java中int的长度为32位），按位计算1出现的次数并除以3取余数，并把这32个结果按照高低位拼接起来，拼接的结果就是正确的结果了。由于我们只用到3个int临时变量，以及需要1个result返回结果，其空间复杂度为O(1)。时间复杂度不变，为O(n)。实际上，因为我们对每一位都记了一次数，因此其准确的时间复杂度为32n。

解法二代码

public class Solution {
    public int singleNumber(int[] A){
        int i, j, bitCount;
        int result = 0;  
        
        for (i = 0; i < 32; i++) {
            bitCount = 0;
            
            // add every i-th bit of the integers into bitCount
            for (j = 0; j < A.length; j++) {  
                bitCount += (A[j] >> i) & 1;
            }  
            bitCount = bitCount % 3;  
            // switch to the right position and add it to the result
            result += bitCount << i;  
        }  
        return result;  
    }
}

解法二的通用解法

解法二是不是一个通用解法呢？如果题目变为，给定一个整数数组，每一个元素出现了m次，只有一个元素出现过1次，找到这一个元素。我们可以用类似的方法做，只不过计算1出现的次数除以m取余数即可。如果只有一个元素出现过n次，那么，我们先判断每一位的计数器是否能够整除m，如果不能，那么那个特殊的数的这一位一定为1（只有特殊数这一位为1才会导致结果不能整除m）。因此，这是一个通用的解法。

通用解法代码

public class Solution {
	/**
	 * Given an array of integers, every element appears m times except for one that appears n times. 
	 * Find that single one.
	 * @param A array of integers
	 * @param m every element except one appears m times
	 * @param n special one appears n times
	 * @return the special integer
	 */
	public int singleNumber(int[] A, int m, int n){
		int i, j, bitCount;
		int result = 0;  
		
	    for (i = 0; i < 32; i++) {
	    	bitCount = 0;
	    	
	    	// add every i-th bit of the integers into bitCount
	        for (j = 0; j < A.length; j++) {  
	        	bitCount += (A[j] >> i) & 1;
	        }  
	        if (bitCount % m != 0){
	        	bitCount = 1;
	        } else {
	        	bitCount = 0;
	        }
	        // switch to the right position and add it to the result
	        result += bitCount << i;  
	    }  
	    return result;  
	}
}