Repository navigation
Expand file tree
/
Copy pathgrid_walking.cpp
More file actions
119 lines (94 loc) · 3.65 KB
/
Copy pathgrid_walking.cpp
File metadata and controls
119 lines (94 loc) · 3.65 KB
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
class Solver {
const static int MOD = 1000000007;
const int totalSteps;
const vector<int> dimensions;
vector<vector<vector<long>>> dimensionWays;
vector<vector<long>> nChooseK;
vector<vector<long>> interleavedWays;
public:
Solver(const int totalSteps, const vector<int>& dimensions) : totalSteps(totalSteps), dimensions(dimensions) {
dimensionWays = vector<vector<vector<long>>>(dimensions.size(), vector<vector<long>>(totalSteps + 1));
for (int i = 0; i < dimensionWays.size(); ++i) {
for (int j = 0; j < totalSteps + 1; ++j) {
dimensionWays[i][j] = vector<long>(dimensions[i], -1);
}
}
nChooseK = vector<vector<long>>(totalSteps + 1, vector<long>(totalSteps + 1));
for (int i = 0; i <= totalSteps; ++i) {
nChooseK[i][0] = 1;
nChooseK[i][i] = 1;
}
for (int i = 1; i <= totalSteps; ++i) {
for (int j = 1; j <= totalSteps; ++j) {
nChooseK[i][j] = (nChooseK[i - 1][j - 1] + nChooseK[i - 1][j]) % MOD;
}
}
interleavedWays = vector<vector<long>>(dimensions.size(), vector<long>(totalSteps + 1, -1));
}
long getWaysInDimension(const int pos, const int dimensionIdx, const int m) {
if (pos < 0 || pos >= dimensions[dimensionIdx]) {
return 0;
}
if (!m) {
return 1;
}
if (dimensionWays[dimensionIdx][m][pos] >= 0) {
return dimensionWays[dimensionIdx][m][pos];
}
int result = getWaysInDimension(pos + 1, dimensionIdx, m - 1) +
getWaysInDimension(pos - 1, dimensionIdx, m - 1);
result %= MOD;
return dimensionWays[dimensionIdx][m][pos] = result;
}
long getInterleavedWaysUsingDimensions(const vector<int>& pos, const int dimensionIdx, const int remainingSteps) {
// orthoganality of dimensions (there are no constraints moving either direction)
// for each dimension we assign k steps to it, and interleave these steps with the rest
// of the dimensions
if (!remainingSteps) {
return 1;
}
if (dimensionIdx >= dimensions.size()) {
return 0;
}
if (interleavedWays[dimensionIdx][remainingSteps] >= 0) {
return interleavedWays[dimensionIdx][remainingSteps];
}
long result = 0;
for (int k = 0; k <= remainingSteps; ++k) {
long waysToMoveInDirections = (getWaysInDimension(pos[dimensionIdx], dimensionIdx, k) *
getInterleavedWaysUsingDimensions(pos, dimensionIdx + 1, remainingSteps - k)) % MOD;
// now multiply with all possible interleavings of this movement with the other ones
result += (waysToMoveInDirections * nChooseK[remainingSteps][k]) % MOD;
result %= MOD;
}
return interleavedWays[dimensionIdx][remainingSteps] = result;
}
long solve(const vector<int>& pos) {
return getInterleavedWaysUsingDimensions(pos, 0, totalSteps);
}
};
int main() {
int nCases;
cin >> nCases;
while (nCases-- > 0) {
int n, m;
cin >> n >> m;
vector<int> pos(n);
for (int i = 0; i < n; ++i) {
cin >> pos[i]; // 0-index
--pos[i];
}
vector<int> dimensions(n);
for (int i = 0; i < n; ++i) cin >> dimensions[i];
Solver solver(m, dimensions);
cout << solver.solve(pos) << endl;
}
return 0;
}