1103 Integer Factorization (30分)

1 问题

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 { a1,a2,⋯,aK} is said to be larger than { b1,b2,⋯,b​K} if there exists 1≤L≤K such that ai =bi for ibL.
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

2 解析

• 题意：求出K个P次方的数的总和为N的K数之和最大的序列，并按序列非递增的顺序以及相应的格式输出

• 思路：
  • 1 使用递归求出序列
    • 参数：序列数index，序列个数nowK，序列和sum，序列次方幂的和sumSqu
    • 递归边界：序列数为0 || 序列个数大于k || 序列次方幂的和大于N
    • 递归式子：
      • 序列数、序列个数+1、 序列和+序列数、序列次方幂和+序列数的次方幂（选择这个数）
      • 序列数-1，序列个数、序列和、序列数的次方幂（不选这个数）
    • 序列个数为K && 序列次方幂的和为N
      • 如果序列和比之前的大，就更新序列和，并重新存序列
    • 2 优化
      • 序列数从N到0开始遍历，让字典序大的优先被选到，可以不用进行sort排序
      • 用一个序列次方幂和专门来存1～N的次方幂

3 参考代码

#include <cstdio>
#include <vector>
#include <cmath>

using std::vector;

const int MAXN = 450;

//169 5 2

int A[MAXN];
int N, K, P;
int maxSum  = -1;
vector<int>temp, ans,fac;

//index号数 已选了nowK个数  总和sum  已选数的每个数的K次方和
void BFS(int index, int nowK, int sum, int sumSqu){
    if(nowK == K && sumSqu == N){
        if(sum > maxSum){
            maxSum = sum;
            ans = temp;
        }
    }

    if(index == 0|| nowK > K || sumSqu > N) return;

    temp.push_back(index);
    BFS(index, nowK + 1, sum + index , sumSqu + fac[index]);

    temp.pop_back();
    BFS(index - 1, nowK, sum, sumSqu);

}

int main(int argc, char const *argv[])
{
    scanf("%d%d%d", &N, &K, &P);//总和N 、K个数、P次方

    int tempPow = 0,k = 1;
    while(tempPow <= N){
        fac.push_back(tempPow);
        tempPow = pow(k++, P);
    }

    BFS(fac.size() - 1, 0, 0, 0);

    if(maxSum != -1){
        printf("%d = ", N);
        for (vector<int>::const_iterator it = ans.begin(); it != ans.end() ; ++it)
        {
            if(it != ans.begin()) printf(" + ");
            printf("%d^%d", *it, P);
        }
    }else{
        printf("Impossible\n");
    }

    return 0;
}