【PAT甲级A1103】 1103 Integer Factorization (30分)（c++）

1103 Integer Factorization (30分)

作者：CHEN, Yue
单位：浙江大学
代码长度限制：16 KB
时间限制：1200 ms
内存限制：64 MB

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​​ +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个数选和大的，如果和相等，按照字符顺序大的。

思路：

将所有k次方以内的数保存进容器，按照深度优先，选择要不要这个数，边界为选择数量达到k，判断是否k个数相加等于n。（由于要按字符字典大的，所以在更新最大值时要加等号）

参考代码：

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;
vector<int> v, ansv, path, temp;
int n, k, p, maxsum = 0;

void dfs(int index, int anssum, int valuesum, int depth) {
    if (depth == k) {
        if (anssum == n && valuesum >= maxsum) {
            path = temp;
            maxsum = valuesum;
        }
        return;
    }
    for (int i = index; i < v.size(); i++) {
        if (anssum + ansv[i] <= n) {
            temp.push_back(v[i]);
            dfs(i, anssum + ansv[i], valuesum + v[i], depth + 1);
            temp.pop_back();
        }
    }
}

int main() {
    scanf("%d%d%d", &n, &k, &p);
    for (int i = 1; i <= n && pow(i, p) <= n; i++) {
        v.push_back(i);
        ansv.push_back(pow(i, p));
    }
    dfs(0, 0, 0, 0);
    if (!path.empty()) {
        printf("%d =", n);
        for (int i = path.size() - 1; i >= 0; i--) {
            if (i != path.size() - 1)printf(" +");
            printf(" %d^%d", path[i], p);
        }
    } else printf("Impossible");
    return 0;
}

如有错误，欢迎指正