dfs处理的问题

搜索 有状态约束的 问题

POJ-1321

在一个给定形状的棋盘(形状可能是不规则的)上面摆放棋子,棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列,请编程求解对于给定形状和大小的棋盘,摆放k个棋子的所有可行的摆放方案C。
Input
输入含有多组测试数据。
每组数据的第一行是两个正整数,n k,用一个空格隔开,表示了将在一个n*n的矩阵内描述棋盘,以及摆放棋子的数目。 n <= 8 , k <= n
当为-1 -1时表示输入结束。
随后的n行描述了棋盘的形状:每行有n个字符,其中 # 表示棋盘区域, . 表示空白区域(数据保证不出现多余的空白行或者空白列)。
Output
对于每一组数据,给出一行输出,输出摆放的方案数目C (数据保证C<2^31)。

 1 #include<iostream>
 2 #include<algorithm>
 3 #include<string>
 4 #include<string.h>
 5 #include<cstdio>
 6 using namespace std;
 7 #define maxn 1000
 8 char a[10][10];
 9 int vis[10];
10 int n,k,m;
11 long long cnt=0;
12 void dfs(int x)//按行遍历
13 {
14     if(m==k)
15     {
16         cnt++;
17         return;
18     }
19     if(x>=n)
20         return ;
21     for(int i=0;i<n;i++)
22     {
23         if(a[x][i]=='#'&&vis[i]==0)
24         {
25             vis[i]=1;
26             m++;
27             dfs(x+1);
28             vis[i]=0;
29             m--;
30         }
31     }
32     dfs(x+1);
33 }
34 int main()
35 {
36     while(cin>>n>>k)
37     {
38     if(n==-1&&k==-1)
39     break;
40     cnt=0,m=0;
41     memset(vis,0,sizeof(vis));
42     for(int i=0;i<n;i++)
43          scanf("%s",&a[i]);
44     dfs(0);
45     cout<<cnt<<endl;
46     }
47 }

方法二:-----超时dfs思想

 1 #include<iostream>
 2 #include<algorithm>
 3 #include<string>
 4 #include<string.h>
 5 #include<cstdio>
 6 using namespace std;
 7 int n,k,cnt=0,m;
 8 char a[10][10];
 9 int vis[10];
10 void dfs(int x)
11 {
12     if(m==k)
13     {
14         cnt++;
15         return;
16     }
17     if(x>=n)
18         return;
19     for(int j=x;j<n;j++)
20     for(int i=0;i<n;i++)
21     {
22         if(a[j][i]=='#'&&vis[i]==0)
23         {
24             vis[i]=1;
25             m++;
26             dfs(x+1);
27             m--;
28             vis[i]=0;
29         }
30     }
31 }
32 int main()
33 {
34     while(cin>>n>>k)
35     {
36         cnt=0,m=0;
37         memset(vis,0,sizeof(vis));
38         if(n==-1&&k==-1)
39             break;
40         for(int i=0;i<n;i++)
41             scanf("%s",&a[i]);
42         dfs(0);
43         cout<<cnt<<endl;
44     }
45 }

二:连通性问题:

1.判断连通块数量问题

http://ybt.ssoier.cn:8088/problem_show.php?pid=1335

【输入样例】

3 3
1 1 1
0 1 0
1 0 

【输出样例】

3

分析:如图三个连通块表示分别用三个颜色表示

1 1 1
0 1 0
1 0 1

小结:感觉dfs写之前需要清楚知道dfs结束遍历条件,遍历是如何遍历的(比如:地图就是四个方向,该题也是四个方向,有些是树图就是for循环遍历)

两个for循环遍历每一块区域的某一个点 ,然后用dfs对该块区域所有点进行标记

 1 #include<iostream>
 2 #include<string>
 3 #include<cstdio>
 4 #include<string.h>
 5 using namespace std;
 6 int n,m;
 7 int a[105][105];
 8 int vis[105][105];
 9 int cnt=0;
10 int turn[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
11 void dfs(int x,int y)
12 {
13     if(x>n||y>m)
14         return;
15     for(int i=0;i<4;i++)
16     {
17         int tx=x+turn[i][0];
18         int ty=y+turn[i][1];
19         if(a[tx][ty]==1&&vis[tx][ty]==0)
20         {
21             vis[tx][ty]=1;
22             a[tx][ty]=0;//防止陷入死循环
23             dfs(tx,ty);
24         }
25     }
26 }
27 int main()
28 {
29     cin>>n>>m;
30     for(int i=1;i<=n;i++)
31         for(int j=1;j<=m;j++)
32         cin>>a[i][j];
33     memset(vis,0,sizeof(vis));
34     
35     for(int i=1;i<=n;i++)
36         for(int j=1;j<=m;j++)
37         {
38             if(a[i][j]==1&&vis[i][j]==0)//遍历每一块区域的某一个点  然后用dfs对该块区域所有点进行标记
39             {
40                 a[i][j]=0;
41                 vis[i][j]=1;
42                 dfs(i,j);
43                 cnt++;
44             }
45         }
46     cout<<cnt<<endl;
47 }

注意:这里很容易犯一个错误,就是把数组a的下标定为0开始,这是个false!!!!!!

原因:我们走四个方向是对该点坐标的x,y进行加一减一操作而进行,但是如果你下标是0,减一就是在下标越界!!!

解决:下标起始定为1

 

三.N皇后问题:https://cn.vjudge.net/problem/HDU-2553   打表加dfs

 

  • #include<iostream> #include<string> #include<cstdio> #include<string.h> using namespace std; int map1[11][11],n,cnt; int panduan(int x,int y){ for(int i=0;i<y;i++)//判断第x行前面是否被标记 if(map1[x][i]==1) return 0; for(int i=x-1,j=y-1;i>=0&&j>=0;i--,j--)//左上对角线判断前面是否存在与map[i][j]成对角线关系的点被标记 { if(map1[i][j]==1) return 0; } for(int i=x+1,j=y-1;i<n&&j>=0;i++,j--)//右上对角线判断前面是否存在与map[i][j]成对角线关系的点被标记 { if(map1[i][j]==1) return 0; } return 1; } void dfs(int mysize){ if(mysize==n) { cnt++; } // cout<<"mysize:"<<mysize<<" cnt:"<<cnt<<endl; // for(int i=0;i<n;i++) // { // for(int j=0;j<n;j++) // cout<<map1[i][j]<<" "; // cout<<endl; // } for(int i=0;i<n;i++)//每行 { if(!map1[i][mysize]&&panduan(i,mysize)) { map1[i][mysize]=1; dfs(mysize+1); map1[i][mysize]=0; } } } int main() { int i; int re2sult[11]; for(i=0;i<11;i++) { memset(map1,0,sizeof(map1)); n=i+1; cnt=0; dfs(0); result[i]=cnt; } while(~scanf("%d",&n)&&n) { printf("%d\n",result[n-1]); } }

 

转载于:https://www.cnblogs.com/Aiahtwo/p/11035840.html

<think>好的,我现在需要处理用户关于深度优先搜索(DFS)算法的问题。首先,用户希望了解DFS的实现方法和常见问题。根据系统指令,我需要确保回答结构清晰,使用正确的中文,并且所有数学公式和代码块都符合格式要求。此外,还要生成相关问题并在引用处添加标识。 首先,回顾一下DFS的基本原理。DFS是一种图遍历算法,使用递归或栈结构,从起始节点尽可能深入探索,直到无法继续再回溯。需要标记已访问节点避免重复访问。这部分内容在引用[1]中有提到,所以需要在相关地方添加引用标识。 接下来,用户需要具体的实现方法。我应该分别给出递归实现和栈实现的代码示例。例如,递归实现可以用Python编写,定义一个函数,参数包括图、当前节点和已访问集合。在递归调用时遍历相邻节点。同时,栈的实现需要手动维护一个栈结构,循环处理直到栈空。代码块需要用三个反引号包裹,并标明语言。 然后,常见问题部分需要列举几个典型问题,比如循环处理、内存溢出、路径记录、非连通图处理以及选择递归还是栈。每个问题需要简要说明原因和解决方法,比如在循环处理中必须标记已访问节点,避免无限循环。路径记录时需要注意回溯,非连通图需要遍历所有节点等。 生成的相关问题应该与DFS的应用、优化、对比等相关。例如,DFS的时间复杂度、与BFS的区别、在二叉树遍历中的应用、解决迷宫问题的方法,以及如何避免栈溢出。这些问题可以帮助用户进一步学习DFS的不同方面。 最后,检查所有数学表达式是否正确使用$...$格式,例如在时间复杂度部分提到$O(V + E)$。独立公式如果有的话需要用$$...$$,但当前内容中可能没有需要独立公式的地方。确保引用标识正确添加,比如在基本原理部分末尾添加[^1]。同时,回答结构要清晰,分点说明实现和常见问题,保持语言流畅自然。 确认没有违反任何系统指令,特别是格式和引用部分。现在可以组织内容,确保每个部分符合要求,然后生成最终回答。</think>### 深度优先搜索(DFS)实现及常见问题 #### 1. DFS 算法实现 DFS 可通过**递归**或**显式栈**实现,核心思想是“深度优先”探索路径,并通过标记已访问节点避免重复遍历。 **递归实现示例(Python):** ```python def dfs_recursive(graph, node, visited=None): if visited is None: visited = set() visited.add(node) print(node) # 处理当前节点 for neighbor in graph[node]: if neighbor not in visited: dfs_recursive(graph, neighbor, visited) ``` **栈实现示例(Python):** ```python def dfs_stack(graph, start): visited = set() stack = [start] while stack: node = stack.pop() if node not in visited: visited.add(node) print(node) # 处理当前节点 # 将未访问的相邻节点逆序入栈(保证顺序与递归一致) stack.extend(reversed([n for n in graph[node] if n not in visited])) ``` --- #### 2. 常见问题及解决方法 1. **循环处理问题** *现象*:图中存在环时可能陷入无限循环。 *解决*:必须使用集合(如`visited`)严格标记已访问节点[^1]。 2. **内存溢出风险** *现象*:递归深度过大(如链状图)导致栈溢出。 *解决*:改用显式栈实现或设置递归深度限制(如Python的`sys.setrecursionlimit`)。 3. **路径记录与回溯** *现象*:需要记录完整路径时,需注意回溯操作。 *解决*:在递归返回前移除当前节点路径,或使用栈保存状态。 4. **非连通图遍历** *现象*:仅遍历起始节点连通分量,遗漏其他部分。 *解决*:遍历所有未访问节点作为起点。 5. **递归与栈的选择** *适用场景*:递归代码简洁但深度受限;显式栈更灵活,适合深度大或需自定义操作的场景。 --- #### 时间复杂度分析 DFS 的时间复杂度为$O(V + E)$,其中$V$为节点数,$E$为边数。空间复杂度为$O(V)$(递归调用栈或显式栈的存储)[^1]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值