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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
#define REP(i,a,b) for(int i=(a);i<(b);i++)
#define RREP(i,a,b) for(int i=(a);i>=(b);i--)
#define pq priority_queue
#define P pair<int,int>
#define P2 pair<int,P>
#define P3 pair<int,P2>
typedef long long ll; typedef long double ld;
using namespace std;
const int INF=1e9, MOD=1e9+7, around[]={0,1,1,-1,-1,0,-1,1,0,0};
const ll LINF=1e18;
const ld PI=abs(acos(-1));
int n,m,k,a,b;
int li[100010]={};
ll dp[2][110];
ll s[2][110];

int main(){
        cin >> n >> k;

        REP(i,0,2) REP(j,0,k+1) dp[i][j]=s[i][j]=0;
        if(li[0]) dp[0][li[0]-1]=1;
        else REP(i,0,k) dp[0][i]=1;
        REP(i,0,k) s[0][i+1]=s[0][i]+dp[0][i];
        REP(q,1,n){
                int tar=q%2, cur=1-tar;
                
                if(li[q]){
                        REP(j,0,k){
                                if(j==li[q]-1) dp[tar][j]=(s[cur][k]-dp[cur][j]+MOD)%MOD; 
                                else dp[tar][j]=0;
                        }        
                }else{
                        REP(j,0,k) dp[tar][j]=(s[cur][k]-dp[cur][j]+MOD)%MOD;
                }
                
                REP(j,0,k) s[tar][j+1]=(s[tar][j]+dp[tar][j]+MOD)%MOD;
        }
        
        cout << s[1-n%2][k] << endl;
        return 0;
}