每日一题(24) - 快速寻找满足条件的两个数

题目来自编程之美

题目：给出一个有序数组和一个数字（定值），寻找和为定值的两个数

要求：时间复杂度是O(n)，空间复杂度为O（1）

思想：

（1）针对数组的首尾各设一个游标nCurForward 和 nBackward，并分别指向数组的头和数组的尾。

（2）在程序执行过程中，游标nCurForward往数组尾部走，游标nBackward往数组头走。

如果 nArr[nCurForward] + nArr[nBackward] > sum，此时应该让两数之和变小一些，此时让nBackward--。

如果 nArr[nCurForward] + nArr[nBackward] < sum，此时应该让两数之和变大一些，此时让nCurForward++。

如果 nArr[nCurForward] + nArr[nBackward] = sum，此时输出这两个数。

代码：

#include <iostream>
#include <assert.h>
using namespace std;

void Find(int nArr[],int nLen,int nSum)
{
	assert(nArr != NULL && nLen > 0);
	int nCurForward = 0;
	int nBackward = nLen - 1;
	while (nCurForward < nBackward)
	{
		if (nArr[nCurForward] + nArr[nBackward] < nSum)
		{
			nCurForward++;
		}
		else if (nArr[nCurForward] + nArr[nBackward] > nSum)
		{
			nBackward--;
		}
		else
		{
			cout<<nArr[nCurForward]<<" "<<nArr[nBackward]<<endl;
			nCurForward++;
			nBackward--;
		}
	}
}

int main()
{
	int nArr[7] = {1,3,5,6,9,12,15};
	Find(nArr,7,15);
	system("pause");
}

注意：

如果原数组无序，可有三种方法做：

方法（1）：不排序 + 哈希 + 遍历数组

具体思路：把所有的数均放入哈希中，之后对于每一个元素a，均去哈希查找sum - a。

时间复杂度近似可以看成O（n），空间复杂度O(n)。

注意：这里把哈希探测的平均时间看成O（1）。

方法（2）：排序 + 二分

具体思路：先进行排序，之后对于数组中的每一个元素a，去数组中二分查找sum - a。

时间复杂度为O（nlogn），空间复杂度为O（1）

方法（3）：排序 + 双游标扫描

具体思路：如上述方法

时间复杂度为排序O（nlogn） + 扫描数组O(n)  = O（nlogn）。空间复杂度为O（n）

拓展：

（1）给出一个有序数组和一个数字（定值），寻找和为定值的三个数

则：对于数组中的任意一个数a，可以在数组中寻找和为Sum - a的两个数。

时间复杂度为O(n^2)，空间复杂度为O（1）

代码：

#include <iostream>
#include <assert.h>
using namespace std;

void Find(int nArr[],int nStart,int nEnd,int nNum,int nSum)
{
	assert(nArr != NULL && nStart <= nEnd);
	int nCurForward = nStart;
	int nBackward = nEnd;
	while (nCurForward < nBackward)
	{
		if (nArr[nCurForward] + nArr[nBackward] < nSum)
		{
			nCurForward++;
		}
		else if (nArr[nCurForward] + nArr[nBackward] > nSum)
		{
			nBackward--;
		}
		else
		{
			cout<<nNum<<" "<<nArr[nCurForward]<<" "<<nArr[nBackward]<<endl;
			nCurForward++;
			nBackward--;
		}
	}
}

void Find(int nArr[],int nLen,int nSum)
{
	bool bIsFind = false;
	for (int i = 0;i < nLen - 2;i++)
	{
		Find(nArr,i + 1,nLen - 1,nArr[i],nSum - nArr[i]);
	}
}

int main()
{
	int nArr[7] = {1,3,5,6,9,12,15};
	Find(nArr,7,16);
	system("pause");
}

拓展（2）给出一个有序数组和一个数字（定值），寻找和为定值的多个数

思路：类似01背包，这里是求方案数。这里使用的是二维数组F，当然也可以使用一维数组做。这里省略。

注意：数组F的初始化值

代码：

#include <iostream>
#include <assert.h>
using namespace std;

//状态F[i][j]:表示前i件物品放入总容量为j的背包的方案总数
//状态转移方程：F[i][j] = F[i - 1][j] + F[i - 1][j - nArr[i]] 
//初始状态： F[i][0] = 1 : 和为0，不需要放入背包，此时认为方案为1，其他全为0

const int MAX = 100;
int F[MAX][MAX];

void Knapsack(int nArr[],int nLen,int nSum)
{
	//初始化
	for (int i = 0;i <= nLen;i++)
	{
		for (int j = 0;j <= nSum;j++)
		{
			F[i][j] = 0;
		}
	}
	for (int i = 0;i < nLen;i++)
	{
		F[i][0] = 1;
	}
	//递推
	for (int i = 1;i <= nLen;i++)//枚举物品
	{
		for (int j = 1;j <= nSum;j++)//容量
		{
			F[i][j] = F[i - 1][j];
			if (j >= nArr[i])
			{
				F[i][j] = F[i - 1][j] + F[i - 1][j - nArr[i]];
			}	
			cout<<"i = "<<i<<",j = "<<j<<": "<<F[i][j]<<endl;
		}
	}
	cout<<"总方案数："<<F[nLen][nSum]<<endl;	
}

int main()
{
	int nArr[7 + 1] = {0,1,3,5,6,9,12,15};
	Knapsack(nArr,7,15);
	//五种
	//15
	//6 9
	//3 12
	//1 5 9
	//1 3 5 6
	system("pause");
}