使用DFS遍历打印矩阵元素

给定具有整数M×N的矩阵grid [] [] ，任务是使用DFS遍历打印矩阵元素。

例子：

Input: mat[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}
Output: 1 2 3 4 8 12 16 15 11 7 6 10 14 13 9 5
Explanation: The matrix elements in the order of their Depth First Search traversal are 1 2 3 4 8 12 16 15 11 7 6 10 14 13 9 5.

Input: mat[][] = {{0, 1, 9, 4}, {1, 2, 3, 4}, {0, 0, -1, -1}, {-1, -1, 0, 1}}
Output: 0 1 9 4 4 -1 1 0 -1 3 2 0 -1 -1 0 1

递归方法：想法是使用递归深度优先搜索来遍历矩阵并打印其元素。请按照以下步骤解决问题：

• 初始化一个二维布尔向量，例如vis [] [] ，以跟踪已访问和未访问的索引。
• 定义一个函数，例如isValid(i，j) ，以检查位置(i，j)是否有效，即(i，j)应该在矩阵内并且不被访问。
• 定义一个递归函数DFS(i，j)：
  • 在每次调用时，标记访问的当前位置(i，j)并在该位置打印元素。
  • 如果各个位置分别是DFS(i + 1，j)，DFS(i，j + 1)，DFS(i – 1，j)和DFS(i，j – 1)，则对所有相邻边进行递归调用。有效，即未访问且在矩阵内。
• 最后，调用函数DFS(0，0)以启动DFS遍历以打印矩阵。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Direction vectors
int dRow[] = { -1, 0, 1, 0 };
int dCol[] = { 0, 1, 0, -1 };
 
// Function to check if current
// position is valid or not
bool isValid(vector >& vis,
             int row, int col,
             int COL, int ROW)
{
    // Check if the cell is out of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited or not
    if (vis[row][col] == true)
        return false;
 
    return true;
}
 
// Utility function to print matrix
// elements using DFS Traversal
void DFSUtil(int row, int col,
             vector > grid,
             vector >& vis,
             int M, int N)
{
    // Mark the current cell visited
    vis[row][col] = true;
 
    // Print the element at the cell
    cout << grid[row][col] << " ";
 
    // Traverse all four adjacent
    // cells of the current element
    for (int i = 0; i < 4; i++) {
 
        int x = row + dRow[i];
        int y = col + dCol[i];
 
        // Check if x and y is
        // valid index or not
        if (isValid(vis, x, y, M, N))
            DFSUtil(x, y, grid, vis, M, N);
    }
}
 
// Function to print the matrix elements
void DFS(int row, int col,
         vector > grid,
         int M, int N)
{
    // Initialize a visiting matrix
    vector > vis(
        M + 1, vector(N + 1, false));
 
    // Function call to print matrix
    // elements by DFS traversal
    DFSUtil(0, 0, grid, vis, M, N);
}
 
// Driver Code
int main()
{
    // Given matrix
    vector > grid{ { 1, 2, 3, 4 },
                               { 5, 6, 7, 8 },
                               { 9, 10, 11, 12 },
                               { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.size();
 
    // Column of the matrix
    int N = grid[0].size();
 
    DFS(0, 0, grid, M, N);
 
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;
class GFG
{
// Direction vectors
static int dRow[] = { -1, 0, 1, 0 };
static int dCol[] = { 0, 1, 0, -1 };
 
// Function to check if current
// position is valid or not
static boolean isValid(boolean[][] vis,
             int row, int col,
             int COL, int ROW)
{
    // Check if the cell is out of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited or not
    if (vis[row][col] == true)
        return false;
 
    return true;
}
 
// Utility function to print matrix
// elements using DFS Traversal
static void DFSUtil(int row, int col,
            int[][] grid,
            boolean[][] vis,
            int M, int N)
{
   
    // Mark the current cell visited
    vis[row][col] = true;
 
    // Print the element at the cell
    System.out.print(grid[row][col] + " ");
 
    // Traverse all four adjacent
    // cells of the current element
    for (int i = 0; i < 4; i++) {
 
        int x = row + dRow[i];
        int y = col + dCol[i];
 
        // Check if x and y is
        // valid index or not
        if (isValid(vis, x, y, M, N))
            DFSUtil(x, y, grid, vis, M, N);
    }
}
// Function to print the matrix elements
static void DFS(int row, int col,
        int[][] grid,
         int M, int N)
{
    // Initialize a visiting matrix
    boolean[][] vis = new boolean[M + 1][N + 1];
    for(int i = 0; i < M + 1; i++)
    {
        for(int j = 0; j < N + 1; j++)
        {
            vis[i][j] = false;
        }
    }
 
    // Function call to print matrix
    // elements by DFS traversal
    DFSUtil(0, 0, grid, vis, M, N);
}
 
// Driver Code
public static void main(String args[])
{
    // Given matrix
    int[][] grid = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.length;
 
    // Column of the matrix
    int N = grid[0].length;
 
    DFS(0, 0, grid, M, N);
}
}
 
// This code is contributed by susmitakundugoaldanga.

Python3

# Python3 program for the above approach
 
# Direction vectors
dRow = [-1, 0, 1, 0]
dCol = [0, 1, 0, -1]
 
# Function to check if current
# position is valid or not
def isValid(row, col, COL, ROW):
    global vis
     
    # Check if the cell is out of bounds
    if (row < 0 or col < 0 or col > COL - 1 or row > ROW - 1):
        return False
 
    # Check if the cell is visited or not
    if (vis[row][col] == True):
        return False
    return True
 
# Utility function to prmatrix
# elements using DFS Traversal
def DFSUtil(row, col,grid, M, N):
    global vis
 
    # Mark the current cell visited
    vis[row][col] = True
 
    # Prthe element at the cell
    print(grid[row][col], end = " ")
 
    # Traverse all four adjacent
    # cells of the current element
    for i in range(4):
 
        x = row + dRow[i]
        y = col + dCol[i]
 
        # Check if x and y is
        # valid index or not
        if (isValid(x, y, M, N)):
            DFSUtil(x, y, grid, M, N)
 
# Function to prthe matrix elementsdef
def DFS(row, col,grid, M, N):
    global vis
    # Initialize a visiting matrix
 
    # Function call to prmatrix
    # elements by DFS traversal
    DFSUtil(0, 0, grid, M, N)
 
# Driver Code
if __name__ == '__main__':
     
    # Given matrix
    grid = [ [ 1, 2, 3, 4 ],
           [ 5, 6, 7, 8 ],
           [ 9, 10, 11, 12 ],
           [ 13, 14, 15, 16 ] ]
 
    # Row of the matrix
    M = len(grid)
 
    # Column of the matrix
    N = len(grid[0])
    vis = [[False for i in range(M)] for i in range(N)]
    DFS(0, 0, grid, M, N)
 
    # This code is contributed by mohit kumar 29.

C#

// C# program to implement
// the above approach
using System;
public class GFG
{
   
// Direction vectors
static int []dRow = { -1, 0, 1, 0 };
static int []dCol = { 0, 1, 0, -1 };
 
// Function to check if current
// position is valid or not
static bool isValid(bool[,] vis,
             int row, int col,
             int COL, int ROW)
{
   
    // Check if the cell is out of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited or not
    if (vis[row,col] == true)
        return false;
 
    return true;
}
 
// Utility function to print matrix
// elements using DFS Traversal
static void DFSUtil(int row, int col,
            int[,] grid,
            bool[,] vis,
            int M, int N)
{
   
    // Mark the current cell visited
    vis[row,col] = true;
 
    // Print the element at the cell
    Console.Write(grid[row,col] + " ");
 
    // Traverse all four adjacent
    // cells of the current element
    for (int i = 0; i < 4; i++) {
 
        int x = row + dRow[i];
        int y = col + dCol[i];
 
        // Check if x and y is
        // valid index or not
        if (isValid(vis, x, y, M, N))
            DFSUtil(x, y, grid, vis, M, N);
    }
}
   
// Function to print the matrix elements
static void DFS(int row, int col,
        int[,] grid,
         int M, int N)
{
   
    // Initialize a visiting matrix
    bool[,] vis = new bool[M + 1,N + 1];
    for(int i = 0; i < M + 1; i++)
    {
        for(int j = 0; j < N + 1; j++)
        {
            vis[i,j] = false;
        }
    }
 
    // Function call to print matrix
    // elements by DFS traversal
    DFSUtil(0, 0, grid, vis, M, N);
}
 
// Driver Code
public static void Main(String []args)
{
   
    // Given matrix
    int[,] grid = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.GetLength(0);
 
    // Column of the matrix
    int N = grid.GetLength(1);
    DFS(0, 0, grid, M, N);
}
}
 
// This code is contributed by 29AjayKumar

输出

1 2 3 4 8 12 16 15 11 7 6 10 14 13 9 5 

时间复杂度： O(N * M)
辅助空间： O(N * M)

迭代方法：想法是使用深度优先迭代遍历矩阵并打印矩阵元素。请按照以下步骤解决问题：

• 定义一个函数，例如isValid(i，j) ，以检查位置(i，j)是否有效，即(i，j)位于矩阵内部并且未被访问。
• 初始化一个二维布尔向量vis [] [] ，以跟踪位置say (i，j)是否已被访问。
• 初始化一个stack >说S来实现DFS遍历。
• 第一推动在所述堆叠中的第一小区(0,0)S标记访问的单元格。
• 在堆栈S不为空时进行迭代：
  • 在每次迭代中，标记要访问的堆栈顶部元素(i，j)并在该位置打印该元素，然后从堆栈S中移除顶部元素。
  • 如果相应的位置有效(即未访问且已被访问)，则将相邻的单元格(即， (i + 1，j)，(i，j +1)，(i – 1，j)和(i，j – 1))推入堆栈中在矩阵内。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Direction vectors
int dRow[] = { -1, 0, 1, 0 };
int dCol[] = { 0, 1, 0, -1 };
 
// Function to check if curruent
// position is valid or not
bool isValid(vector >& vis,
             int row, int col,
             int COL, int ROW)
{
    // Check if the cell is out
    // of bounds
    if (row < 0 || col < 0 || col > COL - 1
        || row > ROW - 1)
        return false;
 
    // Check if the cell is visited
    if (vis[row][col] == true)
        return false;
 
    return true;
}
 
// Function to print the matrix elements
void DFS_iterative(vector > grid,
                   int M, int N)
{
 
    // Stores if a position in the
    // matrix been visited or not
    vector > vis(
        M + 5, vector(N + 5, false));
 
    // Initialize stack to implement DFS
    stack > st;
 
    // Push the first position of grid[][]
    // in the stack
    st.push({ 0, 0 });
 
    // Mark the cell (0, 0) visited
    vis[0][0] = true;
 
    while (!st.empty()) {
 
        // Stores top element of stack
        pair p = st.top();
 
        // Delete the top() element
        // of stack
        st.pop();
 
        int row = p.first;
        int col = p.second;
 
        // Print element at the cell
        cout << grid[row][col] << " ";
 
        // Traverse in all four adjacent
        // sides of current positions
        for (int i = 0; i < 4; i++) {
 
            int x = row + dRow[i];
            int y = col + dCol[i];
 
            // Check if x and y is valid
            // position and then push
            // the position of current
            // cell in the stack
            if (isValid(vis, x, y, M, N)) {
 
                // Push the current cell
                st.push({ x, y });
 
                // Mark current cell visited
                vis[x][y] = true;
            }
        }
    }
}
 
// Driver Code
int main()
{
    // Given matrix
    vector > grid{ { 1, 2, 3, 4 },
                               { 5, 6, 7, 8 },
                               { 9, 10, 11, 12 },
                               { 13, 14, 15, 16 } };
 
    // Row of the matrix
    int M = grid.size();
 
    // Column of the matrix
    int N = grid[0].size();
 
    DFS_iterative(grid, M, N);
 
    return 0;
}

输出：

1 5 9 13 14 15 16 12 8 7 3 4 11 10 6 2

时间复杂度： O(N * M)
辅助空间： O(N * M)