PAT (Advanced Level) Practice 1103 Integer Factorization DFS应用

一、概述

给出一个整数，求他分解为K个P次幂的整数的和。

用DFS来做，由于P至少为2，N最大为400，因此单个加数的最大值为20。那么就可以变为DFS的应用，即求20个数当中，满足条件的数列，都求出来，然后找满足题意的并输出。题目并不难，但为了不超时以及AC还是有点麻烦的。

二、分析

首先考虑DFS函数，如下：

void DFS(int index, int tempSum, int nowK, int sumSeq, int N, int K, int P)//index处理到第几个数，sum序列和，tempsum当前序列和，nowK当前序列内数字数量，sumseq序列P次幂和 
{
	if (sumSeq == N&&nowK == K)//已选择一个序列 
	{
		//printf("sum=%d,tempSum=%d\n",sum,tempSum);
		//for(it1=Max.begin();it1!=Max.end();it1++)
		//	printf("%d",*it1);
		//printf("\n");
		if (tempSum>sum)//如果现在的序列和更大 
		{
			Max = temp;
			sum = tempSum;
		}
		else if (tempSum == sum)//如果现在的序列字典序更大 
		{
			//printf("又一次相等");
			for (it1 = temp.begin(), it2 = Max.begin(); it1 != temp.end(), it2 != Max.end(); it1++, it2++)
			{
				//printf("temp %d Max %d,", *it1, *it2);
				//printf("第一个%d,第二个%d", *it1, *it2);
				if ((*it1) == (*it2))
					continue;
				else if ((*it1) < (*it2))
					break;
				else if ((*it1) > (*it2))
				{

					Max = temp;
					break;
				}
				
			}
			//printf("\n");
		}
		return;
	}
	if (index == 0 || nowK>K || sumSeq>N) return; //这个index的判断如果是N会有很多超时 
	temp.push_back(index);//先判断再压入 
						  //选index 
	DFS(index, tempSum + index, nowK + 1, sumSeq + num[index], N, K, P);
	temp.pop_back();//注意这里没有变量，弹出 
					//不选index
	DFS(index - 1, tempSum, nowK, sumSeq, N, K, P);
}

采用递归，有以下几点要注意：

1、何时return

我们使用DFS是为了找到符合条件的序列，因此，在找到一条序列后就可以return；另外，当触发边界条件时也要return。

即递归出口要使用return。

2、DFS函数的运行逻辑如下：

DFS的参数有以下几个：

index：本次要压入的数字

tempSum：目前序列中的数字和

nowK：目前序列中的数字个数

semSeq：目前序列的P次幂和

注意：参数index还没压入序列中，另外三个的变化与这一index无关，是上一个index引起的变化。

首先判断序列是否符合条件，若符合，返回；

若不符合条件，判断是否触发边界条件，若触发，返回；

若不触发，说明这一条序列还没走完，将index压入；

由于单个相同数字可以多次使用，因此下一个DFS的参数仍为index；

返回后要将压入的变量弹出。

以173 6 2这一组变量为例：

首先，13不是递归出口，13压入，下一步

DFS（13,13,1,169,173,6,2）

仍不return，13压入，下一步

DFS（13,26,2,338,173,6,2）

触发边界条件，return，13被弹出，下一步

DFS（12,13,1,169,173,6,2）

不return，12压入，下一步

。。。。。。

可以看出，参数分为两部分，index自己是一部分，另外三个是一部分，另外三个不随本次的index变化。

即，先压入，然后判断压入的影响。理解了这点，迭代就清楚多了。

由于迭代次数可能过多，因此需要从大往小来递归，而不应从小往大，最大的index是20即可，而不能是400。另外，由于采用的从大往小，那么，第一个序列和最大的序列也必定是字典序最大的序列，这样就减少了判断。我测试点2的bug也出在这里。

我判断时只是简单地判断成若temp对应位大于Max对应位，但应该有一个前提，即大于这位前面的必须全部等于，这我没有判断，因此出错了。

另外需要注意的是，N，P，K，sum都最好用全局变量，这样可以减少DFS的参数。还有就是vector用迭代器访问时要加*

，不能直接访问迭代器。

三、总结

DFS是最重要也最常用的算法之一，必须熟练掌握。

PS：代码如下

#include<stdio.h>
#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;

vector<int> temp, Max;
vector<int>::iterator it1, it2, it;
int num[22];
//选择和最大且字典序最大的 
/*void DFS(int index,int sum,int tempSum,int nowK,int sumSeq,int N,int K,int P)//index处理到第几个数，sum序列和，tempsum当前序列和，nowK当前序列内数字数量，sumseq序列P次幂和
{
if(sumSeq==N&&nowK==K)//已选择一个序列
{
if(tempSum>sum)//如果现在的序列和更大
{
Max=temp;
sum=tempSum;
}
else if(tempSum==sum)//如果现在的序列字典序更大
{
for(it1=temp.begin(),it2=Max.begin();it1!=temp.end(),it2!=Max.end();it1++,it2++)
{
if(it1>it2)
{
Max=temp;
break;
}
}
}
return;
}
if(index>=pow(N,(float)1/P)||nowK>K||sumSeq>N) return; //这个index的判断如果是N会有很多超时
temp.push_back(index);//先判断再压入
//选index
DFS(index,sum,tempSum+index,nowK+1,sumSeq+num[index],N,K,P);
temp.pop_back();//注意这里没有变量，弹出
//不选index
DFS(index+1,sum,tempSum,nowK,sumSeq,N,K,P);
}*/
int sum = 0;
void DFS(int index, int tempSum, int nowK, int sumSeq, int N, int K, int P)//index处理到第几个数，sum序列和，tempsum当前序列和，nowK当前序列内数字数量，sumseq序列P次幂和 
{
	if (sumSeq == N&&nowK == K)//已选择一个序列 
	{
		//printf("sum=%d,tempSum=%d\n",sum,tempSum);
		//for(it1=Max.begin();it1!=Max.end();it1++)
		//	printf("%d",*it1);
		//printf("\n");
		if (tempSum>sum)//如果现在的序列和更大 
		{
			Max = temp;
			sum = tempSum;
		}
		else if (tempSum == sum)//如果现在的序列字典序更大 
		{
			//printf("又一次相等");
			for (it1 = temp.begin(), it2 = Max.begin(); it1 != temp.end(), it2 != Max.end(); it1++, it2++)
			{
				//printf("temp %d Max %d,", *it1, *it2);
				//printf("第一个%d,第二个%d", *it1, *it2);
				if ((*it1) == (*it2))
					continue;
				else if ((*it1) < (*it2))
					break;
				else if ((*it1) > (*it2))
				{

					Max = temp;
					break;
				}
				
			}
			//printf("\n");
		}
		return;
	}
	if (index == 0 || nowK>K || sumSeq>N) return; //这个index的判断如果是N会有很多超时 
	temp.push_back(index);//先判断再压入 
						  //选index 
	DFS(index, tempSum + index, nowK + 1, sumSeq + num[index], N, K, P);
	temp.pop_back();//注意这里没有变量，弹出 
					//不选index
	DFS(index - 1, tempSum, nowK, sumSeq, N, K, P);
}

int main()
{
	int N, K, P;//K个P次幂的和
	scanf("%d %d %d", &N, &K, &P);
	//if(N==173)
	//if(P==2)
	// if(K==6)
	// while(1);//测试点二是173,6,2
	int sqr = pow(N, (float)1 / P);
	//printf("sqr=%d\n",sqr);
	int i;
	for (i = 0; i<22; i++)
		num[i] = pow(i, P);

	DFS(sqr, 0, 0, 0, N, K, P);
	if (Max.size() == 0)
		printf("Impossible");
	else
	{
		printf("%d = ", N);
		int j;
		//for(it=Max.begin();it!=Max.end()-1;it++)
		for (j = 0; j<Max.size() - 1; j++)
			printf("%d^%d + ", Max[j], P);
		printf("%d^%d", Max[j], P);
	}
}