深度优先搜索DFS（一）

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量109 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Mered1th/p/10407199.html
版权
 
实例一  0/1背包问题：
 
有n件物品，每件物品的重量为w[i]，价值为c[i]。现在需要选出若干件物品放入一个容量为V的背包中，使得在选入背包的物品重量和不超过容量V的前提下，让背包中的物品价值之和最大，求最大价值。（1<=n<=20）
  
/**
* Copyright(c)
* All rights reserved.
* Author : Mered1th
* Date : 2019-02-20-13.12.15
* Description : Bag
*/
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<unordered_set>
#include<map>
#include<vector>
#include<set>
using namespace std;

const int maxn=30;
int n,V,maxValue=0;//物品件数，背包容量，最大价值
int w[maxn],c[maxn]; //每件物品的重量，每件物品的价值
void DFS(int index,int sumW,int sumC){
    if(index==n){
        if(sumW<=V&&sumC>maxValue){
            maxValue=sumC;
        }
        return;
    }
    DFS(index+1,sumW,sumC);   //不选
    DFS(index+1,sumW+w[index],sumC+c[index]);   //选
}

int main(){
#ifdef ONLINE_JUDGE
#else
    freopen("1.txt", "r", stdin);
#endif
    scanf("%d%d",&n,&V);
    for(int i=0;i<n;i++){
        scanf("%d",&w[i]);
    }
    for(int i=0;i<n;i++){
        scanf("%d",&c[i]);
    }
    DFS(0,0,0);
    printf("%d\n",maxValue);
    return 0;
}

　　

输入： 
5 8
3 5 1 2 2
4 5 2 1 3

输出：

10

　　

上述方法在加入全部n件物品之后才更新最大价值，实际上可对sumW提前判断，若sumW+w[index]<=V，则再进入选择
  
void DFS2(int index,int sumW,int sumC){
    if(index==n){
        return;
    }
    DFS2(index+1,sumW,sumC);
    if(sumW+w[index]<=V){  //放的进去则选index件物品
        if(sumC+c[index]>maxValue){
            maxValue=sumC+c[index];
        }
        DFS2(index+1,sumW+w[index],sumC+c[index]);
    }

}

　　

  回溯法：
  
bool in[maxn]={0};
void DFS3(int index,int sumW,int sumC){
    if(index==n||sumW>=V){
        if(sumC>maxValue){
            maxValue=sumC;
        }
        return;
    }
    int i=index;
    for(;i<n;i++){
        if(w[i]+sumW<=V && in[i]==false){  //如果能放进去，且该物品不在背包里面
            sumW+=w[i];
            sumC+=c[i];
            in[i]=true;
            DFS3(index+1,sumW,sumC);
            sumW-=w[i]; //回溯
            sumC-=c[i];
            in[i]=false;
        }
    }
}

　　

回溯法输出最优方案（假设最优方案只有一种。。。如果有多种暂时还没想到怎么写。。。）
  
vector<int> ans;
map<int,vector<int> > temp;
void DFS4(int index,int sumW,int sumC){
    if(index==n||sumW>=V){
        if(sumC>maxValue){
            maxValue=sumC;
            temp[maxValue]=ans;
        }
        return;
    }
    int i=index;
    for(;i<n;i++){
        if(w[i]+sumW<=V&&in[i]==false){
            sumW+=w[i];
            sumC+=c[i];
            in[i]=true;
            ans.push_back(i);
            DFS4(index+1,sumW,sumC);
            ans.pop_back();
            sumW-=w[i];
            sumC-=c[i];
            in[i]=false;
        }
    }
}

int main(){
#ifdef ONLINE_JUDGE
#else
    freopen("1.txt", "r", stdin);
#endif
    scanf("%d%d",&n,&V);
    for(int i=0;i<n;i++){
        scanf("%d",&w[i]);
    }
    for(int i=0;i<n;i++){
        scanf("%d",&c[i]);
    }
    DFS4(0,0,0);
    printf("%d\n",maxValue);
    for(int i=0;i<temp[maxValue].size();i++){
        cout<<temp[maxValue][i]<<" ";
    }
    return 0;
}

　　

　　

 
实例二  序列的全部子序列：
 

问题：给定一个序列，枚举这个序列的所有子序列（可以不连续），例如对序列{1,2,3}来说，它的所有子序列为{1}、{2}、{3}、{1,2}，{1,3}、{2,3}、{1,2,3}。

分析：传入参数需要三个，一个是输入序列，一个是输出序列，再加一个变量index用来标记当前位于输入序列的位置。另外还需要用一个容器来存储子序列
  
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<unordered_set>
#include<map>
#include<vector>
#include<set>
using namespace std;
vector<int> ans;
void dfs(string str,int index,string res){
    if(index==str.length()){
        if(res.size()==0) return;  //否则会把“”也输出
        int temp=stoi(res);
        ans.push_back(temp);
        return;
    }
    dfs(str,index+1,res); //选index
    dfs(str,index+1,res+str[index]);//不选index
}
int main(){
    string a="123";
    dfs(a,0,"");
    sort(ans.begin(),ans.end()); //排序
    for(auto it=ans.begin();it!=ans.end();it++){
        cout<<*it<<endl;
    }
    return 0;
}

　　

　变式：给定N个整数（可能有负数），从中选择K个数，使得这K个数之和恰好等于一个给定的整数X；如果有多种方案，选择他们中元素平方和最大的一个。

 
  
const int maxn=110;
int n,k,x,maxsumSqu=-1,A[maxn];
vector<int> temp,ans;
void DFS(int index,int nowK,int sum,int sumSqu){
    if(nowK==k && sum==x){
        if(sumSqu>maxsumSqu){
            maxsumSqu=sumSqu;
            ans=temp;
        }
        return;
    }
    if(index==n || nowK>k || sum>x){
        return;
    }
    temp.push_back(A[index]);
    DFS(index+1,nowK+1,sum+A[index],sumSqu+A[index]*A[index]);
    temp.pop_back();
    DFS(index+1,nowK,sum,sumSqu);
}

　

实例三  全排列问题：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<unordered_set>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=10;
bool isUsed[maxn]={0};
vector<int> num;
int n;
void dfs(int index){
    if(index==n){
        for(int i=0;i<num.size();i++){
            printf("%d",num[i]);
        }
        printf("\n");
        return;
    }
    for(int i=1;i<=n;i++){
        if(isUsed[i]==true) continue;
        num.push_back(i);
        isUsed[i]=true;
        dfs(index+1);
        num.pop_back();
        isUsed[i]=false;
    }
}

int main(){
    n=3;
    dfs(0);
    return 0;
}

　　

实例四  素数环问题（含剪枝）：

 

 

 

 

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<unordered_set>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=100;
bool isPrime[maxn];  //假设都为质数
vector<int> ans;
bool isUsed[maxn];
int n;

void getPrimeTable(){
    memset(isPrime,1,sizeof(isPrime));
    isPrime[0]=isPrime[1]=false;
    for(int i=2;i<maxn;i++){
        if(isPrime[i]){
            for(int j=i+i;j<maxn;j=j+i){
                isPrime[j]=false;
            }
        }
    }
}

void dfs(int index){
    if(index>=n){
        int temp=ans[0]+ans[index-1];  //判断第一个数和最后一个数之和
        if(isPrime[temp]==false){
            return;
        }
        for(int x:ans){
            printf("%d ",x);
        }
        printf("\n");
        return;
    }
    for(int i=2;i<=n;i++){
        if(isUsed[i]==true) continue;
        int temp=ans[index-1]+i;
        if(isPrime[temp]==false) continue;  //剪枝
        ans.push_back(i);
        isUsed[i]=true;
        dfs(index+1);
        ans.pop_back();
        isUsed[i]=false;
    }
}

int main(){
    getPrimeTable();
    n=4;
    ans.push_back(1);
    dfs(1);
    return 0;
}

　　

 
 实例五 N皇后问题：
 
 
 
 实例六 求给定矩阵“块” 的个数：
 
给出一个m*n的矩阵，矩阵中的元素为0或1,。称位置(x,y)与其上下左右四个位置是相邻的。如果矩阵中有若干个1是相邻的（不必两两相邻），那么称这些1构成了一个“块”。求给定的矩阵中“块” 的个数。
 
样例输入： 
6 7
0 1 1 1 0 0 1
0 0 1 0 0 0 0
0 0 0 0 1 0 0
0 0 0 1 1 1 0
1 1 1 0 1 0 0
1 1 1 1 0 0 0
 
样例输出： 
4

　　

 题意理解：   求如图所示“块”的个数

 

分析：首先想到的是DFS遍历所有顶点，标记已访问顶点，最终统计“块”个数。代码如下： 
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<unordered_set>
#include<map>
#include<vector>
#include<set>
using namespace std;
const int maxn=100;
int X[4]={0,0,1,-1};
int Y[4]={1,-1,0,0};
struct node{
    int x,y;
}Node;
int n,m;   //¾ØÕó´óСΪn*m
int matrix[maxn][maxn];
bool inq[maxn][maxn];

bool judge(int x,int y){
    if(x>=n||x<0||y>=m||y<0) return false;
    if(matrix[x][y]==0||inq[x][y]==true) return false;
    return true;
}

void DFS(int u,int v){
    inq[u][v]=true;
    for(int i=0;i<4;i++){
        int newX=u+X[i];
        int newY=v+Y[i];
        if(judge(newX,newY)){
            inq[newX][newY]=true;
            DFS(newX,newY);
        }
    }
}
int main(){
#ifdef ONLINE_JUDGE
#else
    freopen("1.txt", "r", stdin);
#endif
    scanf("%d%d",&n,&m);
    for(int x=0;x<n;x++){
        for(int y=0;y<m;y++){
            scanf("%d",&matrix[x][y]);
        }
    }
    int ans=0;
    for(int x=0;x<n;x++){
        for(int y=0;y<m;y++){
            if(matrix[x][y]==1&&inq[x][y]==false){
                ans++;
                DFS(x,y);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

　

这里用到一个技巧就是：

int X[4]={0,0,1,-1};
int Y[4]={1,-1,0,0};

for(int i=0;i<4;i++){
    int newX=u+X[i];
    int newY=v+Y[i];
}

　

当矩阵过大时，DFS效率远不如BFS，下面给出BFS解法：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<unordered_set>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
const int maxn=100;
int X[4]={0,0,1,-1};
int Y[4]={1,-1,0,0};
struct node{
    int x,y;
}Node;
int n,m;   
int matrix[maxn][maxn];
bool inq[maxn][maxn];

bool judge(int x,int y){
    if(x>=n||x<0||y>=m||y<0) return false;
    if(matrix[x][y]==0||inq[x][y]==true) return false;
    return true;
}

void BFS(int x,int y){
    queue<node> Q;
    Node.x=x;
    Node.y=y;
    Q.push(Node);
    inq[x][y]=true;
    while(!Q.empty()){
        node top=Q.front();
        Q.pop();
        for(int i=0;i<4;i++){
            int newX=top.x+X[i];
            int newY=top.y+Y[i];
            if(judge(newX,newY)){
                Node.x=newX,Node.y=newY;
                Q.push(Node);
                inq[newX][newY]=true;
            }
        }
    }
}


int main(){
#ifdef ONLINE_JUDGE
#else
    freopen("1.txt", "r", stdin);
#endif
    scanf("%d%d",&n,&m);
    for(int x=0;x<n;x++){
        for(int y=0;y<m;y++){
            scanf("%d",&matrix[x][y]);
        }
    }
    int ans=0;
    for(int x=0;x<n;x++){
        for(int y=0;y<m;y++){
            if(matrix[x][y]==1&&inq[x][y]==false){
                ans++;
                BFS(x,y);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

　　

变式（BFS）：

 

  
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<unordered_set>
#include<map>
#include<vector>
#include<set>
#include<queue>
using namespace std;
const int maxn=100;
struct node{
    int x,y;
    int step;
}S,T,Node;
int n,m;
char matrix[maxn][maxn];
bool inq[maxn][maxn]={false};
int X[4]={0,0,1,-1};
int Y[4]={0,0,1,-1};

bool judge(int x,int y){
    if(x>=n||x<0||y>=m||y<0) return false;
    if(matrix[x][y]=='*') return false;
    if(inq[x][y]==false) return false;
    return true;
}

int BFS(){
    queue<node> q;
    q.push(S);
    while(!q.empty()){
        node top=q.front();
        q.pop();
        if(top.x==T.x&&top.y==T.y) return top.step; //到达终点，直接返回当前步数
        for(int i=0;i<4;i++){
            int newX=top.x+X[i];
            int newY=top.y+Y[i];
            if(judge(newX,newY)){
                Node.x=newX,Node.y=newY;
                Node.step=top.step+1;
                q.push(Node);
                inq[newX][newY]=true;
            }
        }
    }
    return -1;
}


int main(){
#ifdef ONLINE_JUDGE
#else
    freopen("1.txt", "r", stdin);
#endif
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++){
        getchar();
        for(int j=0;j<m;j++){
            matrix[i][j]=getchar();
        }
        matrix[i][m+1]='\0';
    }
    scanf("%d%d%d%d",&S.x,&S.y,&T.x,&T.y);
    S.step=0;
    printf("%d\n",BFS());
    return 0;
}

　　

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

转载于:https://www.cnblogs.com/Mered1th/p/10407199.html

weixin_30294295
关注
C/C++ stack实现深度优先搜索DFS算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-17 6694
深度优先搜索（Depth First Search，DFS）是一种图遍历算法，它从一个节点开始，通过访问其相邻节点的方式，依次深入到图中的更深层次。Stack（栈）是一种先进后出（Last In First Out，LIFO）的数据结构，它非常适合实现DFS算法。首先，我们来解释一下Stack实现DFS算法的原理。DFS算法的核心思想是从起始节点开始，将其标记为已访问，并将其相邻节点入栈。然后取出栈顶节点，将其标记为已访问，并将其未访问的相邻节点入栈，直到栈为空。这样就完成了一次深度优先搜索。
零(DFS)
yanghong的博客
07-12 471
题目描述 请考虑一个由1到N（N=3, 4, 5 … 9）的数字组成的递增数列：1 2 3 … N。 现在请在数列中插入“+”表示加，或者“-”表示减，“ ”表示空白(例如1-2 3就等于1-23)，来将每一对数字组合在一起（请不要在第一个数字前插入符号）。 计算该表达式的结果并判断其值是否为0。 请你写一个程序找出所有产生和为零的长度为N的数列。输入 单独的一行表示整数N (3 <= N <=
dfs-0
weixin_36287190的博客
04-18 226
dfs的简单应用 #include<cstdio> #include<vector> //问题描述 输入一个数 输入它的排列 /* 排列与组合是常用的数学方法。 先给一个正整数 ( 1 < = n < = 10 ) 例如n＝3，所有组合,并且按字典序输出： 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 */ using na...
DFS算法
chini9690的博客
08-29 136
#DFS算法 ##DFS ###排列数 问题: 生成1~n的排列 思路: 穷举所有可能 在生成结果数组前把重复的去掉 python code A = [None for i in range(10)] N = 3 def dfs(cur): if cur == N: ...
全排列—dfs（递归算法&&手动模拟）
你相信光吗
04-10 1万+
1.dfs全排列深度优先算法思路导图 此图来自AC中的Hasity作者，万分感谢； 2.dfs递归思想 dfs就是一条路走到头，当无法再往下走时就往上退一步，再看有没有路可以走，如果还没有路的话就再回退一步，重复这个步骤，直到找到可以走的道路； 递归的主要思想在于不断调用本身的函数，层层深入，直到遇到递归终止条件后层层回溯，其思想与dfs基本吻合，从而调用递归实现dfs； 正如y总讲到的回溯，它是在计算机底层执行的（系统有一个隐藏的栈帮我们做回溯），我们无法看到，也不需要操作。因此，理解.
dfs的王牌理解
qq_53321938的博客
07-17 330
基本概念 深度优先搜索算法（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。 思想（用栈的实现） 回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或
深度优先搜索dfs
ZLucker的博客
05-27 283
快6月份了，一学年就又这么荒废了。记录一下dfs。1、栈首先了解一下栈吧，dfs本质是递归，也就是栈的调用。1、栈的特点：与队列不同，他是先进后出。2、栈的基本操作：1、头文件：#include&lt;stack&gt;2、stack&lt;int&gt; st;方法：st.empty()：判断是否为空st.size()：判断元素个数st.top()：返回栈顶元素st.pop()：删除栈顶元素st...
深度优先搜索 DFS
能能
09-03 2087
1、基本思想 在搜索一幅图时，只需要用一个递归来遍历所有顶点。在访问其中一个顶点时： - 将它标记为已访问 - 递归访问它的所有未标记的邻居顶点 DFS只会访问与起点s连通的所有顶点（而不会访问其他顶点）。如果图是连通的，则所有顶点都会被访问到。 DFS中每条边都会被访问两次，且在第二次时总会发现这个顶点已经被标记过了。 2、算法实现 public class DepthFi...
递归回溯深度优先搜索DFS练习题（含C++源码）
02-10
深度优先搜索（Depth First Search，简称DFS）是一种用于遍历或搜索树或图的算法，它按照“尽可能深”的原则访问节点，直到达到叶节点或回溯到无新节点可访问时为止。在这个过程中，DFS通常与递归和回溯策略结合使用...
基于深度优先搜索（DFS）的路径规划算法(Python实现)
03-05
深度优先搜索（DFS）是一种常用的图遍历算法，用于寻找图中的路径。它从起始节点开始，沿着一条路径尽可能深入地探索，直到无法继续为止，然后回溯到上一个节点，继续探索其他路径。DFS的核心原理是通过递归或栈的...
06E 深度优先搜索 DFS1
08-03
深度优先搜索（DFS，Depth-First Search）是一种用于遍历或搜索树或图的算法。在图中，它从一个给定的起始节点开始，尽可能深地探索图的分支，直到到达叶子节点或者回溯到没有未访问过的邻接节点为止。在有向图的DFS...
深度优先搜索DFS算法演示.mp4
10-25
DFS深度优先搜索视频演示。深度优先搜索是一种在开发爬虫早期使用较多的方法。它的目的是要达到被搜索结构的叶结点(即那些不包含任何超链的HTML文件) 。在一个HTML文件中，当一个超链被选择后，被链接的HTML文件将...
dfs解决数塔问题；
QAQ的小耗子的博客
03-28 367
#include &lt;iostream&gt;#include &lt;stdio.h&gt;#include &lt;vector&gt; using namespace std;const int maxn=200;int tower[maxn][maxn];vector&lt;int&gt; temp,ans;int n;int maxsum=-1;void dfs(int x,int ...
图的基本算法(BFS和DFS)
weixin_34223655的博客
04-07 1269
图是一种灵活的数据结构，一般作为一种模型用来定义对象之间的关系或联系。对象由顶点（V）表示，而对象之间的关系或者关联则通过图的边（E）来表示。 图可以分为有向图和无向图，一般用G=(V,E)来表示图。经常用邻接矩阵或者邻接表来描述一副图。 在图的基本算法中，最初需要接触的就是图的遍历算法，根据访问节点的顺序，可分为广度优先搜索（BFS）和深度优先搜索（DFS）。 广度优先搜索（BFS） 广度...
DFS--基本入门模板 和 例题 （绝对入门） (最全)
热门推荐
Romantic Chopin in C Sharp Minor
08-13 4万+
以下是全网收集整理的和自己写的部分，绝对保证dfs轻松入门。 核心代码： 关于dfs参数问题，什么在变化，就把什么设置成参数。 void dfs()//参数用来表示状态 { if(到达终点状态) { ...//根据题意添加 return; } if(越界或者是不合法状态) ...
01 背包问题 DFS/动态规划
larry1648637120的博客
03-19 416
问题： 有n件物品，每件物品的重量为w[i]，价值为c[i]。现有一个容量为V的背包，问如何选取物品放入背包，使得背包内物品的总价值最大。其中每种物品只有1件。 测试样例： input: 5 8 3 5 1 2 2 4 5 2 1 3 output: 10 解法1：DFS #include<cstdio> const int maxn=30; int n,v...
DFS相关练习
qq_41995263的博客
08-05 121
DFS-深度优先遍历 2019-08-04 21:42:26 tags: 深度优先遍历的相关练习 深度优先遍历是一种枚举所有完整路径以遍历所有情况的搜索方法。 对于深度优先遍历，可以用递归来实现。 递归有两个关键点： 1.递归分支 2.递归边界 回顾斐波那契数列：F(0)=1,F(1)=1, F（n）=F(n-1)+F(n-2) (n>=2),每当求F(n)时，将其分为F(n-1)和F(...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 125
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
深度优先搜索DFS理解与应用
深度优先搜索（DFS）是一种在图或树结构中遍历所有节点的算法，其核心思想是从一个起始节点开始，尽可能深入地探索路径，直到无法继续前进时才回溯到上一个节点，尝试其他分支。DFS常用于解决路径查找、是否存在环路...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值