深度优先搜索dfs之1到n的全排列（收藏）

1. /******** 
2. *给你一个数n，输出1到n的全排列 
3. *深度优先搜索 
4. ********/   
5.   
6.   
7. #include <stdio.h>  
8. #include <stdlib.h>  
9. int book[10], a[10], n;  
10.   
11. void dfs(int step)  
12. {  
13.     int i;  
14.     if(step == n+1)//当你在第n+1步的时候，说明前n部已经排好了。   
15.     {  
16.         for(i = 1; i <= n; i++)  
17.             printf("%d ", a[i]);  
18.         printf("\n");  
19.           
20.         return ;//返回之前的一步；   
21.     }  
22.   
23.     for(i = 1; i <= n; i++)//按照1，2，3.。。的方式一一尝试。   
24.     {  
25.         if(book[i]==0)//判断扑克牌i是不是还在手里   
26.         {  
27.             a[step]=i;//将i牌放在第step个盒子里。   
28.             book[i]=1;//表示扑克牌不再第step个盒子里   
29.             dfs(step+1);//继续下一步。   
30.             book[i]=0;//将刚才尝试的扑克收回，才能进行下一步的尝试。   
31.         }  
32.     }  
33.     return ;//结束搜索。   
34. }  
35. int main()  
36. {  
37.     while(~scanf("%d", &n))  
38.         dfs(1);  
39.       
40.     return 0;  
41.  }   

    

-------------------------------------------------------分割线---------------------------------------------------------------

全排列：

全排列是将一组数按一定顺序进行排列，如果这组数有n个，那么全排列数为n!个。

从集合中依次选出每一个元素，作为排列的第一个元素，然后对剩余的元素进行全排列，如此递归处理，从而得到所有元素的全排列。

以对字符串abc进行全排列为例，我们可以这么做：以abc为例
固定a，求后面bc的排列：abc，acb，求好后，a和b交换，得到bac
固定b，求后面ac的排列：bac，bca，求好后，c放到第一位置，得到cba
固定c，求后面ba的排列：cba，cab。

这个思想和回溯法比较吻合。

代码可如下编写所示

[cpp]  view plain  copy

1. // 回溯法搜索全排列树  
2.   
3. #include<stdio.h>  
4.   
5. #define M 20  
6. int n;  
7. int a[M];  
8. int cnt = 0;// 记录全排列个数  
9.   
10. void swap(int *a, int *b)//交换a,b  
11. {  
12.     char t;  
13.     t = *a;  
14.     *a = *b;  
15.     *b = t;  
16. }  
17.   
18. void dfs(int cur)  
19. {  
20.     int i;  
21.     if(cur == n)// 找到 输出全排列  
22.     {  
23.         ++cnt;  
24.         for(i=0; i<n; i++)  
25.             printf("%d ", a[i]);  
26.         printf("\n");  
27.     }  
28.     else  
29.     {  
30.          // 将集合中的所有元素分别与第一个交换，这样就总是在  
31.         // 处理剩下元素的全排列(即用递归)  
32.         for(i=cur; i<n; i++)  
33.         {  
34.             swap(&a[cur], &a[i]);  
35.             dfs(cur+1);  
36.             swap(&a[cur], &a[i]);//回溯  
37.         }  
38.     }  
39. }  
40.   
41.   
42. int main()  
43. {  
44.     while(scanf("%d", &n) != EOF)  
45.     {  
46.         for(int i=0; i<n; i++)  
47.             a[i] = i+1;// 假设集合S为:1 2 3 ... n  
48.         cnt = 0;  
49.         dfs(0);  
50.         printf("count:%d\n", cnt);  
51.     }  
52.     return 0;  
53. }  

或者利用一个vis数组标识每个元素是否已经被访问，代码如下：

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. int a[10];  
4. bool vis[10];  
5. int n;//排列个数 n  
6. void dfs(int dep)  //打印所有的全排列，穷举每一种方案  
7. {  
8.     if(dep == n)  
9.     {  
10.         for(int i = 0; i < n; i++)  
11.         {  
12.             printf("%d ",a[i]);  
13.         }  
14.         printf("\n");  
15.         return ;  
16.     }  
17.     for(int i = 0; i < n; i++)// 找一个最小的未标记的数字，保证了字典序最小  
18.     {  
19.         if(!vis[i])  
20.         {  
21.             a[dep] = i+1;  
22.             vis[i] = true;// 找到了就标记掉，继续下一层  
23.             dfs(dep + 1);  
24.             vis[i] = false;  
25.         }  
26.     }  
27. }  
28. int main()  
29. {  
30.     while(scanf("%d",&n) != EOF)  
31.     {  
32.         dfs(0);  
33.     }  
34.     return 0;  
35. }  

子集构造：

从n个元素的集合S中找出S满足某种性质的子集时，相应解空间树称为子集树。

求n个元素集合的子集，如A = {1, 2, 3}则A集合的子集有:  
 P(A) = {{1,2,3}, {1,2}, {1,3},{1},{2,3},{2},{3},{}}

采用位向量法，构造一个位向量vis[], vis[i] = 1 表示i在子集A中。

代码如下：

[cpp]  view plain  copy

1. #include<stdio.h>  
2.   
3. #define M 20  
4. int n;  
5. int a[M];  
6. int vis[M];  
7. int cnt = 0;// 记录子集个数  
8.   
9.   
10. void dfs(int cur)  
11. {  
12.     int i;  
13.     if(cur == n)// 找到 输出所有子集  
14.     {  
15.         ++cnt;  
16.         int flag =1;  
17.         for(i=0; i<n; i++)  
18.             if(vis[i])  
19.             {  
20.                 printf("%d ", a[i]);  
21.                 flag = 0;  
22.             }  
23.             if(flag)//子集中的空集  
24.                 printf("φ");  
25.         printf("\n");  
26.     }  
27.     else  
28.     {  
29.         for(i=1; i>=0; --i)//vis 中分为 选or不选即 1,0  
30.         {  
31.             vis[cur] = i;  
32.             dfs(cur+1);  
33.         }  
34.     }  
35. }  
36.   
37.   
38. int main()  
39. {  
40.     while(scanf("%d", &n) != EOF)  
41.     {  
42.         for(int i=0; i<n; i++)  
43.             a[i] = i+1;// 假设集合S为:1 2 3 ... n  
44.         cnt = 0;  
45.         dfs(0);  
46.         printf("count:%d\n", cnt);  
47.     }  
48.     return 0;  
49. }  

此外可以采用采用增量构造法，
代码如下：

[cpp]  view plain  copy

1. #include<stdio.h>  
2.   
3. #define M 20  
4. int n;  
5. int a[M];  
6. int vis[M];  
7. int cnt = 0;// 记录子集个数  
8.   
9.   
10. void subset(int cur, int A[])  
11. {  
12.     int i;  
13.     ++cnt;  
14.     if(0 == cur)//子集中的空集  
15.         printf("φ");  
16.     for(i=0; i<cur; ++i)// 打印当前集合  
17.     {  
18.         printf("%d ", A[i]);  
19.     }  
20.     printf("\n");  
21.       
22.     int min  = cur ? A[cur-1]:0;//确定当前元素的最小可能值  
23.     for(i=min; i<n; ++i)  
24.     {  
25.         A[cur] = a[i];  
26.         subset(cur+1, A);//递归构造  
27.     }  
28. }  
29.   
30.   
31. int main()  
32. {  
33.     while(scanf("%d", &n) != EOF)  
34.     {  
35.         for(int i=0; i<n; i++)  
36.             a[i] = i+1;// 假设集合S为:1 2 3 ... n  
37.         cnt = 0;  
38.         int A[M]={0};  
39.         subset(0, A);  
40.         printf("count:%d\n", cnt);  
41.     }  
42.     return 0;  
43. }