[PAT] A1103 Integer Factorization

（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，否则输出答案。
剪枝：
1.tempK==K但是tempSum!=n的时候需要剪枝
2.在枚举的时候，按顺序枚举，上界或者下界可进行剪枝
3.当且仅当tempSum + v[index] <= n时，进行下一层的DFS，而不要进入下一层DFS发现不满足条件再返回，这样开销会比较大
4.每次temv的push_back、pop_back都需要重新分配内存空间，比较耗时，由于答案的序列长度是确定的，可以将ans序列初始化为定长的，这样在递归的过程中就不需要push、pop; pow的计算结果可以保存下来，以免重复计算，耗用多余的时间

坑

1.要先存好次方计算后的值，避免递归时重复计算。
2.直接利用maxsum来判断是否有解，通过设初值为负数。无需额外建立标记判断。
3.倒着递归，从大数开始判断。

AC代码

/*第二次写*/
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<math.h>
#include<vector>
using namespace std;
int n, k, p, maxsum = -1;
vector<int>num, ans, bestans;
void DFS(int index, int result, int sum, int x) {
	if (result == n && x == k) {
		if (sum > maxsum) {
			bestans = ans;
			maxsum = sum;
		}
		else if (sum == maxsum) {
			int i = k - 1;
			while (i >= 0 && ans[i] == bestans[i])i--;
			if (ans[i] > bestans[i])bestans = ans;
		}
		return;
	}
	else if (index < 0 || x >= k || result >= n)return;
	if (result + num[index] <= n) {
		ans[x] = index + 1;
		DFS(index, result + num[index], sum + index, x + 1);
	}
	DFS(index - 1, result, sum, x);
}

int main() {
	int i, a, b;
	scanf("%d%d%d", &n, &k, &p);
	ans.resize(k); bestans.resize(k);
	for (i = 1; i <= n; i++) {
		a = pow(i, p);	
		if (a > n)break;
		num.push_back(a);
	}
	DFS(num.size() - 1, 0, 0, 0);
	if (maxsum < 0)printf("Impossible");
	else {
		printf("%d = %d^%d", n, bestans[0], p);
		for (i = 1; i < k; i++)printf(" + %d^%d", bestans[i], p);
	}
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAX 500
int n, k, p, maxsum = -1;
vector<int>v;
vector<int>solution, maxsolution;
void optmax() {
	int i = 0;
	while (solution[i] == maxsolution[i])i++;
	if (solution[i] > maxsolution[i])
		maxsolution = solution;
}
void DFS(int index, int count, int ans, int sum) {
	if (count == k && ans == n) {
		if (maxsum < sum) {
			maxsum = sum;
			maxsolution = solution;
		}
		else if (maxsum == sum) optmax();  //此处可以不用判断相等情况，也能AC。
		return;
	}
	if (index == 0 || ans > n || count >= k)return;
	if (ans + v[index] <= n) {
		solution.push_back(index);
		DFS(index, count + 1, ans + v[index], sum + index);
		solution.pop_back();
	}
	DFS(index - 1, count, ans, sum);
}
int main() {
	scanf("%d%d%d", &n, &k, &p);
	int temp = 0, index = 1;
	while (temp <= n) {
		v.push_back(temp);
		temp = pow(index, p);
		index++;
	}
	DFS(v.size() - 1, 0, 0, 0);
	if (maxsum < 0)printf("Impossible");
	else {
		printf("%d = %d^%d", n, maxsolution[0], p);
		for (int i = 1; i < k; i++)
			printf(" + %d^%d", maxsolution[i], p);
	}
	return 0;
}

另

如果改成正着来，测试点5就超时了...实在想不通是什么回事，希望走过路过的大神们帮我看看，感激不尽！！！
（我想应该是从大数开始比较容易到达边界，减少了递归次数）

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>
#include<iostream>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAX 500
int n, k, p, maxsum = -1;
vector<int>v;
vector<int>solution, maxsolution;
bool cmp(int a, int b) { return a > b; }
void optmax() {
	int i = 0;
	while (solution[i] == maxsolution[i])i++;
	if (solution[i] > maxsolution[i])
		maxsolution = solution;
}
void DFS(int index, int count, int ans, int sum) {
	if (count == k && ans == n) {
		if (maxsum < sum) {
			maxsum = sum;
			maxsolution = solution;
		}
		else if (maxsum == sum) optmax();
		return;
	}
	if (index >= v.size() || ans > n || count >= k)return;
	if (ans + index <= n) {
		solution[count] = index;
		DFS(index, count + 1, ans + v[index], sum + index);
	}
	DFS(index + 1, count, ans, sum);
}
int main() {
	scanf("%d%d%d", &n, &k, &p);
	solution.resize(k);
	int temp = 0, index = 1;
	while (temp <= n) {
		v.push_back(temp);
		temp = pow(index, p);
		index++;
	}
	DFS(1, 0, 0, 0);
	if (maxsum < 0)printf("Impossible");
	else {
		printf("%d = %d^%d", n, maxsolution[k - 1], p);
		for (int i = k - 2; i >= 0; i--)
			printf(" + %d^%d", maxsolution[i], p);
	}
	return 0;
}