Single Number II

最新推荐文章于 2022-07-02 13:41:47 发布

wjz748305545

最新推荐文章于 2022-07-02 13:41:47 发布

阅读量578

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/wu_george/article/details/19508087

版权

LeetCode 专栏收录该内容

136 篇文章 0 订阅

订阅专栏

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?

题意为：给定一个数组A[n]，其中只有一个元素出现一次，其余都出现3次，求出这个出现一次的奇葩

要求：线性时间，能否不用额外的空间

碰到这类题，我的第一想法都是用位运算来解决，算是定式思维吧！

1、把每个元素都转为二进制，用B[100]来存储，所谓存储是遍历元素A[i]的带符号的二进制位（如：-6，则为-1，-1，0），将该位的值加到B的相对应位。

2、然后遍历B[]，若B[i]%3==1则计算出该位对应的十进制值并叠加，后来才发现没有考虑为负的情况，条件应该为B[i]%3!=0

3、简单的以为可以了，没想到碰到大数的时候，会出现错误。。。明天继续，该熄灯了

用例：

Submission Result: Wrong Answer

Input:	[43,16,45,89,45,-2147483648,45,2147483646,-2147483647,-2147483648,43,2147483647,-2147483646,-2147483648,89,-2147483646,89,-2147483646,-2147483647,2147483646,-2147483647,16,16,2147483646,43]
Output:	-2147483393
Expected:	2147483647

错误代码如下：

int singleNumber(int A[], int n) {
   int b[100]={0}, i, num=0;
    for(i=0; i<n; i++){
		int temp = A[i];
		
		int j=0;
		while(temp){
			int res = temp%2;
			temp /= 2;
			b[j++] += res;
		}
		if(j > num) num = j-1;
	}
	//
	int sum = 0;
	for(i=num; i>=0; i--){
			int res = b[i]%3;
			if(res != 0){
			int bv = res>0 ? 1 : -1 ;
			for(int j=0; j<i; j++) bv *= 2;
			sum += bv;
		}
	}	
	return sum;
}

续上：

仔细看看，2^100足够大了，不可能是大数问题，一定是我的某个地方出了什么问题。

果然，

int res = b[i]%3;
if(res != 0){
int bv = res>0 ? 1 : -1 ;

这几句话有问题，因为只是简单考虑余数为负或正的情况，

但是余数为1或-2的情况是一样的，那就是该位为1；

而余数为2或-1的情况也是一样的，那就是该位为-1；

修改为：

int res = b[i]%3;
if(res != 0){
int bv = (res==-2 || res == 1)  ? 1 : -1 ;

   一提交就可以了，OK！
   完整代码如下：

int singleNumber(int A[], int n) {
   int b[100]={0}, i, num=0;
    for(i=0; i<n; i++){
		int temp = A[i];
		
		int j=0;
		while(temp){
			int res = temp%2;
			temp /= 2;
			b[j++] += res;
		}
		if(j > num) num = j-1;
	}
	//
	int sum = 0;
	for(i=num; i>=0; i--){
			int res = b[i]%3;
			if(res != 0){
			int bv = (res==-2 || res == 1)  ? 1 : -1 ;
			for(int j=0; j<i; j++) bv *= 2;
			sum += bv;
		}
	}	
	return sum;
}

实现了自己的想法之后，再去看别人的实现，突然感觉自己弱爆了。虽然思维是位计算没错，但是别人的位计算才是真位计算。比如：用移位来替代除法运算，还有其它“或”、“异或”，我根本就没有用的意识。。。

实现一：http://blog.csdn.net/wzy_1988/article/details/17100659

位运算

java里int始终占4个字节，32位，我们外层循环遍历32次，然后内层循环记录0-31位每一位出现的次数，内层循环结束后将结果取余于3即为当前位的值

时间复杂度O(32 * n), 空间复杂度O(1)

/**
 * 利用位运算和取余实现
 * 
 * @param A
 * @return
 */
public static int singleNumberII(int[] A) {
    int i, j, bit, result = 0;

    for (i = 0; i < 32; i++) {
        for (j = bit = 0; j < A.length; j++) {
            if (((A[j] >> i) & 1) == 1) {
                bit++;
            }
        }

        bit = bit % 3;

        result |= bit << i;
    }

    return result;
}

实现二： http://www.cnblogs.com/x1957/p/3373994.html

Single Number的加强班

有n个数字，除了一个只出现过一次，其他的都出现了3次！

出现两次我们知道就是xor下就木有啦，那3次怎么搞？

我们还是用二进制位的方式来思考。

那么这些位，除去出现过一次的那个后，其他的都是3的倍数！－－我们把所有位1的个数mod 3，那么剩下的就是只出现过一次那个啦。

我们也没必要开个啥 int bit[32]的数组去统计的

＝＝我们来模拟二进制加法

用两位来计数，到3就把该位清零。

bit2 bit1

bit1 如果该位来的是1 ，保持0,1,0,1。。。（也就是xor），如果是0就不变

当bit1＝1的时候再来一个1，那么bit2=1

当这两个bit同时为1，说明这是3啦（二进制你想想嘛），该位清零。

class Solution {
public:
    int singleNumber(int A[], int n) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int one = 0;
        int two = 0;
        int three = 0;
        for(int i = 0 ; i < n ; i++){
            two |= A[i] & one;
            one = A[i] ^ one;
            three = ~(one&two);
            one &= three;
            two &= three;
        }
        return one;
    }
};

实现四： http://www.tuicool.com/articles/UjQV7n

题目分析： 对于除出现一次之外的所有的整数，其二进制表示中每一位1出现的次数是3的整数倍，将所有这些1清零，剩下的就是最终的数。用ones记录到当前计算的变量为止，二进制1出现“1次”（mod 3 之后的 1）的数位。用twos记录到当前计算的变量为止，二进制1出现“2次”（mod 3 之后的 2）的数位。当ones和twos中的某一位同时为1时表示二进制1出现3次，此时需要清零。即用二进制模拟三进制计算。最终ones记录的是最终结果。 时间复杂度： O（n） 示例代码：

int singleNumber(int A[], int n) {
    int ones = 0, twos = 0, xthrees = 0;
    for(int i = 0; i < n; ++i) {
        twos |= (ones & A[i]);
        ones ^= A[i];
        xthrees = ~(ones & twos);
        ones &= xthrees;
        twos &= xthrees;
    }

    return ones;
}

扩展一：

给定一个包含n个整数的数组，除了一个数出现二次外所有的整数均出现三次，找出这个只出现二次的整数。ones记录1出现一次的数，twos记录1出现2次的数，容易知道twos记录的即是最终结果。

扩展二：

给定一个包含n个整数的数组，有一个整数x出现b次，一个整数y出现c次，其他所有的数均出现a次，其中b和c均不是a的倍数，找出x和y。使用二进制模拟a进制，累计二进制位1出现的次数，当次数达到a时，对其清零，这样可以得到b mod a次x，c mod a次y的累加。遍历剩余结果（用ones、twos、fours...变量表示）中每一位二进制位1出现的次数，如果次数为b mod a 或者 c mod a，可以说明x和y的当前二进制位不同（一个为0，另一个为1），据此二进制位将原数组分成两组，一组该二进制位为1，另一组该二进制位为0。这样问题变成“除了一个整数出现a1次（a1 = b 或 a1 = c）外所有的整数均出现a次”，使用和上面相同的方式计算就可以得到最终结果，假设模拟a进制计算过程中使用的变量为ones、twos、fours...那么最终结果可以用ones | twos | fours ...表示。