dfs练习(一)

最新推荐文章于 2023-04-07 10:58:29 发布
最新推荐文章于 2023-04-07 10:58:29 发布
阅读量387 收藏 2
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/REfusing/article/details/90968482
版权

文章目录

题目：Badge

思路：简单的dfs，因为只用一个分支，当再次回来的时候就是结果。
代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;

int a[maxn], tot = 0;
int n, vis[maxn], ans = 0;
int dfs(int u)
{
    vis[u] = 1;
    int t = a[u];
    if(!vis[t])
        dfs(t);
    else return t;//如果回到之前标记的就是结果
}
int main()
{
    int v;
    scanf("%d", &n);
    tot = 0;
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
    }
    for(int i = 1; i <= n; i++)
    {
        memset(vis, 0, sizeof(vis));
        ans = 0;
        if(i != 1)printf(" ");
        printf("%d", dfs(i));
    }
    printf("\n");
    return 0;
}

题目：Protect Sheep

题意：就是给你一个图，图上有羊和狼，不让狼吃羊，你必须在用狗去把狼隔开，注意不用考虑放置狗的个数最少You don’t have to minimize the number of dogs。
思路：既然不用考虑够的个数最少，那么只需要，判断羊的四周是否是狼，如果是狼那么就输出NO,否则输出YES以及放置后的地图。
代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 505;
char mp[maxn][maxn];
int vis[maxn][maxn];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0}, n, m;
int flag = 1;

int main(){
    scanf("%d %d", &n, &m);
    for(int i = 0; i < n; i++){
        scanf("%s", mp[i]);
    }
    flag = 1;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(mp[i][j] == 'S'){
                if(mp[i][j-1] == 'W'|| mp[i-1][j] == 'W' ||mp[i+1][j] == 'W'|| mp[i][j+1] == 'W'){
                    printf("NO\n");
                    return 0;
                }
            }
        }
    }
    printf("YES\n");
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            if(mp[i][j] == '.')printf("D");
            else printf("%c", mp[i][j]);
        }
        printf("\n");
    }

return 0;
}

题目：King Escape

题意：本题的大体思路就是给你三个点（ax, ay),(bx, by),(cx, cy),问你从（bx,by）这个点能否不经过与（ax, ay)同行同列同一对角线到达（cx, cy),如果能输出YES,否则输出NO。
思路：本题的主体思路就是类似与dfs走迷宫的那类题，但是本题需要加入一些判断，使走过的路线不与（ax, ay)同行同列同一对角线，不同行不同类好比较。但是不同对角线如何比较，通过观察图发现，同一对角线斜路是-1或者1.然后在通过y = x+b或者y = -x+b,把(ax, ay)这个点带入，就能求出b,然后根据方程判断是否与（ax, ay）在同一对角线上。
本题还可以以（ax,by）作为原点建立直角坐标系，如果（bx,by)和（cx,cy）在同一象限那么就输出YES，,否则输出NO。为什么可以这么做你可以看图找一下规律。
参考博客：CF1033A. King Escape的题解
代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1010;
int ax, ay, bx, by, cx, cy, n, b1, b2;
bool Judge1(int x, int y){
     if(y == x+b1)return true;
     else return false;
}
bool Judge2(int x, int y){
     if(y == -x+b2)return true;
     else return false;
}
int dx[10] = {0,0,1,1,1,-1,-1,-1};//八个方向
int dy[10] = {1,-1,1,-1,0,1,-1,0};
int vis[maxn][maxn];//标记
int flag =  0;
bool dfs(int x, int y){
    vis[x][y] = 1;
    if(x == cx && y == cy){//到达终点
        flag = 1;
        return true;
    }
    for(int i = 0; i < 8; i++){
        int tx, ty;
        tx = x+dx[i];
        ty = y+dy[i];
        if(tx >= 1 && tx <= n && ty >= 1 && ty <= n && !vis[tx][ty] && !Judge1(x, y) && !Judge2(x, y) && tx != bx && ty != by){//判断
            vis[tx][ty] = 1;
            if(dfs(tx, ty))return true;//递归
        }
    }
    return false;
}
int main(){

    memset(vis, 0, sizeof vis);
    scanf("%d", &n);
    scanf("%d %d", &bx, &by);
    scanf("%d %d", &ax, &ay);
    scanf("%d %d", &cx, &cy);
    b1 = by-bx;
    b2 = bx+by;
    int t = dfs(ax, ay);
    if(t)cout<<"YES"<<endl;
    else cout<<"NO"<<endl;


return 0;
}

题目：New Year Transportation

题意：本题的题意就是给你i点可以到大（i+ai），问你是否能到大K，如果能到达输出YES,否则话输出NO。因为本题已经约束了1<ai<n-i,所以不用考虑i+ai越界。
思路：本题就是一道水题，简单的dfs就能解决。
代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e4+10;
int a[maxn], n, k;
bool dfs(int x){

     if(x > k)return false;//因为不能回退，所以当x>k时就已经没有搜到
     if(x == k)return true;
     dfs(x+a[x]);
     //return false;
}
int main(){
    scanf("%d %d", &n, &k);
    for(int i = 1; i < n; i++)scanf("%d", &a[i]);
    int t = dfs(1);
    if(t)cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
return 0;
}

题目：Transformation: from A to B

题意：给你两个数a, b,让你通过一两种操作把a变成b，这两中操作分别是x–>2x, x–>x10+1;通过这两种操作如果不能变成b输出NO,如果能就输出YES 操作数 变换的过程
思路：一个思路就是简单的dfs,另外一个就是根据性质去推从b往前推a,如果b是偶数那么b就除以2,如果b为奇数那么就是通过10*x+1这个步骤。
参考博客：CodeForces–TechnoCup–2016.10.15–ProblemA–Transformation: from A to B
dfs代码:

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;
#define LL long long
const int INF = 100000;
int vis[maxn], val[maxn],ans = INF;//val存储路径
LL a, b;
void dfs(LL x, LL step){
     if(x == b){//如果到达终点
        if(step < ans){//步数小于当前的步数
            for(int i = 0; i < step; i++){//更新
                val[i] = vis[i];
            }
            ans = step;
        }
        return;
     }
     if(x*2 <= b){//乘2的操作
        vis[step] = x*2;
        dfs(x*2, step+1);
        vis[step] = 0;
     }
     if(x * 10 + 1 <= b){//后面补1的操作
        vis[step] = x*10+1;
        dfs(x*10+1, step+1);
        vis[step] = 0;
     }
}
int main(){
    scanf("%lld %lld", &a, &b);
    dfs(a, 0);
    if(ans == INF)printf("NO\n");
    else {
        printf("YES\n");
        printf("%d\n", ans+1);
        printf("%d", a);
        for(int i = 0; i < ans; i++){
            printf(" %d", val[i]);
        }
        printf("\n");
    }
return 0;
}

题目：The Way to Home

题意：本题的题意就是给你一个长度为n的字符串，让你从1开始走，走到n,每次走的距离不能超过d,而且每次走的时候只能走数值为1的点，如果可以到达n,输出结果最小步数，否则输出-1。
思路：本题有两种思路一个是dfs,一个数模拟，先说dfs吧，首先我设当前结点为x，然后从k最小开始dfs,然后在到达n点的时候去更新最小值，后来发现跑到第15组就超时了，我感觉这种方法存在问题，从k最大开始搜索这么就不用去更新最小值了，因为这么做一定是最优的，结果跑到44组就超时了，虽然有一定的优化但是还是存在一定问题，我就想可不可以用数组去标记，仔细思考了一下，发现是可以的，为什么是可以的如果我把当前结点标记了如果搜索失败在回溯的时候，如果已经标记了那么证明从该点的路径是不可达的，所以不能走。
模拟的思想其实也差不多，每一次尽量走最大的如果不能走就往前挪一下，重复上述操作。参考博客：The Way to Home (模拟)
dfs代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000;
char str[maxn];
int n, k, ans = maxn;
bool vis[maxn];
bool dfs(int x, int step){
     if(x == n){//到达n点
        ans = step;
        return true;
     }
     for(int i = k; i > 0; i--){
        if(str[x+i] == '1' && !vis[x+i]){
            vis[x+i] = 1;
            if(dfs(x+i, step+1))return true;

        }
     }
     return false;
}
int main(){
    scanf("%d %d", &n, &k);
    scanf("%s", str+1);
    ans = maxn;
    dfs(1,0);
    if(ans == maxn)printf("-1\n");
    else printf("%d\n", ans);

return 0;
}

题目：DZY Loves Chessboard

题目：本题题意就是给你一个矩阵，"."代表可以放置棋子的，“-”代表不可以放置棋子，然后让你把所有相邻的可以放置棋子的位置放置不同的颜色的棋子，如果只能放置一个棋子的这种情况所以放置。
思路：就是一个迷宫类型的搜索的简单变形，只需要增加一个变量就可以，用它来记录之前的情况。
代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 105;
char a[maxn][maxn];
bool vis[maxn][maxn];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1,0, 0};
int n, m;
void dfs(int x, int y, int flag)
{
    if(!flag)a[x][y] = 'B';
    else a[x][y] = 'W';
    for(int i = 0; i < 4; i++)
    {
        int tx, ty;
        tx = x + dx[i];
        ty = y + dy[i];
        if(tx >= 0 && tx < n && ty >=0 && ty < m && a[tx][ty] == '.')
        {
            dfs(tx,ty,!flag);
        }
    }
}
int main()
{
    scanf("%d %d", &n, &m);
    for(int i = 0; i < n; i++)
    {
        scanf("%s", a[i]);
    }
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            if(a[i][j] == '.')dfs(i, j, 0);
        }
    }
    for(int i = 0; i < n; i++)printf("%s\n", a[i]);
    return 0;
}

题目：Students and Shoelaces

题意：本题的题意就是你通过取消只与一个点相连所有点，然后在重复操作，统计你的操作个数。
思路：本题就是一个拓扑排序，因为是无向图，所以所有点都是入度，然后找到入度为1的点。
代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 105;
int a[maxn][maxn];
bool vis[maxn][maxn];
int n, m;
int degree[maxn];

queue<int>q;
int cn = 1, ans = 0, tmp;
void TopSort(int n)
{
    int cnt = 0;
    for(int i = 1; i <= n; i++)
    {
        if(degree[i] == 1)
        {
            q.push(i);
            cnt++;
        }

    }
    if(cnt)ans++;//如果存在入度为1的点，操作次数加一
    while(!q.empty())
    {
        tmp = q.front();
        q.pop();
        for(int i = 1; i <= n; i++)
        {
            if(a[tmp][i])
            {
                degree[i]--;
                degree[tmp]--;

            }
        }
        cnt--;
        if(cnt == 0)//如果第一次的都已经完事了
        {

            for(int i = 1; i <= n; i++)//开始下一步
            {
                if(degree[i] == 1)
                {
                    q.push(i);
                    cnt++;
                }

            }
            if(cnt)ans++;//如果下一步存在，结果加一
        }
    }
}
int main()
{

    int u, v;
    ans = 0;
    scanf("%d %d", &n, &m);
    for(int i = 0; i < m; i++)
    {
        scanf("%d %d", &u, &v);
        a[u][v] = a[v][u] = 1;
        degree[u]++;
        degree[v]++;
    }
    TopSort(n);
    cout<<ans<<endl;
    return 0;
}

题目：Party

题意：本题的题意就是把不同的不存在上级的人放在同一组中。
思路：本题的思想非常简单，就是几个建图加上拓扑排序就完事了，如果存在没有上级的那种就不用处理了。
代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2005;
int degree[maxn];
int mp[maxn][maxn];
struct Node{
       int id, x;
}tmp;
int ans = 0, n;
queue<Node>q;
void TopSort(){//拓扑排序
     for(int i = 1; i <= n; i++){
        if(!degree[i]){
           tmp.id = 1;
           tmp.x = i;
           q.push(tmp);
        }

     }
     while(!q.empty()){
        tmp = q.front();
        int x = tmp.x;
        int id = tmp.id;
        q.pop();
        ans = max(ans, id);
        for(int i = 1; i <= n; i++){
            if(mp[x][i]){
                degree[i]--;
                if(!degree[i]){
                    tmp.x = i;
                    tmp.id = id+1;
                    q.push(tmp);
                }
            }
        }
     }
}
int main(){
    int  t;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++){
        scanf("%d",&t);
        if(t == -1)continue;//不存在上级的这种情况
        mp[t][i] = 1;//反向建图
        degree[i]++;
    }
    TopSort();
    printf("%d\n", ans);

return 0;
}

题目：RumorRumor

题意：就是告诉你贿赂每一个人要多少钱，朋友之间可以免费互传消息，所以问你最小的花费。
思路：本题可以利用并查集写，也可以用dfs写。我只列出dfs代码。
并查集代码：参考博客：codeforces 893 C.Rumor
dfs代码：

#include<bits/stdc++.h>
using namespace std;
const long long INF = 1e9+1;
const int maxn = 1e5+10;
int vis[maxn], val[maxn];
int ne[maxn*2], e[maxn*2],h[maxn*2], tot = 0;
void add(int u, int v)//链式前向星存储,注意无向图，所以需要开2*maxn
{
    e[tot] = v;
    ne[tot] = h[u];
    h[u] = tot++;
}
int ans;
void dfs(int u)//搜索
{
    vis[u] = 1;
    ans = min(ans, val[u]);
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int t = e[i];
        if(!vis[t])
        {

            dfs(t);
        }
    }
}
int main()
{
    int n, m, u, v;
    scanf("%d %d", &n, &m);
    memset(h, -1, sizeof(h));
    for(int i = 1; i <= n; i++)scanf("%d", &val[i]);
    for(int i = 1; i <= m; i++)
    {
        scanf("%d %d", &u, &v);
        add(u, v);
        add(v,u);
    }
    long long sum = 0;

    for(int i = 1; i <= n; i++)
    {
        ans = INF;
        if(!vis[i])//如果没有搜索过
        {
            dfs(i);
            sum += ans;
        }
    }
    printf("%lld\n", sum);
    return 0;
}

题目：Plus from Picture

题意：本题的题意就是给你一个图，当这张图上当且仅当只有一个由* 围成的+号，并且除了这个加好的四个方向上有*, 其他地方不能有 *这种情况下输出YES,否则输出NO。
思路:本题就是一个暴力，首先找到中心点如果找到仅找到一个中心点，那么就以这个点为中心向四周扩展，标记扩展经过的点，然后暴力一遍，有没有没有经过的点，那么就是NO，没有的话就是YES，找到多个或者没有找到中心点也是NO。
代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 505;
char mp[maxn][maxn];
int vis[maxn][maxn];
int n, m;
int main()
{
    scanf("%d %d", &n, &m);
    for(int i =  0; i < n; i++)
    {
        scanf("%s", &mp[i]);
    }
    int st, en, flag = 0;
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            if(mp[i][j] == '*' && i > 0 && i < n-1 && j > 0 && j < m-1)//找中心点
            {
                if(mp[i][j-1] == '*' && mp[i-1][j] == '*' && mp[i][j+1] == '*' && mp[i+1][j] == '*')
                {
                    flag++;
                    st = i;
                    en = j;
                }
            }
        }
    }
    if(flag == 1)
    {
        vis[st][en] = 1;//别忘了把中心点标记一下
        for(int i = st+1; mp[i][en] == '*'; i++)vis[i][en] = 1;
        for(int i = st-1; mp[i][en] == '*'; i--)vis[i][en] = 1;
        for(int i = en+1; mp[st][i] == '*'; i++)vis[st][i] = 1;
        for(int i = en-1; mp[st][i] == '*'; i--)vis[st][i] = 1;
        int k = 0;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                if(mp[i][j] == '*' && !vis[i][j]){
                    k = 1;
                    break;
                }
            }
        }
        if(k)cout<<"NO"<<endl;
        else cout<<"YES"<<endl;
    }
    else cout<<"NO"<<endl;
    return 0;
}

题目：Coloring a Tree

题意：本题的题意就是给你一颗树，每一个节点都应该染成他所需要的颜色，但是在染色的同时会同时把他的子树给染色了，问你需要多少步，把这个树变成你需要的树的颜色。
思路：本题的思路就是从根节点开始染色，把所有的子节点染成需要的颜色。
代码：

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1e4+10;
int vis[maxn], color[maxn];
int head[maxn], nx[maxn], e[maxn], tot = 0;
void add(int u, int v){
    e[tot] = v;
    nx[tot] = head[u];
    head[u] = tot++;
}
void dfs(int x, int cr){
     vis[x] = cr;
     for(int i = head[x]; i != -1; i = nx[i]){
        int t = e[i];
        dfs(t, cr);

     }
}
int main(){
    int n, v;
    memset(vis, 0, sizeof vis);
    memset(head, -1, sizeof head);
    scanf("%d", &n);
    for(int i = 2; i <= n; i++){
        scanf("%d", &v);
        add(v, i);
    }
    int step = 0;
    for(int i = 1; i <= n; i++)scanf("%d", &color[i]);
    for(int i = 1; i <= n; i++){//这个需要根据结果去推一下
        if(vis[i] == color[i])continue;
        else {
            step++;
            dfs(i, color[i]);
        }
    }
    cout<<step<<endl;
return 0;
}

或者：

#include<bits/stdc++.h>
using namespace std;
queue<int>q;
const int maxn = 1e4+10;
int vis[maxn], color[maxn];
int head[maxn], nx[maxn], e[maxn], tot = 0;
void add(int u, int v)
{
    e[tot] = v;
    nx[tot] = head[u];
    head[u] = tot++;
}
void dfs(int x, int cr)
{
    vis[x] = cr;
    for(int i = head[x]; i != -1; i = nx[i])
    {
        int t = e[i];
        dfs(t, cr);
    }
}
int main()
{
    int n, v;
    memset(vis, 0, sizeof vis);
    memset(head, -1, sizeof head);
    scanf("%d", &n);
    for(int i = 2; i <= n; i++)
    {
        scanf("%d", &v);
        add(v, i);
    }
    int step = 0;
    for(int i = 1; i <= n; i++)scanf("%d", &color[i]);
    q.push(1);
    while(!q.empty())
    {
        int t = q.front();
        for(int i = head[t]; i != -1; i = nx[i])
        {
            q.push(e[i]);
        }
        q.pop();
        if(vis[t] == color[t])continue;
        else
        {
            step++;
            dfs(t, color[t]);
        }
    }
    cout<<step<<endl;
    return 0;
}

题目：Two Buttons

由于是最短的所以bfs更好。
代码：

#include<bits/stdc++.h>
using namespace std;
 
int n, m, ans = 0;
int vis[10010];
queue<int>q;
int dfs(int x)
{
    q.push(x);
    vis[x] = 0;
    while(q.size()){
        int t = q.front();
        q.pop();
        if(t == m)return vis[m];
        int xx = t * 2;
        if(xx <= 10000 && !vis[xx]){
            vis[xx] = vis[t] + 1;
            q.push(xx);
        }
        xx = t-1;
        if(xx > 0 && !vis[xx]){
            vis[xx] = vis[t] + 1;
            q.push(xx);
        }
 
    }
 
}
int main()
{
    scanf("%d %d", &n, &m);
    ans = 1e7;
    ans = 0;
    if(n > m)
    {
        cout<<n-m<<endl;
    }
    else
    {
        cout<<dfs(n)<<endl;
    }
 
    return 0;
}

题目： Ice Skating

思路：就是求出几个互相联通的集合，集合的数量减去1就是答案。
代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int x[maxn], y[maxn];
int n, vis[maxn];
void dfs(int i){
     vis[i] = 1;
     for(int j = 1; j <= n; j++){
        if(!vis[j] && (x[i] == x[j] || y[i] == y[j])){
            dfs(j);
        }
     }
}
int main(){
    scanf("%d",&n);
    for(int i = 1; i <= n; i++){
        scanf("%d %d", &x[i], &y[i]);
    }
    int ans = 0;
    for(int i = 1; i <= n; i++){
        if(!vis[i])
        dfs(i), ans++;
    }
    printf("%d\n", ans-1);

return 0;
}
Re:fused
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【dfs】DFS练习题合集（to be countinue）
还有一年
08-14 947
一些深搜题
深度优先搜索（dfs）练习题及详细解答
weixin_45725925的博客
02-21 3891
相信很多人在最先开始学习深度优先搜索（dfs）的时候，都是一脸懵逼，但其实只要通过一定数目的练习，你就可以熟练运用这一算法（骗分神器）了，下面是我挑选出的几道dfs题目（源自洛谷），相信你练习完了以后，对这一神奇算法也会有更深的体会。 首先是一道dfs的入门题： 下面是代码 ...
计蒜客-中国象棋（DFS）
qq_43531919的博客
07-24 1507
中国象棋博大精深，其中马的规则最为复杂，也是最难操控的一颗棋子。 我们都知道象棋中马走"日"，比如在 (2,4)(2, 4)(2,4) 位置的一个马，跳一步能到达的位置有 (0,3)(0, 3)(0,3)，(0,5)(0, 5)(0,5)，(1,2)(1, 2)(1,2)，(1,6)(1, 6)(1,6)，(3,2)(3, 2)(3,2)，(3,6)(3, 6)(3,6)，(4,3)(4, 3)(4,3)，(4,5)(4, 5)(4,5)。 蒜头君正在和花椰妹下棋，蒜头君正在进行战略布局，他需要把在 (x
DFS专题练习
Xpy_021101的博客
04-07 78
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有 2 座岛屿。请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【算法模板】DFS秒杀模板—附练习题（阳光号启航）
小宝的博客
03-20 2403
オレはいつかこの一味にも负けない仲间を集めて、世界一の财宝を见つけて、绝対なってやる！海贼王に！ ​ 总有一天，我会聚集一群不输给这些人的伙伴，并找到世界第一的财宝，我要当海贼王！！！
递归回溯深度优先搜索DFS练习题（含C++源码）
02-10
# 递归回溯深度优先搜索DFS算法练习题 C++ 含源码 包含题目：《过河卒》《出栈序列统计》《算24点》《冗余依赖》《走迷宫》《单项双轨道》《组合的输出》《售货员的难题》《驾车旅游》《关路灯》
DFS-Courses:3318的DFS练习分配
04-25
DFS课程 3318的DFS练习分配。使用的调整矩阵，周期检测和拓扑顺序
图的 DFS 和BFS
07-09
图的遍历方式包括DFS BFS,这个工程文件是俩种遍历方式的实现，适合学习用，工程实践还得加工，具体分析 在我的博客 数据结构练习 10
DFS.rar_the DFS Depth-first
09-20
图的深度搜索算法的C语言实现，平时的上机练习可做参考
LeetCode:leetcode的练习记录
03-22
算法练习 :police_car_light: :police_car_light: :police_car_light: 选择以下问题： 每日挑战和每周竞赛的问题，以及在和上的类似问题。 书 标签 进步 大批 141/287 回溯 28/57 二叉索引树 2/6 二元搜寻 42/...
DFS练习
CrazyMaster_007的博客
07-14 205
第二天，打卡； 目录 前言 A.Oil DepositsPOJ-1562 B.全排列51Nod 2060 C.泉水 HRBUST 1143 D.Tempter of the BoneHDU 1010 E.Prime Ring Problem HDU 1016 F.马走日OpenJ_Bailian - 4123 G.ROADSPOJ - 1724 H.N皇后问题HDU 2553 总结 前言 dfs的基本概念和模板不在详细介绍，可以自行查阅博客学习...
dfs相关练习题
Hoshizola的博客
03-15 236
部分和 /* * 给定整数序列a1,a2,...,an，判断是否可以从中选出若干个数，使它们的和恰好为k * 输入： * n=4 * a={1,2,4,7} * k=13 * 输出： * Yes(13=2+4+7) */ public class _部分和 { private static int kk; public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n
dfs专项练习总结
weixin_43310882
07-21 190
对于dfs搜索，每次for循环一组数字，我们选其中一个进行搜索，按他搜索过后记得要回溯，选择其他的进行搜索。 所以说，对于一次dfs函数，我们需要选择一个。如果你都不选了，进到这一个dfs也就没有了意义。 一 ，NC121 字符串的排列 这道题用全排列可以轻松解决。 不过我不想用全排列，我想使用dfs搜索进行解决。 这个是我第一次写的dfs，下面那个dfs完全没有什么意义，因为如果你不选这个节点，你可可以选其他的，for循环会向后执行，而不是你再来一个dfs来决定不选它。 同时上面这个代码还没有进行去重的
简单DFS入门练习
qq_41706331的博客
02-01 667
1.求连通子块 #表示草地，上下左右连通的草地视为同一块草地，求一共多少块草地 #include<stdio.h> char map[20][20]; bool flag[20][20]; int n,m; void dfs(int x,int y) { if(x < 0 || x >= n || y < 0 || y >= m || flag[x]...
DFS练习题集
rp++
12-13 2335
DFS练习题集,持续更新ing题一 P1605 迷宫- 洛谷题二 P1101 单词方阵-洛谷题三 危险系数-蓝桥杯题四 P1019单词接龙-洛谷题五 2n皇后问题-蓝桥杯题六 P1219 八皇后 - 洛谷 题一 P1605 迷宫- 洛谷 https://blog.csdn.net/UnKfrozen/article/details/84993247 题二 P1101 单词方阵-洛谷 https...
dfs练习题
lijianzhong1的博客
08-01 457
/* Fox Ciel is playing a mobile puzzle game called "Two Dots". The basic levels are played on a board of size n?×?m cells, like this: Each cell contains a dot that has some color. We will use differ...
DFS--基本入门模板 和 例题 （绝对入门） (最全)
热门推荐
Romantic Chopin in C Sharp Minor
08-13 4万+
以下是全网收集整理的和自己写的部分，绝对保证dfs轻松入门。 核心代码： 关于dfs参数问题，什么在变化，就把什么设置成参数。 void dfs()//参数用来表示状态 { if(到达终点状态) { ...//根据题意添加 return; } if(越界或者是不合法状态) ...
dfs经典例题（入门题）
Windsearcher的博客
01-18 1万+
再附上一篇DFS详解的，不明白DFS原理的同学可以看一看：https://blog.csdn.net/li_jeremy/article/details/83714298 以下是全网收集整理的和自己写的部分，绝对保证dfs轻松入门。 核心代码： 关于dfs参数问题，什么在变化，就把什么设置成参数。 void dfs()//参数用来表示状...
bfs和dfs算法可视化
最新发布
05-31
VisuAlgo是一个交互式在线学习平台，提供可视化的算法教学和练习，支持包括BFS和DFS在内的多种算法可视化。 2. Algorithm Visualizer：https://algorithm-visualizer.org/ Algorithm Visualizer也是一个在线算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值