给定一个由N个节点和(N – 1)个边组成的树形式的无向连通图，每个边的任务是计算它在树中所有可能路径上出现的次数。
例子：
Input:
Output: 3 4 3
Explanation:
All possible paths of a given tree are {(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)}
Edge 1 occurs in the paths {(1, 2), (1, 3), (1, 4)}. Therefore, the frequency of the edge is 3.
Edge 2 occurs in the paths {(1, 3), (1, 4), (2, 3), (2, 4)}. Therefore, the frequency of the edge is 4.
Edge 3 occurs in the paths {(1, 4), (2, 4), (3, 4)}. Therefore, the frequency of the edge is 3.
Input:
Output: 4 6 4 4
Explanation:
Edge 1 occurs in the paths {(1, 2), (1, 3), (1, 4), (1, 5)}. Therefore, the frequency of the edge is 4
Edge 2 occurs in the paths {(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)}. Therefore, the frequency of the edge is 6
Edge 3 occurs in the paths {(1, 4), (2, 4), (3, 4), (4, 5)}. Therefore, the frequency of the edge is 4
Edge 4 occurs in the paths {(1, 5), (2, 5), (3, 5), (4, 5)}. Therefore, the frequency of the edge is 4
天真的方法：最简单的方法是从给定图的每个节点生成所有可能的路径，并通过HashMap存储在这些路径中出现的边数。最后，打印每个边的频率。
时间复杂度： O(N 2 )
辅助空间： O(N)
高效方法：为了优化上述方法，需要进行以下观察：
The green-colored edge will appear in all the paths that connect any vertex from the subtree on its left to any vertex from the subtree on its right.
Therefore, the number of paths in which the edge occurs = Product of the count of nodes in the two subtrees = 5 * 3 = 15.
请按照以下步骤解决问题：
- 将树根在任意随机顶点处，例如1。
- 在根目录下执行DFS。使用DFS计算连接到边缘的子树大小。
- 连接到子树的每个边的频率为(子树大小)*(N-子树大小) 。
- 将上面为每个节点计算的值存储在HashMap中。最后，在完成遍历树之后，遍历HashMap以打印结果。
下面是上述方法的实现：
C++
// C++ Program to implement
// the above approach
#include
using namespace std;
// Number of nodes
int N;
// Structure of a Node
struct Node {
int node;
int edgeLabel;
};
// Adjacency List to
// represent the Tree
vector adj[100005];
// Stores the frequencies
// of every edge
vector freq;
// Function to perform DFS
int dfs(int u = 1, int p = 1)
{
// Add the current node to
// size of subtree rooted at u
int sz = 1;
// Iterate over its childern
for (auto a : adj[u]) {
// Check if child is not parent
if (a.node != p) {
// Get the subtree size
// for the child
int val = dfs(a.node, u);
// Set the frequency
// of the current edge
freq[a.edgeLabel]
= val * (N - val);
// Add the subtree size
// to itself
sz += val;
}
}
// Return the subtree size
return sz;
}
// Function to add edge between nodes
void addEdge(int u, int v, int label)
{
adj[u].push_back({ v, label });
adj[v].push_back({ u, label });
}
// Function to print the frequencies
// of each edge in all possible paths
void printFrequencies()
{
// Stores the frequency
// of all the edges
freq = vector(N);
// Perform DFS
dfs();
for (int i = 1; i < N; i++) {
cout << freq[i] << " ";
}
}
// Driver Code
int main()
{
N = 4;
addEdge(1, 2, 1);
addEdge(2, 3, 2);
addEdge(3, 4, 3);
printFrequencies();
return 0;
} Java
// Java Program to implement
// the above approach
import java.util.*;
class GFG{
// Number of nodes
static int N;
// Structure of a Node
static class Node
{
int node;
int edgeLabel;
public Node(int node, int edgeLabel)
{
super();
this.node = node;
this.edgeLabel = edgeLabel;
}
};
// Adjacency List to
// represent the Tree
static Vector []adj = new Vector[100005];
// Stores the frequencies
// of every edge
static int []freq;
// Function to perform DFS
static int dfs(int u , int p)
{
// Add the current node to
// size of subtree rooted at u
int sz = 1;
// Iterate over its childern
for (Node a : adj[u])
{
// Check if child is not parent
if (a.node != p)
{
// Get the subtree size
// for the child
int val = dfs(a.node, u);
// Set the frequency
// of the current edge
freq[a.edgeLabel] = val * (N - val);
// Add the subtree size
// to itself
sz += val;
}
}
// Return the subtree size
return sz;
}
// Function to add edge between nodes
static void addEdge(int u, int v, int label)
{
adj[u].add(new Node( v, label ));
adj[v].add(new Node( u, label));
}
// Function to print the frequencies
// of each edge in all possible paths
static void printFrequencies()
{
// Stores the frequency
// of all the edges
freq = new int[N];
// Perform DFS
dfs(1, 1);
for (int i = 1; i < N; i++)
{
System.out.print(freq[i] + " ");
}
}
// Driver Code
public static void main(String[] args)
{
N = 4;
for (int i = 0; i < adj.length; i++)
adj[i] = new Vector();
addEdge(1, 2, 1);
addEdge(2, 3, 2);
addEdge(3, 4, 3);
printFrequencies();
}
}
// This code is contributed by shikhasingrajput Python3
# Python3 program to implement
# the above approach
# Number of nodes
N = 4
# Structure of a Node
class Node:
def __init__(self, v, label):
self.node = v
self.edgeLabel = label
# Adjacency list to
# represent the Tree
adj = []
for i in range(100005):
adj.append([])
# Stores the frequencies
# of each edge
freq = [0] * N
# Function to perform DFS
def dfs(u = 1, p = 1):
global N
# Add the current node to
# size of subtree rooted at u
sz = 1
# Iterate over its childern
for a in adj[u]:
# Check if child is not parent
if a.node != p:
# Get the subtree size
# for the child
val = dfs(a.node, u)
# Set the frequency
# of the current edge
freq[a.edgeLabel] = val * (N - val)
# Add the subtree size
# to itself
sz += val
# Return the subtree size
return sz
# Function to add edge between nodes
def addEdge(u, v, label):
adj[u].append(Node(v, label))
adj[v].append(Node(u, label))
# Function to print the frequencies
# of each edge in all possible paths
def printFrequencies():
# Stores the frequency
# of all the edges
global N
# Perform DFS
dfs()
for i in range(1, N):
print(freq[i], end = " ")
# Driver code
N = 4
addEdge(1, 2, 1)
addEdge(2, 3, 2)
addEdge(3, 4, 3)
printFrequencies()
# This code is contributed by Stuti PathakC#
// C# Program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
// Number of nodes
static int N;
// Structure of a Node
public class Node
{
public int node;
public int edgeLabel;
public Node(int node,
int edgeLabel)
{
this.node = node;
this.edgeLabel = edgeLabel;
}
};
// Adjacency List to
// represent the Tree
static List []adj =
new List[100005];
// Stores the frequencies
// of every edge
static int []freq;
// Function to perform DFS
static int dfs(int u, int p)
{
// Add the current node to
// size of subtree rooted at u
int sz = 1;
// Iterate over its childern
foreach (Node a in adj[u])
{
// Check if child is not parent
if (a.node != p)
{
// Get the subtree size
// for the child
int val = dfs(a.node, u);
// Set the frequency
// of the current edge
freq[a.edgeLabel] = val * (N - val);
// Add the subtree size
// to itself
sz += val;
}
}
// Return the subtree size
return sz;
}
// Function to add edge between nodes
static void addEdge(int u, int v,
int label)
{
adj[u].Add(new Node(v, label));
adj[v].Add(new Node(u, label));
}
// Function to print the frequencies
// of each edge in all possible paths
static void printFrequencies()
{
// Stores the frequency
// of all the edges
freq = new int[N];
// Perform DFS
dfs(1, 1);
for (int i = 1; i < N; i++)
{
Console.Write(freq[i] + " ");
}
}
// Driver Code
public static void Main(String[] args)
{
N = 4;
for (int i = 0; i < adj.Length; i++)
adj[i] = new List();
addEdge(1, 2, 1);
addEdge(2, 3, 2);
addEdge(3, 4, 3);
printFrequencies();
}
}
// This code is contributed by gauravrajput1 输出：
3 4 3
时间复杂度： O(N)
辅助空间：O(N)