Number of groups formed in a graph of friends

Given n friends and their friendship relations, find the total number of groups that exist. And the number of ways of new groups that can be formed consisting of people from every existing group. 
If no relation is given for any person then that person has no group and singularly forms a group. If a is a friend of b and b is a friend of c, then a b and c form a group.

Examples:

Input : Number of people = 6 
        Relations : 1 - 2, 3 - 4 
                    and 5 - 6 
Output: Number of existing Groups = 3
        Number of new groups that can
        be formed = 8
Explanation: The existing groups are 
(1, 2), (3, 4), (5, 6). The new 8 groups 
that can be formed by considering a 
member of every group are (1, 3, 5), 
(1, 3, 6), (1, 4, 5), (1, 4, 6), (2, 
3, 5), (2, 3, 6), (2, 4, 5) and (2, 4,
6). 

Input:  Number of people = 4 
        Relations : 1 - 2 and 2 - 3 
Output: Number of existing Groups = 2
        Number of new groups that can
        be formed = 3
Explanation: The existing groups are 
(1, 2, 3) and (4). The new groups that 
can be formed by considering a member
of every group are (1, 4), (2, 4), (3, 4).

To count number of groups, we need to simply count connected components in the given undirected graph. Counting connected components can be easily done using DFS or BFS. Since this is an undirected graph, the number of times a Depth First Search starts from an unvisited vertex for every friend is equal to the number of groups formed. 

To count number of ways in which we form new groups can be done using simply formula which is (N1)*(N2)*….(Nn) where Ni is the no of people in i-th group. 

Implementation:

C++

// C++ program to count number of existing
// groups and number of new groups that can
// be formed.
#include <bits/stdc++.h>
using namespace std;

class Graph {
    int V; // No. of vertices

    // Pointer to an array containing
    // adjacency lists
    list<int>* adj;

    int countUtil(int v, bool visited[]);
public:
    Graph(int V); // Constructor

    // function to add an edge to graph
    void addRelation(int v, int w);
    void countGroups();
};

Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];
}

// Adds a relation as a two way edge of
// undirected graph.
void Graph::addRelation(int v, int w)
{
    // Since indexing is 0 based, reducing
    // edge numbers by 1.
    v--;
    w--;
    adj[v].push_back(w);
    adj[w].push_back(v);
}

// Returns count of not visited nodes reachable
// from v using DFS.
int Graph::countUtil(int v, bool visited[])
{
    int count = 1;
    visited[v] = true;
    for (auto i=adj[v].begin(); i!=adj[v].end(); ++i)
        if (!visited[*i])
            count = count + countUtil(*i, visited);
    return count;
}

// A DFS based function to Count number of
// existing groups and number of new groups
// that can be formed using a member of
// every group.
void Graph::countGroups()
{
    // Mark all the vertices as not visited
    bool* visited = new bool[V];
    memset(visited, 0, V*sizeof(int));

    int existing_groups = 0, new_groups = 1;
    for (int i = 0; i < V; i++)
    {
        // If not in any group.
        if (visited[i] == false)
        {
            existing_groups++;

            // Number of new groups that
            // can be formed.
            new_groups = new_groups *
                    countUtil(i, visited);
        }
    }

    if (existing_groups == 1)
        new_groups = 0;

    cout << "No. of existing groups are "
        << existing_groups << endl;
    cout << "No. of new groups that can be"
            " formed are " << new_groups
        << endl;
}

// Driver code
int main()
{
    int n = 6;

    // Create a graph given in the above diagram
    Graph g(n); // total 6 people
    g.addRelation(1, 2); // 1 and 2 are friends
    g.addRelation(3, 4); // 3 and 4 are friends
    g.addRelation(5, 6); // 5 and 6 are friends

    g.countGroups();

    return 0;
}

Java

// Java program to count number of
// existing groups and number of
// new groups that can be formed.
import java.util.*;
import java.io.*;

class Graph{

// No. of vertices
private int V;

// Array of lists for Adjacency
// List Representation
private LinkedList<Integer> adj[];

// Constructor
@SuppressWarnings("unchecked") Graph(int v)
{
    V = v;
    adj = new LinkedList[V];

    for(int i = 0; i < V; i++)
    {
        adj[i] = new LinkedList();
    }
}

// Adds a relation as a two way edge of
// undirected graph.
public void addRelation(int v, int w)
{

    // Since indexing is 0 based, reducing
    // edge numbers by 1.
    v--;
    w--;
    adj[v].add(w);
    adj[w].add(v);
}

// Returns count of not visited nodes
// reachable from v using DFS.
int countUtil(int v, boolean visited[])
{
    int count = 1;
    visited[v] = true;

    // Recur for all the vertices adjacent
    // to this vertex
    Iterator<Integer> i = adj[v].listIterator();
    while (i.hasNext())
    {
        int n = i.next();
        if (!visited[n])
            count = count + countUtil(n, visited);
    }
    return count;
}

// A DFS based function to Count number of
// existing groups and number of new groups
// that can be formed using a member of
// every group.
void countGroups()
{

    // Mark all the vertices as not
    // visited(set as false by default
    // in java)
    boolean visited[] = new boolean[V];
    int existing_groups = 0, new_groups = 1;

    for(int i = 0; i < V; i++)
    {

        // If not in any group.
        if (visited[i] == false)
        {
            existing_groups++;

            // Number of new groups that
            // can be formed.
            new_groups = new_groups *
                        countUtil(i, visited);
        }
    }

    if (existing_groups == 1)
        new_groups = 0;

    System.out.println("No. of existing groups are " +
                    existing_groups);
    System.out.println("No. of new groups that " +
                    "can be formed are " +
                    new_groups);
}

// Driver code
public static void main(String[] args)
{
    int n = 6;

    // Create a graph given in
    // the above diagram
    Graph g = new Graph(n); // total 6 people
    g.addRelation(1, 2); // 1 and 2 are friends
    g.addRelation(3, 4); // 3 and 4 are friends
    g.addRelation(5, 6); // 5 and 6 are friends

    g.countGroups();
}
}

// This code is contributed by MuskanKalra1

Python3

# Python3 program to count number of
# existing groups and number of new
# groups that can be formed.
class Graph:
    def __init__(self, V):
        self.V = V
        self.adj = [[] for i in range(V)]

    # Adds a relation as a two way
    # edge of undirected graph.
    def addRelation(self, v, w):

        # Since indexing is 0 based,
        # reducing edge numbers by 1.
        v -= 1
        w -= 1
        self.adj[v].append(w)
        self.adj[w].append(v)

    # Returns count of not visited
    # nodes reachable from v using DFS.
    def countUtil(self, v, visited):
        count = 1
        visited[v] = True
        i = 0
        while i != len(self.adj[v]):
            if (not visited[self.adj[v][i]]):
                count = count + self.countUtil(self.adj[v][i],
                                                    visited)
            i += 1
        return count

    # A DFS based function to Count number
    # of existing groups and number of new
    # groups that can be formed using a
    # member of every group.
    def countGroups(self):

        # Mark all the vertices as
        # not visited
        visited = [0] * self.V

        existing_groups = 0
        new_groups = 1
        for i in range(self.V):

            # If not in any group.
            if (visited[i] == False):
                existing_groups += 1

                # Number of new groups that
                # can be formed.
                new_groups = (new_groups *
                            self.countUtil(i, visited))

        if (existing_groups == 1):
            new_groups = 0

        print("No. of existing groups are",
                        existing_groups)
        print("No. of new groups that",
            "can be formed are", new_groups)

# Driver code
if __name__ == '__main__':

    n = 6

    # Create a graph given in the above diagram
    g = Graph(n) # total 6 people
    g.addRelation(1, 2) # 1 and 2 are friends
    g.addRelation(3, 4) # 3 and 4 are friends
    g.addRelation(5, 6) # 5 and 6 are friends

    g.countGroups()

# This code is contributed by PranchalK

C#

// C# program to count number of
// existing groups and number of
// new groups that can be formed.
using System;
using System.Collections.Generic;

class Graph {

  // No. of vertices
  private int V;

  // Array of lists for Adjacency
  // List Representation
  private List<int>[] adj;

  // Constructor
  public Graph(int V)
  {
    this.V = V;
    this.adj = new List<int>[ V ];
    for (int i = 0; i < V; i++) {
      adj[i] = new List<int>();
    }
  }

  // Adds a relation as a two way edge of
  // undirected graph.
  public void AddRelation(int v, int w)
  {
    v--;
    w--;
    adj[v].Add(w);
    adj[w].Add(v);
  }

  // Returns count of not visited nodes
  // reachable from v using DFS.
  private int CountUtil(int v, bool[] visited)
  {
    int count = 1;
    visited[v] = true;

    foreach(int i in adj[v])
    {
      if (!visited[i]) {
        count += CountUtil(i, visited);
      }
    }
    return count;
  }

  // A DFS based function to Count number of
  // existing groups and number of new groups
  // that can be formed using a member of
  // every group.
  public void CountGroups()
  {

    // Mark all the vertices as not visited
    bool[] visited = new bool[V];
    for (int i = 0; i < V; i++) {
      visited[i] = false;
    }

    int existing_groups = 0, new_groups = 1;
    for (int i = 0; i < V; i++) {
      // If not in any group.
      if (!visited[i]) {
        existing_groups++;

        // Number of new groups that
        // can be formed.
        new_groups
          = new_groups * CountUtil(i, visited);
      }
    }

    if (existing_groups == 1) {
      new_groups = 0;
    }

    Console.WriteLine("No. of existing groups are "
                      + existing_groups);
    Console.WriteLine(
      "No. of new groups that can be formed are "
      + new_groups);
  }
}

// Driver code
class GFG {
  static void Main(string[] args)
  {
    int n = 6;

    // Create a graph given in the above diagram
    Graph g = new Graph(n); // total 6 people
    g.AddRelation(1, 2); // 1 and 2 are friends
    g.AddRelation(3, 4); // 3 and 4 are friends
    g.AddRelation(5, 6); // 5 and 6 are friends

    g.CountGroups();
  }
}

// This code is contributed by Prasad Kandekar(prasad264)

Javascript

// JavaScript program to count number of existing
// groups and number of new groups that can
// be formed.
class Graph {
    constructor(V) {
        this.V = V;
        this.adj = new Array(V);
        for (let i = 0; i < V; i++) {
            this.adj[i] = [];
        }
    }

    // Adds a relation as a two way edge of
    // undirected graph.
    addRelation(v, w) {
        // Since indexing is 0 based, reducing
        // edge numbers by 1.
        v--;
        w--;
        this.adj[v].push(w);
        this.adj[w].push(v);
    }

    // Returns count of not visited nodes
    // reachable from v using DFS.
    countUtil(v, visited) {
        let count = 1;
        visited[v] = true;

        // Recur for all the vertices adjacent
        // to this vertex
        for (let i of this.adj[v]) {
            if (!visited[i]) {
                count = count + this.countUtil(i, visited);
            }
        }
        return count;
    }

    // A DFS based function to Count number of
    // existing groups and number of new groups
    // that can be formed using a member of
    // every group.
    countGroups() {
        // Mark all the vertices as not visited
        let visited = new Array(this.V);
        for (let i = 0; i < this.V; i++) {
            visited[i] = false;
        }

        let existing_groups = 0, new_groups = 1;
        for (let i = 0; i < this.V; i++) {
            // If not in any group.
            if (!visited[i]) {
                existing_groups++;

                // Number of new groups that
                // can be formed.
                new_groups = new_groups * this.countUtil(i, visited);
            }
        }

        if (existing_groups === 1) {
            new_groups = 0;
        }

        console.log("No. of existing groups are " + existing_groups);
        console.log("No. of new groups that can be formed are " + new_groups);
    }
}

// Driver code
let n = 6;

// Create a graph given in the above diagram
let g = new Graph(n); // total 6 people
g.addRelation(1, 2); // 1 and 2 are friends
g.addRelation(3, 4); // 3 and 4 are friends
g.addRelation(5, 6); // 5 and 6 are friends

g.countGroups();
// This code is contributed by Prasad Kandekar(prasad264)

Output

No. of existing groups are 3
No. of new groups that can be formed are 8

Time complexity: O(N + R) where N is the number of people and R is the number of relations.

This article is contributed by Raj. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.