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

思路：用DFS来做，关键问题是找准递归边界，DSF的变量分别为index（这里用下标来表示factor，首先需要将1～某个数的p次方保存到vec数组中，这里下标 + 1 等于真实的数）、temp_sum（当前sum_k个数p次方的和）、sum_k（已经sum_k个数相加）、temp_max_index_sum（由于如果出现多组解，需输出factor之和最大的那组，用来表示当前factor之和）；max_index_sum初始为-1，若执行完dfs后还为-1，说明没有解，输出Impossible，反之按格式输出正解。

#include<iostream>
#include<cmath>
#include<vector>
using namespace std;
int n, k, p;
vector<int> vec;
vector<int> out_vec, temp_vec;
int max_index_sum = -1;

void dfs(int index, int temp_sum, int sum_k, int temp_max_index_sum){
    if(sum_k == k){
        if(temp_max_index_sum > max_index_sum && temp_sum == n){
            out_vec = temp_vec;
            max_index_sum = temp_max_index_sum;  
        }
        return;

    }
    while (index >= 0)
    {
        if(temp_sum + vec[index] <= n){

            temp_vec[sum_k] = index + 1;

            dfs(index, temp_sum + vec[index], sum_k + 1, temp_max_index_sum + index + 1);



        }
    
        index--;
    }
    


}
int main(){
    cin >> n >> k >> p;
    int max_num = pow(n, 1.0 / p);
    temp_vec.resize(k);
    for(int i = 1; i <= max_num; i++){

        vec.push_back(pow(i, p));
    }
    dfs(vec.size() - 1, 0, 0, 0);
    if(max_index_sum == -1){

        printf("Impossible\n");
    }else
    {
        printf("%d = ", n);
        for(int j = 0; j < k; j++){

            printf("%s%d^%d",j == 0 ? "" : " + ", out_vec[j], p);

        }
    }
    


    
    return 0;
}