PATA 1103 Integer Factorization（30 分）解题报告

1103 Integer Factorization（30 分）

The K−P factorization of a positive integer N is to write N as the sum of the P-th power of K positive integers. You are supposed to write a program to find the K−P factorization of N for any positive integers N,K and P.

Input Specification:

Each input file contains one test case which gives in a line the three positive integers N (≤400), K (≤N) and P (1<P≤7). The numbers in a line are separated by a space.

Output Specification:

For each case, if the solution exists, output in the format:

N = n[1]^P + ... n[K]^P

where n[i] (i = 1, ..., K) is the i-th factor. All the factors must be printed in non-increasing order.

Note: the solution may not be unique. For example, the 5-2 factorization of 169 has 9 solutions, such as 12​2​​+4​2​​+2​2​​+2​2​​+1​2​​, or 11​2​​+6​2​​+2​2​​+2​2​​+2​2​​, or more. You must output the one with the maximum sum of the factors. If there is a tie, the largest factor sequence must be chosen -- sequence { a​1​​,a​2​​,⋯,a​K​​ } is said to be larger than { b​1​​,b​2​​,⋯,b​K​​ } if there exists 1≤L≤K such that a​i​​=b​i​​ for i<L and a​L​​>b​L​​.

If there is no solution, simple output Impossible.

Sample Input 1:

169 5 2

Sample Output 1:

169 = 6^2 + 6^2 + 6^2 + 6^2 + 5^2

Sample Input 2:

169 167 3

Sample Output 2:

Impossible

作者: CHEN, Yue

单位: 浙江大学

时间限制: 1200 ms

内存限制: 64 MB

代码长度限制: 16 KB

 

题目大意：给出一个数n，一个数k，一个指数p，要求你求出k个数的p次方之和为n，这k个数可以重复，如果有不同的解决方案，那么按照这k个数之和最大的情况为最优方案输出，大数在前，小数在后

解题思路：典型的DFS，递归的边界是p次方和为n，且已经选择了k个数，注意这里的数是可以重复的，所以递归的下一层不能简单的把index进行变化，由于这里的输出要求，所以我们不从1开始遍历，我们从最大的可能数，也就是n本身开始，这样可以省去排序时间，降低时间复杂度。

 

AC代码：

#include<iostream>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<algorithm> 
#include<cmath>
using namespace std;
int n,k,p;
vector<int> temp,ans,tsm;
int sumans=-1;//结果数组中序列之和 
void DFS(int index,int nowK,int sum,int sumtemp);
bool cmp(int a,int b);
bool flag=false;
void init();
int main()
{ 
	scanf("%d%d%d",&n,&k,&p);
	init();//建求和表
	DFS(tsm.size()-1,0,0,0);
	//sort(ans.begin(),ans.end(),cmp);
	if(flag==true)
	{
		printf("%d = ",n);
		for(int i=0;i<ans.size();i++)
		{
			if(i<ans.size()-1)
				printf("%d^%d + ",ans[i],p);
			else
				printf("%d^%d",ans[i],p);
		}
	}
	else
		printf("Impossible");
	return 0;
}
//本题需要从大到小DFS，从1开始会发生错误，注意每个数都可以重复使用
//从大到小枚举可以节省排序时间，注意剪枝，否则会超时 
void DFS(int index,int nowK,int sum,int sumtemp)
{
	//cout<<"DFS is run"<<endl;
	if(nowK==k&&sum==n)
	{
		flag=true;
		if(sumtemp>sumans)//temp序列中的最大数大于ans中的最大数 
		{
			ans=temp;
			sumans=sumtemp;
		}
		return;
	}
	if(sum>n||nowK>k)
		return; 
	if(index-1>=0)
	{
		temp.push_back(index);
		if(sum+tsm[index]<=n)//剪枝 
			DFS(index,nowK+1,sum+tsm[index],sumtemp+index);
		temp.pop_back();
		DFS(index-1,nowK,sum,sumtemp);
	}
}

bool cmp(int a,int b)
{
	return a>b;
}

void init()
{
	int temp;
	for(int i=0;temp<=n;i++)
	{
		temp=(int)pow(i*1.0,p*1.0);
		tsm.push_back(temp);
	}
}