Minimize number of notes required to be distributed among students

Given an array arr[] consisting of N strings representing the name of the students in the class and another array of pairs P[][2] such that P[i][0] likes P[i][1], the task is to find the minimum number of notes to be distributed in the class such that sharing of notes can take place only if a student likes another student either directly or indirectly.

Examples:

Input: arr[] = {geeks, for, code, run, compile}, P[][] = {{geeks, for}, {for, code}, {code, run}, {run, compile}, {run, for}}
Output: 3
Explanation:
Below is the image to represent the relationship among the students:

👁 Image

From the above image:

1. Students named {"for", "code", "run"} require a single copy of notes, since there exists a mutual relationship between them.
2. Student named {"geeks"} requires a single copy of notes.
3. Student named {"compile"} also require a single copy of notes.

So, the minimum number of notes required is 3.

Input: arr[] = {geeks, for, all, run, debug, compile}, P[][] = {{geeks, for}, {for, all}, {all, geeks}, {for, run}, {run, compile}, {compile, debug}, {debug, run}}
Output: 2

Approach: The given problem can be solved by finding the number of strongly connected components in a directed graph after generating the relationship graph with the given conditions. Follow the steps below to solve the problem:

• Create a hashmap, say M to map the names of the students to their respective index values.
• Traverse the array A using the variable i and map each string A[i] in the map M to value i.
• Iterate all the pairs in the array P and for each pair get the corresponding values from the HashMap, M and create a directed edge between them.
• After traversing all the pairs, a directed graph is formed having N vertices and M number of edges.
• Create an empty stack S, and perform the DFS traversal of the graph:
  • Create a recursive function that takes the index of a node and a visited array.
  • Mark the current node as visited and traverse all the adjacent and unmarked nodes and call the recursive function with the index of the adjacent node.
  • After traversing all the neighbors of the current node, push the current node in the stack S.
• Reverse directions of all edges to obtain the transpose of the constructed graph.
• Iterate until the stack S is not empty and perform the following steps:
  • Store the top element of the stack S in a variable V and pop it from the stack S.
  • Perform the DFS traversal from node V as the source.
  • Update the number of connected components and store the count in a variable, sat cnt.
• After completing the above steps, print the value of cnt as the result.

Below is the implementation of the above approach:

3

Time Complexity: O(N + M)
Auxiliary Space: O(N)