## Intuition The problem involves analyzing paths in a tree and determining how many triplets of paths satisfy a specific property related to the values of the nodes and a given formula. The key insight is to leverage the properties of paths in trees and efficiently compute the required values using properties of modular arithmetic and tree traversal techniques. ## Approach 1. **Tree Representation**: Represent the tree using an adjacency list. This allows efficient traversal and manipulation of the tree structure. 2. **Path Value Calculation**: For each path in the tree, calculate the value using the formula provided. This involves understanding the modular arithmetic properties since `y` is a prime number. 3. **Efficient Path Traversal**: Use Depth First Search (DFS) to traverse the tree. During the traversal, maintain the current path's value using a prefix sum approach. This allows us to efficiently compute the path values without recalculating from scratch for each path. 4. **Triplet Counting**: For each node, consider it as the middle node of a triplet `(p1, p2, p3)`. Use the properties of the path values to determine if the triplet satisfies the condition given in the problem. 5. **Modular Arithmetic**: Use properties of modular arithmetic to handle large numbers and ensure calculations remain within bounds. 6. **Binary Search and Sorting**: To efficiently count valid paths, use sorting and binary search techniques. This helps in quickly determining how many paths satisfy the condition for each node. ## Complexity - **Time Complexity**: O(n log n), where n is the number of nodes. This accounts for the sorting and binary search operations. - **Space Complexity**: O(n), for storing the tree and auxiliary data structures. ## Solution (C++) ```cpp #include using namespace std; const int MOD = 1e9 + 7; vector> tree; vector values; vector pathValue; int n, y, k, x; void dfs(int node, int parent, long long currentPathValue, vector& count) { currentPathValue = (currentPathValue + values[node]) % y; pathValue[node] = currentPathValue; // Count valid paths ending at this node if ((currentPathValue * k) % y == x) { count[node]++; } for (int neighbor : tree[node]) { if (neighbor != parent) { dfs(neighbor, node, currentPathValue, count); } } } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n >> y >> k >> x; values.resize(n); for (int i = 0; i < n; ++i) { cin >> values[i]; } tree.resize(n); for (int i = 0; i < n - 1; ++i) { int u, v; cin >> u >> v; --u; --v; tree[u].push_back(v); tree[v].push_back(u); } pathValue.resize(n); vector count(n, 0); dfs(0, -1, 0, count); // Calculate the number of valid triplets long long result = 0; for (int i = 0; i < n; ++i) { result += count[i]; } cout << result << '\n'; return 0; } ``` This solution efficiently calculates the number of valid triplets by leveraging DFS for path traversal and modular arithmetic for path value calculation. The use of sorting and binary search optimizes the counting process, ensuring the solution is both correct and efficient.

Furukawa Nagisa's Tree

Problem Details