poj2245(枚举||组合数学||dfs)

http://poj.org/problem?id=2245

Lotto

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 5641		Accepted: 3588

Description

In the German Lotto you have 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

The input 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

Source

Ulm Local 1996

题意：在k个数里选出6个数按照字典序输出

在玩德国游戏Lotto时，要从集合{1，2，……，49}中取出六个数。

一个非常流行的玩法（尽管这种玩法并不能增加你赢的机会）是从这49个数字中取出k个数字（6<k）组成子集S。然后玩游戏的时候仅从S中取出数字。

例如，当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中取数的所有可能游戏。

输入

输入文件包括一个或多个测试情形。

每种情形一行，由多个整数组成，整数之间用空格分隔。行首整数即为k值（6<k<13）。

接着是用于描述集合S的k个整数，全部以升序排列。

在k的位置输入零（0）即表示输入结束。

输出：

对于每一个测试情形，打印出所有可能游戏，每个游戏一行。

每个游戏中的数字必须以升序排列，每两个之间用一个空格分隔。而这些游戏要用类似于字典编纂的方式排序，也就是说，先对最低位排序，然后是第二低位，依次类推，就像输出举例中演示的那样。

按照一开始理解成按照字典序输出Ck6种情况就调用next_permutation()。把产生的数据与测试数据一对发现出大问题了。。。嗨。。题都没看懂就做题。去死只能感叹dfs的强大，这里都用的上啊

 #include <cstdio>
#include <cstring>
static const int MAXN = 15;
int a[MAXN], n;
int ans[MAXN];
void dfs(int index, int depth)//递归填充数并打印组合,相当于DFS过程
{
    if(depth == 6)
    {
        printf("%d", ans[0]);
        for(int i=1;i<6;++i)//如果填充满了6个数，则打印
        {
            printf(" %d", ans[i]);
        }
        printf("\n");
        return;
    }
    for(int i=index;i<n;++i)//未***********************
    {
        ans[depth] = a[i];//上次递归过程填充的是a[i-1],这次递归从a[i]开始填充
        dfs(i+1, depth+1);//填充下一个位置
    }
}
int main()
{
    bool flag = false;
    while(scanf("%d",&n), n)
    {
        if(flag)
        {
            printf("\n");
        }
        else
        {
            flag = true;
        }
        for(int i=0;i<n;++i)
        {
            scanf("%d", &a[i]);
        }
        dfs(0, 0);//递归调用从0 0开始
    }
    return 0;
}