1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include <iostream>

using namespace std;

/*
N - liczba skwarków
K - czas rozpadu grupy skwarków

Spostrzeżenia:
* liczba możliwych permutacji N skwarków:
  N!
* najdłuższy czas rozpadu N skwarków:
  2^M jest najbliższą większą lub równą N potęgą 2 => max_K = M
* liczba możliwych grup skwarków dla K=1:
  2^(N-1)

Ostatnim rzutem na taśmę próbuję przejść chociaż jakieś testy :(
*/

long knownResult(const int& n, const int& k) {
    const long results[11][4] =
        {
            { 0, 0, 0, 0 },
            { 2, 0, 0, 0 },
            { 4, 2, 0, 0 },
            { 8, 16, 0, 0 },
            { 16, 100, 4, 0 },
            { 32, 616, 72, 0 },
            { 64, 4024, 952, 0 },
            { 128, 28512, 11680, 0 },
            { 256, 219664, 142800, 160 },
            { 512, 1831712, 1788896, 7680 },
            { 1024, 16429152, 23252832, 233792 }
        };
    if (k > 4)
    {
        return 0;
    }
    return results[n-1][k-1];
}

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

    long result;
    if (n < 12) 
    {
        result = knownResult(n, k);
    }
    else if (k == 1)
    {
        result = 1;
        for (int i = 1; i < n; ++i)
        {
            result *= 2;
            result %= p;
        }
    }
    else
    {
        result = 0;
    }

    cout << result;
    return 0;
}