天梯赛L3-001 凑零钱 （01背包+dfs）

L3-001 凑零钱 （30 分）

韩梅梅喜欢满宇宙到处逛街。现在她逛到了一家火星店里，发现这家店有个特别的规矩：你可以用任何星球的硬币付钱，但是绝不找零，当然也不能欠债。韩梅梅手边有 10​4​​ 枚来自各个星球的硬币，需要请你帮她盘算一下，是否可能精确凑出要付的款额。

输入格式：

输入第一行给出两个正整数：N（≤10​4​​）是硬币的总个数，M（≤10​2​​）是韩梅梅要付的款额。第二行给出 N 枚硬币的正整数面值。数字间以空格分隔。

输出格式：

在一行中输出硬币的面值 V​1​​≤V​2​​≤⋯≤V​k​​，满足条件 V​1​​+V​2​​+...+V​k​​=M。数字间以 1 个空格分隔，行首尾不得有多余空格。若解不唯一，则输出最小序列。若无解，则输出 No Solution。

注：我们说序列{ A[1],A[2],⋯ }比{ B[1],B[2],⋯ }“小”，是指存在 k≥1 使得 A[i]=B[i] 对所有 i

输入样例 1：

8 9
5 9 8 7 2 3 4 1

输出样例 1：

1 3 5

输入样例 2：

4 8
7 2 4 3

输出样例 2：

No Solution

解题思路 

由于要输出最小序列，所以先给数组v[]排序。

本题的01背包中，dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]] + v[i])。也就是说dp[i][j]的值是由dp[i-1][j]和dp[i-1][j-v[i]] + v[i]中的较大者决定的，当两者相同时，就会产生多解。反过来说，dp[i][j]可能会决定dp[i+1][j]或者dp[i+1][j+v[i+1]]。用一个二维数组way[i][j]（初始化为0）来储存dp[i][j]所决定的对象（1为dp[i+1][j]，2为dp[i+1][j+v[i+1]]，3为两者都能决定）。然后就把路径记录好了，可以用来搜索了。

如果dp[n][m]小于m说明没有方案可以凑到，就直接输出"No Solution"。

否则，因为要求输出最小序列，所以要从小到大试过去。开一个循环i从0到n-1，每次从（i, 0）开始dfs，因为dp[i+1][v[i+1]]都是由dp[i][0]决定的（就是第一个放入背包的要从小到大尝试）。然后用一个stack储存答案，如果找到了等于m的点，就返回true，当dp[i][j]可以决定dp[i+1][j+v[i+1]]的时候（选择v[i+1]加入背包），在返回true前把v[i+1]入栈。如果没有路了（way[i][j] == 0），就返回false。（这段说的有点乱，看代码吧）

还有一点需要注意，当way[i][j]==3的时候，要先dfs （i+1，j+v[i+1]）再dfs（i+1,j）。因为前者把v[i+1]放入背包，后者没有，那就会放入一个比v[i+1]大的。

dfs代码如下

bool dfs(int x, int y, stack& sta)
{
	if(dp[x][y] == m)
		return true;
	if(way[x][y] == 1){
		if(dfs(x + 1, y, sta)){
			return true;
		}
	}
	else if(way[x][y] == 2){
		if(dfs(x + 1, y + v[x + 1], sta)){
			sta.push(v[x + 1]);
			return true;
		}	
	}
	else if(way[x][y] == 3){
		if(dfs(x + 1, y + v[x + 1], sta)){
			sta.push(v[x + 1]);
			return true;
		}		
		if(dfs(x + 1, y, sta))
			return true;
	}
	return false;
}

完整代码如下

#include 
#include 
#include 
#include 
#include 
using namespace std;
int dp[10005][105];
int v[10005];
int way[10005][105]; //1,x+1,y 2,x+1,y+v[x+1] 3,1and2
int n, m;
bool dfs(int x, int y, stack& sta)
{
	if(dp[x][y] == m)
		return true;
	if(way[x][y] == 1){
		if(dfs(x + 1, y, sta)){
			return true;
		}
	}
	else if(way[x][y] == 2){
		if(dfs(x + 1, y + v[x + 1], sta)){
			sta.push(v[x + 1]);
			return true;
		}	
	}
	else if(way[x][y] == 3){
		if(dfs(x + 1, y + v[x + 1], sta)){
			sta.push(v[x + 1]);
			return true;
		}		
		if(dfs(x + 1, y, sta))
			return true;
	}
	return false;
}
int main()
{
	while(cin >> n >> m){
		for(int i = 1; i <= n; i ++)
			cin >> v[i];
		memset(dp, 0, sizeof(dp));
		memset(way, 0, sizeof(way));
		sort(v + 1, v + n + 1);
		for(int i = 1; i <= n; i ++){
			for(int j = 1; j <= m; j ++){
				if(j - v[i] < 0){
					dp[i][j] = dp[i - 1][j];
					if(!way[i - 1][j]){
						way[i - 1][j] = 1;
					}
					else                    //已经决定了一种 
						way[i - 1][j] = 3;
				}			
				else {
					dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + v[i]);
					if(dp[i - 1][j] >= dp[i - 1][j - v[i]] + v[i]){
						if(way[i - 1][j])
							way[i - 1][j] = 3;
						else
							way[i - 1][j] = 1;
					}
					if(dp[i - 1][j] <= dp[i - 1][j - v[i] + v[i]]){
						if(way[i - 1][j - v[i]])
							way[i - 1][j - v[i]] = 3;
						else
							way[i - 1][j - v[i]] = 2;
					}					
				}			
			}
		}
		
		if(dp[n][m] != m)
			cout << "No Solution" << endl;
		else{
			for(int i = 0; i < n; i ++){
				stack sta;
				if(dfs(i, 0, sta)){
					bool first = true;
					while(!sta.empty()){
						if(first)
							first = false;
						else
							cout << " ";
						cout << sta.top();
						sta.pop();
					}
					cout << endl;
					break;
				}
			}		
		}
	}
	return 0;
}