Maximize number of edges added to convert given Tree into a Bipartite Graph

Last Updated : 31 Jan, 2023

Given a tree of N nodes, the task is to find the maximum number of edges that can be added to the tree such that it becomes a bipartite graph.

Note: Self loop or multiple edges are not allowed but cycles are permitted.

Examples:

Input: N = 4, Edges = {{1, 2}, {2, 3}, {1, 4}}
1
/ \
2 4
/
3
Output: 1
Explanation: An edge between nodes 3 and 4 can be added such that the graph still remains bipartite.
No more than 1 edge can be added such that the resultant graph is bipartite.

Input: N = 5, Edges = {{1, 2}, {1, 3}, {2, 4}, {2, 5}}
1
/ \
2 3
/ \
4 5
Output: 2
Explanation: Two edges can be added, (3, 4) and (3, 5) and the graph still remains bipartite.

Naive Approach: The basic way to solve the problem is as follows:

Assign each node of the tree as black or white such that a black node is connected with a white node (There is always such a configuration because a tree is always bipartite).
Then for all possible pair of nodes check if an edge can be added between them.

Follow the steps mentioned below to implement the above idea:

Traverse the tree initially and assign each node as black or white such that each edge connects a black and a white node. (Trees are always bipartite).
Iterate over all pairs of nodes, and check if an edge can be added between them.
- If both the nodes are of different colors and there is no edge between them, an edge can be added. So increment the count.
- Otherwise, no edge can be added.
The final value of count is the answer.

Below is the implementation of the above approach.

C++

// C++ code for the above approach:
 
#include <bits/stdc++.h>
using namespace std;
 
// DFS to mark nodes as black or white.
void dfs(int node, int par, bool isBlack,
         vector<vector<bool> >& adj,
         vector<bool>& color)
{
 
    // Mark color as black or white.
    color[node] = isBlack;
 
    for (int i = 1; i < adj.size(); ++i) {
 
        // If there is no edge,
        // or 'i' is parent, continue.
        if (!adj[node][i] || i == par)
            continue;
 
        dfs(i, node, !isBlack, adj, color);
    }
}
 
// Function to calculate
// maximum number of edges
// that can be added
long long maxEdges(int n,
                   vector<pair<int, int> > edges)
{
 
    // Build adjacency matrix.
    vector<vector<bool> > adj(n + 1,
                              vector<bool>(
                                  n + 1, 0));
    for (auto i : edges) {
        adj[i.first][i.second] = 1;
        adj[i.second][i.first] = 1;
    }
 
    // Call DFS to color nodes.
    vector<bool> color(n + 1);
    dfs(1, 0, 1, adj, color);
 
    long long ans = 0;
 
    // Iterate over all pairs of nodes.
    for (int i = 1; i <= n; ++i) {
        for (int j = i + 1; j <= n; ++j) {
 
            // If the color is different
            // And there is no edge
            // Between them, increment answer.
            if (color[i] != color[j]
                && !adj[i][j])
                ans++;
        }
    }
 
    // Return answer.
    return ans;
}
 
// Driver Code
int main()
{
    int N = 4;
    vector<pair<int, int> > edges
        = { { 1, 2 }, { 2, 3 }, { 1, 4 } };
    cout << maxEdges(N, edges);
    return 0;
}

Java

// Java code for the above approach:
import java.util.*;
 
public class Main {
  public static void main(String[] args)
  {
    int N = 4;
    List<List<Integer> > edges = new ArrayList<>();
    edges.add(Arrays.asList(1, 2));
    edges.add(Arrays.asList(2, 3));
    edges.add(Arrays.asList(1, 4));
    System.out.println(maxEdges(N, edges));
  }
  // Function to calculate
  // maximum number of edges
  // that can be added
  public static long maxEdges(int n,
                              List<List<Integer> > edges)
  {
    // Build adjacency matrix.
    boolean[][] adj = new boolean[n + 1][n + 1];
    for (int i = 0; i < edges.size(); ++i) {
      adj[edges.get(i).get(0)][edges.get(i).get(1)]
        = true;
      adj[edges.get(i).get(1)][edges.get(i).get(0)]
        = true;
    }
    // Call DFS to color nodes.
    boolean[] color = new boolean[n + 1];
    dfs(1, 0, true, adj, color);
 
    long ans = 0;
    // Iterate over all pairs of nodes.
    for (int i = 1; i <= n; ++i) {
      for (int j = i + 1; j <= n; ++j) {
        // If the color is different
        // And there is no edge
        // Between them, increment answer.
        if (color[i] != color[j] && !adj[i][j])
          ans++;
      }
    }
    // return ans
    return ans;
  }
  // DFS to mark nodes as black or white.
  public static void dfs(int node, int par,
                         boolean isBlack, boolean[][] adj,
                         boolean[] color)
  {
     
    // Mark color as black or white.
    color[node] = isBlack;
 
    for (int i = 1; i < adj.length; ++i)
    {
       
      // If there is no edge,
      // or 'i' is parent, continue.
      if (!adj[node][i] || i == par)
        continue;
 
      dfs(i, node, !isBlack, adj, color);
    }
  }
}
 
// This code is contributed by Tapesh(tapeshdua420)

Python3

#  Python code for the above approach:
 
# DFS to mark nodes as black or white.
def dfs(node, par, isBlack, adj, color):
 
  # Mark color as black or white.
    color[node] = isBlack
    for i in range(1, len(adj)):
        # If there is no edge,
         # or 'i' is parent, continue.
        if not adj[node][i] or i == par:
            continue
        dfs(i, node, not isBlack, adj, color)
 
# Function to calculate
# maximum number of edges
# that can be added
def maxEdges(n, edges):
   
  # Build adjacency matrix.
    adj = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
    for i in edges:
        adj[i[0]][i[1]] = 1
        adj[i[1]][i[0]] = 1
 
    # Call DFS to color nodes.
    color = [0 for _ in range(n + 1)]
    dfs(1, 0, 1, adj, color)
 
    ans = 0
 
    # Iterate over all pairs of nodes.
    for i in range(1, n + 1):
        for j in range(i + 1, n + 1):
                # If the color is different
            # And there is no edge
            # Between them, increment answer.
            if color[i] != color[j] and not adj[i][j]:
                ans += 1
        # Return answer.
    return ans
 
 
# Driver Code
N = 4
edges = [[1, 2], [2, 3], [1, 4]]
print(maxEdges(N, edges))
 
# This code is contributed by tapeshdua420.

C#

// C# code for the above approach:
using System;
using System.Collections.Generic;
using System.Linq;
class Program {
    static void Main(string[] args)
    {
        int N = 4;
        List<Tuple<int, int> > edges
            = new List<Tuple<int, int> >(N);
        edges.Add(new Tuple<int, int>(1, 2));
        edges.Add(new Tuple<int, int>(2, 3));
        edges.Add(new Tuple<int, int>(1, 4));
        Console.WriteLine(maxEdges(N, edges));
    }
   
    // DFS to mark nodes as black or white.
    static void dfs(int node, int par, bool isBlack,
                    bool[, ] adj, bool[] color)
    {
       
        // Mark color as black or white.
        color[node] = isBlack;
 
        for (int i = 1; i < adj.GetLength(0); i++) 
        {
           
            // If there is no edge,
            // or 'i' is parent, continue.
            if (adj[node, i] == false || i == par)
                continue;
            dfs(i, node, !isBlack, adj, color);
        }
    }
   
    // Function to calculate
    // maximum number of edges
    // that can be added
    static long maxEdges(int n,
                         List<Tuple<int, int> > edges)
    {
       
        // Build adjacency matrix.
        bool[, ] adj = new bool[n + 1, n + 1];
 
        foreach(Tuple<int, int> tuple in edges)
        {
            adj[tuple.Item1, tuple.Item2] = true;
            adj[tuple.Item2, tuple.Item1] = true;
        }
 
        // Call DFS to color nodes.
        bool[] color = new bool[n + 1];
        dfs(1, 0, true, adj, color);
 
        long ans = 0;
 
        // Iterate over all pairs of nodes.
        for (int i = 1; i <= n; ++i) 
        {
            for (int j = i + 1; j <= n; ++j)
            {
               
                // If the color is different
                // And there is no edge
                // Between them, increment answer.
                if (color[i] != color[j]
                    && adj[i, j] == false)
                    ans++;
            }
        }
       
        // Return answer.
        return ans;
    }
}
 
// This code is contributed by tapeshdua420.

Javascript

// JavaScript code for the above approach:
 
// DFS to mark nodes as black or white.
const dfs = (node, par, isBlack, adj, color) => {
  // Mark color as black or white.
  color[node] = isBlack;
 
  for (let i = 1; i < adj.length; i++) {
// If there is no edge,
// or 'i' is parent, continue.
if (!adj[node][i] || i === par) continue;
 
dfs(i, node, !isBlack, adj, color);
  }
};
 
// Function to calculate
// maximum number of edges
// that can be added
const maxEdges = (n, edges) => {
  // Build adjacency matrix.
  const adj = Array.from({ length: n + 1 }, () =>
Array.from({ length: n + 1 }, () => 0)
  );
  edges.forEach(([a, b]) => {
adj[a][b] = 1;
adj[b][a] = 1;
  });
 
  // Call DFS to color nodes.
  const color = Array.from({ length: n + 1 }, () => false);
  dfs(1, 0, true, adj, color);
 
  let ans = 0;
 
  // Iterate over all pairs of nodes.
  for (let i = 1; i <= n; i++) {
for (let j = i + 1; j <= n; j++) {
    // If the color is different
    // And there is no edge
    // Between them, increment answer.
  if (color[i] !== color[j] && !adj[i][j]) ans++;
}
  }
 
  // Return answer.
  return ans;
};
 
// Driver Code
const N = 4;
const edges = [[1, 2], [2, 3], [1, 4]];
console.log(maxEdges(N, edges));
 
// This code is contributed by Aman Kumar.

Output

Time Complexity: O(N²)
Auxiliary Space: O(N²)

Efficient Approach: The time taken in the above approach can be optimized by using the following observation:

Say, there were initially B black nodes and W white nodes in the tree. So a bipartite graph made from these nodes can have maximum B*W edges.
Therefore, the maximum number of edges that can be added to the tree with N nodes are B*W – (N-1) [as a tree with N node has N-1 edges]

Follow the steps mentioned below:

Traverse the tree initially and assign each node as black or white such that each edge connects a black and a white node. (Trees are always bipartite).
Count the number of black nodes and white nodes.
Use the formula derived above from the observation and calculate the maximum number of edges that can be added.

Below is the implementation of the above approach.

C++

// C++ code for the above approach:
 
#include <bits/stdc++.h>
using namespace std;
 
// DFS to count number of black nodes.
int dfs(int node, int par, bool isBlack,
        vector<vector<int> >& adj)
{
    int no_Of_Black = isBlack;
    for (int i : adj[node]) {
        if (i == par)
            continue;
 
        // Number of black nodes
        // in each subtree.
        no_Of_Black
            += dfs(i, node, !isBlack, adj);
    }
    return no_Of_Black;
}
 
// Function to find maximum edges
long long maxEdges(int n,
                   vector<pair<int, int> > edges)
{
 
    // Build adjacency list.
    vector<vector<int> > adj(n + 1);
    for (auto i : edges) {
        adj[i.first].push_back(i.second);
        adj[i.second].push_back(i.first);
    }
 
    // Number of black nodes.
    int no_Of_Black = dfs(1, 0, 1, adj);
 
    // Number of white nodes.
    int no_Of_White = n - no_Of_Black;
 
    // Number of edges that can be added.
    return (1LL * (no_Of_Black)
                * (no_Of_White)
            - (n - 1));
}
 
// Driver code
int main()
{
    int N = 4;
    vector<pair<int, int> > edges
        = { { 1, 2 }, { 2, 3 }, { 1, 4 } };
    cout << maxEdges(N, edges);
    return 0;
}

Java

// Java code for the above approach:
import java.util.*;
 
public class Main 
{
 
  // Driver code
  public static void main(String[] args)
  {
    int N = 4;
    int[][] edges = { { 1, 2 }, { 2, 3 }, { 1, 4 } };
    System.out.println(maxEdges(N, edges));
  }
 
  // Function to find maximum edges
  public static long maxEdges(int n, int[][] edges)
  {
    // Build adjacency list.
    List<List<Integer> > adj = new ArrayList<>();
    for (int i = 0; i <= n; i++) {
      adj.add(new ArrayList<>());
    }
    for (int[] edge : edges) {
      adj.get(edge[0]).add(edge[1]);
      adj.get(edge[1]).add(edge[0]);
    }
    // Number of black nodes.
    int no_Of_Black = dfs(1, 0, true, adj);
 
    // Number of white nodes.
    int no_Of_White = n - no_Of_Black;
 
    // Number of edges that can be added.
    return ((no_Of_Black) * (no_Of_White) - (n - 1));
  }
 
  // DFS to count number of black nodes.
  public static int dfs(int node, int par,
                        boolean isBlack,
                        List<List<Integer> > adj)
  {
 
    int no_Of_Black = (isBlack == true) ? 1 : 0;
 
    for (int i : adj.get(node)) {
 
      if (i == par)
        continue;
 
      // Number of black nodes
      // in each subtree.
      no_Of_Black += dfs(i, node, !isBlack, adj);
    }
    return no_Of_Black;
  }
}
 
// This code is contributed by Tapesh(tapeshdua420)

Python3

## DFS to count number of black nodes.
def dfs(node, par, isBlack, adj) :
    no_of_black = isBlack
    for i in adj[node]:
        if(i==par):
            continue
         
        ## Number of black nodes
        ## in each subtree.
        no_of_black += dfs(i, node, (not isBlack), adj)
 
    return no_of_black
 
 
def maxEdges(n, edges): 
    adj = []
     
    for i in range(n+1):
        adj.append(list())
     
    ## Create the graph 
    ## From the given input. 
    for i in edges:
        adj[i[0]].append(i[1])
        adj[i[1]].append(i[0])
 
    ## Number of black nodes.
    no_of_black = dfs(1, 0, 1, adj)
 
    ## Number of white nodes.
    no_of_white = n - no_of_black
 
    ## Number of edges that can be added.
    return (no_of_black*no_of_white) - (n-1)
     
# Driver Code
if __name__ == "__main__":
 
    N = 4
    edges = list((list((1, 2)), list((2, 3)), list((1, 4))))
 
    print(maxEdges(N, edges))
     
    # This code is contributed by subhamgoyal2014.

C#

// C# code for the above approach:
using System;
using System.Collections.Generic;
 
class Program {
 
  // Driver code
  static void Main(string[] args)
  {
 
    int N = 4;
 
    int[][] edges
      = { new int[] { 1, 2 }, new int[] { 2, 3 },
         new int[] { 1, 4 } };
 
    Console.WriteLine(maxEdges(N, edges));
  }
 
  // Function to find maximum edges
  static long maxEdges(int n, int[][] edges)
  {
 
    // Build adjacency list.
    List<List<int> > adj = new List<List<int> >();
 
    for (int i = 0; i <= n; i++) {
      adj.Add(new List<int>());
    }
 
    foreach(int[] edge in edges)
    {
 
      adj[edge[0]].Add(edge[1]);
 
      adj[edge[1]].Add(edge[0]);
    }
 
    // Number of black nodes.
    int no_Of_Black = dfs(1, 0, true, adj);
 
    // Number of white nodes.
    int no_Of_White = n - no_Of_Black;
 
    // Number of edges that can be added.
    return ((no_Of_Black) * (no_Of_White) - (n - 1));
  }
 
  // DFS to count number of black nodes.
  static int dfs(int node, int par, bool isBlack,
                 List<List<int> > adj)
  {
 
    int no_Of_Black = (isBlack == true) ? 1 : 0;
 
    foreach(int i in adj[node])
    {
 
      if (i == par)
        continue;
 
      // Number of black nodes
      // in each subtree.
      no_Of_Black += dfs(i, node, !isBlack, adj);
    }
    return no_Of_Black;
  }
}
 
// This code is contributed by Tapesh (tapeshdua420)

Javascript

       // JavaScript code for the above approach
       // DFS to count number of black nodes.
       function dfs(node, par, isBlack, adj) {
           let no_Of_Black = isBlack ? 1 : 0;
           for (let i of adj[node]) {
               if (i == par) continue;
 
               // Number of black nodes
               // in each subtree.
               no_Of_Black += dfs(i, node, !isBlack, adj);
           }
           return no_Of_Black;
       }
 
       // Function to find maximum edges
       function maxEdges(n, edges) {
           // Build adjacency list.
           let adj = new Array(n + 1);
           for (let i = 0; i <= n; i++) {
               adj[i] = [];
           }
           for (let i of edges) {
               adj[i[0]].push(i[1]);
               adj[i[1]].push(i[0]);
           }
 
           // Number of black nodes.
           let no_Of_Black = dfs(1, 0, true, adj);
 
           // Number of white nodes.
           let no_Of_White = n - no_Of_Black;
 
           // Number of edges that can be added.
           return no_Of_Black * no_Of_White - (n - 1);
       }
 
       // Driver code
       let N = 4;
       let edges = [[1, 2], [2, 3], [1, 4]];
       console.log(maxEdges(N, edges));
 
// This code is contributed by Potta Lokesh

Output

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

Suggest improvement

Maximum number of edges to be added to a tree so that it stays a Bipartite graph

Share your thoughts in the comments

Maximize number of edges added to convert given Tree into a Bipartite Graph

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?