poj 1010:STAMPS

1010:STAMPS
总时间限制: 1000ms 内存限制: 65536kB
描述
Have you done any Philately lately?

You have been hired by the Ruritanian Postal Service (RPS) to design their new postage software. The software allocates stamps to customers based on customer needs and the denominations that are currently in stock.

Ruritania is filled with people who correspond with stamp collectors. As a service to these people, the RPS asks that all stamp allocations have the maximum number of different types of stamps in it. In fact, the RPS has been known to issue several stamps of the same denomination in order to please customers (these count as different types, even though they are the same denomination). The maximum number of different types of stamps issued at any time is twenty-five.

To save money, the RPS would like to issue as few duplicate stamps as possible (given the constraint that they want to issue as many different types). Further, the RPS won’t sell more than four stamps at a time.
输入
The input for your program will be pairs of positive integer sequences, consisting of two lines, alternating until end-of-file. The first sequence are the available values of stamps, while the second sequence is a series of customer requests. For example:

1 2 3 0 ; three different stamp types
7 4 0 ; two customers
1 1 0 ; a new set of stamps (two of the same type)
6 2 3 0 ; three customers

Note: the comments in this example are not part of the data file; data files contain only integers.
输出
For each customer, you should print the “best” combination that is exactly equal to the customer’s needs, with a maximum of four stamps. If no such combination exists, print “none”.
The “best” combination is defined as the maximum number of different stamp types. In case of a tie, the combination with the fewest total stamps is best. If still tied, the set with the highest single-value stamp is best. If there is still a tie, print “tie”.

For the sample input file, the output should be:

7 (3): 1 1 2 3
4 (2): 1 3
6 —- none
2 (2): 1 1
3 (2): tie

That is, you should print the customer request, the number of types sold and the actual stamps. In case of no legal allocation, the line should look like it does in the example, with four hyphens after a space. In the case of a tie, still print the number of types but do not print the allocation (again, as in the example).Don’t print extra blank at the end of each line.
样例输入
1 2 3 0 ; three different stamp types
7 4 0 ; two customers
1 1 0 ; a new set of stamps (two of the same type)
6 2 3 0 ; three customers
样例输出
7 (3): 1 1 2 3
4 (2): 1 3
6 —- none
2 (2): 1 1
3 (2): tie

题目传送门在这儿

题目大意：给定n种邮票，每种邮票都可以取无限多张，先在给定m个客户的面值需求，每个客户最多取4张邮票，要求算出用邮票种类最少的方案，如果有两个方案邮票种类相同，那么取其中邮票数较少的方案，如果有票数也相等，则取其中邮票最大面值较大的方案，如果还想等，那么就输出tie。

算法思路：简单的枚举题，用dfs枚举每一次所选的邮票，现将邮票面值按顺序排序，这样好比较邮票的较大面值，如果有最优方案更新，将tie置为false，如果有两个最优方案相等，那么就将tie置为true，最后再按格式输出即可。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int stamps[300]={};
vector<int> ans;
vector<int> maxans;
bool tie=false;
int num;
int maxa=-1;
int cal(){
    int a=0;
    int la=-1;
    for(int i=0;i<ans.size();++i){
        if(la!=ans[i]){
        la=ans[i];
        ++a;
        }
    }
    return a;
}
void dfs(int st,int value,int n){
    if(n>4)
        return;
    if(st==num)
        return;
    if(value==0){
        if(maxa<cal()){
            maxans=ans;
            maxa=cal();
            tie=false;
        }
        else if(maxa==cal()){
            if(ans.size()<maxans.size()){
                maxans=ans;
                tie=false;
            }
            else if(ans.size()==maxans.size()){
                if(stamps[ans[ans.size()-1]]>stamps[maxans[maxans.size()-1]]){
                    ans=maxans;
                    tie=false;
                }
                else if(stamps[ans[ans.size()-1]]==stamps[maxans[maxans.size()-1]]){
                tie=true;
                }
            }
        }
        return;
    }
    for(int i=st;i<num;++i){
        if(value>=stamps[i]){
            ans.push_back(i);
            dfs(i,value-stamps[i],n+1);
            ans.pop_back();
        }
    }
    return;
}
int main(){
    while(cin>>stamps[0]){
    num=1;
    while(cin>>stamps[num],stamps[num])
        ++num;
    sort(stamps,stamps+num);
    int value;
    while(cin>>value,value){
        tie=false;
        maxa=-1;
        ans.clear();
        maxans.clear();
        dfs(0,value,0);
        if(tie){
            cout<<value<<" ("<<maxa<<"): tie"<<endl;
            continue;
        }
        if(maxans.size()!=0){
        cout<<value<<" ("<<maxa<<"): ";
        for(int i=0;i<maxans.size();++i)
            cout<<stamps[maxans[i]]<<" ";
        cout<<endl;
        }
        if(maxans.size()==0){
        cout<<value<<" ---- none"<<endl;
        }
    }
    }
}