Open In App

# Count of node sequences of length K consisting of at least one black edge

Given a tree consisting of N nodes numbered from [1, N] and is colored either black(denoted by 1) or green(denoted by 0), the task is to count the number of sequences of length K [a1, a2, ..aK] such that the path taken between consecutive nodes is the shortest one and the edges covered consist of at least one black edge. Since the answer can be large, print it to modulo of 109+7.

Input: N = 4, K = 4
1-2 0
2-3 0
2-4 0
Output:
Explanation:
Since there is no black edge in the tree. There are no such sequences.

Input: N = 3, K = 3
1-2 1
2-3 1
Output: 24
Explanation:
All the 33 sequences except for (1, 1, 1), (2, 2, 2) and (3, 3, 3) are included in the answer.

Approach:
The idea is to count the number of sequences of length K such that no black edge is covered. Let the count be temp. Then (NK) – temp is the required answer. temp can be easily calculated by removing the black edges and then calculating the size of different components of the resultant graph.

Follow the steps below:

1. Initialize the value of ans as NK.
2. Construct a graph G by adding only green edges.
3. Perform a DFS traversal of the graph and keep subtracting (sizeK) from the ans where size is the number of nodes in different components of the graph G.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the``// above approach``#include ``#define int long long int``using` `namespace` `std;` `const` `int` `mod = 1e9 + 7;``const` `int` `N = 1e5 + 1;` `// Vector to store the graph``vector<``int``> G[N];` `// Iterative Function to calculate``// (ab) % mod in O(log b)``int` `power(``int` `a, ``int` `b) {` `    ``// Initialize result``    ``int` `res = 1;` `    ``// Update x if it is more than``    ``// or equal to p``    ``a = a % mod;``    ``if` `(a == 0)` `      ``// In case x is divisible by p;``      ``return` `0;` `    ``while` `(b > 0) {` `        ``// If a is odd,``        ``// multiply x with result``        ``if` `(b & 1)``            ``res = (res * a) % mod;` `        ``// b must be even now``        ``b = b >> 1; ``// b = b/2``        ``a = (a * a) % mod;``    ``}``    ``return` `res;``}` `// DFS traversal of the nodes``void` `dfs(``int` `i, ``int``& size,``         ``bool``* visited) {``    ` `    ``// Mark the current``    ``// node as visited``    ``visited[i] = ``true``;``    ` `    ``// Increment  the size of the``    ``// current component``    ``size++;` `    ``// Recur for all the vertices``    ``// adjacent to this node``    ``for` `(``auto` `nbr : G[i]) {``        ``if` `(!visited[nbr]) {``          ``dfs(nbr, size, visited);``        ``}``    ``}``}` `// Function to calculate the``// final answer``void` `totalSequences(``int``& ans,``                    ``int` `n, ``int` `k)``{``    ``// Mark all the vertices as``    ``// not visited initially``    ``bool` `visited[n + 1];``    ``memset``(visited, ``false``,``           ``sizeof``(visited));` `  ``// Subtract (size^k) from the answer``  ``// for different components``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``if` `(!visited[i]) {``            ``int` `size = 0;``            ``dfs(i, size, visited);``            ``ans -= power(size, k);``            ``ans += mod;``            ``ans = ans % mod;``        ``}``    ``}``}` `// Function to add edges to the graph``void` `addEdge(``int` `x, ``int` `y, ``int` `color)``{``    ``// If the colour is green,``    ``// include it in the graph``    ``if` `(color == 0) {``        ``G[x].push_back(y);``        ``G[y].push_back(x);``    ``}``}``int32_t main()``{``    ``// Number of node in the tree``    ``int` `n = 3;` `    ``// Size of sequence``    ``int` `k = 3;` `    ``// Initialize the result as n^k``    ``int` `ans = power(n, k);``    ``/* 2``     ``/   \``    ``1     3``       ` `   ``Let us create binary tree as shown``   ``in above example */``    ``addEdge(1, 2, 1);``    ``addEdge(2, 3, 1);` `    ``totalSequences(ans, n, k);``    ``cout << ans << endl;``}`

## Java

 `// Java implementation of the``// above approach``import` `java.util.*;` `class` `GFG{` `static` `int` `mod = (``int``)(1e9 + ``7``);``static` `int` `N = (``int``)(1e5 + ``1``);``static`  `int` `size;``static` `int` `ans;` `// Vector to store the graph``@SuppressWarnings``(``"unchecked"``)``static` `Vector []G = ``new` `Vector[N];` `// Iterative Function to calculate``// (ab) % mod in O(log b)``static` `int` `power(``int` `a, ``int` `b)``{``    ` `    ``// Initialize result``    ``int` `res = ``1``;` `    ``// Update x if it is more than``    ``// or equal to p``    ``a = a % mod;``    ` `    ``if` `(a == ``0``)``    ` `        ``// In case x is divisible by p;``        ``return` `0``;` `    ``while` `(b > ``0``)``    ``{``        ` `        ``// If a is odd,``        ``// multiply x with result``        ``if` `(b % ``2` `== ``1``)``            ``res = (res * a) % mod;` `        ``// b must be even now``        ``b = b >> ``1``; ``// b = b/2``        ``a = (a * a) % mod;``    ``}``    ``return` `res;``}` `// DFS traversal of the nodes``static` `void` `dfs(``int` `i, ``boolean` `[]visited)``{``    ` `    ``// Mark the current``    ``// node as visited``    ``visited[i] = ``true``;``    ` `    ``// Increment  the size of the``    ``// current component``    ``size++;` `    ``// Recur for all the vertices``    ``// adjacent to this node``    ``for``(``int` `nbr : G[i])``    ``{``        ``if` `(!visited[nbr])``        ``{``            ``dfs(nbr, visited);``        ``}``    ``}``}` `// Function to calculate the``// final answer``static` `void` `totalSequences(``int` `n, ``int` `k)``{``    ` `    ``// Mark all the vertices as``    ``// not visited initially``    ``boolean` `[]visited = ``new` `boolean``[n + ``1``];` `    ``// Subtract (size^k) from the answer``    ``// for different components``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``if` `(!visited[i])``        ``{``            ``size = ``0``;``            ``dfs(i, visited);``            ``ans -= power(size, k);``            ``ans += mod;``            ``ans = ans % mod;``        ``}``    ``}``}` `// Function to add edges to the graph``static` `void` `addEdge(``int` `x, ``int` `y, ``int` `color)``{``    ` `    ``// If the colour is green,``    ``// include it in the graph``    ``if` `(color == ``0``)``    ``{``        ``G[x].add(y);``        ``G[y].add(x);``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``for``(``int` `i = ``0``; i < G.length; i++)``        ``G[i] = ``new` `Vector();``        ` `    ``// Number of node in the tree``    ``int` `n = ``3``;` `    ``// Size of sequence``    ``int` `k = ``3``;` `    ``// Initialize the result as n^k``    ``ans = power(n, k);``    ` `    ``/* 2``     ``/   \``    ``1     3``    ``Let us create binary tree as shown``    ``in above example */``    ``addEdge(``1``, ``2``, ``1``);``    ``addEdge(``2``, ``3``, ``1``);` `    ``totalSequences(n, k);``    ``System.out.print(ans + ``"\n"``);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach``mod ``=` `1e9` `+` `7``N ``=` `1e5` `+` `1` `# List to store the graph``G ``=` `[``0``] ``*` `int``(N)` `# Iterative Function to calculate``# (ab) % mod in O(log b)``def` `power(a, b):` `    ``# Initialize result``    ``res ``=` `1` `    ``# Update x if it is more than``    ``# or equal to p``    ``a ``=` `a ``%` `mod` `    ``if` `a ``=``=` `0``:``        ` `        ``# In case x is divisible by p;``        ``return` `0` `    ``while` `b > ``0``:` `        ``# If a is odd,``        ``# multiply x with result``        ``if` `b & ``1``:``            ``res ``=` `(res ``*` `a) ``%` `mod` `        ``# b must be even now``        ``b ``=` `b >> ``1` `# b = b/2``        ``a ``=` `(a ``*` `a) ``%` `mod` `    ``return` `res` `# DFS traversal of the nodes``def` `dfs(i, size, visited):` `    ``# Mark the current``    ``# node as visited``    ``visited[i] ``=` `True` `    ``# Increment the size of the``    ``# current component``    ``size[``0``] ``+``=` `1` `    ``# Recur for all the vertices``    ``# adjacent to this node``    ``for` `nbr ``in` `range``(G[i]):``        ``if` `not` `visited[nbr]:``            ``dfs(nbr, size, visited)` `# Function to calculate the``# final answer``def` `totalSequences(ans, n, k):` `    ``# Mark all the vertices as``    ``# not visited initially``    ``visited ``=` `[``False``] ``*` `(n ``+` `1``)` `    ``# Subtract (size^k) from the answer``    ``# for different components``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``if` `not` `visited[i]:``            ``size ``=` `[``0``]``            ``dfs(i, size, visited)``            ` `            ``ans[``0``] ``-``=` `power(size[``0``], k)``            ``ans[``0``] ``+``=` `mod``            ``ans[``0``] ``=` `ans[``0``] ``%` `mod` `# Function to add edges to the graph``def` `addEdge(x, y, color):` `    ``# If the colour is green,``    ``# include it in the graph``    ``if` `color ``=``=` `0``:``        ``G[x].append(y)``        ``G[y].append(x)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Number of node in the tree``    ``n ``=` `3` `    ``# Size of sequence``    ``k ``=` `3` `    ``# Initialize the result as n^k``    ``ans ``=` `[power(n, k)]` `    ``"""``      ``2``     ``/ \``    ``1   3``        ` `    ``Let us create binary tree as shown``    ``in above example``    ``"""``    ``addEdge(``1``, ``2``, ``1``)``    ``addEdge(``2``, ``3``, ``1``)` `    ``totalSequences(ans, n, k)``    ``print``(``int``(ans[``0``]))` `# This code is contributed by Shivam Singh`

## C#

 `// C# implementation of the``// above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `static` `int` `mod = (``int``)(1e9 + 7);``static` `int` `N = (``int``)(1e5 + 1);``static`  `int` `size;``static` `int` `ans;` `// List to store the graph``static` `List<``int``> []G =``       ``new` `List<``int``>[N];` `// Iterative Function to``// calculate (ab)``// % mod in O(log b)``static` `int` `power(``int` `a,``                 ``int` `b)``{``  ``// Initialize result``  ``int` `res = 1;` `  ``// Update x if it is``  ``// more than or equal``  ``// to p``  ``a = a % mod;` `  ``if` `(a == 0)` `    ``// In case x is``    ``// divisible by p;``    ``return` `0;` `  ``while` `(b > 0)``  ``{``    ``// If a is odd,``    ``// multiply x``    ``// with result``    ``if` `(b % 2 == 1)``      ``res = (res * a) % mod;` `    ``// b must be even now``    ``// b = b/2``    ``b = b >> 1;``    ` `    ``a = (a * a) % mod;``  ``}``  ``return` `res;``}` `// DFS traversal of the nodes``static` `void` `dfs(``int` `i,``                ``bool` `[]visited)``{``  ``// Mark the current``  ``// node as visited``  ``visited[i] = ``true``;` `  ``// Increment  the size of the``  ``// current component``  ``size++;` `  ``// Recur for all the vertices``  ``// adjacent to this node``  ``foreach``(``int` `nbr ``in` `G[i])``  ``{``    ``if` `(!visited[nbr])``    ``{``      ``dfs(nbr, visited);``    ``}``  ``}``}` `// Function to calculate the``// readonly answer``static` `void` `totalSequences(``int` `n,``                           ``int` `k)``{``  ``// Mark all the vertices as``  ``// not visited initially``  ``bool` `[]visited = ``new` `bool``[n + 1];` `  ``// Subtract (size^k) from the``  ``// answer for different components``  ``for``(``int` `i = 1; i <= n; i++)``  ``{``    ``if` `(!visited[i])``    ``{``      ``size = 0;``      ``dfs(i, visited);``      ``ans -= power(size, k);``      ``ans += mod;``      ``ans = ans % mod;``    ``}``  ``}``}` `// Function to add edges``// to the graph``static` `void` `addEdge(``int` `x,``                    ``int` `y,``                    ``int` `color)``{``  ``// If the colour is green,``  ``// include it in the graph``  ``if` `(color == 0)``  ``{``    ``G[x].Add(y);``    ``G[y].Add(x);``  ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``  ``for``(``int` `i = 0; i < G.Length; i++)``    ``G[i] = ``new` `List<``int``>();` `  ``// Number of node``  ``// in the tree``  ``int` `n = 3;` `  ``// Size of sequence``  ``int` `k = 3;` `  ``// Initialize the``  ``// result as n^k``  ``ans = power(n, k);` `  ``/*   2``     ``/   \``    ``1     3``    ``Let us create binary tree``    ``as shown in above example */``  ``addEdge(1, 2, 1);``  ``addEdge(2, 3, 1);` `  ``totalSequences(n, k);``  ``Console.Write(ans + ``"\n"``);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`24`

Time Complexity: O(N), Since DFS traversal requires O(Vertices + Edges) == O(N + (N-1)) == O(N) ) complexity.