【备战蓝桥杯】USACo--> airpro【改变策略】

编码到现在，我明白了一点。我之所以如此安排自己coding， 说实话就是为了尝试恢复到自己去年上半年时的状态。

但是我发现了，越是想恢复原来那个所谓的巅峰状态，就越发现还差了点东西没有，要么是思想，要么是处理问题的思路，或者平时的行为习惯。

于是我就越想弥补，越发现自己不如以前。

其实不然，我现在与以前的状态已经完全不同，我周围的环境，身边的人也已经完全不同，不能再完全按照原来的路子来。

总之，就是得更新策略。得向前看，纵向比较，我是进步了的。整体都在进步，综合都在进步。

某一方面特别强势，而其他方面的缺失，是不能说明强大的。正如木桶理论的最短板理论。

因此，我只需向前奔跑，不管我以前什么状态，什么思想，什么行为习惯。just do it！

我只管提升现在的知识基础、感情基础、环境基础的我的能力就好，并通过熟练，加以融合。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

下面是我的另外一道题，只完成到一半。目前觉得没有很大必要写下去，留待以后吧。

学会的新的思路：

1、将双平方数，另外coding打表出来；

2、放到测试的程序中作为初始的data使用；

3、接下来就是逻辑安排与分析了。

下面的是auxiliary.c  文件

#include <stdio.h>
#include <stdlib.h>
#define INFINITE 1000

void gene(int *in)
{
	int p,q;
//	FILE *out;
//	out = fopen("square.txt","w");
	int i=0;
	for(p=0 ; p <= 250 ;p++)
	{
		for(q=0 ; q <= 250 ; q++)
		{
			//printf("%d,",p*p+q*q);
			in[i++] = p*p+q*q;
		}
	}
	printf("%d",i);
}

void quick(int *in,int l ,int r)
{
	if( l < r )
	{
		int i= l ,j =r, x= in[l];
		while(i < j)//内部判断的都是i和j 
		{
			while( i < j && in[j] >= x )
			j--;
			if(i < j )
			in[i++] = in[j];
			while(i < j && in[i] < x)//注意这个等号可以不要 
			i++;
			if(i < j)
			in[j--] = in[i];
		}
		in[i] = x;
		quick(in,l ,i-1);//注意这里的分界点是i，不是r，下面也是 
		quick(in, i+1 ,r);
	}
}

/*
void quick(int *node,int l,int r)  
{  
    if (l < r)      
    {      
        //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1      
        int i = l, j = r,x = node[l];
        while (i < j)      
        {      
            while(i < j && node[j] >= x) // 从右向左找第一个小于x的数      
                j--;        
            if(i < j)       
                node[i++] = node[j];      
                  
            while(i < j && node[i] < x) // 从左向右找第一个大于等于x的数      
                i++;        
            if(i < j)       
                node[j--] = node[i];      
        }      
        node[i] = x;      
        quick(node, l, i - 1); // 递归调用       
        quick(node, i + 1, r);      
    }    
} */

void merge(int *a,int start,int mid,int end)  
{  
    int i,j,k;  
    //申请辅助数组  
    int *array1=(int *)malloc(sizeof(int)*(mid-start+2));  
    int *array2=(int *)malloc(sizeof(int)*(end-mid+1));  
  
    //把a从mid分开分别赋值给数组  
    for(i=0;i<mid-start+1;i++)  
        *(array1+i)=a[start+i];  
    *(array1+i)=INFINITE;//作为哨兵  
    for(i=0;i<end-mid;i++)  
        *(array2+i)=a[i+mid+1];  
    *(array2+i)=INFINITE;  
    //有序的归并到数组a中  
    i=j=0;  
    for(k=start;k<=end;k++){  
        if(*(array1+i) > *(array2+j)){  
            a[k]=*(array2+j);  
            j++;  
        }  
        else{  
            a[k]=*(array1+i);  
            i++;  
        }  
    }  
    free(array1);  
    free(array2);  
}  
  
//归并排序  
void mergeSort(int *a,int start,int end)  
{  
    int mid=(start+end)/2;  
    if(start<end){  
        //分解  
        mergeSort(a,start,mid);  
        mergeSort(a,mid+1,end);  
        //合并  
        merge(a,start,mid,end);  
    }  
}  

int clear(int *in,int *out)
{
	int i,j=0;
	for(i=0 ; i < 251*251-1; i++)
	{
		if(in[i+1] !=in[i])
		{
			out[j++] = in[i];
		}
	}
	out[j++] = in[i];
	return j;
}
void print(int *out,int len)
{
	FILE *fout;
	fout = fopen("squ.txt","w");
	int i;
	for(i=0 ; i< len ; i++)
	{
		fprintf(fout,"%d,",out[i]);
	}
	fclose(fout);
}

int main()
{
	int square[251*251];
	int out[251*251];
	int len;
	gene(square);
	printf("gene is all done!");
	//mergeSort(square,0,251*251-1);  
	quick(square,0,251*251-1);
	printf("quick is all done!");
	len = clear(square,out);
	printf("clear is all done!");
	print(out,len);
	printf("this is all done!\n--%d",251*251-1);
	return 0;
}

下面是部分测试coding。arc.c

/*
1 5 9 13 17 
【我的思路】
1、预先用程序打出一张双平方数表， 最大250平方 +  250平方
2、利用折半查找搜索题目要求的数据范围。 (或者就一直取数判断，当取到的数大于限制的时候就停止)
3、从数组的步长开始逐个尝试，是否符合方差长度的组合。
1 2 4 5 8 
4、排序结果，输出。 
*/
#include <stdio.h>
int squ[21047]={0,1,2,……};//太多了。省略。网页已经无法保存
int mark(int max)
{
	int i;
	for(i=0 ; i< 21047 ; i++)
	{
		if( squ[i]==max*max*2)
			return i;
	}
	
	/*
	int max2 = max*max*2;
	int beg=0,end = 21046;
	int mid = (beg+end)/2;
	while( squ[mid]!= max2 )
	{
		if( max2 < squ[mid])
		{
			end = mid;
		}
		else
		{
			beg = mid;
		}
	}
	return mid;
	*/
}

int main()
{
	int len,max;
	scanf("%d",&len);
	scanf("%d",&max);
	//获取最大值的数组下标 
	int poi = mark(max);

	int i,step=1;
	int count,dis,beg;
	//方差从1开始， 一个一个实验，寻找 大于等于该方差的 下标
	//1、如果找到了本串， （待优化，继续判断的增加），则从本串开始的下一个下标开始；
	//2、没找全，也继续 同上
	//方差直到 小于 max*max
	//下标直到 小于poi
	for( dis=1 ; dis < max*max ; dis++)
	{
		beg=0;
		count=1;
		for( i=1; beg+i < poi ; i++)
		{
			for( ; squ[beg+i]-squ[beg+i-1]<dis && beg+i < poi; i++);
			if( squ[beg+i]-squ[beg+i-1]==dis)
			{
				count++;
			}
			else
			{		
				
				count=1;
				beg++;
				i=0;
			}
			if( count==len)
			{
				printf("%d %d\n",squ[beg],dis);
				count=1;
				beg++;
				i=0;
			}
		}
	} 
	return 0;
}