A tree is always a Bipartite Graph as we can always break into two disjoint sets with alternate levels. In other words we always color it with two colors such that alternate levels have same color. The task is to compute the maximum no. of edges that can be added to the tree so that it remains Bipartite Graph.

**Examples:**

Input : Tree edges as vertex pairs 1 2 1 3 Output : 0 Explanation : The only edge we can add is from node 2 to 3. But edge 2, 3 will result in odd cycle, hence violation of Bipartite Graph property. Input : Tree edges as vertex pairs 1 2 1 3 2 4 3 5 Output : 2 Explanation : On colouring the graph, {1, 4, 5} and {2, 3} form two different sets. Since, 1 is connected from both 2 and 3, we are left with edges 4 and 5. Since, 4 is already connected to 2 and 5 to 3, only options remain {4, 3} and {5, 2}.

1) Do a simple DFS (or BFS) traversal of graph and color it with two colors.

2) While coloring also keep track of counts of nodes colored with the two colors. Let the two counts be count_color_{0} and count_color_{1}.

3) Now we know maximum edges a bipartite graph can have are count_color_{0} x count_color_{1}.

4) We also know tree with n nodes has n-1 edges.

5) So our answer is count_color_{0} x count_color_{1} – (n-1).

Below is the implementation :

## C++

`// CPP code to print maximum edges such that ` `// Tree remains a Bipartite graph ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// To store counts of nodes with two colors ` `long` `long` `count_color[2]; ` ` ` `void` `dfs(vector<` `int` `> adj[], ` `int` `node, ` `int` `parent, ` `int` `color) ` `{ ` ` ` `// Increment count of nodes with current ` ` ` `// color ` ` ` `count_color[color]++; ` ` ` ` ` `// Traversing adjacent nodes ` ` ` `for` `(` `int` `i = 0; i < adj[node].size(); i++) { ` ` ` ` ` `// Not recurring for the parent node ` ` ` `if` `(adj[node][i] != parent) ` ` ` `dfs(adj, adj[node][i], node, !color); ` ` ` `} ` `} ` ` ` `// Finds maximum number of edges that can be added ` `// without violating Bipartite property. ` `int` `findMaxEdges(vector<` `int` `> adj[], ` `int` `n) ` `{ ` ` ` `// Do a DFS to count number of nodes ` ` ` `// of each color ` ` ` `dfs(adj, 1, 0, 0); ` ` ` ` ` `return` `count_color[0] * count_color[1] - (n - 1); ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 5; ` ` ` `vector<` `int` `> adj[n + 1]; ` ` ` `adj[1].push_back(2); ` ` ` `adj[1].push_back(3); ` ` ` `adj[2].push_back(4); ` ` ` `adj[3].push_back(5); ` ` ` `cout << findMaxEdges(adj, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java code to print maximum edges such that ` `// Tree remains a Bipartite graph ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` `// To store counts of nodes with two colors ` `static` `long` `[]count_color = ` `new` `long` `[` `2` `]; ` ` ` `static` `void` `dfs(Vector<Integer> adj[], ` `int` `node, ` ` ` `int` `parent, ` `boolean` `color) ` `{ ` ` ` `// Increment count of nodes with current ` ` ` `// color ` ` ` `count_color[color == ` `false` `? ` `0` `: ` `1` `]++; ` ` ` ` ` `// Traversing adjacent nodes ` ` ` `for` `(` `int` `i = ` `0` `; i < adj[node].size(); i++) ` ` ` `{ ` ` ` ` ` `// Not recurring for the parent node ` ` ` `if` `(adj[node].get(i) != parent) ` ` ` `dfs(adj, adj[node].get(i), node, !color); ` ` ` `} ` `} ` ` ` `// Finds maximum number of edges that can be added ` `// without violating Bipartite property. ` `static` `int` `findMaxEdges(Vector<Integer> adj[], ` `int` `n) ` `{ ` ` ` `// Do a DFS to count number of nodes ` ` ` `// of each color ` ` ` `dfs(adj, ` `1` `, ` `0` `, ` `false` `); ` ` ` ` ` `return` `(` `int` `) (count_color[` `0` `] * ` ` ` `count_color[` `1` `] - (n - ` `1` `)); ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `n = ` `5` `; ` ` ` `Vector<Integer>[] adj = ` `new` `Vector[n + ` `1` `]; ` ` ` `for` `(` `int` `i = ` `0` `; i < n + ` `1` `; i++) ` ` ` `adj[i] = ` `new` `Vector<Integer>(); ` ` ` ` ` `adj[` `1` `].add(` `2` `); ` ` ` `adj[` `1` `].add(` `3` `); ` ` ` `adj[` `2` `].add(` `4` `); ` ` ` `adj[` `3` `].add(` `5` `); ` ` ` `System.out.println(findMaxEdges(adj, n)); ` `} ` `} ` ` ` `// This code is contributed by Rajput-Ji ` |

*chevron_right*

*filter_none*

## Python3

`# Python 3 code to print maximum edges such ` `# that Tree remains a Bipartite graph ` `def` `dfs(adj, node, parent, color): ` ` ` ` ` `# Increment count of nodes with ` ` ` `# current color ` ` ` `count_color[color] ` `+` `=` `1` ` ` ` ` `# Traversing adjacent nodes ` ` ` `for` `i ` `in` `range` `(` `len` `(adj[node])): ` ` ` ` ` `# Not recurring for the parent node ` ` ` `if` `(adj[node][i] !` `=` `parent): ` ` ` `dfs(adj, adj[node][i], ` ` ` `node, ` `not` `color) ` ` ` `# Finds maximum number of edges that ` `# can be added without violating ` `# Bipartite property. ` `def` `findMaxEdges(adj, n): ` ` ` ` ` `# Do a DFS to count number of ` ` ` `# nodes of each color ` ` ` `dfs(adj, ` `1` `, ` `0` `, ` `0` `) ` ` ` ` ` `return` `(count_color[` `0` `] ` `*` ` ` `count_color[` `1` `] ` `-` `(n ` `-` `1` `)) ` ` ` `# Driver code ` ` ` `# To store counts of nodes with ` `# two colors ` `count_color ` `=` `[` `0` `, ` `0` `] ` `n ` `=` `5` `adj ` `=` `[[] ` `for` `i ` `in` `range` `(n ` `+` `1` `)] ` `adj[` `1` `].append(` `2` `) ` `adj[` `1` `].append(` `3` `) ` `adj[` `2` `].append(` `4` `) ` `adj[` `3` `].append(` `5` `) ` `print` `(findMaxEdges(adj, n)) ` ` ` `# This code is contributed by PranchalK ` |

*chevron_right*

*filter_none*

## C#

`// C# code to print maximum edges such that ` `// Tree remains a Bipartite graph ` `using` `System; ` `using` `System.Collections.Generic; ` ` ` `class` `GFG ` `{ ` ` ` `// To store counts of nodes with two colors ` `static` `long` `[]count_color = ` `new` `long` `[2]; ` ` ` `static` `void` `dfs(List<` `int` `> []adj, ` `int` `node, ` ` ` `int` `parent, ` `bool` `color) ` `{ ` ` ` `// Increment count of nodes with current ` ` ` `// color ` ` ` `count_color[color == ` `false` `? 0 : 1]++; ` ` ` ` ` `// Traversing adjacent nodes ` ` ` `for` `(` `int` `i = 0; i < adj[node].Count; i++) ` ` ` `{ ` ` ` ` ` `// Not recurring for the parent node ` ` ` `if` `(adj[node][i] != parent) ` ` ` `dfs(adj, adj[node][i], node, !color); ` ` ` `} ` `} ` ` ` `// Finds maximum number of edges that can be added ` `// without violating Bipartite property. ` `static` `int` `findMaxEdges(List<` `int` `> []adj, ` `int` `n) ` `{ ` ` ` `// Do a DFS to count number of nodes ` ` ` `// of each color ` ` ` `dfs(adj, 1, 0, ` `false` `); ` ` ` ` ` `return` `(` `int` `) (count_color[0] * ` ` ` `count_color[1] - (n - 1)); ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` ` `int` `n = 5; ` ` ` `List<` `int` `> []adj = ` `new` `List<` `int` `>[n + 1]; ` ` ` `for` `(` `int` `i = 0; i < n + 1; i++) ` ` ` `adj[i] = ` `new` `List<` `int` `>(); ` ` ` ` ` `adj[1].Add(2); ` ` ` `adj[1].Add(3); ` ` ` `adj[2].Add(4); ` ` ` `adj[3].Add(5); ` ` ` `Console.WriteLine(findMaxEdges(adj, n)); ` `} ` `} ` ` ` `// This code is contributed by PrinciRaj1992 ` |

*chevron_right*

*filter_none*

**Output:**

2

**Time Complexity:** O(n)

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

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Maximum number of edges in Bipartite graph
- Minimum number of Edges to be added to a Graph to satisfy the given condition
- Maximum number of edges that N-vertex graph can have such that graph is Triangle free | Mantel's Theorem
- Maximum number of edges among all connected components of an undirected graph
- Maximum edges that can be added to DAG so that is remains DAG
- Minimum edges to be added in a directed graph so that any node can be reachable from a given node
- Minimum number of edges that need to be added to form a triangle
- Tree, Back, Edge and Cross Edges in DFS of Graph
- Ways to Remove Edges from a Complete Graph to make Odd Edges
- Minimum number of edges between two vertices of a Graph
- Minimum number of edges between two vertices of a graph using DFS
- Number of Simple Graph with N Vertices and M Edges
- Count number of edges in an undirected graph
- Program to find total number of edges in a Complete Graph
- Check if a given graph is Bipartite using DFS
- Check whether a given graph is Bipartite or not
- Find number of edges that can be broken in a tree such that Bitwise OR of resulting two trees are equal
- Maximum Bipartite Matching
- Maximum Possible Edge Disjoint Spanning Tree From a Complete Graph
- Path with minimum XOR sum of edges in a directed graph