Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Ways to color a skewed tree such that parent and child have different colors

  • Difficulty Level : Easy
  • Last Updated : 07 Sep, 2021

Given a skewed tree (Every node has at most one child) with N nodes and K colors. You have to assign a color from 1 to K to each node such that parent and child has different colors. Find the maximum number of ways of coloring the nodes.
Examples – 
 

Input : N = 2, K = 2.
Output :  
Let A1 and A2 be the two nodes.
Let A1 is parent of A2.
Colors are Red and Blue.
Case 1: A1 is colored Red 
       and A2 is colored Blue.
Case 2: A1 is colored Blue 
       and A2 is colored Red.
No. of ways : 2      

Input : N = 3, K = 3.
Output : 
A1, A2, A3 are the nodes. 
A1 is parent of A2 
and A2 is parent of A3.
Let colors be R, B, G.
A1 can choose any three colors 
and A2 can choose 
any other two colors
and A3 can choose 
any other two colors 
than its parents.
No. of ways: 12

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Note that only the root and children (children, grand children, grand grand children …. and all) should have different colors. The root of the tree can choose any of the K colors so K ways. Every other node can choose other K-1 colors other than its parent. So every node has K-1 choices. 
Here, we select the tree as every node as only one child. We can choose any of the K colors for the root of the tree so K ways. And we are left with K-1 colors for its child. So for every child we can assign a color other than its parent. Thus, for each of the N-1 nodes we are left with K-1 colors. Thus the answer is K*(K-1)^(N-1).
We can find the answer by using normal power function which takes O(N) time complexity. But for better time complexity we use Faster Exponentiation function which takes O(log N) time complexity. 
 

C++




// C++ program to count number of ways to color
// a N node skewed tree with k colors such that
// parent and children have different colors.
#include <bits/stdc++.h>
using namespace std;
 
// fast_way is recursive
// method to calculate power
int fastPow(int N, int K)
{
    if (K == 0)
        return 1;
    int temp = fastPow(N, K / 2);
    if (K % 2 == 0)
        return temp * temp;
    else
        return N * temp * temp;
}
 
int countWays(int N, int K)
{
    return K * fastPow(K - 1, N - 1);
}
 
// driver program
int main()
{
    int N = 3, K = 3;
    cout << countWays(N, K);
    return 0;
}

Java




// Java program to count number of ways to color
// a N node skewed tree with k colors such that
// parent and children have different colors.
import java.io.*;
 
class GFG {
    // fast_way is recursive
    // method to calculate power
    static int fastPow(int N, int K)
    {
        if (K == 0)
            return 1;
        int temp = fastPow(N, K / 2);
        if (K % 2 == 0)
            return temp * temp;
        else
            return N * temp * temp;
    }
 
    static int countWays(int N, int K)
    {
        return K * fastPow(K - 1, N - 1);
    }
 
    // Driver program
    public static void main(String[] args)
    {
        int N = 3, K = 3;
        System.out.println(countWays(N, K));
    }
}
 
// This code is contributed by vt_m.

Python3




# Python3 program to count 
# number of ways to color
# a N node skewed tree with
# k colors such that parent
# and children have different
# colors.
 
# fast_way is recursive
# method to calculate power
def fastPow(N, K):
    if (K == 0):
        return 1;
     
    temp = fastPow(N, int(K / 2));
    if (K % 2 == 0):
        return temp * temp;
    else:
        return N * temp * temp;
 
def countWays(N, K):
    return K * fastPow(K - 1, N - 1);
 
# Driver Code
N = 3;
K = 3;
print(countWays(N, K));
 
# This code is contributed by mits

C#




// C# program to count number of ways
// to color a N node skewed tree with
// k colors such that parent and
// children  have different colors
using System;
 
class GFG {
 
    // fast_way is recursive
    // method to calculate power
    static int fastPow(int N, int K)
    {
        if (K == 0)
            return 1;
        int temp = fastPow(N, K / 2);
        if (K % 2 == 0)
            return temp * temp;
        else
            return N * temp * temp;
    }
 
    static int countWays(int N, int K)
    {
        return K * fastPow(K - 1, N - 1);
    }
 
    // Driver code
    public static void Main()
    {
        int N = 3, K = 3;
        Console.WriteLine(countWays(N, K));
    }
}
 
// This code is contributed by vt_m.

PHP




<?php
// PHP program to count number
// of ways to color a N node
// skewed tree with k colors
// such that parent and children
// have different colors.
 
// fast_way is recursive
// method to calculate power
function fastPow($N, $K)
{
    if ($K == 0)
        return 1;
         
    $temp = fastPow($N, $K / 2);
     
    if ($K % 2 == 0)
        return $temp * $temp;
    else
        return $N * $temp * $temp;
}
 
function countWays($N, $K)
{
    return $K * fastPow($K - 1, $N - 1);
}
 
    // Driver Code
    $N = 3;
    $K = 3;
    echo countWays($N, $K);
 
// This code is contributed by ajit
?>

Javascript




<script>
 
// Javascript program to count number of ways to color
// a N node skewed tree with k colors such that
// parent and children have different colors.
 
    // fast_way is recursive
    // method to calculate power
    function fastPow(N, K)
    {
        if (K == 0)
            return 1;
        let temp = fastPow(N, Math.floor(K / 2));
        if (K % 2 == 0)
            return temp * temp;
        else
            return N * temp * temp;
    }
   
    function countWays(N, K)
    {
        return K * fastPow(K - 1, N - 1);
    }
     
// Driver code
    let N = 3, K = 3;
    document.write(countWays(N, K));
     
    // This code is contributed by sanjoy_62.
</script>

Javascript




<script>
 
// Javascript program to count number of ways to color
// a N node skewed tree with k colors such that
// parent and children have different colors.
 
    // fast_way is recursive
    // method to calculate power
    function fastPow(N, K)
    {
        if (K == 0 || N == 0)
            return 1;
        return K *(K - 1)*(N - 1);
    }
     
// Driver code
    let N = 3, K = 3;
    document.write(fastPow(N, K));
     
    // This code is contributed by sanjoy_62.
</script>

Output : 
 

 12

This article is contributed by Harsha Mogali. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@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.
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :