PAT A1103. Integer Factorization (30)

原文链接: PAT A1103. Integer Factorization (30)

上一篇: PAT A1097. Deduplication on a Linked List (25)

下一篇: PAT A1091. Acute Stroke (30)

1103. Integer Factorization (30)

https://www.patest.cn/contests/pat-a-practise/1103

时间限制

1200 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

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 = n1^P + ... nK^P

where ni (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

分析：dfs深度优先搜索。先把i从0开始所有的i的p次方的值存储在v[i]中，直到v[i] > n为止。然后深度优先搜索，记录当前正在相加的index（即v[i]的i的值），当前的总和tempSum，当前K的总个数tempK，以及因为题目中要求输出因子的和最大的那个，所以保存一个facSum为当前因子的和，让它和maxFacSum比较，如果比maxFacSum大就更新maxFacSum和要求的ans数组的值。
在ans数组里面存储因子的序列，tempAns为当前深度优先遍历而来的序列，从v[i]的最后一个index开始一直到index == 1，因为这样才能保证ans和tempAns数组里面保存的是从大到小的因子的顺序。一开始maxFacSum == -1，如果dfs后maxFacSum并没有被更新，还是-1，那么就输出Impossible，否则输出答案。

#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;
int n, k, p, maxFacSum = -1;
vector<int> v, ans, tempAns;
void init() {
    int temp = 0, index = 1;
    while(temp <= n) {
        v.push_back(temp);
        temp = pow(index, p);
        index++;
    }
}
void dfs(int index, int tempSum, int tempK, int facSum) {
    if(tempSum == n && tempK == k) {
        if(facSum > maxFacSum) {
            ans = tempAns;
            maxFacSum = facSum;
        }
        return ;
    }
    if(tempSum > n || tempK > k) return ;
    if(index >= 1) {
        tempAns.push_back(index);
        dfs(index, tempSum + v[index], tempK + 1, facSum + index);
        tempAns.pop_back();
        dfs(index - 1, tempSum, tempK, facSum);
    }
}
int main() {
    scanf("%d%d%d", &n, &k, &p);
    init();
    dfs(v.size() - 1, 0, 0, 0);
    if(maxFacSum == -1) {
        printf("Impossible");
        return 0;
    }
    printf("%d = ", n);
    for(int i = 0; i < ans.size(); i++) {
        if(i != 0) printf(" + ");
        printf("%d^%d", ans[i], p);
    }
    return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector> 
using namespace std;

//maxSum 存放最大底数之和 
int n, k, p, maxSum = -1;
//fac 存放不超过n的i^p数列,ans存放最优底数序列,temp存放递归中的临时底数序列
vector<int> fac, ans, temp;

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

//初始化fac数组,注意0也存进去
void init() {
	int i = 0, temp = 0;
	while (temp <= n) {
		fac.push_back(temp);
		temp = power(++i);
	}
}

//当前访问fac[index],nowk是当前选中个数
//sum是当前选中的数之和,facSum是当前选中底数之和
void dfs(int index, int nowk, int sum, int facSum) {
	if (sum == n && nowk == k) {
		if (facSum > maxSum) {
			ans = temp;
			maxSum = facSum;
		}
		return;
	}
	if (sum > n || nowk > k) return;
	if (index > 0) {		//fac[0]不需要选择 
		temp.push_back(index);	//把底数加入临时序列
		dfs(index, nowk + 1, sum + fac[index], facSum + index);	//选的分支
		temp.pop_back();	//选的分支结束后把刚刚加进去的数pop掉
		dfs(index - 1, nowk, sum, facSum);
	}
}

int main(int argc, char *argv[]) {
	scanf("%d%d%d", &n, &k, &p);
	init();
	dfs(fac.size() - 1, 0, 0, 0);	//从fac的最后一位开始往前搜索
	if (maxSum == -1)
		printf("Impossible\n");
	else {
		printf("%d = %d^%d", n, ans[0], p);
		for (int i = 1; i < ans.size(); i++)
			printf(" + %d^%d", ans[i], p);
	}
	return 0;
}