Problem:
Score : 1200 points

Problem Statement

Find the number of the possible tuples of sequences (A_0,A_1,...,A_N) that satisfy all of the following conditions, modulo M:

For every i (0\leq i\leq N), A_i is a sequence of length i consisting of integers between 1 and K (inclusive);

For every i (1\leq i\leq N), A_{i-1} is a subsequence of A_i, that is, there exists 1\leq x_i\leq i such that the removal of the x_i-th element of A_i would result in a sequence equal to A_{i-1};

For every i (1\leq i\leq N), A_i is lexicographically larger than A_{i-1}.

Constraints

1 \leq N,K \leq 300

2 \leq M \leq 10^9

N, K and M are integers.

Input

Input is given from Standard Input in the following format:

N K M

Output

Print the number of the possible tuples of sequences (A_0,A_1,...,A_N), modulo M.

Sample Input 1

2 2 100

Sample Output 1

5

Five tuples below satisfy the conditions:

(),(1),(1,1)

(),(1),(1,2)

(),(1),(2,1)

(),(2),(2,1)

(),(2),(2,2)

Sample Input 2

4 3 999999999

Sample Output 2

358

Sample Input 3

150 150 998244353

Sample Output 3

186248260

Solution in C++ (GCC 9.2.1) (judge verdict: Accepted)

#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>

using ll = long long;
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))

int const nmax = 300;
int dp[5 + nmax][5 + nmax];
int comb[5 + nmax][5 + nmax];
int sum[5 + nmax][5 + nmax];
int modulo;

void computecomb() {
  for(int i = 0;i <= nmax; i++) {
    comb[i][0] = 1;
    for(int j = 1;j <= i; j++) {
      comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j]; 
      if(modulo <= comb[i][j])
        comb[i][j] -= modulo;
    }
  }
}

int main() {
  int n, k;
  std::cin >> n >> k >> modulo;
  computecomb();
  for(int i = 0;i <= k; i++)
    dp[0][i] = dp[1][i] = 1;
  sum[1][0] = dp[1][0];
  for(int i = 1;i <= k; i++)
    sum[1][i] = (sum[1][i - 1] + dp[1][i]) % modulo;

  for(int i = 2;i <= n + 1; i++) {
    for(int j = 1; j <= k; j++) {
      for(int i2 = 1; i2 < i; i2++) {
        dp[i][j] += 1LL * sum[i2][j - 1] * dp[i - i2][j] % modulo * comb[i - 2][i2 - 1] % modulo;
        if(modulo <= dp[i][j])
          dp[i][j] -= modulo;
      }
      sum[i][j] = sum[i][j - 1] + dp[i][j];
      if(modulo <= sum[i][j])
        sum[i][j] -= modulo;
    }
  }
  std::cout << dp[n + 1][k];
  return 0;
}