要添加到树的最大边数，使其保持二分图

一棵树总是一个二分图，因为我们总是可以分成两个不相交的具有交替级别的集合。换句话说，我们总是用两种颜色给它上色，这样交替的层次就具有相同的颜色。任务是计算最大数量。可以添加到树中的边数，使其保持二分图。
例子：

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）对图进行简单的DFS（或BFS）遍历并用两种颜色对其进行着色。
2）在着色的同时，还要跟踪用两种颜色着色的节点的计数。让这两个计数为 count_color ₀和 count_color ₁ 。
3) 现在我们知道二分图可以拥有的最大边是 count_color ₀ x count_color ₁ 。
4）我们也知道有n个节点的树有n-1条边。
5) 所以我们的答案是 count_color ₀ x count_color ₁ – (n-1)。
下面是实现：

C++

// CPP code to print maximum edges such that
// Tree remains a Bipartite graph
#include 
using namespace std;
 
// To store counts of nodes with two colors
long long count_color[2];
 
void dfs(vector 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 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 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;
}

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 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 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[] adj = new Vector[n + 1];
    for (int i = 0; i < n + 1; i++)
        adj[i] = new Vector();
     
    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

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

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 []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 []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 []adj = new List[n + 1];
    for (int i = 0; i < n + 1; i++)
        adj[i] = new List();
     
    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

Javascript

输出：