DFS题库+详解

最新推荐文章于 2022-05-10 11:35:06 发布
最新推荐文章于 2022-05-10 11:35:06 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： DFS 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45665007/article/details/107338542
版权

DFS

文章目录

1.走出迷宫-NC14572

小明现在在玩一个游戏，游戏来到了教学关卡，迷宫是一个N*M的矩阵。 小明的起点在地图中用“S”来表示，终点用“E”来表示，障碍物用“#”来表示，空地用“.”来表示。 障碍物不能通过。小明如果现在在点（x，y）处，那么下一步只能走到相邻的四个格子中的某一个：（x+1，y），（x-1，y），（x，y+1），（x，y-1）； 小明想要知道，现在他能否从起点走到终点。

输入描述：
本题包含多组数据。每组数据先输入两个数字N,M接下来N行，每行M个字符，表示地图的状态。数据范围：2<=N,M<=500保证有一个起点S，同时保证有一个终点E.
输出描述：
每组数据输出一行，如果小明能够从起点走到终点，那么输出Yes，否则输出No

输入：
3 3
S…
…E
…
3 3
S##

##E
输出：
Yes
No

#include<bits/stdc++.h>
#include<time.h>
#include<iostream>
#include<ostream>
#include<cstdio>
#include<algorithm>
#include<iomanip>
#include<cstring>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
#define maxn 10000000
typedef long long ll;
const int INF=0x7fffffff;//2147483647
const int SUP=0x80000000;//-2147483648
#define loop(a,b,i) for(int i=a;i<b;i++)
#define loopx(a,b,i) for(int i=a;i<=b;i++)
#define lson (p<<1)
#define rson ((p<<1)|1)
#define mid ((l+r)>>1)
#define MAX 100005
char dfs[505][505];
int dir[4][2]={1,0,-1,0,0,-1,0,1};
int n,m,flag;
void DFS(int x,int y)
{
    for(int i=0;i<4;i++)
    {
        int X=x+dir[i][0],Y=y+dir[i][1];
        if(X>=0&&X<n&&Y>=0&&Y<m&&dfs[X][Y]!='#'&&dfs[X][Y]!='1')
        {
            if(dfs[X][Y]=='E')flag=1;
            dfs[X][Y]='1';
            DFS(X,Y);
        }
    }
}
int main()
{
    while(cin>>n>>m)
    {
        int x,y;
        memset(dfs,'0',sizeof(dfs));
        flag=0;
        for (int i=0;i<n;i++)
            for (int j=0;j<m;j++)
            {
                cin>>dfs[i][j];
                if (dfs[i][j]=='S')
                {
                    x=i;y=j;
                }
            }
        DFS(x,y);
        if(flag)cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
}

2.数芝麻-NC14591

有天糖在宿舍闲着没事， 拿出粉笔在地上画了n*n个方格， 每个方格放上一定数量的芝麻， 并规定如果两个方格相邻且都有芝麻，那这两个方块都属于同一片区域。现在问你的是， 有没有存在这样的区域， 它的芝麻的总数量为m

输入描述：
有多组数据，每组数据第一行为n(n<=100)和m, 接下来有n行n列数据， 每个数字代表每个方格里的芝麻数量,， 当n和m等于0时结束输入。
输出描述：
对于每一组数据，输出一行，如果能找这样的区域， 输出”YES”, 否则输出“NO”。

输入：
3 2
1 0 0
1 0 1
1 0 1
0 0
输出：
YES

#include<bits/stdc++.h>
#include<time.h>
#include<iostream>
#include<ostream>
#include<cstdio>
#include<algorithm>
#include<iomanip>
#include<cstring>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
#define maxn 10000000
typedef long long ll;
const int INF=0x7fffffff;//2147483647
const int SUP=0x80000000;//-2147483648
#define loop(a,b,i) for(int i=a;i<b;i++)
#define loopx(a,b,i) for(int i=a;i<=b;i++)
#define lson (p<<1)
#define rson ((p<<1)|1)
#define mid ((l+r)>>1)
#define MAX 100005
int dfs[505][505];
int D[105][105];
int dir[8][2]={1,0,-1,0,0,-1,0,1};
int n,m,flag,sum;
void DFS(int x,int y)
{
    if(D[x][y]==1||dfs[x][y]==0||x<0||x>=n||y<0||y>=n)return;
    D[x][y]=1;
    sum+=dfs[x][y];
    for(int i=0;i<4;i++)
    {
        int X=x+dir[i][0],Y=y+dir[i][1];
        DFS(X,Y);
    }
}
int main()
{
    while(cin>>n>>m)
    {
        if(n==0&&m==0)break;
        int x,y;
        memset(dfs,0,sizeof(dfs));
        memset(D,0,sizeof(D));
        flag=0;
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
            {
                cin>>dfs[i][j];
            }
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                {
                    sum=0;
                    DFS(i,j);
                    if(sum==m)flag=1;
                }
        if(flag)cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}

3.邮票面值设计-NC16813（dp+dfs）

给定一个信封，最多只允许粘贴N张邮票，计算在给定K(N+K≤15)种邮票的情况下（假定所有的邮票数量都足够），如何设计邮票的面值，能得到最大值MAX,使在1至MAX之间的每一个邮资值都能得到。 例如，N=3,K=2，如果面值分别为1分、4分，则在1分～6分之间的每一个邮资值都能得到（当然还有8分、9分和 12分）；如果面值分别为1分、3分，则在1分～7分之间的每一个邮资值都能得到。可以验证当N=3,K=2时，7分就是可以得到的连续的邮资最大值，所以 MAX=7，面值分别为1分、3分。

输入描述：
1行。2个整数，代表N,K。
输出描述：
2行。第一行若干个数字，表示选择的面值，从小到大排序。第二行，输出“MAX=S”，S表示最大的面值。

输入：
3 2
输出：
1 3
MAX=7

思路：
1.首先面值里边必有1，故a[1]=1
2.其次直接枚举暴力会超时，故用dp来找到每次搜索的上确界进行搜素剪枝

#include<bits/stdc++.h>
#include<time.h>
#include<iostream>
#include<ostream>
#include<cstdio>
#include<algorithm>
#include<iomanip>
#include<cstring>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
#define maxn 10000000
typedef long long ll;
const int INF=0x7fffffff;//2147483647
const int SUP=0x80000000;//-2147483648
#define loop(a,b,i) for(int i=a;i<b;i++)
#define loopx(a,b,i) for(int i=a;i<=b;i++)
#define lson (p<<1)
#define rson ((p<<1)|1)
#define mid ((l+r)>>1)
#define MAX 100005
char mapp[50][50];
//int dir[8][2]={1,0,-1,0,0,-1,0,1,1,1,1,-1,-1,1,-1,-1};
int n,K;
int a[20];//存储邮票面值
int ans[20];//存储结果
int dp[50000];//储存组成x的邮票最小张数（dp[x]）
int maxx=0;//连续邮资最大值
int DP(int k)//找到k种类个数时的连续邮资最大值(搜索剪枝）
{
    memset(dp,63,sizeof(dp));dp[0]=0;
    for(int i=1;i<=k;i++)
        for(int j=a[i];j<=a[k]*n;j++)
            if(dp[j-a[i]]<n)
                dp[j]=min(dp[j],dp[j-a[i]]+1);
    int x=1;
    while(dp[x]<=20)x++;//得到k种时的连续邮资最大值
    return x-1;//返回k种时连续邮资最大值
}
void dfs(int k)//找到满足条件的最大连续邮资数
{
    if(k==K+1)
    {
        int t=DP(K);
        if(t>maxx)
        {
            maxx=t;
            memcpy(ans,a,sizeof(a));
        }
        return ;
    }
    int end=DP(k-1);//前一种类数所能达到的最大连续邮资数
    for(int i=a[k-1]+1;i<=end+1;i++)//枚举并向下搜索
    {
        a[k]=i;dfs(k+1);
    }
}
int main()
{
    cin>>n>>K;
    a[1]=1;
    dfs(2);
    for(int i=1;i<=K;i++)cout<<ans[i]<<" ";
    cout<<endl<<"MAX="<<maxx;
    return 0;
}

4.小H和游戏-NC15158（树+dfs+并查集思想）

小H正在玩一个战略类游戏，她可以操纵己方的飞机对敌国的N座城市(编号为1~N)进行轰炸 敌国的城市形成了一棵树，小H会依次进行Q次轰炸，每次会选择一个城市A进行轰炸，和这座城市距离不超过2的城市都会受损(这里距离的定义是两点最短路径上的边数)，轰炸结束后，小H还想知道当前城市A受损的次数 作为游戏的开发者之一，你有义务回答小H的问题

输入描述：
第1行，两个整数N(1≤N≤750000)、Q(1≤Q≤750000)第2到N行，每行两个整数表示树上的一条边第N+1~N+Q行，每行一个整数，表示小H这次轰炸的城市。
输出描述：
输出Q行，每行一个整数表示这一次轰炸的城市在此次轰炸后共计受损几次。

输入：
4 4
1 2
2 3
3 4
1
2
3
4
输出：
1
2
3
3
思路：
定义：直接受损：x直接被轰炸　　间接受损：x被相邻节点波及
1.用vector二维数组存储x的所有邻接点vector[x]
2.dfs(x,f)找x的父节点
3.cnt数组含义
cnt[x][0]–自己受损
cnt[x][1]–儿子受损
cnt[x][2]–孙子受损
4.每次询问节点x需要的操作：
①x会波及他的儿子和孙子：cnt[x][1]++;cnt[x][2]++;代表这是x波及的。
②x会波及父亲：cnt[fa[x]][0]++;
③用cnt[fa[x]][1]++;储存x直接受损，用父节点存储原因看5.
④x会波及到爷爷：cnt[fa[fa[x]]][0]++;
5.通过3.可以看出：
①cnt[x][0]代表x的儿子波及给x+x孙子波及给x
②cnt[fa[x]][1]代表x直接受损+x父亲因自身受损波及x受损。
所以用父节点存储儿子的直接受损。
故cnt[fa[x]][1]=x直接受损+x父亲直接受损所波及给x
③cnt[fa[fa[x]]][2]代表x的爷爷波及给x的
综上当前x受损数=x儿子和孙子波及给x的+x直接受损和父亲波及给x的+x爷爷波及给x的=cnt[x][0]+cnt[fa[x]][1]+cnt[fa[fa[x]][2]

#include<bits/stdc++.h>
#include<time.h>
#include<cctype>
#include<iostream>
#include<ostream>
#include<cstdio>
#include<algorithm>
#include<iomanip>
#include<cstring>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
#define maxn 10000000
typedef long long ll;
const int INF=0x7fffffff;//2147483647
const int SUP=0x80000000;//-2147483648
#define loop(a,b,i) for(int i=a;i<b;i++)
#define loopx(a,b,i) for(int i=a;i<=b;i++)
#define lson (p<<1)
#define rson ((p<<1)|1)
#define mid ((l+r)>>1)
#define MAX 100005
//char mapp[1005][1005];
//int dir[8][2]={1,0,-1,0,0,-1,0,1,1,1,1,-1,-1,1,-1,-1};
const int inf = 750010;
int n,q;
int maxx=0;
int cnt[inf][3];//存储该节点破损次数
//（cnt[x][0]--本身 cnt[x][1]--儿子 cnt[x][2]--孙子）
int fa[inf];//x的父亲是谁
vector<int>que[inf];//二维数组，存储树，节点关系
void dfs(int x,int f)//找x的父亲
{
    fa[x]=f;
    for(auto i : que[x])//遍历和x相邻节点
    {
        if(i==f)continue;//排除x的父亲
        else dfs(i,x);
    }
}
void solve()//询问
{
    dfs(1,0);//1的父亲是0
    memset(cnt,0,sizeof(cnt));
    while(q--)
    {
        int x;
        cin >> x;
        //cnt[x][0]--本身 cnt[x][1]--儿子 cnt[x][2]--孙子
        cnt[x][1]++;cnt[x][2]++;//x波及x的儿子和孙子，但不记录x自身
        cnt[fa[x]][0]++; cnt[fa[x]][1]++;//x父亲被波及破损，再将x直接破损记录在父节点上，这样父节点就可以表现x破损情况
        cnt[fa[fa[x]]][0]++;//x爷爷被x波及破损
        int s=cnt[x][0] + cnt[fa[x]][1] + cnt[fa[fa[x]]][2];
        //s=x被儿子或者孙子波及到次数+自身破损次数和受父亲波及+受爷爷波及
        cout<<s<<endl;
    }
}
int main()
{
    cin>>n>>q;
    int x,y;
    for(int i=1;i<=n-1;i++)
        {
            cin>>x>>y;
            que[x].push_back(y);//记录x相邻节点
            que[y].push_back(x);//记录y相邻节点
        }
    solve();
    return 0;
}

5.乌龟跑步-NC15294（四维数组dfs）

有一只乌龟，初始在0的位置向右跑。 这只乌龟会依次接到一串指令，指令T表示向后转，指令F表示向前移动一个单位。乌龟不能忽视任何指令。 现在我们要修改其中正好n个指令（一个指令可以被改多次，一次修改定义为把某一个T变成F或把某一个F变成T）。 求这只乌龟在结束的时候离起点的最远距离。（假设乌龟最后的位置为x，我们想要abs(x)最大，输出最大的abs(x)）

输入描述：
第一行一个字符串c表示指令串。c只由F和T构成。第二行一个整数n。1 <= |c| <= 100, 1 <= n <= 50
输出描述：
一个数字表示答案。

输入：
FT
1
FFFTFFF
2
输出：
2
6
思路：
定义四个参数的dfs：①当前字符串位置②剩余操作数③乌龟位置④面朝方向（1右0左）

#include<bits/stdc++.h>
using namespace std;
string h;
int n;
int length;
bool dp[105][55][205][2];
int ans=0;
void dfs(int def,int n,int pos,int way)
{
  if(def==length)//当走到字符串最末尾的时候
  {
      if((n%2)==0) ans=max(ans,abs(pos));
//判断是否剩余步骤数是2的倍数，因为只要是2的倍数，随便选取一个，
//比如F,先改为T，再改为F，每改两次便会回到原来的，
//故只要是2的倍数就能保证和剩余0操作步骤是一样的。
      return;
  }
  if(n<0||dp[def][n][pos][way]) return;//如果操作步数小于0说明上一次改写错误，即没有操作数却改变字符。
//不可以n<=0，因为若n=0，上一步是正确的，可能改了也可能没改，但这一步没有操作数了，只能选择不改。
  dp[def][n][pos][way]=1;//标记目前的状态，下次再到该状态的时候便停止
  if(h[def]=='F')
  {
      if(way==0)
      {
          dfs(def+1,n-1,pos,1);
                    //改变：字符串向前，操作数-1，位置不便（由前进变为改方向），方向变为正向1
          dfs(def+1,n,pos-1,0);
                   //不改变：字符串向前，操作数不变，位置向后退，方向不变保持负方向
      }
      else
      {
          dfs(def+1,n-1,pos,0);
                   //改变：字符串向前，操作数-1，位置不便（由前进变为改方向），方向变为负向0
          dfs(def+1,n,pos+1,1);
                   //不改变：字符串向前，操作数不变，位置向前进，方向不变保持正方向
      }
  }
  else
  {
      if(way==0)
      {
          dfs(def+1,n-1,pos-1,0);
          dfs(def+1,n,pos,1);
      }
      else
      {
          dfs(def+1,n-1,pos+1,1);
          dfs(def+1,n,pos,0);
      }
  }
}
int main()
{
cin>>h>>n;
length=h.size();
memset(dp,0,sizeof(dp));//先初始化为0
dfs(0,n,0,1);//开始字符串位置在0，有n个操作次数，乌龟位置为0，方向为正方向1
cout<<ans<<endl;
}

6.（）

Ycmapleaf
关注
专栏目录
【dfs】DFS练习题合集（to be countinue）
还有一年
08-14 1128
一些深搜题
DFS 和 BFS使用场景分析
weixin_45621536的博客
03-30 1518
1.dfs为深度搜索算法 可以在脑海中想像一颗树， 从根节点开始选择左子节点或右子节点向下并且标记，直到到达叶子结点。 回溯到上一层，看是否存在未被标记的节点，然后向下走。 应用场景： 1.排列组合问题 2.N * N 走迷宫问题 3.连通块 实战分析： 1.排列问题 94. 递归实现排列型枚举 - AcWing题库 #include <iostream> #include <cstring> #include <algorithm> using namespace st
dfs算法题库
weixin_52045928的博客
04-04 242
这是一些dfs的算法题。 dfs-全排列 dfs-选数 dfs-瓷砖铺放 dfs-铺地砖 dfs-凑算式子 dfs-字母阵列 dfs-算式900 dfs-牌型种类 dfs-打开所有的灯 dfs-Lake Counting S dfs-求细胞数量
DFS题目
weixin_53729021的博客
02-28 159
持续更新 ing~~~ 1.洛谷P1434 [SHOI2002]滑雪（dfs+记忆化搜索） 链接：P1434 [SHOI2002]滑雪 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 思路： dfs+记忆化搜索（有一点类似于dp） 不能写暴力的dfs，多余的搜索次数太多了，会直接超时，将已经搜索过的路径存下来，下一次走过的路就不用搜索了。 AC代码： #include <bits/stdc++.h> using namespace std; int dir.
dfs练习题
Cichard
04-20 314
POJ1321 棋盘问题 题意：#号位置可以放置棋子，给你一个n*n的棋盘，其中有多少种可以放置k个棋子的办法，同时要满足一个条件就是同一行同一列不能有两个棋子及以上 思路：dfs深搜，用vis数组标记各个列是否放置了妻子，board数组表示棋盘，dfs(i,j)表示到达了第i行，已经放置了j个棋子，注意回溯。具体实现看代码 #include <cstdio> #include &lt...
牛客题库 ACM Battle（dfs）
weixin_43791787的博客
03-24 258
https://ac.nowcoder.com/acm/problem/14122 原文章：https://www.cnblogs.com/GorgeousBankarian/p/10384302.html 这道题有些类似下棋，赢得方法就是尽快铺满棋盘。对于这种起点、终点不确定的找最优解的搜索应该用Dfs，找到每种点滴方法的结果并筛选。因为，连通的点，相互影响，更好的方法是遍历边，边只要其中一...
2017年南京财经大学826数据结构考研题库及答案详解
09-29
本资源针对的是2017年南京财经大学826数据结构考研科目的复习，包含了题库与答案详解，对于准备这个考试的学生来说具有极高的参考价值。 在数据结构的学习中，你需要掌握以下几个关键知识点： 1. **线性结构**：...
数据结构 题库及详解
06-19
图的遍历算法如深度优先搜索（DFS）和广度优先搜索（BFS）是解决许多问题的关键。 七、哈希表 哈希表通过哈希函数将键映射到数组的特定位置，实现快速查找。冲突解决策略如开放寻址法和链地址法是哈希表设计的重要...
leetcode题库-leetcode:leetcode
06-29
《LeetCode题库详解与深度探索》 LeetCode，作为全球知名的在线编程挑战平台，深受程序员们的喜爱。它提供了一系列的算法题目，旨在提升程序员的编程技能和问题解决能力。这个压缩包“leetcode-main”很可能是某位...
DFS常见模板题
星宇康的博客
07-06 763
是
红与黑
六级不考550+不改名
09-25 1037
题目描述 有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。 你站在其中一块黑色的瓷砖上，只能向相邻的黑色瓷砖移动。请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 输入格式 包括多组数据。每组数据的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量，W和H都不超过20。 在接下来的H行中，每行包括W个字符。每个字符表示一块瓷砖的颜色，规则如下: .：黑色的瓷砖； #：白色的瓷砖； @：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每组数据中唯一出现一次。 当在一
dfs各大题目类型
qq_61903556的博客
05-10 1194
1.遍历各个位置，并且记录每组遍历的路程 遍历各个位置的时候就在每个dfs（u）里遍历下一个dfs（u+1）。 记录路程用数组。 如果要求每个数只能用一次或者每个点只能走一次的话用一个bool或int数组来储存他的状态（遍历过或没遍历过） 如果问题有边界的情况，如给你了n个位置，或者是n*n的图我们遍历每一行的话，递归的出口就是当我们那层的数等于n，如果一个位置有多种情况（如能填多个数）的话，我们需要回溯操作的时候，先在dfs之前把状态修改，在dfs之后把状态复原。 例题1：n个数的全排列 题目
leetcode 576. 出界的路径数-DFS-库函数-动态规划
Julse的博客
08-17 236
题目来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems 特别鸣谢：来自夸夸群的 醉笑陪公看落花@知乎，王不懂不懂@知乎，QFIUNE@csdn 感谢醉笑陪公看落花@知乎 倾囊相授，感谢小伙伴们督促学习，一起进步 文章目录题目分析DFS - 超时DFS-字典实现备忘录-通过DFS- 库函数实现备忘录-通过DFS - 库函数 - 推导式 - 通过动态规划 - 通过运行效果 给你一个大小为 m x n 的网格和一个球。球的起始坐标为 [startRow, s.
牛客：乌龟跑步
WeChat:A15047825994
04-19 209
题目链接：https://ac.nowcoder.com/acm/problem/15294 题目描述： 有一只乌龟，初始在0的位置向右跑。 这只乌龟会依次接到一串指令，指令T表示向后转，指令F表示向前移动一个单位。乌龟不能忽视任何指令。 现在我们要修改其中正好n个指令（一个指令可以被改多次，一次修改定义为把某一个T变成F或把某一个F变成T）。 求这只乌龟在结束的时候离起点的最远距离。（假设乌龟最...
J - 炸弹人
qq_42865713的博客
02-12 353
给定一个N × N的2D地图，包含空地'.'，障碍'#'，敌人'E'和炸弹'B'。   当一枚炸弹爆炸时，冲击会向上下左右4个方向辐射，直到地图边界或者遇到障碍。   E E E..#..BEEBE . E 例如上图中的第3行7列的B爆炸时，除了第1列的E没被波及之外，其他E都会被炸到。 同时如果冲击波及到另一枚炸弹，会引发连锁反应，即被...
基于DFS的算法题
小李的专栏
09-01 583
迷宫寻物： n*m 矩阵中，1表示障碍，0表示通路，起始点任意，假设坐标为（0,0），目标点为（3,2）， 找到最短路径到达目标点。 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 这类问题一般使用深度优先搜索（DFS）。其实这个算法是有步骤的。 int n,m,p,q,mins=999999; int book[51][51]; int a[
DFS练习题集
rp++
12-13 2362
DFS练习题集,持续更新ing题一 P1605 迷宫- 洛谷题二 P1101 单词方阵-洛谷题三 危险系数-蓝桥杯题四 P1019单词接龙-洛谷题五 2n皇后问题-蓝桥杯题六 P1219 八皇后 - 洛谷 题一 P1605 迷宫- 洛谷 https://blog.csdn.net/UnKfrozen/article/details/84993247 题二 P1101 单词方阵-洛谷 https...
DFS经典题目详解
360°顺滑
01-30 2977
【洛谷】P1605 迷宫 【洛谷】P1605 迷宫 原题链接：https://www.luogu.com.cn/problem/P1605 思路： 简单 dfs，先对地图进行标记，空地和障碍分开标记不同的数字，然后从起始点开始深搜，如果是终点就方案书加 1，否则就向四个方向不断搜索，符合条件就标记搜索，然后回溯。 Code： import java.util.Scanner; pub...
数据结构--图的DFS和BFS算法题总结
星星leslie的博客
11-23 1336
文章目录有向图的创建、求度、遍历求解连通分量个数 有向图的创建、求度、遍历 题目描述 从键盘接收有向图的顶点集，弧集，创建有向图，并完成下列任务： （1）计算结点的出度、入度以及度; (2) 从第一个顶点出发，求一个深度优先遍历序列; (3) 从第一个顶点顶点出发，求一个广度优先遍历序列。 注意：以用户输入各个顶点的顺序为顶点的序号。 在深度和广度优先遍历中，优先选择序号小的顶点。 ...
拓扑排序 dfsc++
最新发布
10-20
在C++中，可以使用DFS算法进行拓扑排序。具体实现方法是，对于每个节点，先将其标记为正在访问中，然后遍历其所有的邻居节点，如果邻居节点已经被访问过了，就说明存在环，返回false；如果邻居节点还没有被访问过，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值