算法实现之回溯算法

深度优先算法DFS

深度优先搜索是一种递归的搜索方式，它会优先探索一个分支直到无法继续，然后回溯到之前的节点，再探索其他分支。

Java实现：

import java.util.*;

class DFSAlgorithm 
{
    // 用邻接表表示图
    private final Map<Integer, List<Integer>> graph;

    public DFSAlgorithm()
    {
        this.graph = new HashMap<>();
    }

    // 添加边
    public void addEdge(int v, int w) 
    {
        graph.computeIfAbsent(v, ArrayList::new).add(w);
    }

    // 深度优先搜索
    public void DFS(int start) 
    {
        Set<Integer> visited = new HashSet<>();
        DFSUtil(start, visited);
    }

    private void DFSUtil(int v, Set<Integer> visited)
    {
        visited.add(v);
        System.out.print(v + " ");

        
        
        List<Integer> neighbors = graph.get(v);
        if (neighbors != null) 
        {
            for (int neighbor : neighbors)
            {
                if (!visited.contains(neighbor)) 
                {
                    DFSUtil(neighbor, visited);
                }
            }
        }
    }

    public static void main(String[] args) 
    {
        DFSAlgorithm dfs = new DFSAlgorithm();

       
        
        dfs.addEdge(0, 1);
        dfs.addEdge(0, 2);
        dfs.addEdge(1, 2);
        dfs.addEdge(2, 0);
        dfs.addEdge(2, 3);
        dfs.addEdge(3, 3);

        System.out.println("深度优先搜索结果：");
        dfs.DFS(2);
    }
}

实例：N皇后问题

在n×n的棋盘上摆放n个皇后，使任意两个皇后都不能处于同一行、同一列或同一斜线上。

Java实现：

class NQueens
 {
    private static int N;


    private static void printBoard(int[][] board)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }


    private static boolean isSafe(int[][] board, int row, int col)
    {

        for (int i = 0; i < row; i++)
        {
            if (board[i][col] == 1)
            {
                return false;
            }
        }

        // 检查左上对角线
        for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
        {
            if (board[i][j] == 1)
            {
                return false;
            }
        }

        // 检查右上对角线
        for (int i = row, j = col; i >= 0 && j < N; i--, j++)
        {
            if (board[i][j] == 1)
            {
                return false;
            }
        }

        return true;
    }

    // 解决N皇后问题的回溯算法
    private static void solveNQueens(int[][] board, int row)
    {
        if (row == N)//合法
        {
            printBoard(board);
            return;
        }

        for (int col = 0; col < N; col++)
        {
            if (isSafe(board, row, col))
            {
                // 在当前位置落子
                board[row][col] = 1;

                // 递归解决子问题
                solveNQueens(board, row + 1);

                // 回溯，撤销当前位置的落子
                board[row][col] = 0;
            }
        }
    }

    public static void main(String[] args)
    {
        N = 4;
        int[][] board = new int[N][N];
        solveNQueens(board, 0);
    }
}

广度优先算法BFS

一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果，并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

Java实现：

import java.util.*;

 class BFSAlgorithm
 {
    // 用邻接表表示图
    private final Map<Integer, List<Integer>> graph;

    public BFSAlgorithm()
    {
        this.graph = new HashMap<>();
    }

    // 添加边
    public void addEdge(int v, int w)
    {
        graph.computeIfAbsent(v, ArrayList::new).add(w);
    }

    // 广度优先搜索
    public void BFS(int start)
    {
        Set<Integer> visited = new HashSet<>();
        Queue<Integer> queue = new LinkedList<>();

        visited.add(start);
        queue.offer(start);

        while (!queue.isEmpty())
        {
            int vertex = queue.poll();
            System.out.print(vertex + " ");

            List<Integer> neighbors = graph.get(vertex);
            if (neighbors != null)
            {
                for (int neighbor : neighbors)
                {
                    if (!visited.contains(neighbor))
                    {
                        visited.add(neighbor);
                        queue.offer(neighbor);
                    }
                }
            }
        }
    }

    public static void main(String[] args) 
    {
        BFSAlgorithm bfs = new BFSAlgorithm();

        bfs.addEdge(0, 1);
        bfs.addEdge(0, 2);
        bfs.addEdge(1, 2);
        bfs.addEdge(2, 0);
        bfs.addEdge(2, 3);
        bfs.addEdge(3, 3);

        System.out.println("广度优先搜索结果：");
        bfs.BFS(2);
    }
}

本文仅为学习记录，如有错误欢迎指出。