Problem:
Score : 1000 points

Problem Statement

Consider the following game:

The game is played using a row of N squares and many stones.

First, a_i stones are put in Square i\ (1 \leq i \leq N).

A player can perform the following operation as many time as desired: "Select an integer i such that Square i contains exactly i stones. Remove all the stones from Square i, and add one stone to each of the i-1 squares from Square 1 to Square i-1."

The final score of the player is the total number of the stones remaining in the squares.

For a sequence a of length N, let f(a) be the minimum score that can be obtained when the game is played on a.

Find the sum of f(a) over all sequences a of length N where each element is between 0 and K (inclusive).
Since it can be extremely large, find the answer modulo 1000000007 (= 10^9+7).

Constraints

1 \leq N \leq 100

1 \leq K \leq N

Input

Input is given from Standard Input in the following format:

N K

Output

Print the sum of f(a) modulo 1000000007 (= 10^9+7).

Sample Input 1

2 2

Sample Output 1

10

There are nine sequences of length 2 where each element is between 0 and 2. For each of them, the value of f(a) and how to achieve it is as follows:

f(\{0,0\}): 0 (Nothing can be done)

f(\{0,1\}): 1 (Nothing can be done)

f(\{0,2\}): 0 (Select Square 2, then Square 1)

f(\{1,0\}): 0 (Select Square 1)

f(\{1,1\}): 1 (Select Square 1)

f(\{1,2\}): 0 (Select Square 1, Square 2, then Square 1)

f(\{2,0\}): 2 (Nothing can be done)

f(\{2,1\}): 3 (Nothing can be done)

f(\{2,2\}): 3 (Select Square 2)

Sample Input 2

20 17

Sample Output 2

983853488

Solution in C (GCC 5.4.1) (judge verdict: Accepted)

#include <stdio.h>
#include <stdlib.h>
#define int long long
#define p (int)(1e9 + 7)

int MOD(int a){
	a %= p;
	return a >= 0 ? a : a + p;
}

int power(int a, int N){
	if(N == 0){
		return 1;
	}
	else if(N % 2 == 0){
		return power(MOD(a * a), N / 2);
	}
	else{
		return MOD(a * power(a, N - 1));
	}
}

int max(int a, int b){
	return a >= b ? a : b;
}

signed main(){
	int N, K, L, i, j, k, ans, j_max, next_j_max;
	scanf("%lld%lld", &N, &K);
/*	for(i = 1, L = 1; i <= K; i++){
		L += (K + i - 1) / i;
	}
	printf("L = %lld\n", L);
*/	L = K * K;
	int **dp = (int **)malloc(sizeof(int *) * (N + 1));
	for(i = 0; i <= N; i++){
		dp[i] = (int *)malloc(sizeof(int) * (L + 1));
		for(j = 0; j <= L; j++){
			dp[i][j] = 0;
		}
	}
	if(N == K){
		dp[N][0] = K;
		dp[N][1] = 1;
		next_j_max = 1;
	}
	else{
		dp[N][0] = K + 1;
		next_j_max = 0;
	}
	for(i = N; i > 1; i--){
		j_max = next_j_max;
//		printf("(i, j_max) = (%lld, %lld)\n", i, j_max);
		for(j = 0; j <= j_max; j++){
			for(k = 0; k <= K; k++){
				if(k + j < i - 1 || i - 1 < k){
					dp[i - 1][j] = MOD(dp[i - 1][j] + dp[i][j]);
				}
				else{
					dp[i - 1][j + (k + j) / (i - 1)] = MOD(dp[i - 1][j + (k + j) / (i - 1)] + dp[i][j]);
					next_j_max = max(next_j_max, j + (k + j) / (i - 1));
				}
			}
		}
	}
/*	for(i = 1; i <= N; i++){
		printf("i = %lld\n", i);
		for(j = 0; j <= L; j++){
			printf("%lld  ", dp[i][j]);
		}printf("\n");
	}
*/	ans = MOD(((K * (K + 1)) / 2) * power(K + 1, N - 1) * N);
	for(j = 0; j <= next_j_max; j++){
		ans = MOD(ans - dp[1][j] * j);
	}
	printf("%lld\n", ans);
	return 0;
}