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

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# 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.