1342 Lotto【dfs】

Lotto

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 1724    Accepted Submission(s): 845

Problem Description

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

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
  
  

一个比较复杂的 dfs 题目，其实也是比较简单的，只是把给定的数的全部的组合按顺序打印出来而已......

最近两天学了递归和dfs，感觉的确有些难懂，昨天见到学长写的把所有的排列打出来的代码，感觉好神奇啊！！就看着看着去理解，也差不多理解了点，今天见到这个题，就自己琢磨了...打出所有的组合，这个比着打出全排列少了很多东西。肯定是要加限定条件的，然后自己试着改造打印全排列的程序，最后想到，全部的组合，肯定是每个后一项都大于前一项，就想着加限定，没想到竟然加对了，哈哈~~

说说自己对这个程序的理解吧，这个程序比较简单的 dfs 递归调用的小功能，在循环中递归，那么递归几次，相当于几层循环，也就是相当于用几层循环来控制输出给出的值，这个理解了，那么自己给程序加上限定条件达到想要的目的，会好理解很多......这个只能自己理解，别人基本帮不上忙......

ps：

因为每一次递归调用，递归内部都有一个循环，那么就跳进了循环，只有当这一层循环执行完毕，才会返回到上一次的循环，所以这样在循环里调用递归的方法，有多少次递归（和限定条件有关），那么就相当于执行了几层循环！也就相当于循环打出所有的排列组合了...

#include<stdio.h>
#include<string.h>
int x[105],y[105],z[105],n,kase;
void dfs(int v)
{
    if(v==6)//控制什么时候输出
    {
        int i;
        for(i=0;i<5;++i)
        {
            printf("%d ",x[i]);
        }
        printf("%d\n",x[i]);//注意每行最后没有空格
        return;
    }
    for(int i=0;i<n;++i)//这个循环递归，相当于多层循环...
    {
        if(!z[i])
        {
            z[i]=1;//标记上
            x[v]=y[i];
            if(v==0||(x[v-1]<x[v]))//这个就是限定，只打印排列
            {
                dfs(v+1);//满足以上条件，就继续递归循环
            }
            z[i]=0;//取消标记
        }
    }
}
int main()
{
    while(scanf("%d",&n),n)
    {
        memset(z,0,sizeof(z));//.这个不能少
        if(kase++)//输出的空行注意啊
        {
            printf("\n");
        }
        for(int i=0;i<n;++i)//输入...
        {
            scanf("%d",&y[i]);
        }
        dfs(0);//调用输出....
    }
    return 0;
}