最小二分组

给定从1 到 N的N个顶点图的邻接列表表示，任务是计算给定图的最小二部组。

例子：

Input: N = 5 
Below is the given graph with number of nodes is 5: 
 

Output: 3 
Explanation: 
Possible groups satisfying the Bipartite property: [2, 5], [1, 3], [4] 
Below is the number of bipartite groups can be formed: 
 

方法：
这个想法是在给定的N 个节点图中找到所有 Connected Components 的最大高度，以找到最小的二部组。以下是步骤：

1. 对于给定图中的所有未访问顶点，从当前顶点开始，找到当前连通分量的高度。
2. 启动 DFS Traversal 以查找所有 Connected Components 的高度。
3. 为所有连接组件计算的最大高度给出了所需的最小二分组。

下面是上述方法的实现：

C++

#include 
using namespace std;
 
// Function to find the height sizeof
// the current component with vertex s
int height(int s, vector adj[],
           int* visited)
{
    // Visit the current Node
    visited[s] = 1;
    int h = 0;
 
    // Call DFS recursively to find the
    // maximum height of current CC
    for (auto& child : adj[s]) {
 
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = max(h, 1 + height(child, adj,
                                  visited));
        }
    }
    return h;
}
 
// Function to find the minimum Groups
int minimumGroups(vector adj[], int N)
{
    // Initialise with visited array
    int visited[N + 1] = { 0 };
 
    // To find the minimum groups
    int groups = INT_MIN;
 
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (int i = 1; i <= N; i++) {
 
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            int comHeight;
            comHeight = height(i, adj, visited);
            groups = max(groups, comHeight);
        }
    }
 
    // Return the minimum bipartite matching
    return groups;
}
 
// Function that adds the current edges
// in the given graph
void addEdge(vector adj[], int u, int v)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
 
// Drivers Code
int main()
{
    int N = 5;
 
    // Adjacency List
    vector adj[N + 1];
 
    // Adding edges to List
    addEdge(adj, 1, 2);
    addEdge(adj, 3, 2);
    addEdge(adj, 4, 3);
 
    cout << minimumGroups(adj, N);
}

Java

import java.util.*;
 
class GFG{
  
// Function to find the height sizeof
// the current component with vertex s
static int height(int s, Vector adj[],
           int []visited)
{
    // Visit the current Node
    visited[s] = 1;
    int h = 0;
  
    // Call DFS recursively to find the
    // maximum height of current CC
    for (int  child : adj[s]) {
  
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = Math.max(h, 1 + height(child, adj,
                                  visited));
        }
    }
    return h;
}
  
// Function to find the minimum Groups
static int minimumGroups(Vector adj[], int N)
{
    // Initialise with visited array
    int []visited= new int[N + 1];
  
    // To find the minimum groups
    int groups = Integer.MIN_VALUE;
  
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (int i = 1; i <= N; i++) {
  
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            int comHeight;
            comHeight = height(i, adj, visited);
            groups = Math.max(groups, comHeight);
        }
    }
  
    // Return the minimum bipartite matching
    return groups;
}
  
// Function that adds the current edges
// in the given graph
static void addEdge(Vector adj[], int u, int v)
{
    adj[u].add(v);
    adj[v].add(u);
}
  
// Drivers Code
public static void main(String[] args)
{
    int N = 5;
  
    // Adjacency List
    Vector []adj = new Vector[N + 1];
    for (int i = 0 ; i < N + 1; i++)
        adj[i] = new Vector();
     
    // Adding edges to List
    addEdge(adj, 1, 2);
    addEdge(adj, 3, 2);
    addEdge(adj, 4, 3);
  
    System.out.print(minimumGroups(adj, N));
}
}
 
// This code is contributed by 29AjayKumar

Python3

import sys
 
# Function to find the height sizeof
# the current component with vertex s
def height(s, adj, visited):
 
    # Visit the current Node
    visited[s] = 1
    h = 0
  
    # Call DFS recursively to find the
    # maximum height of current CC
    for child in adj[s]:
  
        # If the node is not visited
        # then the height recursively
        # for next element
        if (visited[child] == 0):
            h = max(h, 1 + height(child, adj,
                                  visited))
     
    return h
 
# Function to find the minimum Groups
def minimumGroups(adj, N):
 
    # Initialise with visited array
    visited = [0 for i in range(N + 1)]
  
    # To find the minimum groups
    groups = -sys.maxsize
  
    # Traverse all the non visited Node
    # and calculate the height of the
    # tree with current node as a head
    for i in range(1, N + 1):
  
        # If the current is not visited
        # therefore, we get another CC
        if (visited[i] == 0):
            comHeight = height(i, adj, visited)
            groups = max(groups, comHeight)
         
    # Return the minimum bipartite matching
    return groups
 
# Function that adds the current edges
# in the given graph
def addEdge(adj, u, v):
     
    adj[u].append(v)
    adj[v].append(u)
 
# Driver code   
if __name__=="__main__":
     
    N = 5
  
    # Adjacency List
    adj = [[] for i in range(N + 1)]
  
    # Adding edges to List
    addEdge(adj, 1, 2)
    addEdge(adj, 3, 2)
    addEdge(adj, 4, 3)
  
    print(minimumGroups(adj, N))
 
# This code is contributed by rutvik_56

C#

using System;
using System.Collections.Generic;
 
class GFG{
   
// Function to find the height sizeof
// the current component with vertex s
static int height(int s, List []adj,
           int []visited)
{
    // Visit the current Node
    visited[s] = 1;
    int h = 0;
   
    // Call DFS recursively to find the
    // maximum height of current CC
    foreach (int  child in adj[s]) {
   
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = Math.Max(h, 1 + height(child, adj,
                                  visited));
        }
    }
    return h;
}
   
// Function to find the minimum Groups
static int minimumGroups(List []adj, int N)
{
    // Initialise with visited array
    int []visited= new int[N + 1];
   
    // To find the minimum groups
    int groups = int.MinValue;
   
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (int i = 1; i <= N; i++) {
   
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            int comHeight;
            comHeight = height(i, adj, visited);
            groups = Math.Max(groups, comHeight);
        }
    }
   
    // Return the minimum bipartite matching
    return groups;
}
   
// Function that adds the current edges
// in the given graph
static void addEdge(List []adj, int u, int v)
{
    adj[u].Add(v);
    adj[v].Add(u);
}
   
// Drivers Code
public static void Main(String[] args)
{
    int N = 5;
   
    // Adjacency List
    List []adj = new List[N + 1];
    for (int i = 0 ; i < N + 1; i++)
        adj[i] = new List();
      
    // Adding edges to List
    addEdge(adj, 1, 2);
    addEdge(adj, 3, 2);
    addEdge(adj, 4, 3);
   
    Console.Write(minimumGroups(adj, N));
}
}
  
// This code is contributed by Rajput-Ji

Javascript

 
 
// Function to find the height sizeof
// the current component with vertex s
function height(s, adj, visited)
{
    // Visit the current Node
    visited[s] = 1;
    var h = 0;
 
    // Call DFS recursively to find the
    // maximum height of current CC
    adj[s].forEach(child => {
         
 
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = Math.max(h, 1 + height(child, adj,
                                  visited));
        }
    });
    return h;
}
 
// Function to find the minimum Groups
function minimumGroups(adj, N)
{
    // Initialise with visited array
    var visited = Array(N+1).fill(0);
 
    // To find the minimum groups
    var groups = -1000000000;
 
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (var i = 1; i <= N; i++) {
 
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            var comHeight;
            comHeight = height(i, adj, visited);
            groups = Math.max(groups, comHeight);
        }
    }
 
    // Return the minimum bipartite matching
    return groups;
}
 
// Function that adds the current edges
// in the given graph
function addEdge(adj, u, v)
{
    adj[u].push(v);
    adj[v].push(u);
}
 
// Drivers Code
var N = 5;
 
// Adjacency List
var adj = Array.from(Array(N+1), ()=>Array())
 
// Adding edges to List
addEdge(adj, 1, 2);
addEdge(adj, 3, 2);
addEdge(adj, 4, 3);
 
document.write( minimumGroups(adj, N));
 
 
 

输出：

3

时间复杂度： O(V+E)，其中 V 是顶点的数量，E 是边的集合。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。