PAT-1103 Integer Factorization

最新推荐文章于 2020-07-28 19:41:56 发布

原创最新推荐文章于 2020-07-28 19:41:56 发布 · 175 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#pat

浙大PAT-Advanced 专栏收录该内容

119 篇文章

订阅专栏

博客围绕将正整数N分解为K个整数的P次幂之和展开。当分解不唯一时，需输出和最大的K个数，若仍不唯一则选字典序大的。考虑到可能组合多，放弃全存再判断，采用每找到一个更新的方式，还通过递归枚举并保证后数不大于前数来节省时间。

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

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 122+42+22+22+12, or 112+62+22+22+22, 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 { a1,a2,⋯,aK } is said to be larger than { b1,b2,⋯,bK } if there exists 1≤L≤K such that ai=bi for i<L and aL>bL.

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个数，还不唯一选字典序大的。试了一下，按照题目数据大小，分解出来的可能组合最多有几万种，于是放弃了找到所有序列后再来统计和最大的，而是每找到一个更新一下（当然也可以全部存下来再判断，试过最坏时间多30%，空间消耗也更多）。递归地枚举每一位，需要保证后面的数不大于前面的数，这样还可以省掉很多暴力枚举时间。

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

vector<int> ans;
vector<int> tmp;
int N,K,P;	
int summax=0;//当前最大和
bool newans(){
	int sum=0;
	for(int i=0;i<K;i++){
		sum+=tmp[i];
	}
	if(sum>summax){//有更大的和
		summax=sum;
		return true;
	}else if(sum==summax){//和相等，有更大序列
		for(int i=0;i<K;i++){
			if(tmp[i]!=ans[i])
				return tmp[i]>ans[i];
		}
	}else{
		return false;
	}
}
void kpn(int k,int n){
	if(k==1){
		int t=pow(n,1.0/P);
		if((int)pow(t*1.0,P)==n){
			tmp.push_back(t);
			if(newans()){//有新结果
				ans.insert(ans.begin(),tmp.begin(),tmp.end());
			}
			tmp.pop_back();
		}
		return;
	}
	int min=pow(n*1.0/k,1.0/P);
	int t=pow(min*1.0,P)*k;
	if(t<n)
		min++;
	int max=pow((n-k+1)*1.0,1.0/P);
	if(tmp.size()!=0&&max>tmp.back())//保证后面的数不大于前面的数
		max=tmp.back();
	for(int i=min;i<=max;i++){//第k位从小到大尝试
		tmp.push_back(i);
		int nn=n-pow(i*1.0,P);
		kpn(k-1,nn);
		tmp.pop_back();
	}
}
int main(){
	scanf("%d%d%d",&N,&K,&P);
	kpn(K,N);

	if(ans.size()==0){
		printf("Impossible\n");
		return 0;
	}
	printf("%d = ",N);
	for(int i=0;i<K;i++){
		if(i!=0)printf(" + ");
		printf("%d^%d",ans[i],P);
	}

	return 0;
}