个人复习：带技巧的搜索（1）

最新推荐文章于 2022-02-21 16:58:44 发布

原创最新推荐文章于 2022-02-21 16:58:44 发布 · 292 阅读

0 ·

CC 4.0 BY-SA版权

学习同时被 2 个专栏收录

8 篇文章

订阅专栏

其他OJ网址

6 篇文章

订阅专栏

本文解析了一道算法题，题目要求通过已知的最终数值逆向求出初始排列，涉及字典序最小解的概念及实现方法。文章详细介绍了算法思路、剪枝技巧和优化手段。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目传送门

写出一个11至NN的排列a_iai，然后每次将相邻两个数相加，构成新的序列，再对新序列进行这样的操作，显然每次构成的序列都比上一次的序列长度少11，直到只剩下一个数字位置。下面是一个例子：

3,1,2,43,1,2,4

4,3,64,3,6

7,97,9

1616

最后得到1616这样一个数字。

现在想要倒着玩这样一个游戏，如果知道NN，知道最后得到的数字的大小sumsum，请你求出最初序列a_iai，为11至NN的一个排列。若答案有多种可能，则输出字典序最小的那一个。

[color=red]管理员注：本题描述有误，这里字典序指的是1,2,3,4,5,6,7,8,9,10,11,121,2,3,4,5,6,7,8,9,10,11,12

而不是1,10,11,12,2,3,4,5,6,7,8,91,10,11,12,2,3,4,5,6,7,8,9[/color]

输入输出格式

输入格式：

两个正整数n,sumn,sum。

输出格式：

输出包括11行，为字典序最小的那个答案。

当无解的时候，请什么也不输出。（好奇葩啊）

输入输出样例

输入样例#1：

4 16

输出样例#1：

3 1 2 4

说明

对于40\%40%的数据，n≤7n≤7；

对于80\%80%的数据，n≤10n≤10；

对于100\%100%的数据，n≤12,sum≤12345n≤12,sum≤12345。

分析：

分析题目：每次合并两个数字，最后合并为一个数字，画出从上到下的示意图：

n=3的时候：
假设序列为：1 2 3

(1) (2) (3)

(1+2) (2+3)

(1+2+2+3)

1、3，重复加1次，2重复加2次

1:1

2:2

3:3

n=4:

假设序列为：1 2 3 4

(1) (2) (3) (4) // 1:1 2:1 3:1 4:1

(1+2) (2+3) (3+4) // 1:1 2:1 每一组都单独看第一层

(1+2*2+3) (2+3*2+4) //1:1 2:2 3:1 第二层

(1+2*3+3*3+4) //1:1 2:3 3:3 4:1 第三层

我们可以看出最外面我一层永远只会加一次，并且下面一层由上面一层得出

最一个和最后一个都只重复1次

第i（i>2）层的第j个数字重复加的次数为：第i-1层的j个数字的重复次数+第i-1层的j-1重复次数

用数组表示：a[i][j]=a[i-1][j]+a[i-1][j-1]

先求出所有的情况

int mod[15][15]
void set_mod()
{
	memset(mod,0,sizeof(mod));
	mod[1][0]=1,mod[1][1]=1;
	mod[2][1]=1,mod[2][2]=1;
	//初始化1,2 
	for(int i=3;i<=n;i++)
	{
		mod[i][1]=1,mod[i][i]=1;
		for(int j=2;j<i;j++)
		{
			mod[i][j]=mod[i-1][j]+mod[i-1][j-1];
		}
	}
}

其实就是杨辉三角.......

然后把序列从小到依次测试就行。

序列从小大大有两种方法：

（1）:自己用循环写

（2）:用STL的next_permutation 自动生成下一个序列（按照字典打下生成，如果是最大返回false）

自己写循环：

int array(int a[],int n)  //测试函数
{
/*生成序列需要注意交换后前面的大小，每次交换后，交换后地方后面数字应该从小到大*/
	 int i;
	 int j, k;
	 while (1)     
    {  
       	if(right(a)) //如果目前序列和num大小一样，则返回1，直接跳出
		   return 1;
		   
		for (j = n - 2;a[j] > a[j + 1] && j >= 0 ; j--);  
        if (j < 0) //全部生成完了
        return 0;
        for (k = n - 1; k > j&&a[k] < a[j]; k--);  
        exchange(a[k], a[j]); 
        for (int l = j + 1, r = n - 1; l < r; l++, r--)          
        exchange(a[l], a[r]);
    } 
}

用STL：

int last(int list[])
{
	do
    {
        if(right(list))
			return 1;
    }while(next_permutation(list,list+n));  //数组的一个范围进行序列生成，如果是最大，返回false
}

貌似用STL时间会久一点。

~~剪枝：~~

如果需要判断的值不在n序列的最小值和最大值之间，或者等于也可以直接输出(需要对称选最小的输出，然并卵..）...

代码就不放了，时间不减反多....

用我这个算法不给加测评机吸氧，会TL第9个数据点，第十个也是900+ms。吸氧就能AC。。。。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#define Max 1005
#define max(a,b) a>b?a:b;
#define min(a,b) a>b?b:a;
#define exchange(one,two) {int c=one;one=two;two=c;};
using namespace std;
int num;  //需要查找的数字 
int mod[20][20];
int n; //数字大小 
int all_max;
void show(int list[])
{
	for(int i=0;i<n;i++)
	{
		printf("%d",list[i]);
		if(i!=n-1)
			printf(" ");
		else
			printf("\n");
	}
}
int right(int list[])
{
	int this_num=0;
	for(int i=1;i<=n;i++)
	{
		this_num=mod[n][i]*list[i-1]+this_num;
	}
	if(this_num==num)
		return 1;
	else
		return 0;
 }
 int right1(int list[])
{
	int this_num=0;
	for(int i=1;i<=n;i++)
	{
		this_num=mod[n][i]*list[i-1]+this_num;
	}
	return this_num;
 }
int array(int a[],int n)
{
	 int i;
	 int j, k;
	 while (1)     
    {  
       	if(right(a))
		   return 1;
		   
		for (j = n - 2;a[j] > a[j + 1] && j >= 0 ; j--);  
        if (j < 0) 
        return 0;
        for (k = n - 1; k > j&&a[k] < a[j]; k--);  
        exchange(a[k], a[j]); 
        for (int l = j + 1, r = n - 1; l < r; l++, r--)          
        exchange(a[l], a[r]);
    }  
}
int last(int list[])
{
	do
    {
        if(right(list))
			return 1;
    }while(next_permutation(list,list+n));
}
int reduce_one()
{
	int laji[20];
	int numm=1;
	int i=0,j=n-1;
	while(numm<=n)
	{
		if(i>j)
			break;
		laji[i++]=numm++;
		if(i>j)
			break;
		laji[j--]=numm++;
	}
	int minmin=0,maxmax=0;
	for(int i=1;i<=n;i++)
	{
		maxmax=mod[n][i]*laji[i-1]+maxmax;
	}
	all_max=maxmax;
	if(maxmax==num)
	{
		for(int i=0;i<n;i++)
		{
			if(i<n/2)
			if(laji[i]>laji[n-i-1])
			{
				printf("%d",laji[n-i-1]);
				laji[n-i-1]=laji[i];
			}
			else
			{
				printf("%d",laji[i]);
			}
			else
			printf("%d",laji[i]);
			if(i!=n-1)
			printf(" ");
			else
			printf("\n");
		}
		return 0;
	}
	numm=n;
	i=0,j=n-1;
	while(numm>0)
	{
		if(i>j)
			break;
		laji[i++]=numm--;
		if(i>j)
			break;
		laji[j--]=numm--;
	}
	for(int i=1;i<=n;i++)
	{
		minmin=mod[n][i]*laji[i-1]+minmin;
	}
//	printf("%d %d\n",num,minmin);
	if(num==minmin)
	{
		for(int i=0;i<n;i++)
		{
			if(i<n/2)
			if(laji[i]>laji[n-i-1])
			{
				printf("%d",laji[n-i-1]);
				laji[n-i-1]=laji[i];
			}
			else
			{
				printf("%d",laji[i]);
			}
			else
			printf("%d",laji[i]);
			if(i!=n-1)
			printf(" ");
			else
			printf("\n");
		}
		return 0;
	}
	if(num>minmin&&num<maxmax)
		return 1;
	else
		return 0; 
}

void set_mod()
{
	memset(mod,0,sizeof(mod));
	mod[1][0]=1,mod[1][1]=1;
	mod[2][1]=1,mod[2][2]=1;
	//初始化1,2 
	for(int i=3;i<=n;i++)
	{
		mod[i][1]=1,mod[i][i]=1;
		for(int j=2;j<i;j++)
		{
			mod[i][j]=mod[i-1][j]+mod[i-1][j-1];
		}
	}
}

int main()
{
	scanf("%d%d",&n,&num);
	set_mod();
	int list[]={1,2,3,4,5,6,7,8,9,10,11,12};
//	if(reduce_one())  //没啥用的剪枝..
	if(array(list,n))
		show(list);
	return 0;
}

看题解后，思路没错，但是我不应该每次都对序列重新计算，在计算序列的同时保存前面序列的结果，这样没错急需要计算一个值。题解方法只用了80ms。一样的思路....还需要多加强！