poj1010 dfs/枚举

题意：
给出不同类型的一组邮票，不同类型的邮票面值可能相同。求符合用户输入面值，且最多取4张邮票的最佳方案。最佳方案满足以下要求：
类型数最多。
如果类型数相同，则张数少者。
如果张数也相同，则单张面值最大者。
如果以上都相同，则无最佳方案（平局）。
如果不能达到用户的输入面值，则输出none。

难度：**

算法：
1.dfs

2.暴搜(枚举)

/*
dfs：注意剪枝 
*/ 
#include<stdio.h>
#include <iostream>
#include <string.h>
#include <algorithm>
#include <map> 
using namespace std;

int stamp_val[100];			// stamp_val[i]=j：第i类邮票的面额是j 
int request[100];			// request[i]=j：第i位顾客的需求是j 
int best_ans[5];			// 记录最佳答案 
int curr_ans[5];			// 记录当前答案 
bool visited[100];			// 访问标志 
 	
int max_types;				// 最大类型数 
int min_stamp_num;			// 最少张数 
int highest_val;			// 最大面额 
bool isTie;					// tie标志 
int stamp_num;				// 邮票总数， stamp_val数组的长度 


// 更新最优解 
void updateBest()
{
	for (int i=1; i<=4; i++)
	{
		best_ans[i] = curr_ans[i];
	}
}

/*
curr_stamp_num:当前的邮票张数
curr_types:当前的邮票类型数
curr_highest:当前的最大面额
start:从第start个类型的邮票开始搜索
curr:当前已选所有邮票的总面额
request:客户输入的面额 
*/
void dfs(int curr_stamp_num,int curr_types,int curr_highest,int start,int curr,int request)
{
	// 判断是否出现了最优解 
	if (curr == request)
	{
		if (max_types < curr_types)
		{
			max_types = curr_types;
			min_stamp_num = curr_stamp_num;
			highest_val = curr_highest;
			isTie=false;
			updateBest();
		}
		else if (max_types == curr_types)
		{
			if (min_stamp_num >  curr_stamp_num)
			{
				min_stamp_num = curr_stamp_num;
				highest_val = curr_highest;
				isTie=false;
				updateBest();
			}
			else if (min_stamp_num ==  curr_stamp_num)
			{
				if (highest_val < curr_highest)
				{
					highest_val = curr_highest;
					isTie=false;
					updateBest();
				}
				else if (highest_val == curr_highest)
				{
					isTie = true;
				}
			}
		}
		return ;
	}
	// 已四张，返回 
	if (curr_stamp_num == 4)
	{
		return;
	}
	/*
	此处为何从start而不是0开始搜索？
	1.避免重复，如 1 1 2 同 1 2 1在数值上是相同的
	2.更重要的是：从0开始是错误的！
	  回溯结束时，节点i被置为false，那么搜索i+1时如果仍从0开始搜索，会误认为i未访问过，因此，类型数会误加1 
	*/
	for (int i=start; i<stamp_num; i++)
	{
		if (stamp_val[i] >0 && curr+stamp_val[i] <= request)
		{
			curr_ans[curr_stamp_num+1]=stamp_val[i];
			if (visited[i])
			{
				visited[i] = true;
				dfs(curr_stamp_num+1,curr_types,stamp_val[i],i,curr+stamp_val[i],request);
			}
			else
			{
				visited[i] = true;
				dfs(curr_stamp_num+1,curr_types+1,stamp_val[i],i,curr+stamp_val[i],request);
			}
			visited[i] = false;
			curr_ans[curr_stamp_num+1]=0;
		}
	}
}


int main()
{
	int tmp;
	while (scanf("%d",&tmp)!=EOF)
	{
		int stamp_value;
		stamp_num = 1;
		int req;
		int customer_num = 0;
		memset(stamp_val,0,sizeof(int));
		memset(request,0,sizeof(int));
		memset(best_ans,0,sizeof(int));
		memset(curr_ans,0,sizeof(int));
		memset(visited,false,sizeof(bool));
		
		stamp_val[0] = tmp;
		while (scanf("%d",&stamp_value))
		{
			if (stamp_value == 0)
			{
				break;
			}
			stamp_val[stamp_num++] = stamp_value;
		}
		while(scanf("%d",&req))
		{
			if (req == 0)
			{
				break;
			}
			request[customer_num++] = req;
		}
		sort(stamp_val,stamp_val+stamp_num);
	
		for (int i=0; i<customer_num; i++)
		{
			max_types = 0;
			isTie = false;
			min_stamp_num = 0;
			if (stamp_val[stamp_num-1]*4 >= request[i] && stamp_val[0] <= request[i])
			{
				dfs(0,0,0,0,0,request[i]);
			}
			printf("%d ",request[i]);
			if (max_types == 0)
			{
				printf("---- none\n");
			}
			else if (isTie)
			{
				printf("(%d): tie\n",max_types);
			}
			else 
			{
				sort(best_ans,best_ans+5);
				printf("(%d):",max_types);
				for (int j=1; j<=4; j++)
				{
					if (best_ans[j] == 0)
					{
						continue;
					}
					printf(" %d",best_ans[j]);
				}
				printf("\n");
			}
		}
	}
}

/*
枚举/暴搜：注意剪枝，如果面值相同的邮票超过5枚，其它的"剪掉" 
*/ 

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
using namespace std; 

int cmp(const void* a,const void* b)
{
    return (int*)a - (int*)b;
} 

struct ANS
{
    int types;
    int num ;
    int max_value ;
    int stamps[30];
}; 


int stamps[100];
int request[100];

// 获取类型数 
int get_types(int a, int b, int c, int d)
{
    map<int,int> mp;
    mp[a]++;
    mp[b]++;
    mp[c]++;
    mp[d]++;
    mp.erase(0);
    return mp.size();
}

int main()
{
    int tmp;
    while (scanf("%d",&tmp)!=EOF)
    {
    	int stamp_num,req,stamp_value ;
    	int customer_num = 1;
    	memset(stamps,0,sizeof(stamps));
    	memset(request,0,sizeof(request));
    	stamps[1] = tmp;
    	stamp_num = 2;
    	
    	map<int,int> mp;
    	mp[tmp]++;
	    while(scanf("%d",&stamp_value))
	    {
	        if (stamp_value == 0)
	        {
	            break; 
	        } 
	        mp[stamp_value]++;
	        // if the number of the stamps which have the same value is more than 5,then do not put it into stamps arrays. 
	        if (mp[stamp_value] < 6)
	        {
	        	stamps[stamp_num++] = stamp_value;
	        }
	    }
	    while(scanf("%d",&req))
	    {
	        if (req == 0)
	        {
	            break;
	        }
	        request[customer_num++] = req;
	    }
	    qsort(stamps,stamp_num,sizeof(int),cmp);
	   
	    // for each person
	    int curr;
	    for (int i=1; i<customer_num; i++)
	    {
	        // curr = 0;
	        ANS tmp_ans;
	        ANS best_ans = {0,0,0,{0,0,0,0,0}};                    
	        bool tier = false;
	        // the fist stamp
	        for (int j=0; j<stamp_num; j++)
	        {
	            // the second stamp
	            for (int k=j; k<stamp_num; k++)
	            {
	                // the third stamp
	                for (int l=k; l<stamp_num; l++)
	                {
	                    // the forth stamp
	                    for (int m=l; m<stamp_num; m++)
	                    {
	                        curr = stamps[j] + stamps[k] + stamps[l] + stamps[m];
	                        if (curr > request[i])
	                        {
	                        	break;
	                        }
	                        else if (curr == request[i])
	                        {
	                            tmp_ans.max_value =  max(max(stamps[j],stamps[k]),max(stamps[l],stamps[m]));
	                            tmp_ans.types = get_types(j,k,l,m);
	
	                            int cnt=1;
	                            if (stamps[j] != 0)
	                            {
	                                tmp_ans.stamps[cnt++] = stamps[j];
	                            }    
	                            if (stamps[k] != 0)
	                            {
	                                tmp_ans.stamps[cnt++] = stamps[k];
	                            }
	                            if (stamps[l] != 0)
	                            {
	                                tmp_ans.stamps[cnt++] = stamps[l];
	                            }
	                            if (stamps[m] != 0)
	                            {
	                                tmp_ans.stamps[cnt++] = stamps[m];
	                            }
	                            tmp_ans.num = cnt-1;    
	                            
								// compare the tmp answer with the current best answer
	                            bool flag = false;
	                            if (tmp_ans.types > best_ans.types)
	                            {
	                                flag = true;
	                                tier = false;
	                            }            
	                            else if (tmp_ans.types == best_ans.types)
	                            {
	                                if (tmp_ans.num < best_ans.num)
	                                {
	                                    flag = true;
	                                    tier = false;
	                                }
	                                else if (tmp_ans.num == best_ans.num)
	                                {
	                                    if (tmp_ans.max_value > best_ans.max_value)
	                                    {
	                                        flag = true;
	                                        tier = false;
	                                    }
	                                    else if (tmp_ans.max_value == best_ans.max_value)
	                                    {
	                                        tier = true;
	                                    }
	                                }
	                            }
	                            
	                            // update the best answer
	                            if (flag)
	                            {
	                                best_ans.num = tmp_ans.num;
	                                best_ans.types = tmp_ans.types;
	                                best_ans.max_value = tmp_ans.max_value;
	                                for (int ii=1; ii<=best_ans.num; ii++)
	                                {
	                                    best_ans.stamps[ii] = tmp_ans.stamps[ii];
	                                }
	                            }
	                        }
	                    }
	                }
	            }
	        }
	        // output the answer
	        printf("%d ",request[i]);
	        if (best_ans.num == 0)
	        {
	            printf("---- none\n");
	        }
	        else if (tier)
	        {
	            printf("(%d): tie\n",best_ans.types);
	        }
	        else 
	        {
	            sort(best_ans.stamps,best_ans.stamps+5);
	            printf("(%d):",best_ans.types);
	            for (int j=1; j<=4; j++)
	            {
	                if (best_ans.stamps[j] == 0)
	                {
	                    continue;
	                }
	                printf(" %d",best_ans.stamps[j]);
	            }
	            printf("\n");
	        }
	    }
	}
}