📜  网格上最大的连接组件

📅  最后修改于: 2021-06-25 22:05:06             🧑  作者: Mango

给定一个在不同单元格中具有不同颜色的网格,每种颜色由一个不同的数字表示。任务是找出网格上最大的连接组件。最大的组件网格是指最大的单元格集合,这样您就可以通过仅在集合中相邻的单元格之间移动而从该单元格中的任何一个单元格移动到该单元格中的任何其他单元格。
例子:

方法 :
该方法是将给定的网格可视化为图形,每个单元格代表图形的一个单独节点,每个节点连接到四个其他节点,这些节点将分别在该网格的上,下,左和右。现在,对图的每个节点进行BFS搜索,找到与当前节点具有相同颜色值的所有连接到当前节点的节点
这是上面示例的图形:

网格的图形表示


在每个单元(i,j),都可以执行BFS。从一个单元格可能的移动将是向右,向左,从顶部或从底部开始。仅移动到范围内且颜色相同的那些单元格。如果先前已经访问了相同的节点,则网格的最大分量值将存储在result [] []数组中。使用备注,减少任何单元上的BFS数量。 Visited [] []数组用于标记先前是否已访问过该单元格,并且在为每个单元格完成BFS时count会存储连接的组件的计数。存储最大数量,并使用result [] []数组打印结果网格。
下面是上述方法的说明:

C++
// CPP program to print the largest
// connected component in a grid
#include 
using namespace std;
 
const int n = 6;
const int m = 8;
 
// stores information about  which cell
// are already visited in a particular BFS
int visited[n][m];
 
// result stores the final result grid
int result[n][m];
 
// stores the count of cells in the largest
// connected component
int COUNT;
 
// Function checks if a cell is valid i.e it
// is inside the grid and equal to the key
bool is_valid(int x, int y, int key, int input[n][m])
{
    if (x < n && y < m && x >= 0 && y >= 0) {
        if (visited[x][y] == false && input[x][y] == key)
            return true;
        else
            return false;
    }
    else
        return false;
}
 
// BFS to find all cells in
// connection with key = input[i][j]
void BFS(int x, int y, int i, int j, int input[n][m])
{
    // terminating case for BFS
    if (x != y)
        return;
 
    visited[i][j] = 1;
    COUNT++;
 
    // x_move and y_move arrays
    // are the possible movements
    // in x or y direction
    int x_move[] = { 0, 0, 1, -1 };
    int y_move[] = { 1, -1, 0, 0 };
 
    // checks all four points connected with input[i][j]
    for (int u = 0; u < 4; u++)
        if (is_valid(i + y_move[u], j + x_move[u], x, input))
            BFS(x, y, i + y_move[u], j + x_move[u], input);
}
 
// called every time before a BFS
// so that visited array is reset to zero
void reset_visited()
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            visited[i][j] = 0;
}
 
// If a larger connected component
// is found this function is called
// to store information about that component.
void reset_result(int key, int input[n][m])
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (visited[i][j] && input[i][j] == key)
                result[i][j] = visited[i][j];
            else
                result[i][j] = 0;
        }
    }
}
// function to print the result
void print_result(int res)
{
    cout << "The largest connected "
         << "component of the grid is :" << res << "\n";
 
    // prints the largest component
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (result[i][j])
                cout << result[i][j] << " ";
            else
                cout << ". ";
        }
        cout << "\n";
    }
}
 
// function to calculate the largest connected
// component
void computeLargestConnectedGrid(int input[n][m])
{
    int current_max = INT_MIN;
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            reset_visited();
            COUNT = 0;
 
            // checking cell to the right
            if (j + 1 < m)
                BFS(input[i][j], input[i][j + 1], i, j, input);
 
            // updating result
            if (COUNT >= current_max) {
                current_max = COUNT;
                reset_result(input[i][j], input);
            }
            reset_visited();
            COUNT = 0;
 
            // checking cell downwards
            if (i + 1 < n)
                BFS(input[i][j], input[i + 1][j], i, j, input);
 
            // updating result
            if (COUNT >= current_max) {
                current_max = COUNT;
                reset_result(input[i][j], input);
            }
        }
    }
    print_result(current_max);
}
// Drivers Code
int main()
{
    int input[n][m] = { { 1, 4, 4, 4, 4, 3, 3, 1 },
                        { 2, 1, 1, 4, 3, 3, 1, 1 },
                        { 3, 2, 1, 1, 2, 3, 2, 1 },
                        { 3, 3, 2, 1, 2, 2, 2, 2 },
                        { 3, 1, 3, 1, 1, 4, 4, 4 },
                        { 1, 1, 3, 1, 1, 4, 4, 4 } };
 
    // function to compute the largest
    // connected component in the grid
    computeLargestConnectedGrid(input);
    return 0;
}


Java
// Java program to print the largest
// connected component in a grid
import java.util.*;
import java.lang.*;
import java.io.*;
 
class GFG
{
static final int n = 6;
static final int m = 8;
 
// stores information about which cell
// are already visited in a particular BFS
static final int visited[][] = new int [n][m];
 
// result stores the final result grid
static final int result[][] = new int [n][m];
 
// stores the count of
// cells in the largest
// connected component
static int COUNT;
 
// Function checks if a cell
// is valid i.e it is inside
// the grid and equal to the key
static boolean is_valid(int x, int y,
                        int key,
                        int input[][])
{
    if (x < n && y < m &&
        x >= 0 && y >= 0)
    {
        if (visited[x][y] == 0 &&
            input[x][y] == key)
            return true;
        else
            return false;
    }
    else
        return false;
}
 
// BFS to find all cells in
// connection with key = input[i][j]
static void BFS(int x, int y, int i,
                int j, int input[][])
{
    // terminating case for BFS
    if (x != y)
        return;
 
    visited[i][j] = 1;
    COUNT++;
 
    // x_move and y_move arrays
    // are the possible movements
    // in x or y direction
    int x_move[] = { 0, 0, 1, -1 };
    int y_move[] = { 1, -1, 0, 0 };
 
    // checks all four points
    // connected with input[i][j]
    for (int u = 0; u < 4; u++)
        if ((is_valid(i + y_move[u],
             j + x_move[u], x, input)) == true)
            BFS(x, y, i + y_move[u],
                      j + x_move[u], input);
}
 
// called every time before
// a BFS so that visited
// array is reset to zero
static void reset_visited()
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            visited[i][j] = 0;
}
 
// If a larger connected component
// is found this function is
// called to store information
// about that component.
static void reset_result(int key,
                         int input[][])
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (visited[i][j] ==1 &&
                input[i][j] == key)
                result[i][j] = visited[i][j];
            else
                result[i][j] = 0;
        }
    }
}
 
// function to print the result
static void print_result(int res)
{
    System.out.println ("The largest connected " +
                    "component of the grid is :" +
                                            res );
 
    // prints the largest component
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (result[i][j] != 0)
                System.out.print(result[i][j] + " ");
            else
                System.out.print(". ");
        }
        System.out.println();
    }
}
 
// function to calculate the
// largest connected component
static void computeLargestConnectedGrid(int input[][])
{
    int current_max = Integer.MIN_VALUE;
 
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            reset_visited();
            COUNT = 0;
 
            // checking cell to the right
            if (j + 1 < m)
                BFS(input[i][j], input[i][j + 1],
                                    i, j, input);
 
            // updating result
            if (COUNT >= current_max)
            {
                current_max = COUNT;
                reset_result(input[i][j], input);
            }
            reset_visited();
            COUNT = 0;
 
            // checking cell downwards
            if (i + 1 < n)
                BFS(input[i][j],
                    input[i + 1][j], i, j, input);
 
            // updating result
            if (COUNT >= current_max)
            {
                current_max = COUNT;
                reset_result(input[i][j], input);
            }
        }
    }
    print_result(current_max);
}
// Driver Code
public static void main(String args[])
{
    int input[][] = {{1, 4, 4, 4, 4, 3, 3, 1},
                     {2, 1, 1, 4, 3, 3, 1, 1},
                     {3, 2, 1, 1, 2, 3, 2, 1},
                     {3, 3, 2, 1, 2, 2, 2, 2},
                     {3, 1, 3, 1, 1, 4, 4, 4},
                     {1, 1, 3, 1, 1, 4, 4, 4}};
 
    // function to compute the largest
    // connected component in the grid
    computeLargestConnectedGrid(input);
}
}
 
// This code is contributed by Subhadeep


Python3
# Python3 program to print the largest
# connected component in a grid
  
n = 6;
m = 8;
  
# stores information about  which cell
# are already visited in a particular BFS
visited = [[0 for j in range(m)]for i in range(n)]
  
# result stores the final result grid
result = [[0 for j in range(m)]for i in range(n)]
  
# stores the count of cells in the largest
# connected component
COUNT = 0
  
# Function checks if a cell is valid i.e it
# is inside the grid and equal to the key
def is_valid(x, y, key, input):
 
    if (x < n and y < m and x >= 0 and y >= 0):
        if (visited[x][y] == 0 and input[x][y] == key):
            return True;
        else:
            return False;
     
    else:
        return False;
  
# BFS to find all cells in
# connection with key = input[i][j]
def BFS(x, y, i, j, input):
     
    global COUNT
     
    # terminating case for BFS
    if (x != y):
        return;
  
    visited[i][j] = 1;
    COUNT += 1
  
    # x_move and y_move arrays
    # are the possible movements
    # in x or y direction
    x_move = [ 0, 0, 1, -1 ]
    y_move = [ 1, -1, 0, 0 ]
  
    # checks all four points connected with input[i][j]
    for u in range(4):
     
        if (is_valid(i + y_move[u], j + x_move[u], x, input)):
            BFS(x, y, i + y_move[u], j + x_move[u], input);
  
# called every time before a BFS
# so that visited array is reset to zero
def reset_visited():
 
    for i in range(n):
        for j in range(m):
            visited[i][j] = 0
  
# If a larger connected component
# is found this function is called
# to store information about that component.
def reset_result(key, input):
 
    for i in range(n):
        for j in range(m):
            if (visited[i][j] != 0 and input[i][j] == key):
                result[i][j] = visited[i][j];
            else:
                result[i][j] = 0;
         
# function to print the result
def print_result(res):
 
    print("The largest connected "+
          "component of the grid is :" + str(res));
  
    # prints the largest component
    for i in range(n):
        for j in range(m):
            if (result[i][j] != 0):
                print(result[i][j], end = ' ')
                 
            else:
                print('. ',end = '')
         
        print()
          
# function to calculate the largest connected
# component
def computeLargestConnectedGrid(input):
 
    global COUNT
    current_max = -10000000000
  
    for i in range(n):
        for j in range(m):
            reset_visited();
            COUNT = 0;
  
            # checking cell to the right
            if (j + 1 < m):
                BFS(input[i][j], input[i][j + 1], i, j, input);
  
            # updating result
            if (COUNT >= current_max):
                current_max = COUNT;
                reset_result(input[i][j], input);
             
            reset_visited();
            COUNT = 0;
  
            # checking cell downwards
            if (i + 1 < n):
                BFS(input[i][j], input[i + 1][j], i, j, input);
  
            # updating result
            if (COUNT >= current_max):
                current_max = COUNT;
                reset_result(input[i][j], input);
             
    print_result(current_max);
 
# Drivers Code
if __name__=='__main__':
     
    input = [ [ 1, 4, 4, 4, 4, 3, 3, 1 ],
                        [ 2, 1, 1, 4, 3, 3, 1, 1 ],
                        [ 3, 2, 1, 1, 2, 3, 2, 1 ],
                        [ 3, 3, 2, 1, 2, 2, 2, 2 ],
                        [ 3, 1, 3, 1, 1, 4, 4, 4 ],
                        [ 1, 1, 3, 1, 1, 4, 4, 4 ] ];
  
    # function to compute the largest
    # connected component in the grid
    computeLargestConnectedGrid(input);
 
# This code is contributed by pratham76


C#
// C# program to print the largest
// connected component in a grid
using System;
 
class GFG
{
public const int n = 6;
public const int m = 8;
 
// stores information about which cell
// are already visited in a particular BFS
public static readonly int[][] visited =
              RectangularArrays.ReturnRectangularIntArray(n, m);
 
// result stores the final result grid
public static readonly int[][] result =
              RectangularArrays.ReturnRectangularIntArray(n, m);
 
// stores the count of cells in the
// largest connected component
public static int COUNT;
 
// Function checks if a cell is valid i.e
// it is inside the grid and equal to the key
internal static bool is_valid(int x, int y,
                              int key, int[][] input)
{
    if (x < n && y < m &&
        x >= 0 && y >= 0)
    {
        if (visited[x][y] == 0 &&
            input[x][y] == key)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}
 
// BFS to find all cells in
// connection with key = input[i][j]
public static void BFS(int x, int y, int i,
                       int j, int[][] input)
{
    // terminating case for BFS
    if (x != y)
    {
        return;
    }
 
    visited[i][j] = 1;
    COUNT++;
 
    // x_move and y_move arrays
    // are the possible movements
    // in x or y direction
    int[] x_move = new int[] {0, 0, 1, -1};
    int[] y_move = new int[] {1, -1, 0, 0};
 
    // checks all four points
    // connected with input[i][j]
    for (int u = 0; u < 4; u++)
    {
        if ((is_valid(i + y_move[u],
             j + x_move[u], x, input)) == true)
        {
            BFS(x, y, i + y_move[u],
                j + x_move[u], input);
        }
    }
}
 
// called every time before
// a BFS so that visited
// array is reset to zero
internal static void reset_visited()
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            visited[i][j] = 0;
        }
    }
}
 
// If a larger connected component is
// found this function is called to
// store information about that component.
internal static void reset_result(int key,
                                  int[][] input)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (visited[i][j] == 1 &&
                input[i][j] == key)
            {
                result[i][j] = visited[i][j];
            }
            else
            {
                result[i][j] = 0;
            }
        }
    }
}
 
// function to print the result
internal static void print_result(int res)
{
    Console.WriteLine("The largest connected " +
                      "component of the grid is :" + res);
 
    // prints the largest component
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (result[i][j] != 0)
            {
                Console.Write(result[i][j] + " ");
            }
            else
            {
                Console.Write(". ");
            }
        }
        Console.WriteLine();
    }
}
 
// function to calculate the
// largest connected component
public static void computeLargestConnectedGrid(int[][] input)
{
    int current_max = int.MinValue;
 
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            reset_visited();
            COUNT = 0;
 
            // checking cell to the right
            if (j + 1 < m)
            {
                BFS(input[i][j], input[i][j + 1],
                                    i, j, input);
            }
 
            // updating result
            if (COUNT >= current_max)
            {
                current_max = COUNT;
                reset_result(input[i][j], input);
            }
            reset_visited();
            COUNT = 0;
 
            // checking cell downwards
            if (i + 1 < n)
            {
                BFS(input[i][j], input[i + 1][j],
                                    i, j, input);
            }
 
            // updating result
            if (COUNT >= current_max)
            {
                current_max = COUNT;
                reset_result(input[i][j], input);
            }
        }
    }
    print_result(current_max);
}
 
public static class RectangularArrays
{
    public static int[][] ReturnRectangularIntArray(int size1,
                                                    int size2)
    {
        int[][] newArray = new int[size1][];
        for (int array1 = 0; array1 < size1; array1++)
        {
            newArray[array1] = new int[size2];
        }
 
        return newArray;
    }
}
 
// Driver Code
public static void Main(string[] args)
{
    int[][] input = new int[][]
    {
        new int[] {1, 4, 4, 4, 4, 3, 3, 1},
        new int[] {2, 1, 1, 4, 3, 3, 1, 1},
        new int[] {3, 2, 1, 1, 2, 3, 2, 1},
        new int[] {3, 3, 2, 1, 2, 2, 2, 2},
        new int[] {3, 1, 3, 1, 1, 4, 4, 4},
        new int[] {1, 1, 3, 1, 1, 4, 4, 4}
    };
 
    // function to compute the largest
    // connected component in the grid
    computeLargestConnectedGrid(input);
}
}
// This code is contributed by Shrikant13


输出:
The largest connected component of the grid is :9
. . . . . . . . 
. 1 1 . . . . . 
. . 1 1 . . . . 
. . . 1 . . . . 
. . . 1 1 . . . 
. . . 1 1 . . .

如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。