Arithmetic Progressions

最新推荐文章于 2022-04-25 10:51:53 发布

iby07

最新推荐文章于 2022-04-25 10:51:53 发布

阅读量610

点赞数

分类专栏： USACO 文章标签： output search 算法 integer file struct

本文链接：https://blog.csdn.net/iby07/article/details/6103189

版权

USACO 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Problem：

Arithmetic Progressions

An arithmetic progression is a sequence of the form a, a+b, a+2b, ..., a+nb where n=0,1,2,3,... . For this problem, a is a non-negative integer and b is a positive integer.

Write a program that finds all arithmetic progressions of length n in the set S of bisquares. The set of bisquares is defined as the set of all integers of the form p² + q² (where p and q are non-negative integers).

TIME LIMIT: 5 secs

PROGRAM NAME: ariprog

INPUT FORMAT

Line 1:	N (3 <= N <= 25), the length of progressions for which to search
Line 2:	M (1 <= M <= 250), an upper bound to limit the search to the bisquares with 0 <= p,q <= M.

SAMPLE INPUT (file ariprog.in)

5
7

OUTPUT FORMAT

If no sequence is found, a singe line reading `NONE'. Otherwise, output one or more lines, each with two integers: the first element in a found sequence and the difference between consecutive elements in the same sequence. The lines should be ordered with smallest-difference sequences first and smallest starting number within those sequences first.

There will be no more than 10,000 sequences.

SAMPLE OUTPUT (file ariprog.out)

/*
ID:Iby071
PROG:ariprog
LANG:C++
*/

#include<iostream>
#include<fstream>
using namespace std;

int divide(int a[],int low,int high)
{	int k=a[low];
	do
	{	while(low<high && a[high]>=k) --high;
		if(low<high) {a[low]=a[high];++low;}
		while(low<high && a[low]<=k) ++low;
		if(low<high) {a[high]=a[low];--high;}
	}while(low!=high);
	a[low]=k;
	return low;
}

void quickSort(int a[],int low,int high)
{	int mid;
	if(low>=high) return;
	mid=divide(a,low,high);
	quickSort(a,low,mid-1);
	quickSort(a,mid+1,high);
}

//生成所有p，q属于[0，m]的双平方数，存入Bisquare数组中，并在isBisquare数组中标记之
void SetBisquare(bool isBisquare[],int m,int Bisquare[],int &length)
{	length=0;
	int tmp;
	for(int p=0;p<=m;++p)
		for(int q=p;q<=m;++q)			//Note：q从p开始取，循环总量可以减少一半
		{	tmp=p*p+q*q;
			isBisquare[tmp]=true;
			Bisquare[length]=tmp;
			++length;
		}
	quickSort(Bisquare,0,length-1);
}

//判断是否存在a为首元素，b为差，n为元素个数的等差数列
bool JudgeAB(bool isBisquare [],int a,int b,int n)
{	for(int i=1;i<n;++i)
		if(!isBisquare[a+i*b]) return false;
	return true;
}

int main()
{	ifstream fin("ariprog.in");
	ofstream fout("ariprog.out");
	bool *isBisquare;
	int Bisquare[126002];				//126002=2*251*251
	bool flag=false;					//是否存在这样的等差数列
	int n,m,max,length;

fin>>n>>m;
	max=2*m*m;
	isBisquare=new bool [max+1];
	for(int i=0;i<max;++i) isBisquare[i]=false;

SetBisquare(isBisquare,m,Bisquare,length);
	
	for(int b=1;b<=Bisquare[length-1]/(n-1);++b)		//剪枝1：（n-1）*b<=最大的双平方数
	{	int last=-1;
		for(int i=0;Bisquare[i]+(n-1)*b<=max;++i)		//剪枝2：a自身必然取双平方数
			if(Bisquare[i]!=last && JudgeAB(isBisquare,Bisquare[i],b,n))		//Biquare数组中，仍然可能存在相等的项，经quickSort后，它们必紧紧相邻
			{	fout<<Bisquare[i]<<' '<<b<<endl;
				flag=true;
				last=Bisquare[i];
			}
	}

if(!flag) fout<<"NONE/n";

return 0;
}

MY GAIN:
一开始的算法糟糕透了。
1.并不是生成好双平方数然后依次去检验。
而是从0到max对a和b用两层循环去不断生成等差数列，然后一一去check是否为双平方数。算是穷举吧T T
举个例子，当n=18，m=100，max=2*100*100，这种算法所需的时间近,18*20000*20000=7.2*10^9 >> 2000000（穷举法使用范围）。
2.也没有使用快排。
而直接用了STL的优先级队列。一个struct类型数组保存a和b数对。先对b依次入了队，出队后再对相同b的a入队。

现在使用的这个算法是在别人的博客里学来的，基本思想如下：
1.对[0，m]范围之内的p，q生成所有双平方数，保存在Bisquare数组中，并建立了一个2*m*m+1大小的数组isBisquare来保存每个数是否为双平方数（便于检验ab）。
这里应当注意的是，new出来的bool数组默认值是true，要一一手动赋值。
2.对Bisquare数组快速排序。这即是对a的排序。
另外应注意到，Bisquare数组中其实是可能有重复元素的。经过快排，它们也移动到一起，便于后来skip之。
3.因为先对b排序，再对a排序，所以外层循环是b，内层是a。
为了保证等差数列最大元素a+（n-1）*b<=max，必须有（n-1）*b<=max。是b的循环条件。
而等差数列第一个元素即为a，故a根本不需从0到max-1依次++，只需要a依次是Bisquare中的元素即可。
由于有相等元素，需要用一个last来进行比较，skip相等的元素值。last的初始化位置需要注意。
4.判断a和b是否满足条件，满足则输出。