1103 Integer Factorization (30分)

第一个深度优先搜索的题目。
很显然这个就是分情况讨论，每次选和不选某值，最终将满足结果的序列筛选出来，我自己写的一个dfs遍历，我比较喜欢对每一个元素进行遍历，用循环控制，这样的好处是避免递归层数太多。但是我写完提交测试发现测试点2,5答案错误，想了半天觉得可能是有答案并列时排序出了问题

因为我把排序算法删除，再提交代码仍然是2,5错误。
但是我感觉自己的排序函数并没有出错，就很迷。。
（测试点2,5错误）

#include<iostream>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
bool cmp(vector<int>&A, vector<int>&B) {
	sort(A.begin(), A.end());
	sort(B.begin(), B.end());
	int t = min(A.size(), B.size());
	for (int i = 0; i < t; i++) {
		if (A[i] == B[i])continue;
		if (A[i] > B[i])return true;
		else return false;
	}
	return false;
}
int val[22];
vector<int>ans, tmp;
vector < vector<int>>V;
int N, K, P, flag = 0, tsum = 0, ttsum = 0, vsum = 0;
void dfs(int sum, int index) {
	if (sum + val[index] > N||tmp.size()>K)return;
	else if (sum + val[index] == N&&tmp.size()==K-1) {
		tmp.push_back(index);
		ans = tmp;
		tsum = vsum;
		return;
	}
	sum += val[index];
	vsum += index;
	tmp.push_back(index);
	for (int j = index; j >= 1; j--) {
		dfs(sum, j);
	}
	tmp.pop_back();
	vsum -= index;
}
int main() {
	scanf("%d%d%d", &N, &K, &P);
	for (int i = 0; i <= sqrt(N); i++) {
		val[i] = pow(i, P);
	}
	for (int j = sqrt(N); j >= 1; j--) {
		tmp.clear();
		ans.clear();
		tsum = 0;
		dfs(0, j);
		if (ans.size() != 0) {
			if (tsum < ttsum)continue;
			if (tsum > ttsum) {
				V.clear();
				ttsum = tsum;
			}
			V.push_back(ans);
		}
	}
	if (V.size() == 0)printf("Impossible\n");
	else {
		if (V.size() > 1) {
			sort(V.begin(), V.end(), cmp);
			reverse(V[0].begin(), V[0].end());
		}
		printf("%d =", N);
		for (int i = 0; i < V[0].size(); i++) {
			if (i == 0)printf(" %d^%d", V[0][i], P);
			else printf(" + %d^%d", V[0][i], P);
		}
	}
	return 0;
}

反思了一下，发现自己的dfs函数存在本质上的错误，漏掉了很对情况，我的代码并不会充分考虑每个条件，不会考虑一个结点是选和不选情况，而是选择一切能选的加到底，不满足题设就返回。

学习了大神的 代码，有一些收获：
一：递归及时剪枝，不要进入多余的层数。
二：需要计算的参数尽量少使用全局变量，而是加到函数参数里面，这样可以层层保存。
三：对全局变量vector的使用，一个每次选完要记得pop掉，这样在进入下一层就相当于不选。

附修改后的代码：

#include<iostream>
#include<math.h>
#include<vector>
using namespace std;
int val[21];
int N, K, P, maxK = 0;
vector<int>tmp, ans;
void DFS(int index, int sum, int numK, int facsum) {
	if (sum == N && numK == K) {
		if (facsum > maxK) {
			maxK = facsum;
			ans = tmp;
			return;
		}
	}
	if (numK >= K || sum >= N)return;
	if (index < 1)return;
	if (sum + val[index] <= N) {
		tmp.push_back(index);
		DFS(index, sum + val[index], numK + 1, facsum + index);
		tmp.pop_back();
	}
	DFS(index - 1, sum, numK, facsum);
}
int main() {
	scanf("%d%d%d", &N, &K, &P);
	for (int i = 0; i <= pow(N, (double)1 / P); i++) {
		val[i] = pow(i, P);
	}
	DFS(pow(N, (double)1 / P), 0, 0, 0);
	if (ans.size() == 0)printf("Impossible\n");
	else {
		printf("%d =",N);
		for (int i = 0; i < ans.size(); i++) {
			if (i == 0)printf(" %d^%d", ans[i], P);
			else printf(" + %d^%d", ans[i], P);
		}
	}
	return 0;
}