📜  二进制网格中最长连接的1的长度

📅  最后修改于: 2021-04-22 08:32:40             🧑  作者: Mango

给定大小为N * M的网格仅包含01 ,任务是查找给定网格中连接的最长1的长度。我们只能从网格的任何当前单元格向左,向右,向上或向下移动。

例子:

方法:想法是在当前单元格值为1的网格上进行DFS遍历,并递归调用当前单元格的所有四个方向,其中值为1并更新连接的最大长度1

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
#define row 6
#define col 7
using namespace std;
 
int vis[row + 1][col + 1], id;
int diameter = 0, length = 0;
 
// Keeps a track of directions
// that is up, down, left, right
int dx[] = { -1, 1, 0, 0 };
int dy[] = { 0, 0, -1, 1 };
 
// Function to perform the dfs traversal
void dfs(int a, int b, int lis[][col],
         int& x, int& y)
{
 
    // Mark the current node as visited
    vis[a][b] = id;
 
    // Increment length from this node
    length++;
 
    // Update the diameter length
    if (length > diameter) {
        x = a;
        y = b;
        diameter = length;
    }
    for (int j = 0; j < 4; j++) {
 
        // Move to next cell in x-direction
        int cx = a + dx[j];
 
        // Move to next cell in y-direction
        int cy = b + dy[j];
 
        // Check if cell is invalid
        // then continue
        if (cx < 0 || cy < 0 || cx >= row
            || cy >= col || lis[cx][cy] == 0
            || vis[cx][cy]) {
            continue;
        }
 
        // Perform DFS on new cell
        dfs(cx, cy, lis, x, y);
    }
 
    vis[a][b] = 0;
 
    // Decrement the length
    length--;
}
 
// Function to find the maximum length of
// connected 1s in the given grid
void findMaximumLength(int lis[][col])
{
 
    int x, y;
 
    // Increment the id
    id++;
    length = 0;
    diameter = 0;
 
    // Traverse the grid[]
    for (int i = 0; i < row; i++) {
 
        for (int j = 0; j < col; j++) {
 
            if (lis[i][j] != 0) {
 
                // Find start point of
                // start dfs call
                dfs(i, j, lis, x, y);
                i = row;
                break;
            }
        }
    }
 
    id++;
    length = 0;
    diameter = 0;
 
    // DFS Traversal from cell (x, y)
    dfs(x, y, lis, x, y);
 
    // Print the maximum length
    cout << diameter;
}
 
// Driver Code
int main()
{
    // Given grid[][]
    int grid[][col] = { { 0, 0, 0, 0, 0, 0, 0 },
                        { 0, 1, 0, 1, 0, 0, 0 },
                        { 0, 1, 0, 1, 0, 0, 0 },
                        { 0, 1, 0, 1, 0, 1, 0 },
                        { 0, 1, 1, 1, 1, 1, 0 },
                        { 0, 0, 0, 1, 0, 0, 0 } };
 
    // Function Call
    findMaximumLength(grid);
 
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
 
class GFG{
     
static final int row = 6;
static final int col = 7;
static int [][]vis = new int[row + 1][col + 1];
static int id;
static int diameter = 0, length = 0;
static int x = 0, y = 0;
 
// Keeps a track of directions
// that is up, down, left, right
static int dx[] = { -1, 1, 0, 0 };
static int dy[] = { 0, 0, -1, 1 };
 
// Function to perform the dfs traversal
static void dfs(int a, int b, int lis[][])
{
     
    // Mark the current node as visited
    vis[a][b] = id;
 
    // Increment length from this node
    length++;
 
    // Update the diameter length
    if (length > diameter)
    {
        x = a;
        y = b;
        diameter = length;
    }
 
    for(int j = 0; j < 4; j++)
    {
         
       // Move to next cell in x-direction
       int cx = a + dx[j];
        
       // Move to next cell in y-direction
       int cy = b + dy[j];
        
       // Check if cell is invalid
       // then continue
       if (cx < 0 || cy < 0 ||
           cx >= row || cy >= col ||
           lis[cx][cy] == 0 || vis[cx][cy] > 0)
       {
           continue;
       }
        
       // Perform DFS on new cell
       dfs(cx, cy, lis);
    }
     
    vis[a][b] = 0;
 
    // Decrement the length
    length--;
}
 
// Function to find the maximum length of
// connected 1s in the given grid
static void findMaximumLength(int lis[][])
{
     
    // Increment the id
    id++;
    length = 0;
    diameter = 0;
 
    // Traverse the grid[]
    for(int i = 0; i < row; i++)
    {
       for(int j = 0; j < col; j++)
       {
          if (lis[i][j] != 0)
          {
               
              // Find start point of
              // start dfs call
              dfs(i, j, lis);
              i = row;
              break;
          }
       }
    }
 
    id++;
    length = 0;
    diameter = 0;
 
    // DFS Traversal from cell (x, y)
    dfs(x, y, lis);
 
    // Print the maximum length
    System.out.print(diameter);
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given grid[][]
    int grid[][] = { { 0, 0, 0, 0, 0, 0, 0 },
                     { 0, 1, 0, 1, 0, 0, 0 },
                     { 0, 1, 0, 1, 0, 0, 0 },
                     { 0, 1, 0, 1, 0, 1, 0 },
                     { 0, 1, 1, 1, 1, 1, 0 },
                     { 0, 0, 0, 1, 0, 0, 0 } };
 
    // Function Call
    findMaximumLength(grid);
}
}
 
// This code is contributed by amal kumar choubey


Python3
# Python3 program for the above approach
row = 6
col = 7
  
vis = [[0 for i in range(col + 1)]
          for j in range(row + 1)]
id = 0
diameter = 0
length = 0
  
# Keeps a track of directions
# that is up, down, left, right
dx = [ -1, 1, 0, 0 ]
dy = [ 0, 0, -1, 1 ]
  
# Function to perform the dfs traversal
def dfs(a, b, lis, x, y):
     
    global id, length, diameter
     
    # Mark the current node as visited
    vis[a][b] = id
  
    # Increment length from this node
    length += 1
  
    # Update the diameter length
    if (length > diameter):
        x = a
        y = b
        diameter = length
     
    for j in range(4):
  
        # Move to next cell in x-direction
        cx = a + dx[j]
  
        # Move to next cell in y-direction
        cy = b + dy[j]
  
        # Check if cell is invalid
        # then continue
        if (cx < 0 or cy < 0 or
            cx >= row or cy >= col or
            lis[cx][cy] == 0 or vis[cx][cy]):
            continue
     
        # Perform DFS on new cell
        dfs(cx, cy, lis, x, y)
     
    vis[a][b] = 0
  
    # Decrement the length
    length -= 1
     
    return x, y
 
# Function to find the maximum length of
# connected 1s in the given grid
def findMaximumLength(lis):
     
    global id, length, diameter
     
    x = 0
    y = 0
  
    # Increment the id
    id += 1
     
    length = 0
    diameter = 0
  
    # Traverse the grid[]
    for i in range(row):
        for j in range(col):
            if (lis[i][j] != 0):
  
                # Find start point of
                # start dfs call
                x, y = dfs(i, j, lis, x, y)
                i = row
                break
  
    id += 1
    length = 0
    diameter = 0
  
    # DFS Traversal from cell (x, y)
    x, y = dfs(x, y, lis, x, y)
  
    # Print the maximum length
    print(diameter)
 
# Driver Code
if __name__=="__main__":
     
    # Given grid[][]
    grid = [ [ 0, 0, 0, 0, 0, 0, 0 ],
             [ 0, 1, 0, 1, 0, 0, 0 ],
             [ 0, 1, 0, 1, 0, 0, 0 ],
             [ 0, 1, 0, 1, 0, 1, 0 ],
             [ 0, 1, 1, 1, 1, 1, 0 ],
             [ 0, 0, 0, 1, 0, 0, 0 ] ]
  
    # Function Call
    findMaximumLength(grid)
  
# This code is contributed by rutvik_56


C#
// C# program for the above approach
using System;
 
class GFG{
     
static readonly int row = 6;
static readonly int col = 7;
static int [,]vis = new int[row + 1, col + 1];
static int id;
static int diameter = 0, length = 0;
static int x = 0, y = 0;
 
// Keeps a track of directions
// that is up, down, left, right
static int []dx = { -1, 1, 0, 0 };
static int []dy = { 0, 0, -1, 1 };
 
// Function to perform the dfs traversal
static void dfs(int a, int b, int [,]lis)
{
     
    // Mark the current node as visited
    vis[a, b] = id;
 
    // Increment length from this node
    length++;
 
    // Update the diameter length
    if (length > diameter)
    {
        x = a;
        y = b;
        diameter = length;
    }
 
    for(int j = 0; j < 4; j++)
    {
         
        // Move to next cell in x-direction
        int cx = a + dx[j];
         
        // Move to next cell in y-direction
        int cy = b + dy[j];
         
        // Check if cell is invalid
        // then continue
        if (cx < 0 || cy < 0 ||
            cx >= row || cy >= col ||
            lis[cx, cy] == 0 || vis[cx, cy] > 0)
        {
            continue;
        }
         
        // Perform DFS on new cell
        dfs(cx, cy, lis);
    }
    vis[a, b] = 0;
     
    // Decrement the length
    length--;
}
 
// Function to find the maximum length of
// connected 1s in the given grid
static void findMaximumLength(int [,]lis)
{
     
    // Increment the id
    id++;
    length = 0;
    diameter = 0;
 
    // Traverse the grid[]
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col; j++)
        {
            if (lis[i, j] != 0)
            {
                 
                // Find start point of
                // start dfs call
                dfs(i, j, lis);
                i = row;
                break;
            }
        }
    }
     
    id++;
    length = 0;
    diameter = 0;
 
    // DFS Traversal from cell (x, y)
    dfs(x, y, lis);
 
    // Print the maximum length
    Console.Write(diameter);
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given grid[,]
    int [,]grid = { { 0, 0, 0, 0, 0, 0, 0 },
                    { 0, 1, 0, 1, 0, 0, 0 },
                    { 0, 1, 0, 1, 0, 0, 0 },
                    { 0, 1, 0, 1, 0, 1, 0 },
                    { 0, 1, 1, 1, 1, 1, 0 },
                    { 0, 0, 0, 1, 0, 0, 0 } };
 
    // Function Call
    findMaximumLength(grid);
}
}
 
// This code is contributed by amal kumar choubey


输出:
9




时间复杂度: O(行+列)