剑指offer(40~42)数组中只出现一次的数字--和为S的连续正数序列--和为S的两个数字

数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。

思路分析1:可以应对数组元素相对集中的实例
我采用辅助数组存储每一个数字出现的次数，然后遍历辅助数组，找出出现一次的元素。思路简单，复杂度$O(n)$，但是如果这个数组的的最大值很大，是0x7F FF FF FF，最小值很小，是0。那么这个辅助数组占用的空间就是2G，这明显不现实。尽管这种方法通过了牛客网的OJ，只能说明牛客网的测试用例数组元素相对集中。这种方法不能应对这样的题目。

class Solution {
public:
	void FindNumsAppearOnce(vector<int> data, int* num1, int *num2) {
		int max = data[0], min = data[0];
		for (size_t i = 0; i<data.size(); i++)
		{
			if (data[i]>max)
				max = data[i];
			if (data[i]<min)
				min = data[i];
		}

		vector<int> hash(max - min + 1);
		for (size_t i = 0; i<data.size(); i++)
			hash[data[i] - min]++;

		int tmp = 0;
		for (size_t i = 0; i<hash.size(); i++)
		{
			if (hash[i] == 1)
			{
				if (tmp == 0)
				{
					tmp = i + min;
					*num1 = tmp;
				}
				else
					*num2 = i + min;
			}
		}
	}
};

思路分析2:正确做法
我们知道相同的两个数的二进制位肯定全都相同，这样出现偶数次的数值与自己亦或结果为0。那如果将整个数组的元素挨个亦或之后的结果ret就只是出现一次的那两个数亦或的结果了。对于ret的二进制位中为1的那个位index1，num1和num2的index1位一定一个是0，一个是1。那么再次去遍历数组，如果数组元素的index1为1，*num1^data[i]，否则*num2^data[i]，就能得到num1和num2。

class Solution {
public:
	void FindNumsAppearOnce(vector<int> data, int* num1, int *num2) {
		if (data.size()<2)
			return;

		int ret = 0;
		for (size_t i = 0; i<data.size(); i++)
			ret ^= data[i];

		size_t index1 = FindFirst1(ret);
		*num1 = *num2 = 0;
		for (size_t j = 0; j<data.size(); j++)
		{
			if (Is1(data[j], index1))
				*num1 ^= data[j];
			else
				*num2 ^= data[j];
		}
	}
	size_t FindFirst1(int num)
	{
		size_t index1 = 0;
		while ((index1<32) && ((num&1) == 0))
		{
			num = num >> 1;
			index1++;
		}
		return index1;
	}
	bool Is1(int num, size_t index1)
	{
		num = num >> index1;
		return (num & 1);
	}
};

牛客网链接

和为S的连续正数序列

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序。

思路分析$O(n^2)$的做法
连续整数序列的起始元素肯定不重复。比如，除过18,19,20,21,22外，再也找不到以18开始的序列和为100了。那么我只需要从1开始去判断这个数是开始有没有序列和等于sum，如果有存储就push进ret二维数组中。

class Solution {
public:
    vector<vector<int> > FindContinuousSequence(int sum) {
        vector<vector<int>> ret;
        vector<int> one;
        for(int i=1;i<sum;i++)
        {
            one.clear();
            if(IsSequence(one,sum,i))
                ret.push_back(one);
        }
        return ret;
    }
    
    bool IsSequence(vector<int>& one,int sum,int i)
    {
        bool is=false;
        int add=0;
        for(;add<sum;i++)
        {
            one.push_back(i);
            add+=i;
        }
        if(add==sum)
        {
            is=true;
            return is;
        }
        return false;
    }
};

思路分析$O(n)$的做法

class Solution {
public:
	vector<vector<int> > FindContinuousSequence(int sum) {
		vector<vector<int>> ret;
		int small = 1, big = 2;
		int cur = 3;
		while (small<big&&big<sum)
		{
			if (cur<sum)
			{
				big++;
				cur += big;
			}
			else if (cur>sum)
			{
				cur -= small;
				small++;
			}
			else
			{
				int len = big - small + 1;
				vector<int> one(len);
				for (int i = 0; i < len; i++)
					one[i] = small + i;

				ret.push_back(one);

				big++;
				cur += big;
			}
		}
		for (size_t i = 0; i < ret.size(); i++)
		{
			for (size_t j = 0; j < ret[i].size(); j++)
				cout << ret[i][j];
			cout << endl;
		}
		return ret;
	}
};

牛客网链接

和为S的两个数字

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。

思路分析：
一开始我在想这有什么难的呢？定义两个下标，由数组两端向中间遍历，定义一个mul变量用于存储最小乘积，mul初始值等于array[array.size()-1]。如果和小于sum，++begin，如果和大于sum，–end，如果等于sum，如果两个数乘积还小于mul，那么更新mul，更新这两个数。结果不很如意，未能达到时间要求。
后来取消了mul这个变量，一旦出现两数之和等于sum，那么往后再出现的数值乘积都不会小于第一次出现的这两个数了。

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        int begin=0,end=array.size()-1;
        vector<int> ret;
        int cur=0;
        while(begin<end)
        {
            cur=array[end]+array[begin];
            if(cur<sum)
                begin++;
            else if(cur>sum)
                end--;
            else
            {
                ret.push_back(array[begin]);
                ret.push_back(array[end]);
                return ret;
            }
        }
        return ret;
    }
};

牛客网链接