Problem:
Score : 200 points

Problem Statement

There are N balls placed in a row.
AtCoDeer the deer is painting each of these in one of the K colors of his paint cans.
For aesthetic reasons, any two adjacent balls must be painted in different colors.

Find the number of the possible ways to paint the balls.

Constraints

1≦N≦1000

2≦K≦1000

The correct answer is at most 2^{31}-1.

Input

The input is given from Standard Input in the following format:

N K

Output

Print the number of the possible ways to paint the balls.

Sample Input 1

2 2

Sample Output 1

2

We will denote the colors by 0 and 1. There are two possible ways: we can either paint the left ball in color 0 and the right ball in color 1, or paint the left in color 1 and the right in color 0.

Sample Input 2

1 10

Sample Output 2

10

Since there is only one ball, we can use any of the ten colors to paint it. Thus, the answer is ten.

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::cmp::{max, min};
use std::io::stdin;
use std::str::FromStr;

fn main() {
    let (n, k): (usize, usize) = input_two().unwrap();
    let mut ans = k;
    ans *= vec![k-1; n].iter().take(n-1).product::<usize>();

    println!("{}", ans);
}

fn input<T: FromStr>() -> Result<T, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    Ok(buf.trim().parse().ok().unwrap())
}

fn input_vec<T: FromStr>() -> Result<Vec<T>, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    Ok(buf
        .trim()
        .split_whitespace()
        .map(|x| x.parse().ok().unwrap())
        .collect::<Vec<_>>())
}

fn input_two<T: FromStr>() -> Result<(T, T), T::Err> {
    let tmp = input_vec::<String>().unwrap();
    Ok((tmp[0].parse()?, tmp[1].parse()?))
}

fn input_three<T: FromStr + Clone>() -> Result<(T, T, T), T::Err> {
    let tmp = input_vec::<T>().ok().unwrap();
    // println!("{:?}", tmp);
    Ok((tmp[0].clone(), tmp[1].clone(), tmp[2].clone()))
}