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

解题思路 ：

这道题会给你三个数，分别是n，k，p，你需要求得k个数，每个数的p次方相加，最后得到n，如果有多个这种组合，那么要取底数和最大的那一种

解题思路类似于DFS，就是用递归的方法对结果集合进行搜索，找到所有可能的结果集，并且计算底数和，最后将底数和最大的组合输出。

核心代码如下

void DFS(int index, int nowK, int sum, int facSum){
	if(sum==n && nowK==k){	//找到一个满足的序列 
		if(facSum > maxFacSum){
			ans = temp;
			maxFacSum = facSum;
		}
		return ;
	}
	if(sum>n || nowK>k) return;	//这种情况下不会产生答案，直接返回 
	if(index>=1){	//fac[0]不需要选 
		temp.push_back(index);
		DFS(index, nowK+1, sum+fac[index], facSum+index);	//选 
		temp.pop_back();		//进入不选前的准备
		DFS(index-1, nowK, sum, facSum); 
	}	
} 

DFS函数有四个参数，分别是：index代表当前所选底数；nowK表示当前搜索结果集中的底数数量；sum表示当前求得的和；facSum表示当前结果集中底数和。

我们在每一趟搜索中都有两种选择，分别是选和不选。

如果是选的话，参数就会变成 DFS(index, nowK+1, sum+fac[index], facSum+index)

如果是不选的话，参数会变成 DFS(index-1, nowK, sum, facSum)

函数有两个递归出口，第一个是 sum==n && nowK==k，这表示已经找到一组可行解，判断是否是最优解，并且记录当前的最优解，退出递归

第二个是 sum>n || nowK>k，这表示继续搜索也找不到满足条件的解了，所以退出递归

完整代码如下

#include <stdio.h>
#include <vector>
#include <algorithm>
using namespace std;

//n是最后求和得到的数，k是k个数相加，p是指数
//maxFacSum是当前底数和的最大值 
int n, k, p, maxFacSum=-1;

//fac存放0^p,1^p...i^p，并且满足i^p不超过n
//ans存放最优的底数序列
//temp存放当前递归的临时底数序列 
vector<int> fac, ans, temp;

//power计算函数，计算x^p
int power(int x){
	int ans=1;
	for(int i=0; i<p; i++){
		ans *= x;
	}
	return ans;
} 

//init函数预处理fac数组
void init(){
	int i=0, tmp=0;
	//当tmp^p不超过n的时候，不断加入到容器中 
	while(tmp <= n){
		fac.push_back(tmp);
		tmp = power(++i);
	}
} 

//DFS函数，当前访问fac[index]，有两种情况，分别是选和不选
//nowK为当前选中个数，sum为当前选中的数之和，facSum为当前选中底数之和
void DFS(int index, int nowK, int sum, int facSum){
	if(sum==n && nowK==k){	//找到一个满足的序列 
		if(facSum > maxFacSum){
			ans = temp;
			maxFacSum = facSum;
		}
		return ;
	}
	if(sum>n || nowK>k) return;	//这种情况下不会产生答案，直接返回 
	if(index>=1){	//fac[0]不需要选 
		temp.push_back(index);
		DFS(index, nowK+1, sum+fac[index], facSum+index);	//选 
		temp.pop_back();		//进入不选前的准备
		DFS(index-1, nowK, sum, facSum); 
	}	
} 

int main(){
	scanf("%d %d %d", &n, &k, &p);
	init();
	DFS(fac.size()-1, 0, 0, 0);
	if(maxFacSum==-1) printf("Impossible\n");
	else {
		printf("%d = %d^%d", n, ans[0], p);
		for(int i=1; i<k; i++){
			printf(" + %d^%d", ans[i], p);
		}
	}
	return 0;
}