Ways to paint N paintings such that adjacent paintings don’t have same colors

Given two integers n and m, where n represent some paintings numbered from 1 to n and m represent some colours 1 to m with unlimited amount. The task is to find the number of ways to paint the paintings such that no two consecutive paintings have the same colors.
Note: Answer must be calculated in modulo 10^9 +7 as answer can be very large. 
Examples:

Input: n = 4, m = 2 
Output: 2

Input: n = 4, m = 6
Output: 750

Asked in : National Instruments
Approach:
The total number of given color is m and the total paintings are from 1 to n. As per the condition of no two adjacent painting having the same color, first painting can be painted by anyone out of m colors and the rest of any painting can be painted by any of m-1 color except the color used for the painting just preceding that. Hence if we derive the solution for total number of ways, 

m * (m-1)^(n-1) is the actual answer. 

Now, this can be either calculated by simple iteration or by the method of efficient power calculation in O(logn) time.
Below is the implementation of the above approach: 

C++

// C++ implementation of the above approach
#include <bits/stdc++.h>
#define modd 1000000007
using namespace std;

// Function for finding the power
unsigned long power(unsigned long x,
                    unsigned long y, unsigned long p)
{
    unsigned long res = 1; // Initialize result

    x = x % p; // Update x if it is more than or
    // equal to p

    while (y > 0) {

        // If y is odd, multiply x with result
        if (y & 1)
            res = (res%p * x%p) % p;

        // y must be even now
        y = y >> 1; // y = y/2
        x = (x%p * x%p) % p;
    }
    return res;
}

// Function to calculate the number of ways
int ways(int n, int m)
{
    // Answer must be modulo of 10^9 + 7
    return power(m - 1, n - 1, modd) * m % modd;
}

// Driver code
int main()
{
    int n = 5, m = 5;
    cout << ways(n, m);

    return 0;
}

Java

// Java implementation of the above approach

class GFG
{
    static final int modd = 1000000007;

    // Function for finding the power
    static long power(long x, long y, long p)
    {
        long res = 1; // Initialize result

        // Update x if it is more than or
        // equal to p
        x = x % p;

        while (y > 0)
        {
            // If y is odd, multiply x with result
            if (y % 2 == 1)
            {
                res = (res%p * x%p) % p;
            }

            // y must be even now
            y = y >> 1; // y = y/2
            x = (x%p * x%p) % p;
        }
        return res;
    }

    // Function to calculate the number of ways
    static int ways(int n, int m)
    {
        // Answer must be modulo of 10^9 + 7
        return (int) (power(m - 1, n - 1, modd)
                            * m % modd);
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 5, m = 5;
        System.out.println(ways(n, m));

    }
}

// This code is contributed by 29AjayKumar

Python3

# Python3 implementation of the
# above approach

modd = 1000000007

# Function for finding the power
def power(x, y, p):

    res = 1 # Initialize result

    x = x % p # Update x if it is more
              # than or equal to p

    while (y > 0):

        # If y is odd, multiply x with result
        if (y & 1):
            res = (res%p * x%p) % p

        # y must be even now
        y = y >> 1 # y = y/2
        x = (x%p * x%p) % p

    return res

# Function to calculate the number of ways
def ways(n, m):

    # Answer must be modulo of 10^9 + 7
    return power(m - 1, n - 1, modd) * m % modd

# Driver code
n, m = 5, 5
print(ways(n, m))

# This code is contributed
# by Mohit Kumar 29

C#

// C# implementation of the above approach
using System;

class GFG
{
    static int modd = 1000000007;

    // Function for finding the power
    static long power(long x, long y, long p)
    {
        long res = 1; // Initialize result

        // Update x if it is more than or
        // equal to p
        x = x % p;

        while (y > 0)
        {
            // If y is odd, multiply x with result
            if (y % 2 == 1)
            {
                res = (res%p * x%p) % p;
            }

            // y must be even now
            y = y >> 1; // y = y/2
            x = (x%p * x%p) % p;
        }
        return res;
    }

    // Function to calculate the number of ways
    static int ways(int n, int m)
    {
        // Answer must be modulo of 10^9 + 7
        return (int) (power(m - 1, n - 1, modd)
                            * m % modd);
    }

    // Driver code
    static public void Main ()
    {
            int n = 5, m = 5;
        Console.WriteLine(ways(n, m));
    }
}

// This code is contributed by ajit

PHP

<?php
// PHP implementation of the above approach

// Iterative Function to calculate
// (x^y)%p in O(log y)
function power($x, $y, $p)
{
    // Initialize result
    $res = 1;

    // Update x if it is more
    // than or equal to p
    $x = $x % $p;

    while ($y > 0)
    {
        // If y is odd, multiply
        // x with result
        if ($y & 1)
            $res = ($res % $p * $x % $p) % $p;

        // y must be even now

        // y = $y/2
        $y = $y >> 1;
        $x = ($x % $p * $x % $p) % $p;
    }
    return $res;
}

// Function to calculate the number of ways
function ways($n, $m)
{
    $modd =1000000007;

    // Answer must be modulo of 10^9 + 7
    return (power($m - 1, $n - 1,
                  $modd) * $m ) % $modd;
}

// Driver code
$n = 5;
$m = 5;
echo ways($n, $m);

// This code is contributed
// by Arnab Kundu
?>

Javascript

<script>
    // Javascript implementation of the above approach

    let modd = 1000000007;

    // Function for finding the power
    function power(x, y, p)
    {
        let res = 1; // Initialize result

        // Update x if it is more than or
        // equal to p
        x = x % p;

        while (y > 0)
        {
            // If y is odd, multiply x with result
            if (y % 2 == 1)
            {
                res = (res%p * x%p) % p;
            }

            // y must be even now
            y = y >> 1; // y = y/2
            x = (x%p * x%p) % p;
        }
        return res;
    }

    // Function to calculate the number of ways
    function ways(n, m)
    {
        // Answer must be modulo of 10^9 + 7
        return (power(m - 1, n - 1, modd) * m % modd);
    }

    let n = 5, m = 5;
      document.write(ways(n, m));

</script>

Output:

1280

Time Complexity: O(logN)
Auxiliary Space: O(1), since no extra space has been taken.