Lotto（DFS）

http://acm.hdu.edu.cn/showproblem.php?pid=1342

Lotto

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 3025    Accepted Submission(s): 1440

Problem Description

我们有一个游戏，从集合{1,2,3,...,49}中选择6个数来组成新的集合。现在我们有一种玩法是从这49个数字中选出k(k>6)个组成集合S，然后玩从S中选数字的游戏（选择6个数字组成新集合）。例如，k = 8, S = {1,2,3,5,8,13,21,34}, 那么有28中可能： [1,2,3,5,8,13], [1,2,3,5,8,21], [1,2,3,5,8,34], [1,2,3,5,13,21], ... [3,5,8,13,21,34]. 

你的工作是写一个程序读取整数k和集合S然后打印从S中选择数字的所有可能。
In a Lotto I have ever played, one has to select 6 numbers from the set {1,2,...,49}. A popular strategy to play Lotto - although it doesn't increase your chance of winning - is to select a subset S containing k (k>6) of these 49 numbers, and then play several games with choosing numbers only from S. For example, for k=8 and S = {1,2,3,5,8,13,21,34} there are 28 possible games: [1,2,3,5,8,13], [1,2,3,5,8,21], [1,2,3,5,8,34], [1,2,3,5,13,21], ... [3,5,8,13,21,34].
Your job is to write a program that reads in the number k and the set S and then prints all possible games choosing numbers only from S.

 

 

Input

输入包括0或多组测试用例。对每一组用例为一行包括多个用空格隔开的整数。这一行第一个数字是k（6<k<13）然后k个按升序排列的整数组成集合S。输入以k = 0结束。

The input file will contain one or more test cases. Each test case consists of one line containing several integers separated from each other by spaces. The first integer on the line will be the number k (6 < k < 13). Then k integers, specifying the set S, will follow in ascending order. Input will be terminated by a value of zero (0) for k. 

 

 

Output

对每一组测试数据，打印所有的可能，每一种可能打印一行。每个游戏的数字必须按照升序排序，并且彼此相隔恰好一个空格。每种可能本身必须按照字典顺序排序，这意味着按照最低的数字先排序，然后按第二个排序，依此类推，如下面的示例输出所示。测试用例之间被空行隔开，最后一个测试用例之后没有空行。

For each test case, print all possible games, each game on one line. The numbers of each game have to be sorted in ascending order and separated from each other by exactly one space. The games themselves have to be sorted lexicographically, that means sorted by the lowest number first, then by the second lowest and so on, as demonstrated in the sample output below. The test cases have to be separated from each other by exactly one blank line. Do not put a blank line after the last test case. 

 

 

Sample Input

7 1 2 3 4 5 6 7

8 1 2 3 5 8 13 21 34

0

 

 

Sample Output

1 2 3 4 5 6

1 2 3 4 5 7

1 2 3 4 6 7

1 2 3 5 6 7

1 2 4 5 6 7

1 3 4 5 6 7

2 3 4 5 6 7

 

1 2 3 5 8 13

1 2 3 5 8 21

1 2 3 5 8 34

1 2 3 5 13 21

1 2 3 5 13 34

1 2 3 5 21 34

1 2 3 8 13 21

1 2 3 8 13 34

1 2 3 8 21 34

1 2 3 13 21 34

1 2 5 8 13 21

1 2 5 8 13 34

1 2 5 8 21 34

1 2 5 13 21 34

1 2 8 13 21 34

1 3 5 8 13 21

1 3 5 8 13 34

1 3 5 8 21 34

1 3 5 13 21 34

1 3 8 13 21 34

1 5 8 13 21 34

2 3 5 8 13 21

2 3 5 8 13 34

2 3 5 8 21 34

2 3 5 13 21 34

2 3 8 13 21 34

2 5 8 13 21 34

3 5 8 13 21 34

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;

int n;
int a[14],book[14];

void dfs(int step,int sum)
{
    if(step>n&&sum!=6)
    {
        return ;
    }
    if(step==n+1&&sum==6)
    {
        int flag=0;
        for(int i=1;i<=n;i++)
        {
            if(book[i]==1)
            {
                if(flag==0)
                {
                    printf("%d",a[i]);
                    flag=1;
                }
                else
                {
                    printf(" %d",a[i]);
                }
            }
        }
        printf("\n");
        return ;
    }
    for(book[step]=1;book[step]>=0;book[step]--)
    {
        if(book[step]==1)
        {
            dfs(step+1,sum+1);
        }
        else
        {
            dfs(step+1,sum);
        }
    }
}

int main()
{
    int flag=0;
    while(scanf("%d",&n))
    {
        if(n==0)
        {
            break;
        }
        if(flag==1)
        {
            printf("\n");
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        dfs(1,0);
        flag=1;
    }
    return 0;
}