华为oj 寻找等差数列

本题提供两种解法：

1.找到首尾之间的所有的素数形成一个数组prime，那么这个数组形成的等差数列中，公差最大的的就是这个数列首尾数字的差值，对公差从1到最大值进行循环，找到数列中公差等于上述范围的所有数列，找到数列包含数字最多的就可以了，时间复杂度O（kn^2）。

#include<iostream>
using namespace std;
int prime[200];
int Count = 0;
void getPrime(int m, int n)
{
	int flag = false;
	for (int i = m; i <= n; i++)
	{
		if (i == 1)
		{
			continue;
		}
		for (int j = 2; j*j <= i; j++)
		{
			if (i%j == 0)
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			prime[Count] = i;
			Count++;
		}
		else
		{
			flag = false;
		}
	}
}
int main()
{
	int start, end, temp, val = 0, sum = 1, max = 0;
	int result[100];
	int out[100];
	cin >> start >> end;
	if (start<0 || end<0 || start>end)
	{
		return 0;
	}
	getPrime(start, end);
	if (Count>1)
	{
		temp = prime[1];
	}
	else if (Count == 1)
	{
		cout << prime[0] << endl;
	}
	else
	{
		return 0;
	}
	temp = prime[Count - 1] - prime[0];
	for (int k = 1; k <= temp; k++)
	{
		for (int i = 0; i < Count - 1; i++)
		{
			val = i;
			result[0] = prime[i];
			for (int j = i + 1; j < Count; j++)
			{
				if ((prime[j] - prime[val]) == k)
				{
					val = j;
					result[sum] = prime[j];
					sum++;
				}
			}
			if (max<sum)
			{
				max = sum;
				for (int i = 0; i < sum; i++)
				{
					out[i] = result[i];
				}
			}
			sum = 1;
		}
	}

	for (int i = 0; i < max; i++)
	{
		cout << out[i];
		if (i != max - 1)
		{
			cout << " ";
		}
	}
	return 0;
}

2.采用动态规划的方法，找到首尾之间的所有的素数形成一个数组nums，设 dp[i][diff]表示以 i 结尾，公差是diff 的数列包含的元素个数，若元素k<i,那么我们可以知道,如果nums[i]-nums[k]==diff,那么dp[i][diff] = dp[k][diff]+1;

#include<iostream>
using namespace std;

int getPrime(int start, int end, int *nums)
{
	int flag = 1, count = 0, i, j;

	if (start <= 1)
	{
		start = 2;
	}

	for (i = start; i <= end; i++)
	{
		for (j = 2; j*j < i; j++)
		{
			if (i%j == 0)
			{
				break;
			}
		}
		if (i<j*j)
		{
			*(nums + count) = i;
			count++;
		}

	}
	return count;
}

int main()
{
	int dp[500][500], nums[100], len[100];
	int start, end, size, max, i, j, t, p;

	//初始化
	memset(dp, 0, sizeof(int)*500*500);
	memset(nums, 0, sizeof(int)* 100);
	memset(len, 0, sizeof(int)* 100);

	cin >> start >> end;
	max = -1;
	size = getPrime(start, end, nums);

	//动态规划
	for (i = 1; i<size; i++)
	{
		for (j = i - 1; j >= 0; j--)
		{
			int diff = nums[i] - nums[j];
			dp[i][diff] = dp[j][diff] + 1;

			if (dp[i][diff]>max)
			{
				max = dp[i][diff];
				end = i;
				t = diff;
			}
			else if (dp[i][diff] == max)
			{
				if (t < diff)
				{
					max = dp[i][diff];
					end = i;
					t = diff;
				}
			}

		}
	}

	//输出
	p = nums[end];

	for (int k = max; k >= 0; k--)
	{
		cout << p - k*t << endl;
	}
	return 0;
}

结论：动态规划还需要多练多思考！！！