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

原文地址：https://blog.csdn.net/haiboself/article/details/51946327

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

如以下循环:

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!" );

}

对应递归:

[java]view plain copy
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中的一个数字。

输出描述:

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

输入例子:

输出例子:

4
2
2

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

[java]view plain copy
<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>  