利用递归来模拟多重嵌套循环.

 //利用递归来模拟多重嵌套循环.

如以下循环:

1

2

3

4

5

6

for(int i=0;i<100;i++)

    for(int j=0;j<100;j++)

        for(int k=0;k<100;k++){

            System.out.println("hello!");

        }

   

对应递归:

public static void demo(){    int[] counts = new int[3];    counts[0] = 1;    counts[1] = 2;    counts[2] = 3;     for(int i=0;i<counts[0];i++)        for(int j=0;j<counts[1];j++)            for(int k=0;k<counts[2];k++){                System.out.println("hello!");            }     int index = 0;//下标    dfs(counts,index);//对应递归} //对应递归,和i,j,k的三层循环执行顺序和效果想通过.public static void dfs(int[] counts,int index){    for(int i=0;i<counts[index];i++){        if(index == counts.length-1){//到最后一个循环控制变量k了            System.out.println("hello");        }        else{            dfs(counts,index+1);        }    }}

应用:

卢卡斯的驱逐者大军已经来到了赫柏的卡诺萨城，赫柏终于下定决心,集结了大军,与驱逐者全面开战。
卢卡斯的手下有6名天之驱逐者，这6名天之驱逐者各赋异能，是卢卡斯的主力。
为了击败卢卡斯，赫柏必须好好考虑如何安排自己的狂战士前去迎战。
狂战士的魔法与一些天之驱逐者的魔法属性是相克的，第i名狂战士的魔法可以克制的天之驱逐者的集合为Si(Si中的每个元素属于[0,5])。
为了公平，两名狂战士不能攻击同一个天之驱逐者。
现在赫柏需要知道共有多少种分派方案。
例：
S1={01},S2={23}，代表编号为0的狂战士的魔法可以克制编号为0和编号为1的天之驱逐者，编号为1的狂战士的魔法可以克制编号为2和编号为3的天之驱逐者，共有四种方案：02,03,12,13。
02---代表第一个狂战士负责编号为0的驱逐者，第二个狂战士负责编号为2的驱逐者；
03---代表第一个狂战士负责编号为0的驱逐者，第二个狂战士负责编号为3的驱逐者；
12---代表第一个狂战士负责编号为1的驱逐者，第二个狂战士负责编号为2的驱逐者;
13---代表第一个狂战士负责编号为1的驱逐者，第二个狂战士负责编号为3的驱逐者;
S1={01},S2={01}，代表编号为0的狂战士的魔法可以克制编号为0和编号为1的天之驱逐者，编号为1的狂战士的魔法可以克制编号为0和编号为1的天之驱逐者，共有两种方案：01,10。

输入描述:

多组测试数据，请处理到文件结束。
对于每组测试数据：
第一行为一个整数N，代表狂战士的数量。
第二行为N个字符串，第i个字符串表示第i个狂战士能够克制的天之驱逐者的集合。
保证：
1<=N<=6，1<=每个字符串的长度<=6，且每个字符都是0~5中的一个数字。

输出描述:

输出一个整数，代表分配方案数

输入例子:

201 23201 0133 015 5

输出例子:

422

分析: 可以套用for循环嵌套的模型来解决. 但是由于:1,狂战士数量未知 2,狂战士数量可能很多,最多需要写6层的嵌套.所以采用递归来实现和循环嵌套相同的执行过程.

<span style="color:#999999;">import java.util.Scanner;public class Main{       static String res = "";//每个可能的组合结果    static int num = 0;//所求组合数量        public static void main(String[] args) {               Scanner in = new Scanner(System.in);       int xb = 0;       while(in.hasNext()){           int count = in.nextInt();           String[] Si = new String[count];                       for(int i=0;i<count;i++)               Si[i] = in.next();                       dfs(Si,xb);           System.out.println(num);                       res = "";           num = 0;       }   }    //递归,和循环嵌套模型执行顺序相同   private static void dfs(String[] Si,int xb) {       for(int i=0;i<Si[xb].length();i++){           if(!res.contains(Si[xb].charAt(i)+"")){               if(xb == Si.length-1){//到了数组尾                   num++;               }               else{                   res = res + Si[xb].charAt(i);                   dfs(Si, xb+1);                   res = res.substring(0,res.length()-1);               }           }       }   }}</span>