1103 Integer Factorization (30 分)

最新推荐文章于 2020-07-10 10:14:15 发布

ME->CS

最新推荐文章于 2020-07-10 10:14:15 发布

阅读量170

点赞数

分类专栏： PAT甲级

本文链接：https://blog.csdn.net/weixin_42582136/article/details/99897218

版权

PAT甲级专栏收录该内容

111 篇文章 0 订阅

订阅专栏

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

题目分析：
将a分解为b项以c为指数的正数求和的形式，采用dfs求解，从a的根号下c次方开始深度优先搜索，将1到pow(a,1.0/c)这些数的c次方储存起来，因为会频繁用到。可以将时间从1000ms+降到200ms+
输出要求因子和最大的结果，如果有相等情况，貌似是相当于将因子转化为字符串，按字典序大的输出，一开始我写了搜索函数是将所有结果搜出来再按要求排序，于是有了比较函数

sort(re.begin(), re.end(), [](vector<int>& a, vector<int>& b)
			{
				int sum_a = accumulate(a.begin(), a.end(), 0), sum_b = accumulate(b.begin(), b.end(), 0);
				if (sum_a != sum_b)
					return sum_a > sum_b;
				else
				{
					string sa ,sb;
					for (int i = 0; i < a.size(); i++)
					{
						sa += to_string(a[i]);
						sb += to_string(b[i]);
					}
					return sa>sb;
				}
			});

后来提交发现有一个点通不过，说实话output那段英文我也看得不是很明白，然后想了想我是从pow(a,1.0/c)开始搜索的，那么先搜出来的结果在字典序上一定是大于后面的，如果后面搜出来的结果因子和大于之前的，直接更新就行，如果相等的话，不会更新之前的结果，那么也就按字典序在前保存了正确的结果。

#include<iostream>
#include<vector>
#include<cmath>
#include<numeric>
using namespace std;
vector<int>re,path,power;
int max_sum = -1;
void dfs(int sum, int b, int cur)
{
	if (path.size() > b || sum < 0) 
		return;
	if (sum == 0 && path.size() == b)
	{
		int tmp = accumulate(path.begin(), path.end(), 0);
		if (tmp > max_sum) 
		{
			max_sum = tmp;
			re = path;
		}
		return;
	}
	for (int i = cur; i >= 1; i--)
	{
		path.push_back(i);
		dfs(sum - power[i - 1], b, i);
		path.pop_back();
	}
}
int main()
{
	int a, b, c;
	cin >> a >> b >> c;
	int max_value = pow(a, 1.0 / c);
	for (int i = 1; i <= max_value; i++)
		power.push_back(pow(i, c));
	dfs(a, b, max_value);
	if (re.size())
	{
		cout << a << " = " << re[0] << "^"<<c;
		for (int i = 1; i < b; i++)
			cout << " + " << re[i] << "^" << c;
	}
	else
		cout << "Impossible";
	return 0;
}