求连通块的数量（dfs、bfs）

21RGHLY

已于 2023-03-22 09:06:58 修改

阅读量266

点赞数

分类专栏： java 好题蓝桥杯文章标签：深度优先宽度优先算法

于 2023-03-22 09:06:11 首次发布

本文链接：https://blog.csdn.net/RGHLY21/article/details/129702108

版权

java 同时被 3 个专栏收录

81 篇文章 1 订阅

订阅专栏

蓝桥杯

44 篇文章 1 订阅

订阅专栏

好题

20 篇文章 0 订阅

订阅专栏

文章提供了两个Java程序，分别实现了广度优先搜索(BFS)和深度优先搜索(DFS)算法。这两个算法常用于图的遍历。BFS程序计算从起点开始能走到的所有崭新黑瓷砖的数量，而DFS程序则标记并计数从起点开始的所有路径。

摘要由CSDN通过智能技术生成

AC代码：
1、bfs

import javax.swing.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.nio.file.attribute.AclEntryFlag;
import java.security.AlgorithmConstraints;
import java.sql.Struct;
import java.text.CollationElementIterator;
import java.text.DateFormatSymbols;
import java.util.*;
import java.util.stream.Collectors;


public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)0 + 20;
    static math_myself math_me = new math_myself();
    static char g[][] = new char[N][N];
    static boolean used[][] = new boolean[N][N];
    static int dx[] = {-1,0,1,0},dy[] = {0,1,0,-1};
    static Queue<PII> q = new LinkedList<>();

    static int n,m;

    static int bfs(int x, int y)
    {
        q.add(new PII(x,y));
        used[x][y] = true;
        int cnt = 1; // 起点就是黑色砖块，也要算进去

        while(q.size() > 0)
        {
            PII t = q.poll();

            for(int i = 0 ; i < 4 ; i ++)
            {
                int x_cur = t.x + dx[i],y_cur = t.y + dy[i];
                if(x_cur < 0 || x_cur >= n || y_cur < 0 || y_cur >= m)  continue; // 越界不走
                if (used[x_cur][y_cur])  continue; // 走过的瓷砖不走
                if (g[x_cur][y_cur] != '.')  continue; // 不是崭新的黑瓷砖不走

                // 崭新的黑瓷砖必然是可以走的
                used[x_cur][y_cur] = true;
                q.add(new PII(x_cur,y_cur));
                cnt ++;
            }
        }
        return cnt;
    }

    public static void main(String[] args ) throws IOException
    {
        while(true)
        {
            q.clear();
            for(int i = 0 ; i < n; i ++)  Arrays.fill(used[i],false);
            // 正常是先输入n,再输入m，这题反着
            m = rd.nextInt();
            n = rd.nextInt();

            if (m == 0 || n == 0) break;
            // 读入矩阵
            for(int i = 0 ; i < n ; i ++)  g[i] = rd.next().toCharArray();

            // 寻找起点
            int x = 0,y = 0,flag = 0;
            for(int i = 0 ; i < n ; i ++)
            {
                for(int j = 0 ; j < m ; j ++)
                {
                    if(g[i][j] == '@')
                    {
                        x = i;
                        y = j;
                        flag = 1;
                    }
                    if (flag == 1)  break;
                }
            }

            pw.println(bfs(x,y));
        }
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException   { return reader.readLine(); }

    static String next() throws IOException
    {
        while (!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException  { return Integer.parseInt(next()); }

    static double nextDouble() throws IOException { return Double.parseDouble(next()); }

    static long nextLong() throws IOException  { return Long.parseLong(next());}

    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class PII
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
}

class math_myself
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

2、dfs

import javax.swing.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.nio.file.attribute.AclEntryFlag;
import java.security.AlgorithmConstraints;
import java.sql.Struct;
import java.text.CollationElementIterator;
import java.text.DateFormatSymbols;
import java.util.*;
import java.util.stream.Collectors;


public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)0 + 20;
    static math_myself math_me = new math_myself();
    static char g[][] = new char[N][N];
    static int dx[] = {-1,0,1,0},dy[] = {0,1,0,-1};
    static int n,m;
    static int cnt;

    // 只有崭新的黑色瓷砖才会进dfs
    static void dfs(int x, int y)
    {
        g[x][y] = '#'; // 走过的点变成红色瓷砖，以免重复走
        cnt ++; // 走过的黑色的
        for(int i = 0 ; i < 4 ; i ++)
        {
            int x_cur = x + dx[i],y_cur = y + dy[i];
            if(x_cur < 0 || x_cur >= n || y_cur < 0 || y_cur >= m || g[x_cur][y_cur] == '#')  continue;  // 红色的瓷砖或者走过的黑瓷砖（变成红色瓷砖）不会进dfs
            dfs(x_cur,y_cur);
        }
    }

    public static void main(String[] args ) throws IOException
    {
        while(true)
        {
            cnt = 0;
            // 正常是先输入n,再输入m，这题反着
            m = rd.nextInt();
            n = rd.nextInt();

            if (m == 0 || n == 0) break;
            // 读入矩阵
            for(int i = 0 ; i < n ; i ++)  g[i] = rd.next().toCharArray();

            // 寻找起点
            int x = 0,y = 0,flag = 0;
            for(int i = 0 ; i < n ; i ++)
            {
                for(int j = 0 ; j < m ; j ++)
                {
                    if(g[i][j] == '@')
                    {
                        x = i;
                        y = j;
                        flag = 1;
                    }
                    if (flag == 1)  break;
                }
            }

            dfs(x,y); // 传入起点

            pw.println(cnt);
        }
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException   { return reader.readLine(); }

    static String next() throws IOException
    {
        while (!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException  { return Integer.parseInt(next()); }

    static double nextDouble() throws IOException { return Double.parseDouble(next()); }

    static long nextLong() throws IOException  { return Long.parseLong(next());}

    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class PII
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
}

class math_myself
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}