text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
const long long int mod = 1000000007;
int N, M, Q;
int S;
struct matrix {
vector<vector<long long int> > T;
};
matrix I, DP;
void get_I() {
I.T = vector<vector<long long int> >(S, vector<long long int>(S, 0));
for (int i = 0; i < S; i++) I.T[i][i] = 1;
DP.T = vector<vector<long long int> >(1, vector<long long int>(S, 0));
DP.T[0][0] = 1;
}
matrix mul(matrix a, matrix b) {
matrix ret;
ret.T = vector<vector<long long int> >(
a.T.size(), vector<long long int>(b.T[0].size(), 0));
for (int i = 0; i < a.T.size(); i++) {
for (int j = 0; j < b.T[0].size(); j++) {
for (int k = 0; k < a.T[0].size(); k++) {
ret.T[i][j] += a.T[i][k] * b.T[k][j] % mod;
ret.T[i][j] %= mod;
}
}
}
return ret;
}
matrix pw(matrix x, long long int n) {
matrix ret = I;
while (n) {
if (n % 2) ret = mul(ret, x);
x = mul(x, x);
n /= 2;
}
return ret;
}
struct query {
int typo, x, y, t;
};
vector<query> qur;
int Xn;
vector<int> X;
map<int, int> dx;
void compress() {
X.push_back(1);
for (int i = 0; i < Q; i++) X.push_back(qur[i].t);
sort(X.begin(), X.end());
X.resize(unique(X.begin(), X.end()) - X.begin());
Xn = X.size();
for (int i = 0; i < Xn; i++) dx[X[i]] = i;
for (int i = 0; i < Q; i++) qur[i].t = dx[qur[i].t];
}
int dj[5] = {0, 0, 1, -1, 0};
int di[5] = {1, -1, 0, 0, 0};
matrix IC;
vector<matrix> C;
void get_C() {
C.resize(Xn);
for (int i = 0; i < Xn; i++)
C[i].T = vector<vector<long long int> >(S, vector<long long int>(S, 0));
IC.T = vector<vector<long long int> >(S, vector<long long int>(S, 0));
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
for (int k = 0; k < 5; k++) {
int ni = i + di[k];
int nj = j + dj[k];
if (ni < 0 || N <= ni) continue;
if (nj < 0 || M <= nj) continue;
IC.T[i * M + j][ni * M + nj] = 1;
}
}
}
C[0].T = IC.T;
for (int i = 0; i < Q; i++) {
int typo = qur[i].typo, x = qur[i].x, y = qur[i].y, t = qur[i].t;
if (i != 0)
C[t].T = C[qur[i - 1].t].T;
else
C[t].T = IC.T;
if (typo == 2) {
for (int j = 0; j < S; j++) {
C[t].T[j][y * M + x] = 0;
}
}
if (typo == 3) {
for (int j = 0; j < S; j++) {
C[t].T[j][y * M + x] = (1 & IC.T[j][y * M + x]);
}
}
}
}
int main() {
scanf("%d %d %d", &N, &M, &Q);
S = N * M;
get_I();
qur.resize(Q);
for (int i = 0; i < Q; i++) {
int typo, x, y, t;
scanf("%d %d %d %d", &typo, &x, &y, &t);
if (typo == 2) t--;
qur[i] = {typo, --y, --x, t};
}
compress();
get_C();
int curtime = 0;
for (int i = 0; i < Q; i++) {
int typo = qur[i].typo, x = qur[i].x, y = qur[i].y, t = qur[i].t;
if (typo == 1) {
for (int j = curtime; j < t; j++) {
long long int dt = (long long int)X[j + 1] - (long long int)X[j];
DP = mul(DP, pw(C[j], dt));
}
curtime = t;
printf("%I64d\n", DP.T[0][y * M + x]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
int d[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int n, m, q;
int N;
vector<int> G[22];
struct Mat {
int a[22][22];
Mat operator*(const Mat& x) const {
Mat rep;
memset(rep.a, 0, sizeof(rep.a));
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
rep.a[i][j] += 1LL * a[i][k] * x.a[k][j] % p;
if (rep.a[i][j] >= p) rep.a[i][j] -= p;
}
}
}
return rep;
}
} danwei, ori;
Mat powmod(Mat x, int y) {
Mat ret = danwei;
while (y) {
if (y & 1) ret = ret * x;
x = x * x;
y >>= 1;
}
return ret;
}
int has[22];
int getid(int x, int y) { return x * m + y; }
int main() {
scanf("%d%d%d", &n, &m, &q);
N = n * m;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) danwei.a[i][j] = i == j;
ori = danwei;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int id = getid(i, j);
for (int di = 0; di < 4; di++) {
int ni = i + d[di][0];
int nj = j + d[di][1];
if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
G[id].push_back(getid(ni, nj));
ori.a[id][getid(ni, nj)] = 1;
}
}
}
}
Mat cur = danwei;
int tl = 1;
while (q--) {
int ty, x, y, t;
scanf("%d%d%d%d", &ty, &x, &y, &t);
x--, y--;
if (ty == 1) {
cur = cur * powmod(ori, t - tl);
tl = t;
printf("%d\n", cur.a[0][getid(x, y)]);
}
if (ty == 2) {
cur = cur * powmod(ori, t - 1 - tl);
int id = getid(x, y);
has[id] = 1;
for (int j = 0; j < G[id].size(); j++) {
ori.a[G[id][j]][id] = 0;
}
ori.a[id][id] = 0;
tl = t - 1;
}
if (ty == 3) {
cur = cur * powmod(ori, t - tl);
int id = getid(x, y);
has[id] = 0;
for (int j = 0; j < G[id].size(); j++) {
if (!has[G[id][j]]) ori.a[id][G[id][j]] = 1;
ori.a[G[id][j]][id] = 1;
}
ori.a[id][id] = 1;
tl = t;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct node {
long long k[51][51];
} a, ans;
long long t, n, m, q, op, x, y, z, s = 1, mp[26][26];
inline long long read() {
long long sum = 0, x = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') x = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = sum * 10 + ch - '0';
ch = getchar();
}
return sum * x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
return;
}
inline node mul(node a, node b) {
node c;
memset(c.k, 0, sizeof(c.k));
for (register long long i = 1; i <= t; ++i)
for (register long long j = 1; j <= t; ++j)
for (register long long p = 1; p <= t; p++)
c.k[i][j] = (c.k[i][j] + a.k[i][p] * b.k[p][j]) % mod;
return c;
}
inline void power(long long b) {
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) ans = mul(a, ans);
}
inline void build() {
for (register long long i = 1; i <= t; ++i)
for (register long long j = 1; j <= t; ++j) {
long long aa = ((i - 1) / m) + 1, bb = (i - 1) % m + 1,
A = ((j - 1) / m) + 1, B = (j - 1) % m + 1;
if (mp[aa][bb] == 0 && mp[A][B] == 0 && abs(A - aa) + abs(B - bb) <= 1)
a.k[i][j] = 1;
else
a.k[i][j] = 0;
}
}
signed main() {
n = read();
m = read();
q = read();
t = n * m;
ans.k[1][1] = 1;
while (q--) {
build();
op = read();
x = read();
y = read();
z = read();
power(z - s);
s = z;
if (op == 2 || op == 3) ans.k[(x - 1) * m + y][1] = 0;
if (op == 2) mp[x][y] = 1;
if (op == 3) mp[x][y] = 0;
if (op == 1) {
write(ans.k[(x - 1) * m + y][1]);
putchar('\n');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct mat {
int a[25][25];
} now;
bool bz[25][25];
int n, m, q, last;
const int fx[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int poi(int x, int y) { return (x - 1) * m + y; }
mat mul(mat x, mat y) {
mat z;
memset(z.a, 0, sizeof(z.a));
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++)
for (int k = 1; k <= n * m; k++)
z.a[i][j] = (z.a[i][j] + x.a[i][k] * 1ll * y.a[k][j]) % 1000000007;
return z;
}
mat pow(mat x, int y) {
mat ret;
memset(ret.a, 0, sizeof(ret.a));
for (int i = 1; i <= n * m; i++) ret.a[i][i] = 1;
while (y) {
if (y % 2 == 1) ret = mul(ret, x);
x = mul(x, x);
y /= 2;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
last = 1;
for (int i = 1; i <= n * m; i++) now.a[i][i] = 1;
for (int i = 1; i <= q; i++) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
mat tmp;
memset(tmp.a, 0, sizeof(tmp.a));
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) {
for (int p = 0; p <= 3; p++) {
int xx = j + fx[p][0], yy = k + fx[p][1];
if (xx <= 0 || yy <= 0 || xx > n || yy > m) continue;
if (bz[j][k] || bz[xx][yy])
tmp.a[poi(j, k)][poi(xx, yy)] = 0;
else
tmp.a[poi(j, k)][poi(xx, yy)] = 1;
}
if (bz[j][k])
tmp.a[poi(j, k)][poi(j, k)] = 0;
else
tmp.a[poi(j, k)][poi(j, k)] = 1;
}
now = mul(now, pow(tmp, t - last));
if (tp == 2) {
bz[x][y] = 1;
} else if (tp == 3) {
bz[x][y] = 0;
} else {
printf("%d\n", now.a[1][poi(x, y)]);
}
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int n, m, q, t;
int g[(20 + 10)][(20 + 10)], tmp[(20 + 10)][(20 + 10)],
ret[(20 + 10)][(20 + 10)], ans[(20 + 10)][(20 + 10)],
gg[(20 + 10)][(20 + 10)];
int s[(20 + 10)][(20 + 10)];
int dx[] = {-1, 0, 1, 0, 0};
int dy[] = {0, -1, 0, 1, 0};
bool out(int x, int y) { return x < 0 || x >= n || y < 0 || y >= m; }
void add(int &u, int v) {
u += v;
if (u >= 1000000007) u -= 1000000007;
}
void mul(int a[(20 + 10)][(20 + 10)], int b[(20 + 10)][(20 + 10)]) {
memset(tmp, 0, sizeof tmp);
for (int i = 0; i < t; ++i) {
for (int j = 0; j < t; ++j) {
for (int k = 0; k < t; ++k) {
add(tmp[i][j], (long long)a[i][k] * b[k][j] % 1000000007);
}
}
}
memcpy(a, tmp, sizeof tmp);
}
void qpow(int a[(20 + 10)][(20 + 10)], int k) {
memset(ret, 0, sizeof ret);
for (int i = 0; i < t; ++i) ret[i][i] = 1;
while (k) {
if (k & 1) mul(ret, a);
mul(a, a);
k >>= 1;
}
}
int get(int x, int y) { return x * m + y; }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
s[i][j] = 1;
for (int k = 0; k < 5; ++k) {
int x = i + dx[k], y = j + dy[k];
if (out(x, y)) continue;
g[get(i, j)][get(x, y)] = 1;
}
}
}
t = n * m;
for (int i = 0; i < t; ++i) ans[i][i] = 1;
int last = 1;
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
--x, --y;
memcpy(gg, g, sizeof g);
qpow(gg, t - last);
last = t;
mul(ans, ret);
if (tp == 1)
printf("%d\n", ans[get(0, 0)][get(x, y)]);
else {
if (tp == 3) s[x][y] = 1;
for (int i = 0; i < 5; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (out(nx, ny) || s[nx][ny] == 0) continue;
g[get(x, y)][get(nx, ny)] = tp == 2 ? 0 : 1;
g[get(nx, ny)][get(x, y)] = tp == 2 ? 0 : 1;
}
if (tp == 2) s[x][y] = 0;
}
}
}
|
#include <bits/stdc++.h>
const int N = 25;
const int mod = 1e9 + 7;
const int dx[] = {1, -1, 0, 0, 0}, dy[] = {0, 0, 1, -1, 0};
int h, w, n, q;
bool ok[N][N];
void upd(int &x, int y) { (x += y) >= mod && (x -= mod); }
struct Matrix {
int n, m, A[N][N];
Matrix(int _n = 0, int _m = 0) { n = _n, m = _m, memset(A, 0, sizeof(A)); }
void operator~() {
for (int i = 1; i <= n; ++i) A[i][i] = 1;
}
Matrix operator*(const Matrix &b) const {
Matrix ans(n, b.m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= b.m; ++j)
for (int k = 1; k <= m; ++k) {
upd(ans.A[i][j], 1LL * A[i][k] * b.A[k][j] % mod);
}
return ans;
}
Matrix operator^(const int &b) const {
Matrix ans(n, n), x = *this;
~ans;
for (int p = b; p; p >>= 1, x = x * x)
if (p & 1) ans = ans * x;
return ans;
}
};
void build(Matrix &a) {
memset(a.A, 0, sizeof(a.A));
for (int i = 1; i <= h; ++i)
for (int j = 1; j <= w; ++j)
if (ok[i][j]) {
for (int k = 0; k <= 4; ++k) {
int x = i + dx[k], y = j + dy[k];
if (x >= 1 && x <= h && y >= 1 && y <= w && ok[x][y])
a.A[(i - 1) * w + j][(x - 1) * w + y] = 1;
}
}
}
int main() {
scanf("%d%d%d", &h, &w, &q), n = h * w;
int now = 1;
Matrix ans(n, 1), a(n, n);
ans.A[1][1] = 1;
memset(ok, 1, sizeof(ok));
while (q--) {
int opt, x, y, t;
scanf("%d%d%d%d", &opt, &x, &y, &t);
build(a), ans = (a ^ (t - now)) * ans, now = t;
if (opt == 1) printf("%d\n", ans.A[(x - 1) * w + y][1]);
if (opt == 2) ans.A[(x - 1) * w + y][1] = 0, ok[x][y] = 0;
if (opt == 3) ans.A[(x - 1) * w + y][1] = 0, ok[x][y] = 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class _Tp>
void ckmax(_Tp &a, _Tp b) {
if (a < b) a = b;
}
template <class _Tp>
void ckmin(_Tp &a, _Tp b) {
if (a > b) a = b;
}
template <class _Tp>
_Tp gcd(_Tp a, _Tp b) {
return (b == 0) ? (a) : (gcd(b, a % b));
}
int read() {
char ch = getchar();
bool f = 1;
int x = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') f = 0, ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch & 15);
ch = getchar();
}
return f ? x : -x;
}
const int inf = 1000000000;
const long long Inf = 1000000000000000000ll;
const long long mod = 1000000007;
const int xx[4] = {-1, 0, 1, 0}, yy[4] = {0, -1, 0, 1};
int nm, n, m, q, can[21][21];
struct Mat {
long long a[21][21];
Mat() { memset(a, 0ll, sizeof(a)); }
Mat friend operator*(Mat A, Mat B) {
Mat C;
for (int i = 1; i <= nm; ++i)
for (int j = 1; j <= nm; ++j)
for (int k = 1; k <= nm; ++k)
C.a[i][j] = (C.a[i][j] + A.a[i][k] * B.a[k][j]) % mod;
return C;
}
} now;
Mat qpow(Mat A, int p) {
Mat res;
for (int i = 1; i <= nm; ++i) res.a[i][i] = 1;
while (p) {
if (p & 1) res = res * A;
A = A * A;
p >>= 1;
}
return res;
}
int id(int x, int y) { return (x - 1) * m + y; }
int main() {
n = read();
m = read();
q = read();
nm = n * m;
int lst = 1, t, x, y, opt;
for (int i = 1; i <= nm; ++i) now.a[i][i] = 1;
while (q--) {
opt = read();
x = read();
y = read();
t = read();
Mat tmp;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
for (int op = 0; op < 4; ++op) {
int nx = i + xx[op], ny = j + yy[op];
if (nx < 1 || ny < 1 || nx > n || ny > m) continue;
tmp.a[id(i, j)][id(nx, ny)] = 1 - (can[i][j] || can[nx][ny]);
}
tmp.a[id(i, j)][id(i, j)] = 1 - can[i][j];
}
now = now * qpow(tmp, t - lst);
if (opt == 1) printf("%d\n", now.a[1][id(x, y)]);
if (opt == 2) can[x][y] = 1;
if (opt == 3) can[x][y] = 0;
lst = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
struct matrix {
long long m[20][20];
int r, c;
matrix(int r_, int c_) { r = r_, c = c_; }
};
void mul(const matrix &a, const matrix &b, matrix &c) {
for (int i = 0; i < a.r; i++)
for (int j = 0; j < b.c; j++) {
c.m[i][j] = 0;
for (int k = 0; k < a.c; k++) {
c.m[i][j] += a.m[i][k] * b.m[k][j];
if (c.m[i][j] >= MOD) c.m[i][j] %= MOD;
}
}
c.r = a.r;
c.c = b.c;
}
void mp(const matrix &a, const long long &p, matrix &res) {
int x = log(p) / log(2) + 1 + 1e-9;
matrix t(a.r, a.c), *t2 = &t, *t1 = &res;
res.r = res.c = a.r;
for (int i = 0; i < res.c; i++)
for (int j = 0; j < res.c; j++) res.m[i][j] = i == j;
for (; x >= 0; x--) {
mul(*t1, *t1, *t2);
swap(t1, t2);
if (p & (1ll << x)) {
mul(*t1, a, *t2);
swap(t1, t2);
}
}
res = *t1;
}
int n, m, q, hascat[25][25], typ, x, y, t;
int di[] = {0, 0, 1, -1, 0};
int dj[] = {1, -1, 0, 0, 0};
bool isvalid(int i, int j) { return (i >= 0 && j >= 0 && i < n && j < m); }
int to1d(int i, int j) { return (i * m + j); }
matrix S(20, 20);
void fixS() {
memset(S.m, 0, sizeof S.m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (hascat[i][j]) continue;
for (int k = 0; k < 5; ++k) {
int ni = i + di[k];
int nj = j + dj[k];
if (isvalid(ni, nj) && !hascat[ni][nj]) {
S.m[to1d(i, j)][to1d(ni, nj)] = 1;
}
}
}
}
int main() {
scanf("%d", &n), scanf("%d", &m), scanf("%d", &q);
matrix A(20, 1), B(20, 1), res(20, 20);
memset(A.m, 0, sizeof A.m);
memset(B.m, 0, sizeof B.m);
memset(S.m, 0, sizeof S.m);
A.m[0][0] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
for (int k = 0; k < 5; ++k) {
int ni = i + di[k];
int nj = j + dj[k];
if (isvalid(ni, nj)) {
S.m[to1d(i, j)][to1d(ni, nj)] = 1;
}
}
}
int curt = 0;
for (int i = 0; i < q; ++i) {
scanf("%d", &typ), scanf("%d", &x), scanf("%d", &y), scanf("%d", &t);
--x, --y, --t;
fixS();
mp(S, t - curt, res);
mul(res, A, B);
memset(A.m, 0, sizeof A.m);
for (int j = 0; j < n * m; ++j) A.m[j][0] = B.m[j][0];
if (typ == 1) cout << B.m[to1d(x, y)][0] << endl;
if (typ == 2) {
hascat[x][y] = 1;
} else if (typ == 3) {
hascat[x][y] = 0;
}
curt = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
struct matrix {
int t[20 + 1][20 + 1];
};
int r, c, q;
bool inside(int x, int y) { return (x >= 1 && x <= r && y >= 1 && y <= c); }
int dx[] = {0, 0, 1, -1, 0};
int dy[] = {1, -1, 0, 0, 0};
matrix muti(const matrix &A, const matrix &B, int m, int n) {
matrix C;
memset(C.t, 0, sizeof C.t);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
C.t[i][j] = (1ll * A.t[i][k] * B.t[k][j] + C.t[i][j]) % mod;
return C;
}
matrix show(matrix A) {
for (int i = 1; i <= r * c; i++) {
for (int j = 1; j <= r * c; j++) printf("%d ", A.t[i][j]);
printf("\n");
}
printf("----\n");
}
matrix start, curr, mul;
int last = 1;
void goNext(int t) {
int k = t - last;
matrix B = mul;
while (k > 0) {
if (k % 2) curr = muti(curr, B, 1, r * c);
B = muti(B, B, r * c, r * c);
k /= 2;
}
last = t;
}
void input() {
scanf("%d %d %d", &r, &c, &q);
for (int x = 1; x <= r; x++)
for (int y = 1; y <= c; y++)
for (int k = 0; k < 5; k++) {
int cx = x + dx[k];
int cy = y + dy[k];
if (inside(cx, cy)) start.t[(x - 1) * c + y][(cx - 1) * c + cy] = 1;
}
mul = start;
curr.t[1][1] = 1;
while (q > 0) {
int tp, x, y, t;
scanf("%d %d %d %d", &tp, &x, &y, &t);
goNext(t - 1);
if (tp == 2) {
goNext(t - 1);
for (int i = 1; i <= r * c; i++) mul.t[i][(x - 1) * c + y] = 0;
} else if (tp == 3) {
goNext(t);
for (int i = 1; i <= r * c; i++)
mul.t[i][(x - 1) * c + y] = start.t[i][(x - 1) * c + y];
}
goNext(t);
if (tp == 1) printf("%d\n", curr.t[1][(x - 1) * c + y]);
q--;
}
}
int main() { input(); }
|
#include <bits/stdc++.h>
using namespace std;
long double EPS = (long double)1e-11L;
const double PI = 3.141592653589793238462;
const int INF = 1e9 + 7;
const long long LINF = 1e18 + 7;
const int MOD = 1e9 + 7;
const int S = 21;
int n, m, s;
vector<long long> bad, ans;
vector<vector<long long> > T;
vector<vector<long long> > mult(const vector<vector<long long> >& a,
const vector<vector<long long> >& b) {
vector<vector<long long> > c(s, vector<long long>(s));
for (int i = 0; i < (int)(s); ++i) {
for (int j = 0; j < (int)(s); ++j) {
for (int k = 0; k < (int)(s); ++k) {
c[i][j] = (c[i][j] + a[i][k] * b[k][j] % MOD) % MOD;
}
}
}
return c;
}
vector<vector<long long> > binPow(int b) {
vector<vector<long long> > res(s, vector<long long>(s));
for (int i = 0; i < (int)(s); ++i) {
for (int j = 0; j < (int)(s); ++j) {
res[i][j] = i == j;
}
}
vector<vector<long long> > a = T;
for (int i = 0; i < (int)(s); ++i) {
if (bad[i]) {
for (int j = 0; j < (int)(s); ++j) {
a[j][i] = 0;
}
}
}
while (b) {
if (b & 1) res = mult(res, a);
a = mult(a, a);
b >>= 1;
}
return res;
}
void upd(int dt) {
vector<vector<long long> > res = binPow(dt);
vector<long long> nAns(s);
for (int i = 0; i < (int)(s); ++i) {
for (int j = 0; j < (int)(s); ++j) {
nAns[j] = (nAns[j] + ans[i] * res[i][j] % MOD) % MOD;
}
}
ans = nAns;
}
int main() {
int q;
cin >> n >> m >> q;
s = n * m;
T.assign(s, vector<long long>(s));
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
int from = i * m + j;
for (int q = 0; q < (int)(n); ++q) {
for (int k = 0; k < (int)(m); ++k) {
if ((i - q) * (i - q) + (j - k) * (j - k) <= 1) {
int to = q * m + k;
T[from][to] = 1;
}
}
}
}
}
int curt = 1;
ans.resize(s), bad.resize(s);
ans[0] = 1;
for (int i = 0; i < (int)(q); ++i) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
x--, y--;
upd(t - curt);
curt = t;
int p = x * m + y;
if (tp == 1) {
cout << ans[p] << endl;
continue;
}
if (tp == 2) {
bad[p] = 1;
ans[p] = 0;
continue;
}
bad[p] = 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long a[25][25], b[25][25], ans[25][25], now[25][25];
int n, m, q;
long long f[2][25];
int bb[25];
int dq, dqt, x, y, t, z;
void mul(long long a[25][25], int x) {
for (int i = 1; i <= n * m; ++i)
for (int j = 1; j <= n * m; ++j) b[i][j] = a[i][j];
for (int i = 1; i <= n * m; ++i)
for (int j = 1; j <= n * m; ++j) ans[i][j] = 0;
for (int i = 1; i <= n * m; ++i) ans[i][i] = 1;
while (x) {
if (x & 1) {
memset(now, 0, sizeof(now));
for (int i = 1; i <= n * m; ++i)
for (int j = 1; j <= n * m; ++j)
for (int k = 1; k <= n * m; ++k) {
now[i][j] += ans[i][k] * b[k][j] % mod;
now[i][j] %= mod;
}
for (int i = 1; i <= n * m; ++i)
for (int j = 1; j <= n * m; ++j) ans[i][j] = now[i][j];
}
x /= 2;
memset(now, 0, sizeof(now));
for (int i = 1; i <= n * m; ++i)
for (int j = 1; j <= n * m; ++j)
for (int k = 1; k <= n * m; ++k) {
now[i][j] += b[i][k] * b[k][j] % mod;
now[i][j] %= mod;
}
for (int i = 1; i <= n * m; ++i)
for (int j = 1; j <= n * m; ++j) b[i][j] = now[i][j];
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n * m; ++i) f[1][i] = 0;
f[1][1] = 1;
for (int i = 1; i <= n * m; ++i) a[i][i] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
dq = (i - 1) * m + j;
if (i > 1) a[dq][dq - m] = 1;
if (i < n) a[dq][dq + m] = 1;
if (j > 1) a[dq][dq - 1] = 1;
if (j < m) a[dq][dq + 1] = 1;
}
dqt = 1;
for (int i = 1; i <= n * m; ++i) bb[i] = 1;
for (int zz = 1; zz <= q; ++zz) {
scanf("%d", &z);
if (z == 1) {
scanf("%d%d%d", &x, &y, &t);
mul(a, t - dqt);
memset(now, 0, sizeof(now));
for (int i = 1; i <= 1; ++i)
for (int j = 1; j <= n * m; ++j)
for (int k = 1; k <= n * m; ++k) {
now[i][j] += f[i][k] * ans[k][j] % mod;
now[i][j] %= mod;
}
for (int i = 1; i <= n * m; ++i) f[1][i] = now[1][i];
printf("%I64d\n", f[1][(x - 1) * m + y]);
dqt = t;
} else if (z == 2) {
scanf("%d%d%d", &x, &y, &t);
mul(a, t - dqt);
memset(now, 0, sizeof(now));
for (int i = 1; i <= 1; ++i)
for (int j = 1; j <= n * m; ++j)
for (int k = 1; k <= n * m; ++k) {
now[i][j] += f[i][k] * ans[k][j] % mod;
now[i][j] %= mod;
}
for (int i = 1; i <= n * m; ++i) f[1][i] = now[1][i];
f[1][(x - 1) * m + y] = 0;
dq = (x - 1) * m + y;
bb[dq] = 0;
a[dq][dq] = 0;
if (x > 1) a[dq][dq - m] = 0, a[dq - m][dq] = 0;
if (x < n) a[dq][dq + m] = 0, a[dq + m][dq] = 0;
if (y > 1) a[dq][dq - 1] = 0, a[dq - 1][dq] = 0;
if (y < m) a[dq][dq + 1] = 0, a[dq + 1][dq] = 0;
dqt = t;
} else if (z == 3) {
scanf("%d%d%d", &x, &y, &t);
mul(a, t - dqt);
memset(now, 0, sizeof(now));
for (int i = 1; i <= 1; ++i)
for (int j = 1; j <= n * m; ++j)
for (int k = 1; k <= n * m; ++k) {
now[i][j] += f[i][k] * ans[k][j] % mod;
now[i][j] %= mod;
}
for (int i = 1; i <= n * m; ++i) f[1][i] = now[1][i];
dq = (x - 1) * m + y;
a[dq][dq] = 1;
bb[dq] = 1;
if (x > 1)
a[dq][dq - m] = min(bb[dq], bb[dq - m]), a[dq - m][dq] = a[dq][dq - m];
if (x < n)
a[dq][dq + m] = min(bb[dq], bb[dq + m]), a[dq + m][dq] = a[dq][dq + m];
if (y > 1)
a[dq][dq - 1] = min(bb[dq], bb[dq - 1]), a[dq - 1][dq] = a[dq][dq - 1];
if (y < m)
a[dq][dq + 1] = min(bb[dq], bb[dq + 1]), a[dq + 1][dq] = a[dq][dq + 1];
dqt = t;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int MOD = (int)1e9 + 7;
const int dx[] = {0, -1, 0, 1, 0};
const int dy[] = {0, 0, 1, 0, -1};
struct Matrix {
long long mat[N][N];
};
bool blocked[N][N];
int m, n, q;
int size;
Matrix operator*(const Matrix a, const Matrix b) {
Matrix c;
for (int i = 0; i < size; ++i)
for (int j = 0; j < size; ++j) {
c.mat[i][j] = 0;
for (int k = 0; k < size; ++k)
c.mat[i][j] = (c.mat[i][j] + a.mat[i][k] * b.mat[k][j]) % MOD;
}
return c;
}
Matrix power(Matrix a, int p) {
Matrix ans;
memset(ans.mat, 0, sizeof(ans.mat));
for (int i = 0; i < size; ++i) ans.mat[i][i] = 1;
for (; p; p >>= 1) {
if (p & 1) ans = ans * a;
a = a * a;
}
return ans;
}
int getIndex(int x, int y) { return x * n + y; }
void update(Matrix &a) {
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j) {
int cur = getIndex(i, j);
for (int k = 0; k < size; ++k) a.mat[cur][k] = 0;
if (blocked[i][j]) continue;
for (int d = 0; d < 5; ++d) {
int x = i + dx[d], y = j + dy[d];
if (x < 0 || y < 0 || x >= m || y >= n || blocked[x][y]) continue;
a.mat[cur][getIndex(x, y)] = 1;
}
}
}
void multiply(Matrix gap, long long ans[]) {
int newAns[N];
for (int i = 0; i < size; ++i) {
newAns[i] = 0;
for (int j = 0; j < size; ++j)
newAns[i] = (newAns[i] + ans[j] * gap.mat[i][j]) % MOD;
}
for (int i = 0; i < size; ++i) ans[i] = newAns[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> m >> n >> q;
size = m * n;
Matrix a;
update(a);
long long ans[N];
memset(ans, 0, sizeof(ans));
ans[0] = 1;
int lastT = 1;
while (q--) {
int type, x, y, t;
cin >> type >> x >> y >> t;
--x;
--y;
Matrix gap = power(a, t - lastT - 1);
multiply(gap, ans);
multiply(a, ans);
if (type != 1) {
blocked[x][y] ^= 1;
update(a);
}
if (type == 1) cout << ans[getIndex(x, y)] << '\n';
lastT = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 1000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 317;
const int maxL = 302;
struct Mat {
int n, m;
int a[20][20];
Mat(int x, int y, int fl = 0) {
n = x;
m = y;
for (int i = 0; i < 20; i++)
for (int j = 0; j < 20; j++)
if (i == j)
a[i][j] = fl;
else
a[i][j] = 0;
}
};
Mat operator*(const Mat &p, const Mat &q) {
Mat ans(p.n, q.m);
for (int i = 0; i < p.n; i++)
for (int j = 0; j < q.m; j++)
for (int k = 0; k < p.m; k++)
ans.a[i][j] = (ans.a[i][j] + (1LL) * p.a[i][k] * q.a[k][j] % mod) % mod;
return ans;
}
Mat power(Mat p, int k) {
Mat ans(p.n, p.m, 1);
while (k) {
if (k & 1) ans = ans * p;
k >>= 1;
p = p * p;
}
return ans;
}
int a[20][20];
int n, m;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
bool is_ok(int x, int y) {
if (x < 0 || y < 0 || n <= x || m <= y) return false;
return true;
}
Mat make() {
Mat ans(n * m, n * m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[i][j] == 1) continue;
ans.a[i * m + j][i * m + j] = 1;
for (int k = 0; k < 4; k++) {
int v = i + dx[k], u = j + dy[k];
if (is_ok(v, u) && a[v][u] == 0) ans.a[i * m + j][v * m + u] = 1;
}
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> n >> m >> q;
Mat p(n * m, 1);
p.a[0][0] = 1;
Mat qq = make();
int cur = 1;
for (int i = 0; i < q; i++) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
x--;
y--;
int dif = t - cur;
p = power(qq, dif) * p;
cur = t;
if (tp == 1)
cout << p.a[x * m + y][0] << endl;
else {
a[x][y] ^= 1;
qq = make();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1 << 29;
const long long inf = 1ll << 60;
const long long mod = 1e9 + 7;
void GG() {
cout << "-1\n";
exit(0);
}
long long mpow(long long a, long long n, long long mo = mod) {
long long re = 1;
while (n > 0) {
if (n & 1) re = re * a % mo;
a = a * a % mo;
n >>= 1;
}
return re;
}
long long inv(long long b, long long mo = mod) {
if (b == 1) return b;
return (mo - mo / b) * inv(mo % b) % mo;
}
const int maxn = 20;
int n, m, q;
bool cat[maxn][maxn];
array<long long, 20> A;
inline int first(int a, int b) { return a * m + b; }
void mul(array<array<long long, 20>, 20> &c, array<array<long long, 20>, 20> a,
array<array<long long, 20>, 20> b) {
for (int i = (0); i < (20); ++i)
for (int j = (0); j < (20); ++j) {
c[i][j] = 0;
for (int k = (0); k < (20); ++k) {
c[i][j] += a[i][k] * b[k][j];
c[i][j] %= mod;
}
}
}
void move(int T) {
array<array<long long, 20>, 20> pM;
for (int i = (0); i < (20); ++i)
for (int j = (0); j < (20); ++j) pM[i][j] = 0;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
if (cat[i][j]) continue;
pM[first(i, j)][first(i, j)] = 1;
if (i) pM[first(i, j)][first(i - 1, j)] = 1;
if (j) pM[first(i, j)][first(i, j - 1)] = 1;
if (i < n - 1) pM[first(i, j)][first(i + 1, j)] = 1;
if (j < m - 1) pM[first(i, j)][first(i, j + 1)] = 1;
}
array<array<long long, 20>, 20> M;
for (int i = (0); i < (20); ++i)
for (int j = (0); j < (20); ++j) M[i][j] = i == j;
while (T > 0) {
if (T % 2 == 1) {
mul(M, M, pM);
}
mul(pM, pM, pM);
T /= 2;
}
array<long long, 20> nA;
for (int i = (0); i < (20); ++i) {
nA[i] = 0;
for (int j = (0); j < (20); ++j) {
nA[i] = (nA[i] + A[j] * M[i][j]) % mod;
}
}
A = nA;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m >> q;
fill(A.begin(), A.end(), 0);
A[0] = 1;
int prv = 1;
for (int tmpcnt = (0); tmpcnt < (q); ++tmpcnt) {
int TP;
cin >> TP;
int x, y, t;
cin >> x >> y >> t;
--x;
--y;
if (TP == 1) {
move(t - prv);
prv = t;
cout << A[first(x, y)] << '\n';
}
if (TP == 2) {
move(t - prv);
prv = t;
cat[x][y] = 1;
A[first(x, y)] = 0;
}
if (TP == 3) {
move(t - prv);
prv = t;
cat[x][y] = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
const long long M = 1e9 + 7;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int n, m, q, tp;
class matrix {
public:
long long m[N][N];
matrix() { memset(m, 0, sizeof m); }
matrix operator*(matrix b) {
matrix tor;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
tor.m[i][j] = 0;
for (int k = 0; k < N; ++k) {
tor.m[i][j] = (tor.m[i][j] + m[i][k] * b.m[k][j]) % M;
}
}
}
return tor;
}
};
matrix ONE;
matrix pow(matrix m, int p) {
if (p == 0) {
return ONE;
}
matrix ret = pow(m, p / 2);
ret = ret * ret;
if (p & 1) {
ret = ret * m;
}
return ret;
}
bool good(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < m); }
matrix edge;
int cat[N][N];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < N; ++i) {
ONE.m[i][i] = 1;
}
matrix cur;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
edge.m[i * m + j][i * m + j] = 1;
for (int k = 0; k < 4; ++k) {
int ni = i + dx[k];
int nj = j + dy[k];
if (good(ni, nj)) {
edge.m[i * m + j][ni * m + nj] = 1;
}
}
}
}
cur = ONE;
int last = 1;
for (int i = 0; i < q; ++i) {
int x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
--x;
--y;
cur = cur * pow(edge, t - last);
if (tp == 1) {
printf("%I64d\n", cur.m[0][x * m + y]);
}
if (tp == 2) {
edge.m[x * m + y][x * m + y] = 0;
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (good(nx, ny)) {
edge.m[x * m + y][nx * m + ny] = 0;
edge.m[nx * m + ny][x * m + y] = 0;
}
}
cat[x][y] = 1;
}
if (tp == 3) {
edge.m[x * m + y][x * m + y] = 1;
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (good(nx, ny) && !cat[nx][ny]) {
edge.m[x * m + y][nx * m + ny] = 1;
edge.m[nx * m + ny][x * m + y] = 1;
}
}
cat[x][y] = 0;
}
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long x, long long p, long long M) {
long long ret = 1;
while (p) {
if (p & 1) ret = ret * x % M;
x = x * x % M;
p /= 2;
}
return ret;
}
long long n, m, N;
long long dp[2][25];
long long mark[50][50];
vector<vector<long long> > cnt;
vector<vector<long long> > mult(vector<vector<long long> > a,
vector<vector<long long> > b) {
vector<vector<long long> > ret(N, vector<long long>(N, 0));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
ret[i][j] = 0;
for (int k = 0; k < N; k++)
ret[i][j] = (ret[i][j] + a[i][k] * b[k][j] % 1000000007) % 1000000007;
}
return ret;
}
vector<vector<long long> > matpow(vector<vector<long long> > x, long long p) {
vector<vector<long long> > ret(N, vector<long long>(N, 0));
for (int i = 0; i < N; i++) ret[i][i] = 1;
while (p) {
if (p & 1) ret = mult(ret, x);
x = mult(x, x);
p /= 2;
}
return ret;
}
void update(int cur, int prv) {
for (int i = 0; i < N; i++) {
dp[cur][i] = 0;
for (int j = 0; j < N; j++)
dp[cur][i] = (dp[cur][i] + dp[prv][j] * cnt[i][j]) % 1000000007;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
N = n * m;
long long q;
cin >> q;
long long tp, x, y, t;
long long T = 1;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int cur, prv;
cur = 0;
prv = 1;
while (q--) {
cin >> tp >> x >> y >> t;
x--;
y--;
swap(cur, prv);
vector<vector<long long> > tmp(N, vector<long long>(N, 0));
for (int i = 0; i < N; i++)
for (int j = i; j < N; j++) {
int x1, y1, x2, y2;
x1 = i / m;
y1 = i % m;
x2 = j / m;
y2 = j % m;
if (abs(x1 - x2) + abs(y1 - y2) <= 1 && !mark[x1][y1] &&
!mark[x2][y2]) {
tmp[i][j] = 1;
tmp[j][i] = 1;
}
}
cnt = matpow(tmp, t - T);
update(cur, prv);
if (tp == 1)
cout << dp[cur][x * m + y] << "\n";
else if (tp == 2)
mark[x][y]++, dp[cur][x * m + y] = 0;
else if (tp == 3)
mark[x][y]--;
T = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int sz;
struct Matrix {
long long x[22][22];
void print() {
for (int i = 0, _a = (sz); i < _a; i++) {
for (int j = 0, _a = (sz); j < _a; j++) cout << x[i][j] << ' ';
cout << endl;
}
cout << endl;
}
} A, I;
struct Vector {
long long x[22];
void print() {
{
cout << "x"
<< " = ";
for (int _ = 0, _a = (sz); _ < _a; _++) cout << x[_] << ' ';
cout << endl;
};
}
} f;
Vector update(const Vector& f, const Matrix& A) {
Vector res;
for (int i = 0, _a = (sz); i < _a; i++) {
res.x[i] = 0;
for (int j = 0, _a = (sz); j < _a; j++)
res.x[i] = (res.x[i] + A.x[i][j] * f.x[j]) % MOD;
}
return res;
}
Matrix operator*(const Matrix& a, const Matrix& b) {
Matrix res;
for (int i = 0, _a = (sz); i < _a; i++)
for (int j = 0, _a = (sz); j < _a; j++) {
res.x[i][j] = 0;
for (int k = 0, _a = (sz); k < _a; k++)
res.x[i][j] = (res.x[i][j] + a.x[i][k] * b.x[k][j]) % MOD;
}
return res;
}
Matrix power(Matrix a, int k) {
Matrix res = I;
while (k) {
if (k & 1) res = res * a;
a = a * a;
k >>= 1;
}
return res;
}
const int MN = 22;
int m, n, q, id[MN][MN];
const int di[5] = {-1, 1, 0, 0, 0};
const int dj[5] = {0, 0, -1, 1, 0};
bool outside(int u, int v) { return u < 1 || v < 1 || u > m || v > n; }
void init() {
int cur = 0;
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++) id[i][j] = cur++;
memset(I.x, 0, sizeof I.x);
memset(A.x, 0, sizeof A.x);
sz = m * n;
for (int i = 0, _a = (sz); i < _a; i++) I.x[i][i] = 1;
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++) {
for (int dir = 0, _a = (5); dir < _a; dir++) {
int ii = i + di[dir], jj = j + dj[dir];
if (outside(ii, jj)) continue;
A.x[id[i][j]][id[ii][jj]] = 1;
}
}
}
int main() {
ios ::sync_with_stdio(false);
while (cin >> m >> n >> q) {
init();
memset(f.x, 0, sizeof f.x);
f.x[0] = 1;
int cur_time = 1;
while (q--) {
int typ;
cin >> typ;
int x, y, t;
cin >> x >> y >> t;
Matrix up = power(A, t - 1 - cur_time);
f = update(f, up);
if (typ == 2) {
for (int dir = 0, _a = (5); dir < _a; dir++) {
int xx = x + di[dir], yy = y + dj[dir];
if (outside(xx, yy)) continue;
A.x[id[x][y]][id[xx][yy]] = 0;
}
}
f = update(f, A);
if (typ == 1) {
cout << (int)f.x[id[x][y]] << '\n';
}
cur_time = t;
if (typ == 3) {
for (int dir = 0, _a = (5); dir < _a; dir++) {
int xx = x + di[dir], yy = y + dj[dir];
if (outside(xx, yy)) continue;
A.x[id[x][y]][id[xx][yy]] = 1;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
inline bool valid(int i, int j) {
if (i < 0 || i >= n || j < 0 || j >= m) return false;
return true;
}
inline int f(int i, int j) {
int x = i * (m) + j;
return x;
}
void print(vector<vector<long long> > a) {
cout << endl;
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
cout << endl;
}
}
vector<vector<long long> > iden(int n) {
vector<vector<long long> > a;
a.resize(n);
for (int i = 0; i < n; i++) a[i].assign(n, 0);
for (int i = 0; i < n; i++) a[i][i] = 1;
return a;
}
vector<vector<long long> > iden2(int n) {
vector<vector<long long> > a;
a.resize(n);
for (int i = 0; i < n; i++) a[i].assign(n, 0);
for (int i = 0; i < n; i++) a[i][i] = 0;
return a;
}
vector<vector<long long> > matrixmulti(vector<vector<long long> > m1,
vector<vector<long long> > m2) {
vector<vector<long long> > m3;
int a = m1.size(), b = m1[0].size(), c = m2.size(), d = m2[0].size();
if (b != c) cout << "CANNOT MULTIPLY" << endl;
m3.resize(a);
for (int i = 0; i < a; i++) m3[i].assign(d, 0);
for (int i = 0; i < a; i++) {
for (int j = 0; j < d; j++) {
m3[i][j] = 0;
for (int k = 0; k < b; k++)
m3[i][j] =
(m3[i][j] + (m1[i][k] * 1ll * m2[k][j]) % (long long)(1e9 + 7)) %
(long long)(1e9 + 7);
}
}
return m3;
}
vector<vector<long long> > matrixpower(vector<vector<long long> > a, int n) {
if (n == 0) return iden(a.size());
vector<vector<long long> > res = iden(a.size());
vector<vector<long long> > b = a;
while (n) {
if (n & 1) res = matrixmulti(res, b);
b = matrixmulti(b, b);
n >>= 1;
}
return res;
}
vector<vector<long long> > make(int k) {
vector<vector<long long> > res;
res.resize(k);
for (int i = 0; i < k; i++) res[i].assign(k, 0);
for (int i = 0; i < k; i++) {
int a, b;
if (m != 1)
b = i % m;
else
b = 0;
a = (i - b) / (m);
res[i][i] = 1;
if (valid(a + 1, b)) {
res[i][f(a + 1, b)] = 1;
}
if (valid(a - 1, b)) {
res[i][f(a - 1, b)] = 1;
}
if (valid(a, b + 1)) {
res[i][f(a, b + 1)] = 1;
}
if (valid(a, b - 1)) {
res[i][f(a, b - 1)] = 1;
}
}
return res;
}
vector<vector<long long> > makebase(int k = 3) {
vector<vector<long long> > res;
res.resize(k);
for (int i = 0; i < k; i++) {
res[i].resize(1);
res[i][0] = 0;
}
res[1][0] = 1;
return res;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
int k = m * n;
int q;
scanf("%d", &q);
vector<vector<long long> > res = make(k);
vector<vector<long long> > ans;
ans.resize(1);
ans[0].assign(k, 0);
ans[0][0] = 1;
int cur = 1;
while (q--) {
int tp;
scanf("%d", &tp);
int x, y, t;
scanf("%d", &x);
scanf("%d", &y);
scanf("%d", &t);
x--;
y--;
if (tp == 1) {
vector<vector<long long> > B = matrixpower(res, t - cur);
ans = matrixmulti(ans, B);
int num = (int)ans[0][f(x, y)];
cur = t;
printf("%d\n", num);
} else if (tp == 2) {
int num = f(x, y);
int pw = t - cur;
vector<vector<long long> > B = matrixpower(res, pw - 1);
ans = matrixmulti(ans, B);
for (int i = 0; i < k; i++) res[i][num] = 0;
ans = matrixmulti(ans, res);
cur = t;
} else if (tp == 3) {
int num = f(x, y);
int pw = t - cur;
vector<vector<long long> > B = matrixpower(res, pw);
ans = matrixmulti(ans, B);
res[num][num] = 1;
int a = x, b = y;
if (valid(a + 1, b)) res[f(a + 1, b)][num] = 1;
if (valid(a - 1, b)) res[f(a - 1, b)][num] = 1;
if (valid(a, b + 1)) res[f(a, b + 1)][num] = 1;
if (valid(a, b - 1)) res[f(a, b - 1)][num] = 1;
cur = t;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long L(long long x) { return x >= 1000000007 ? x % 1000000007 : x; }
struct matrix {
int N, M;
long long a[22][22];
matrix() {}
matrix(const matrix& A) {
N = A.N, M = A.M;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) a[i][j] = A.a[i][j];
}
matrix& operator=(const matrix& A) {
N = A.N, M = A.M;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) a[i][j] = A.a[i][j];
return *this;
}
void init(int _N, int _M) {
N = _N, M = _M;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) a[i][j] = 0;
}
matrix operator*(const matrix& A) const {
matrix ret;
ret.init(N, A.M);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= A.M; j++)
for (int k = 1; k <= M; k++)
ret.a[i][j] = L(ret.a[i][j] + L(a[i][k] * A.a[k][j]));
return ret;
}
matrix operator^(long long x) const {
matrix ret, A(*this);
ret.init(N, N);
for (int i = 1; i <= N; i++) ret.a[i][i] = 1;
while (x) {
if (x & 1) ret = ret * A;
A = A * A;
x >>= 1;
}
return ret;
}
};
int n, m, q, a[10002][4];
matrix A, DP;
int gt(int i, int j) { return (i - 1) * m + j; }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= q; i++) {
for (int j = 0; j < 4; j++) scanf("%d", &a[i][j]);
if (a[i][0] == 2) a[i][3]--;
}
a[0][3] = 1;
A.init(n * m, 1);
A.a[gt(1, 1)][1] = 1;
DP.init(n * m, n * m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i > 1) DP.a[gt(i, j)][gt(i - 1, j)] = 1;
if (i < n) DP.a[gt(i, j)][gt(i + 1, j)] = 1;
if (j > 1) DP.a[gt(i, j)][gt(i, j - 1)] = 1;
if (j < m) DP.a[gt(i, j)][gt(i, j + 1)] = 1;
DP.a[gt(i, j)][gt(i, j)] = 1;
}
}
for (int qq = 1; qq <= q; qq++) {
A = (DP ^ (a[qq][3] - a[qq - 1][3])) * A;
int i = a[qq][1], j = a[qq][2];
if (a[qq][0] == 1) {
printf("%lld\n", A.a[gt(i, j)][1]);
}
if (a[qq][0] == 2) {
if (i > 1) DP.a[gt(i, j)][gt(i - 1, j)] = 0;
if (i < n) DP.a[gt(i, j)][gt(i + 1, j)] = 0;
if (j > 1) DP.a[gt(i, j)][gt(i, j - 1)] = 0;
if (j < m) DP.a[gt(i, j)][gt(i, j + 1)] = 0;
DP.a[gt(i, j)][gt(i, j)] = 0;
}
if (a[qq][0] == 3) {
if (i > 1) DP.a[gt(i, j)][gt(i - 1, j)] = 1;
if (i < n) DP.a[gt(i, j)][gt(i + 1, j)] = 1;
if (j > 1) DP.a[gt(i, j)][gt(i, j - 1)] = 1;
if (j < m) DP.a[gt(i, j)][gt(i, j + 1)] = 1;
DP.a[gt(i, j)][gt(i, j)] = 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 0}, dy[] = {0, 1, 0, -1, 0};
const int mod = 1e9 + 7;
struct mat {
int n;
vector<vector<int>> f;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
mat(int _n) {
n = _n;
f.assign(n, vector<int>(n, 0));
}
mat one() {
mat res(n);
for (int i = 0; i < n; i++) res.f[i][i] = 1;
return res;
}
mat operator*(const mat &m) {
mat res(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
add(res.f[i][k], (long long)f[i][j] * m.f[j][k] % mod);
return res;
}
mat binpow(int k) {
mat res = one();
mat n = (*this);
while (k > 0) {
if (k & 1) res = res * n;
n = n * n;
k >>= 1;
}
return res;
}
void print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << f[i][j] << " ";
cout << endl;
}
cout << endl;
}
};
int n, m, q;
bool a[25][25];
bool check(int i, int j) {
return 0 <= min(i, j) && i < n && j < m && !a[i][j];
}
int id(int i, int j) { return i * m + j; }
void add(int i, int j, int val, mat &mul) {
int x = id(i, j);
for (int dir = 0; dir < 5; dir++) {
int u = i + dx[dir];
int v = j + dy[dir];
int y = id(u, v);
if (check(u, v)) mul.f[x][y] = mul.f[y][x] = val;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
mat base(n * m);
base.f[0][0] = 1;
mat mul(n * m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) add(i, j, 1, mul);
for (int cur = 1; q > 0; q--) {
int op, i, j, t;
cin >> op >> i >> j >> t;
i--;
j--;
base = base * mul.binpow(t - cur);
cur = t;
if (op == 2) {
a[i][j] = true;
add(i, j, 0, mul);
base.f[0][id(i, j)] = 0;
} else if (op == 3) {
a[i][j] = false;
add(i, j, 1, mul);
} else
cout << base.f[0][id(i, j)] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
struct Matrix {
int a[25][25];
} now;
bool bz[25][25];
int n, m, q, last;
const int D[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
inline int calc(int x, int y) { return (x - 1) * m + y; }
Matrix mul(Matrix x, Matrix y) {
Matrix z;
memset(z.a, 0, sizeof(z.a));
for (int i = 1; i <= n * m; ++i)
for (int k = 1; k <= n * m; ++k)
for (int j = 1; j <= n * m; ++j)
z.a[i][j] = (z.a[i][j] + x.a[i][k] * 1ll * y.a[k][j]) % 1000000007;
return z;
}
Matrix pow(Matrix x, int y) {
Matrix ret;
memset(ret.a, 0, sizeof(ret.a));
for (int i = 1; i <= n * m; ++i) ret.a[i][i] = 1;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) ret = mul(ret, x);
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
last = 1;
for (int i = 1; i <= n * m; ++i) now.a[i][i] = 1;
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
Matrix tmp;
memset(tmp.a, 0, sizeof(tmp.a));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
for (int k = 0; k < 4; ++k) {
int xx = i + D[k][0], yy = j + D[k][1];
if (xx <= 0 || yy <= 0 || xx > n || yy > m) continue;
if (bz[i][j] || bz[xx][yy])
tmp.a[calc(i, j)][calc(xx, yy)] = 0;
else
tmp.a[calc(i, j)][calc(xx, yy)] = 1;
}
if (bz[i][j])
tmp.a[calc(i, j)][calc(i, j)] = 0;
else
tmp.a[calc(i, j)][calc(i, j)] = 1;
}
}
now = mul(now, pow(tmp, t - last));
if (tp == 1) printf("%d\n", now.a[1][calc(x, y)]);
if (tp == 2) bz[x][y] = 1;
if (tp == 3) bz[x][y] = 0;
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
vector<vector<long long> > multiply(const vector<vector<long long> > &A,
const vector<vector<long long> > &B) {
assert(A[0].size() == B.size());
vector<vector<long long> > C(A.size(), vector<long long>(B[0].size()));
for (long long i = 0; i < A.size(); i++) {
for (long long j = 0; j < B[0].size(); j++) {
for (long long k = 0; k < B.size(); k++) {
C[i][j] += A[i][k] * B[k][j];
C[i][j] %= MOD;
}
}
}
return C;
}
vector<vector<long long> > power(const vector<vector<long long> > &A,
long long p) {
assert(p >= 1);
if (p == 1) return A;
if (p % 2 == 1) return multiply(power(A, p - 1), A);
return power(multiply(A, A), p / 2);
}
long long n, m;
vector<char> used(20, false);
void delcat(vector<vector<long long> > &mat, long long x, long long y) {
long long pos = m * x + y;
used[pos] = false;
for (long long i = 0; i < n * m; i++) {
long long nx = i / m, ny = i % m;
if (abs(nx - x) + abs(ny - y) <= 1 && !used[i]) {
mat[pos][i] = mat[i][pos] = 1;
}
}
}
void addcat(vector<vector<long long> > &mat, long long x, long long y) {
long long pos = m * x + y;
used[pos] = true;
for (long long i = 0; i < n * m; i++) {
mat[pos][i] = mat[i][pos] = 0;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long q;
cin >> n >> m >> q;
vector<vector<long long> > v(n * m, vector<long long>(1));
v[0][0] = 1;
vector<vector<long long> > mat(n * m, vector<long long>(n * m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
delcat(mat, i, j);
}
}
long long prevt = 1;
for (long long times = 0; times < q; times++) {
long long tp, x, y, curt;
cin >> tp >> x >> y >> curt;
x--;
y--;
if (curt > prevt) {
v = multiply(power(mat, curt - prevt), v);
prevt = curt;
}
if (tp == 1) {
cout << v[x * m + y][0] << '\n';
} else if (tp == 2) {
addcat(mat, x, y);
} else {
delcat(mat, x, y);
}
}
}
|
#include <bits/stdc++.h>
struct mat {
int a[25][25];
} now;
bool bz[25][25];
int n, m, q, last;
const int D[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
inline int calc(int x, int y) { return (x - 1) * m + y; }
mat mul(mat x, mat y) {
mat z;
memset(z.a, 0, sizeof(z.a));
for (int i = 1; i <= n * m; ++i)
for (int k = 1; k <= n * m; ++k)
for (int j = 1; j <= n * m; ++j)
z.a[i][j] = (z.a[i][j] + x.a[i][k] * 1ll * y.a[k][j]) % 1000000007;
return z;
}
mat pow(mat x, int y) {
mat ret;
memset(ret.a, 0, sizeof(ret.a));
for (int i = 1; i <= n * m; ++i) ret.a[i][i] = 1;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) ret = mul(ret, x);
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
last = 1;
for (int i = 1; i <= n * m; ++i) now.a[i][i] = 1;
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
mat tmp;
memset(tmp.a, 0, sizeof(tmp.a));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
for (int k = 0; k < 4; ++k) {
int xx = i + D[k][0], yy = j + D[k][1];
if (xx <= 0 || yy <= 0 || xx > n || yy > m) continue;
if (bz[i][j] || bz[xx][yy])
tmp.a[calc(i, j)][calc(xx, yy)] = 0;
else
tmp.a[calc(i, j)][calc(xx, yy)] = 1;
}
if (bz[i][j])
tmp.a[calc(i, j)][calc(i, j)] = 0;
else
tmp.a[calc(i, j)][calc(i, j)] = 1;
}
}
now = mul(now, pow(tmp, t - last));
if (tp == 1) printf("%d\n", now.a[1][calc(x, y)]);
if (tp == 2) bz[x][y] = 1;
if (tp == 3) bz[x][y] = 0;
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, q, t = 1;
long long mul(long long a, long long b) {
return (a * b) % ((long long)1e9 + 7);
}
vector<vector<long long> > mult(const vector<vector<long long> >& a,
const vector<vector<long long> >& b) {
vector<vector<long long> > v(a.size(), vector<long long>(b[0].size()));
for (long long i = 0; i < a.size(); i++)
for (long long j = 0; j < b[0].size(); j++)
for (long long k = 0; k < a[0].size(); k++)
v[i][j] = ((mul(a[i][k], b[k][j]) + v[i][j])) % ((long long)1e9 + 7);
return v;
}
vector<vector<long long> > pow(const vector<vector<long long> >& v,
long long p) {
if (p == 0) {
vector<vector<long long> > pp(v.size(), vector<long long>(v.size()));
for (long long i = 0; i < pp.size(); i++) pp[i][i] = 1;
return pp;
}
if (p == 1) return v;
if (p % 2 == 1)
return mult(pow(v, p - 1), v);
else
return pow(mult(v, v), p / 2);
}
long long f(long long i, long long j) { return m * (i - 1) + j - 1; }
void fill(const vector<vector<long long> >& c, vector<vector<long long> >& a) {
a.assign(a.size(), vector<long long>(a[0].size(), 0));
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (c[i][j] == 0) continue;
k = f(i, j);
a[k][k] = 1;
if (i > 1) {
a[k][k - m] = 1;
}
if (i < n) {
a[k][k + m] = 1;
}
if (j > 1) {
a[k][k - 1] = 1;
}
if (j < m) {
a[k][k + 1] = 1;
}
}
}
void print(vector<vector<long long> >& v) {
cout << endl << endl << endl;
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < v[0].size(); j++) cout << v[i][j] << " ";
cout << endl;
}
cout << endl << endl << endl;
}
int main() {
cin >> n >> m >> q;
vector<vector<long long> > v(n * m, vector<long long>(1, 0));
v[0][0] = 1;
vector<vector<long long> > a(n * m, vector<long long>(n * m, 0));
vector<vector<long long> > c(n + 1, vector<long long>(m + 1, 1));
fill(c, a);
int time = 1;
vector<vector<long long> > b;
while (q--) {
long long t, x, y, pt;
cin >> t >> x >> y >> pt;
if (t == 1) {
b = pow(a, pt - time);
time = pt;
v = mult(b, v);
cout << v[f(x, y)][0] << endl;
}
if (t == 2) {
b = pow(a, pt - time);
time = pt;
v = mult(b, v);
c[x][y] = 0;
fill(c, a);
v[f(x, y)][0] = 0;
}
if (t == 3) {
b = pow(a, pt - time);
time = pt;
v = mult(b, v);
c[x][y] = 1;
fill(c, a);
v[f(x, y)][0] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
const int MOD = 1000000007;
const int dir[5][2] = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int h, w, n, Q;
bool book[N][N];
struct Matrix {
int n, m;
long long mat[N][N];
Matrix() {
memset(mat, 0, sizeof(mat));
return;
}
Matrix operator*(const Matrix &b) const {
Matrix res;
res.n = n, res.m = b.m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= b.m; j++)
for (int k = 1; k <= m; k++)
res.mat[i][j] = (res.mat[i][j] + mat[i][k] * b.mat[k][j] % MOD) % MOD;
return res;
}
friend Matrix ksm(Matrix a, long long b) {
Matrix res;
res.n = a.n, res.m = a.n;
for (int i = 1; i <= a.n; i++) res.mat[i][i] = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a, b >>= 1;
}
return res;
}
};
void build(Matrix &a) {
memset(a.mat, 0, sizeof(a.mat));
for (int i = 1; i <= h; i++)
for (int j = 1; j <= w; j++)
if (book[i][j])
for (int k = 0; k <= 4; k++) {
int x = i + dir[k][0], y = j + dir[k][1];
if (x < 1 || x > h || y < 1 || y > w) continue;
if (!book[x][y]) continue;
a.mat[(i - 1) * w + j][(x - 1) * w + y] = 1;
}
return;
}
int main() {
scanf("%d%d%d", &h, &w, &Q);
n = h * w;
int now = 1;
Matrix ans, a;
ans.n = n, ans.m = 1;
a.n = n, a.m = n;
ans.mat[1][1] = 1;
memset(book, true, sizeof(book));
while (Q--) {
int op, x, y, t;
scanf("%d%d%d%d", &op, &x, &y, &t);
build(a);
ans = (ksm(a, t - now)) * ans;
now = t;
if (op == 1) printf("%lld\n", ans.mat[(x - 1) * w + y][1]);
if (op == 2) ans.mat[(x - 1) * w + y][1] = 0, book[x][y] = false;
if (op == 3) ans.mat[(x - 1) * w + y][1] = 0, book[x][y] = true;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 25;
int q, h[N], n, m, x, y, z, yon[5][2] = {{0, 1}, {-1, 0}, {1, 0}, {0, -1}}, t,
all, p, fg;
int take(int x, int y) { return (x - 1) * m + y - 1; }
class matrix {
public:
vector<vector<int> > v;
matrix() {
v.resize(21);
for (int i = 0; i <= 20; i++) v[i].resize(21, 0);
}
vector<int>& operator[](int x) { return v[x]; }
matrix operator*(matrix x) {
matrix ans;
for (int i = 0; i <= all; i++)
for (int j = 0; j <= all; j++)
for (int k = 0; k <= all; k++)
ans[i][j] = (ans[i][j] + (long long)x[i][k] * v[k][j] % mod) % mod;
return ans;
}
} M;
void move(int x) {
matrix C;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int q = 0; q <= 4; q++) {
int x = i + yon[q][0], y = j + yon[q][1];
if (x < 1 || x > n || y < 1 || y > m || h[take(x, y)] || h[take(i, j)])
continue;
C[take(i, j)][take(x, y)] = 1;
}
while (x) {
if (x & 1) M = C * M;
C = C * C;
x >>= 1;
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
int last = 1;
all = n * m - 1;
for (int i = 0; i <= all; i++) M[i][i] = 1;
for (int i = 1; i <= q; i++) {
scanf("%d %d %d %d", &t, &x, &y, &z);
move(z - last);
last = z;
if (t == 1) printf("%d\n", M[take(1, 1)][take(x, y)]);
if (t == 2) h[take(x, y)] = 1;
if (t == 3) h[take(x, y)] = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m, nn, q;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool cat[30][30];
struct Matrix {
int a[22][22]{};
} ans, base;
int main() {
auto add = [&](int &x, int y) {
x += y;
if (x >= mod) x -= mod;
};
auto mul = [&](Matrix a, Matrix b) {
Matrix c;
for (int i = 0; i < nn; i++) {
for (int j = 0; j < nn; j++) {
for (int k = 0; k < nn; k++) {
add(c.a[i][j], a.a[i][k] * 1ll * b.a[k][j] % mod);
}
}
}
return c;
};
auto qpow = [&](int b) {
for (; b; b >>= 1, base = mul(base, base))
if (b & 1) ans = mul(base, ans);
};
auto build = [&] {
memset(base.a, 0, sizeof base.a);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int id = i * m + j;
base.a[id][id] = 1;
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
int id1 = nx * m + ny;
base.a[id][id1] = cat[i][j] == 0 && cat[nx][ny] == 0;
}
}
}
}
};
scanf("%d %d %d", &n, &m, &q);
ans.a[0][0] = 1;
nn = n * m;
int nowt = 1;
while (q--) {
build();
int op, x, y, t;
scanf("%d %d %d %d", &op, &x, &y, &t);
x--;
y--;
qpow(t - nowt);
nowt = t;
if (op == 1)
printf("%d\n", ans.a[x * m + y][0]);
else if (op == 2)
cat[x][y] = true, ans.a[x * m + y][0] = 0;
else
cat[x][y] = false, ans.a[x * m + y][0] = 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct matrix {
long long a[41][41];
} ans;
int n, m, q, tot;
long long safe(long long n) {
if (n < 0) n += (((-n) / 1000000007 + 1) * 1000000007);
if (n >= 1000000007) n %= 1000000007;
return n;
}
matrix cal(matrix a, matrix b) {
matrix ans;
for (int i = 0; i < tot; i++)
for (int j = 0; j < tot; j++) {
ans.a[i][j] = 0;
for (int k = 0; k < tot; k++)
ans.a[i][j] = (ans.a[i][j] + safe(a.a[i][k] * b.a[k][j])) % 1000000007;
}
return ans;
}
matrix quickmod(matrix a, long long n) {
matrix ans;
memset(ans.a, 0, sizeof(ans.a));
for (int i = 0; i < tot; i++) ans.a[i][i] = 1;
while (n) {
if (n % 2) ans = cal(ans, a);
a = cal(a, a);
n /= 2;
}
return ans;
}
long long cal(long long x, long long y) {
if (x < 0 || x == n) return -1;
if (y < 0 || y == m) return -1;
return (x * m + y);
}
matrix v;
int pb(int x, int y) {
int id = cal(x, y);
if (id == -1) return 0;
if (v.a[id][id] == 1) return 0;
return 1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
tot = n * m;
long long pret = 1;
matrix ans, a;
memset(ans.a, 0, sizeof(ans.a));
memset(a.a, 0, sizeof(a.a));
memset(v.a, 0, sizeof(v.a));
for (int i = 0; i < tot; i++) ans.a[i][i] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int id = cal(i, j);
a.a[id][id] = 1;
if (cal(i + 1, j) != -1) a.a[id][cal(i + 1, j)] = 1;
if (cal(i - 1, j) != -1) a.a[id][cal(i - 1, j)] = 1;
if (cal(i, j - 1) != -1) a.a[id][cal(i, j - 1)] = 1;
if (cal(i, j + 1) != -1) a.a[id][cal(i, j + 1)] = 1;
}
for (int i = 0; i < q; i++) {
long long tp, x, y, t;
scanf("%lld%lld%lld%lld", &tp, &x, &y, &t);
x--;
y--;
if (tp == 1) {
ans = cal(ans, quickmod(a, t - pret));
printf("%lld\n", ans.a[0][cal(x, y)]);
}
if (tp == 2) {
ans = cal(ans, quickmod(a, t - pret));
int id = cal(x, y);
v.a[id][id] = 1;
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
ans.a[cal(j, k)][id] = a.a[cal(j, k)][id] = a.a[id][cal(j, k)] = 0;
}
if (tp == 3) {
ans = cal(ans, quickmod(a, t - pret));
int id = cal(x, y);
a.a[id][id] = 1;
v.a[id][id] = 0;
if (cal(x - 1, y) != -1 && pb(x - 1, y))
a.a[id][cal(x - 1, y)] = a.a[cal(x - 1, y)][id] = 1;
if (cal(x + 1, y) != -1 && pb(x + 1, y))
a.a[id][cal(x + 1, y)] = a.a[cal(x + 1, y)][id] = 1;
if (cal(x, y + 1) != -1 && pb(x, y + 1))
a.a[id][cal(x, y + 1)] = a.a[cal(x, y + 1)][id] = 1;
if (cal(x, y - 1) != -1 && pb(x, y - 1))
a.a[id][cal(x, y - 1)] = a.a[cal(x, y - 1)][id] = 1;
}
pret = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long n, m, q;
vector<vector<long long>> g;
long long mat[20][20];
long long hsh(long long x, long long y) { return x * m + y; }
const long long dx[] = {0, 0, -1, 1, 0}, dy[] = {-1, 1, 0, 0, 0};
void solve() {
memset(mat, 0, sizeof mat);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
for (long long d = 0; d < 5; d++) {
long long ii = i + dx[d], jj = j + dy[d];
if (ii < 0 || ii >= n || jj < 0 || jj >= m) continue;
if (g[ii][jj] == 0 && g[i][j] == 0) {
mat[hsh(i, j)][hsh(ii, jj)] = 1;
}
}
}
}
for (long long i = 0; i < n * m; i++) {
for (long long j = 0; j < n * m; j++) {
assert(mat[i][j] == mat[j][i]);
}
}
}
long long res[20][20];
void mul(long long a[20][20], long long b[20][20], long long c[20][20]) {
memset(res, 0, sizeof res);
for (long long i = 0; i < 20; i++) {
for (long long j = 0; j < 20; j++) {
for (long long k = 0; k < 20; k++) {
res[i][j] += (a[i][k] * b[k][j]) % MOD;
res[i][j] %= MOD;
}
}
}
for (long long i = 0; i < 20; i++) {
for (long long j = 0; j < 20; j++) {
c[i][j] = res[i][j];
}
}
}
long long ret[20][20];
void Exp(long long k, long long a[20][20]) {
while (k) {
if (k & 1) {
mul(ret, a, ret);
}
mul(a, a, a);
k /= 2;
}
}
signed main() {
cin >> n >> m >> q;
g = vector<vector<long long>>(n, vector<long long>(m));
long long lstT = 1;
for (long long i = 0; i < 20; i++) ret[i][i] = 1;
while (q--) {
long long T, X, Y, Z;
cin >> T >> X >> Y >> Z;
X--;
Y--;
solve();
Exp(Z - lstT, mat);
if (T == 1) {
cout << ret[0][hsh(X, Y)] << "\n";
} else {
g[X][Y] ^= 1;
}
lstT = Z;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long p) {
long long res = 1;
a %= p;
for (; b; b >>= 1) {
if (b & 1) res = res * a % p;
a = a * a % p;
}
return res;
}
template <typename T>
T gcd(T x, T y) {
while (y) {
T t = x % y;
x = y;
y = t;
}
return x;
}
template <typename T>
T lsM(T x, T y) {
return x / gcd(x, y) * y;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int n, m, mp[25][25];
struct mat {
int a[25][25];
} now;
mat mul(mat x, mat y) {
mat z;
memset(z.a, 0, sizeof z.a);
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++)
for (int k = 1; k <= n * m; k++) {
z.a[i][j] = (z.a[i][j] + 1LL * x.a[i][k] * y.a[k][j]) % 1000000007;
}
return z;
}
mat power(mat x, int y) {
mat res;
memset(res.a, 0, sizeof res.a);
for (int i = 1; i <= n * m; i++) res.a[i][i] = 1;
while (y) {
if (y & 1) res = mul(res, x);
x = mul(x, x);
y >>= 1;
}
return res;
}
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int id(int x, int y) { return (x - 1) * m + y; }
int main() {
int q;
scanf("%d%d%d", &n, &m, &q);
int lst = 1;
memset(now.a, 0, sizeof now.a);
for (int i = 1; i <= n * m; i++) now.a[i][i] = 1;
while (q--) {
int typ, x, y, t;
scanf("%d%d%d%d", &typ, &x, &y, &t);
mat tmp;
memset(tmp.a, 0, sizeof tmp.a);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx < 1 || nx > n || ny < 1 || ny > m || mp[i][j] || mp[nx][ny])
continue;
tmp.a[id(i, j)][id(nx, ny)] = 1;
}
if (!mp[i][j]) tmp.a[id(i, j)][id(i, j)] = 1;
}
now = mul(now, power(tmp, t - lst));
if (typ == 1)
printf("%d\n", now.a[1][id(x, y)]);
else if (typ == 2)
mp[x][y] = 1;
else
mp[x][y] = 0;
lst = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dr[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dc[] = {0, -1, 0, 1, -1, 1, -1, 1};
int const MAX = 100 + 7;
int const MOD = 1e9 + 7;
class matrix {
public:
vector<vector<long long>> mat;
matrix(long long n, long long m, long long num = -1) {
mat.resize(n);
if (num == -1)
for (int i = 0; i < n; ++i) {
mat[i].resize(m, 0);
mat[i][i] = 1;
}
else
for (int i = 0; i < n; ++i) mat[i].resize(m, num);
}
static vector<vector<long long>> multi_matrix(vector<vector<long long>> a,
vector<vector<long long>> b) {
matrix c(a.size(), b[0].size(), 0);
for (int i = 0; i < a.size(); ++i)
for (int j = 0; j < b[0].size(); ++j) {
for (int k = 0; k < b.size(); ++k)
c.mat[i][j] += (a[i][k] * b[k][j]) % MOD, c.mat[i][j] %= MOD;
}
return c.mat;
}
static vector<vector<long long>> matrix_power(vector<vector<long long>> a,
long long k) {
if (k == 0) {
matrix c(a.size(), a.size());
return c.mat;
}
if (k % 2 == 1) return multi_matrix(a, matrix_power(a, k - 1));
return matrix_power(multi_matrix(a, a), k / 2);
}
};
int n, m, q, cat[22][22];
vector<vector<long long>> bulid() {
matrix G(n * m, n * m, 0);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (!cat[i][j]) {
G.mat[i * m + j][i * m + j] = 1;
for (int k = 0; k < 4; ++k)
if (i + dr[k] != -1 && j + dc[k] != -1 && i + dr[k] < n &&
j + dc[k] < m)
if (!cat[i + dr[k]][j + dc[k]])
G.mat[i * m + j][(i + dr[k]) * m + j + dc[k]] = 1;
}
return G.mat;
}
int main() {
cin >> n >> m >> q;
matrix G(n * m, n * m, 0), cur(n * m, n * m);
int last_time = 1;
for (int i = 0; i < q; ++i) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
x--, y--;
G.mat = bulid();
cur.mat = matrix::multi_matrix(cur.mat,
matrix::matrix_power(G.mat, t - last_time));
if (tp == 1) {
cout << cur.mat[0][x * m + y] % MOD << "\n";
} else
cat[x][y] ^= 1;
last_time = t;
}
}
|
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
using namespace std;
long long Trans[21][21];
int idx[21][21], n, m, sz;
int dx[] = {0, -1, 1, 0, 0};
int dy[] = {0, 0, 0, -1, 1};
long long ans[21];
long long MOD = 1e9 + 7;
long long I[21][21];
long long temp[21][21];
bool mark[21];
bool chk(int x, int y) {
if (x >= 0 && y >= 0 && y < m && x < n) return 1;
return 0;
}
void mult(long long a[][21], long long b[][21]) {
long long c[21][21];
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) {
c[i][j] = 0;
for (int k = 0; k < sz; k++) {
c[i][j] = (c[i][j] + (a[i][k] * b[k][j]) % MOD) % MOD;
}
}
}
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) a[i][j] = c[i][j];
}
}
void power_upd(int p) {
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) {
temp[i][j] = Trans[i][j];
}
}
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) {
if (i == j)
I[i][j] = 1;
else
I[i][j] = 0;
}
}
while (p > 0) {
if (p & 1) {
mult(I, temp);
}
mult(temp, temp);
p >>= 1;
}
long long d[21];
for (int i = 0; i < sz; i++) {
d[i] = 0;
for (int j = 0; j < sz; j++) {
d[i] = (d[i] + I[i][j] * ans[j]) % MOD;
}
}
for (int i = 0; i < sz; i++) ans[i] = d[i];
}
int main() {
int q;
cin >> n >> m >> q;
sz = n * m;
int cur = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
idx[i][j] = cur++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 5; k++) {
int ii = i + dx[k];
int jj = j + dy[k];
if (!chk(ii, jj)) continue;
Trans[idx[i][j]][idx[ii][jj]] = 1;
Trans[idx[ii][jj]][idx[i][j]] = 1;
}
}
}
cur = 1;
ans[0] = 1;
while (q--) {
int x, y, t, ty;
cin >> ty >> x >> y >> t;
power_upd(t - cur);
cur = t;
x--;
y--;
if (ty == 1) {
cout << ans[idx[x][y]] << endl;
} else if (ty == 2) {
int k = idx[x][y];
for (int i = 0; i < sz; i++) {
Trans[i][k] = 0;
Trans[k][i] = 0;
}
ans[k] = 0;
mark[k] = 1;
} else if (ty == 3) {
int k = idx[x][y];
mark[k] = 0;
for (int i = 0; i < 5; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (!chk(nx, ny)) continue;
int nk = idx[nx][ny];
if (!mark[nk]) Trans[k][nk] = Trans[nk][k] = 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 10;
const int MOD = 1e9 + 7;
const int INF = 1e9;
int n, m, q;
int mat[33][22][22];
int dp[22];
set<int> all;
int f(int i, int j) { return i * m + j; }
void mul(int res[22][22], int a[22][22], int b[22][22]) {
for (int i = 0; i < n * m; ++i) {
for (int j = 0; j < n * m; ++j) {
res[i][j] = 0;
for (int k = 0; k < n * m; ++k) {
res[i][j] = (res[i][j] + 1LL * a[i][k] * b[k][j]) % MOD;
}
}
}
}
void go(int step) {
for (int mask = 0; step != 0; ++mask) {
if (mask > 0) {
mul(mat[mask], mat[mask - 1], mat[mask - 1]);
}
if ((step >> mask) & 1) {
int ndp[22] = {};
for (int i = 0; i < n * m; ++i) {
for (int j = 0; j < n * m; ++j) {
ndp[j] = (ndp[j] + 1LL * dp[i] * mat[mask][i][j]) % MOD;
}
}
for (int i = 0; i < n * m; ++i) {
dp[i] = ndp[i];
}
step ^= 1 << mask;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
for (int di = -1; di <= 1; ++di) {
for (int dj = -1; dj <= 1; ++dj) {
if (abs(di) + abs(dj) > 1) {
continue;
}
int ni = i + di, nj = j + dj;
if (ni < 0 || ni >= n || nj < 0 || nj >= m) {
continue;
}
mat[0][f(i, j)][f(ni, nj)] = 1;
}
}
}
}
int last = 1;
dp[f(0, 0)] = 1;
while (q-- > 0) {
int type, x, y, t;
scanf("%d%d%d%d", &type, &x, &y, &t);
x--;
y--;
if (type == 2) {
go(t - last);
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
if (abs(dx) + abs(dy) > 1) {
continue;
}
int nx = x + dx, ny = y + dy;
if (nx < 0 || nx >= n || ny < 0 || ny >= m) {
continue;
}
mat[0][f(nx, ny)][f(x, y)] = 0;
mat[0][f(x, y)][f(nx, ny)] = 0;
}
}
all.insert(f(x, y));
dp[f(x, y)] = 0;
} else if (type == 3) {
go(t - last);
all.erase(f(x, y));
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
if (abs(dx) + abs(dy) > 1) {
continue;
}
int nx = x + dx, ny = y + dy;
if (nx < 0 || nx >= n || ny < 0 || ny >= m) {
continue;
}
if (!all.count(f(nx, ny))) {
mat[0][f(nx, ny)][f(x, y)] = 1;
mat[0][f(x, y)][f(nx, ny)] = 1;
}
}
}
} else {
go(t - last);
printf("%d\n", dp[f(x, y)]);
}
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DX[] = {-1, 0, 1, 0};
const int DY[] = {0, -1, 0, 1};
const int PRIME = 1000000007;
int n, m, q;
int cur_time = 1;
vector<long long> cur_x;
vector<bool> cats;
int event_type, event_x, event_y, event_time;
int coord_to_vindex(int r, int c) { return r * m + c; }
int coord_to_mindex(int r, int c) { return r * m * n + c; }
void dump_matrix(const vector<long long>& mat) {
for (int i = (0); i <= (int(n * m) - 1); ++i) {
for (int j = (0); j <= (int(n * m) - 1); ++j) {
cerr << mat[coord_to_mindex(i, j)] << " ";
}
cerr << "\n";
}
}
void dump_vector(const vector<long long>& vec) {
for (int i = (0); i <= (int(n * m) - 1); ++i) {
cerr << vec[i] << " ";
}
cerr << "\n";
}
vector<long long> make_matrix() {
vector<long long> result(n * m * n * m);
for (int i = (0); i <= (int(n) - 1); ++i) {
for (int j = (0); j <= (int(m) - 1); ++j) {
int matrix_row = coord_to_vindex(i, j);
if (cats[matrix_row]) {
continue;
}
result[coord_to_mindex(matrix_row, matrix_row)] = 1;
for (int k = (0); k <= (int(4) - 1); ++k) {
int ip = i + DY[k];
int jp = j + DX[k];
if (ip >= 0 && ip < n && jp >= 0 && jp < m) {
int matrix_col = coord_to_vindex(ip, jp);
result[coord_to_mindex(matrix_row, matrix_col)] = 1;
}
}
}
}
return result;
}
vector<long long> mult_matrix_matrix(const vector<long long>& a,
const vector<long long>& b) {
vector<long long> result(a.size());
for (int i = (0); i <= (int(m * n) - 1); ++i) {
for (int j = (0); j <= (int(m * n) - 1); ++j) {
for (int k = (0); k <= (int(m * n) - 1); ++k) {
result[coord_to_mindex(i, j)] +=
a[coord_to_mindex(i, k)] * b[coord_to_mindex(k, j)];
result[coord_to_mindex(i, j)] %= PRIME;
}
}
}
return result;
}
void exponentiate_matrix(vector<long long>* mat, int e) {
vector<vector<long long> > powers;
powers.push_back(*mat);
for (int i = 1; i <= e; i = 2 * i) {
powers.push_back(mult_matrix_matrix(powers[powers.size() - 1],
powers[powers.size() - 1]));
}
vector<long long> result(mat->size(), 0);
for (int i = (0); i <= (int(n * m) - 1); ++i) {
result[coord_to_mindex(i, i)] = 1;
}
for (int i = 0; e > 0; ++i) {
if (e & 0x1) {
result = mult_matrix_matrix(result, powers.at(i));
}
e >>= 1;
}
*mat = result;
}
vector<long long> mult_matrix_vector(const vector<long long>& mat,
const vector<long long>& v) {
vector<long long> result(v.size());
for (int i = (0); i <= (int(v.size()) - 1); ++i) {
for (int j = (0); j <= (int(v.size()) - 1); ++j) {
result[i] += mat[coord_to_mindex(i, j)] * v[j];
result[i] %= PRIME;
}
}
return result;
}
void move_to_event() {
vector<long long> mat = make_matrix();
exponentiate_matrix(&mat, event_time - cur_time);
cur_x = mult_matrix_vector(mat, cur_x);
cur_time = event_time;
}
void apply_event() {
int index = coord_to_vindex(event_x - 1, event_y - 1);
if (event_type == 1) {
cout << cur_x[index] << "\n";
} else if (event_type == 2) {
assert(cats[index] == false && "Cat appears twice?");
cats[index] = true;
cur_x[index] = 0;
} else if (event_type == 3) {
assert(cats[index] == true && "Cat disappears twice?");
cats[index] = false;
} else {
assert(false && "weird event type");
}
}
int main() {
cin >> n >> m >> q;
cur_x = vector<long long>(n * m, 0);
cur_x[0] = 1;
cats = vector<bool>(n * m, false);
for (int i = (0); i <= (int(q) - 1); ++i) {
cin >> event_type >> event_x >> event_y >> event_time;
move_to_event();
apply_event();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
void mulmat(int c[][32], int a[][32], int b[][32]) {
int t[32][32];
memset(t, 0, sizeof(t));
for (int i = 0, to = n; i < to; ++i)
for (int j = 0, to = n; j < to; ++j)
for (int k = 0, to = n; k < to; ++k)
t[i][j] += (1LL * a[i][k] * b[k][j]) % 1000000007,
t[i][j] %= 1000000007;
memcpy(c, t, sizeof(t));
}
void powmat(int c[][32], int a[][32], int e) {
int t[32][32], r[32][32];
memcpy(t, a, sizeof(t));
memset(r, 0, sizeof(r));
for (int i = 0, to = n; i < to; ++i) r[i][i] = 1;
while (e) {
if (e & 1) mulmat(r, r, t);
e >>= 1;
mulmat(t, t, t);
}
memcpy(c, r, sizeof(r));
}
int x[32][32], ox[32][32], w[32][32], w2[32][32];
int ni, nj, q;
int id(int i, int j) {
if (i < 0 || j < 0 || i >= ni || j >= nj) return 31;
return i * nj + j;
}
int main() {
scanf("%d%d%d", &ni, &nj, &q);
n = ni * nj;
for (int i = 0, to = ni; i < to; ++i) {
for (int j = 0, to = nj; j < to; ++j) {
ox[id(i, j)][id(i, j)] = 1;
ox[id(i, j)][id(i + 1, j)] = 1;
ox[id(i, j)][id(i - 1, j)] = 1;
ox[id(i, j)][id(i, j + 1)] = 1;
ox[id(i, j)][id(i, j - 1)] = 1;
}
}
memcpy(x, ox, sizeof(x));
for (int i = 0, to = n; i < to; ++i) w[i][i] = 1;
int t = 1;
while (q--) {
int o, a, b, tt;
scanf("%d%d%d%d", &o, &a, &b, &tt);
a = id(a - 1, b - 1);
if (o == 2) tt--;
powmat(w2, x, tt - t);
mulmat(w, w, w2);
if (o == 1) {
printf("%d\n", w[0][a]);
} else if (o == 2) {
for (int i = 0, to = n; i < to; ++i) x[i][a] = 0;
} else {
for (int i = 0, to = n; i < to; ++i) x[i][a] = ox[i][a];
}
t = tt;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct matrix {
int mat[25][25];
matrix() { memset(mat, 0, sizeof(mat)); }
void print(int n) {
int j, k;
for (j = 1; j <= n; j++) {
for (k = 1; k <= n; k++) {
printf("%d ", mat[j][k]);
}
printf("\n");
}
}
} A, B, C;
int rx[] = {0, 1, 0, -1, 0}, ry[] = {1, 0, -1, 0, 0};
int n, m;
bool mark[25];
matrix operator*(matrix a, matrix b) {
matrix ans;
int j, k, i;
for (j = 1; j <= n * m; j++) {
for (k = 1; k <= n * m; k++) {
for (i = 1; i <= n * m; i++) {
ans.mat[j][k] =
(ans.mat[j][k] + 1LL * a.mat[j][i] * b.mat[i][k] % 1000000007) %
1000000007;
}
}
}
return ans;
}
matrix operator^(matrix a, int b) {
matrix t = a, ans;
int j, k;
for (j = 1; j <= n * m; j++) ans.mat[j][j] = 1;
while (b) {
if (b & 1) ans = ans * t;
t = t * t;
b >>= 1;
}
return ans;
}
bool check(int x, int y, int n, int m) {
return x >= 1 && x <= n && y >= 1 && y <= m;
}
int main() {
int q;
scanf("%d%d%d", &n, &m, &q);
int j, k, i;
for (j = 1; j <= n; j++) {
for (k = 1; k <= m; k++) {
for (i = 0; i < 5; i++) {
int x = j + rx[i], y = k + ry[i];
if (!check(x, y, n, m)) continue;
int id = k + (j - 1) * m, id1 = y + (x - 1) * m;
B.mat[id][id1] = 1;
}
}
}
int pre = 1;
for (j = 1; j <= 20; j++) A.mat[j][j] = 1;
for (j = 0; j < q; j++) {
int op, x, y, t;
scanf("%d%d%d%d", &op, &x, &y, &t);
for (k = 1; k <= n * m; k++) {
for (i = 1; i <= n * m; i++) {
if (mark[k] || mark[i])
C.mat[k][i] = 0;
else
C.mat[k][i] = B.mat[k][i];
}
}
A = A * (C ^ (t - pre));
if (op == 1) {
printf("%d\n", A.mat[1][y + (x - 1) * m]);
} else if (op == 2)
mark[y + (x - 1) * m] = 1;
else
mark[y + (x - 1) * m] = 0;
pre = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > a;
long long mod = 1e9 + 7;
long long mul(long long a, long long b) { return (a * b) % mod; }
vector<long long> operator*(const vector<vector<long long> > &a,
const vector<long long> &b) {
vector<long long> ans(a.size(), 0);
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < b.size(); ++j) {
ans[i] = (ans[i] + mul(a[i][j], b[j])) % mod;
}
}
return ans;
}
vector<vector<long long> > operator*(const vector<vector<long long> > &a,
const vector<vector<long long> > &b) {
vector<vector<long long> > ans(a.size(), vector<long long>(b[0].size(), 0));
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < b[0].size(); ++j) {
for (int l = 0; l < a[0].size(); ++l) {
ans[i][j] = (ans[i][j] + mul(a[i][l], b[l][j])) % mod;
}
}
}
return ans;
}
vector<vector<long long> > bin_pow(const vector<vector<long long> > &a,
long long k) {
if (k == 0) {
vector<vector<long long> > E(a.size(), vector<long long>(a.size(), 0));
for (int i = 0; i < a.size(); ++i) E[i][i] = 1ll;
return E;
}
if (k % 2) {
return a * bin_pow(a, k - 1);
} else {
vector<vector<long long> > ans = bin_pow(a, k / 2);
return ans * ans;
}
}
long long n, m;
int main() {
long long q;
cin >> n >> m >> q;
long long s = n * m;
vector<vector<long long> > a(s, vector<long long>(s, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
a[i * m + j][i * m + j] = 1;
if (i != 0) {
a[(i - 1) * m + j][i * m + j] = 1;
}
if (i != n - 1) {
a[(i + 1) * m + j][i * m + j] = 1;
}
if (j != 0) {
a[i * m + j - 1][i * m + j] = 1;
}
if (j != m - 1) {
a[i * m + j + 1][i * m + j] = 1;
}
}
}
vector<long long> v(s, 0);
v[0] = 1;
long long tlast = 1;
for (int i = 0; i < q; ++i) {
long long p, x, y, t;
cin >> p >> x >> y >> t;
--x;
--y;
if (p == 1) {
v = bin_pow(a, t - tlast) * v;
cout << v[x * m + y] << endl;
}
if (p == 2) {
v = bin_pow(a, t - tlast) * v;
a[x * m + y][x * m + y] = 0;
if (x != 0) {
a[(x - 1) * m + y][x * m + y] = 0;
}
if (x != n - 1) {
a[(x + 1) * m + y][x * m + y] = 0;
}
if (y != 0) {
a[x * m + y - 1][x * m + y] = 0;
}
if (y != m - 1) {
a[x * m + y + 1][x * m + y] = 0;
}
}
if (p == 3) {
v = bin_pow(a, t - tlast) * v;
a[x * m + y][x * m + y] = 1;
if (x != 0) {
a[(x - 1) * m + y][x * m + y] = 1;
}
if (x != n - 1) {
a[(x + 1) * m + y][x * m + y] = 1;
}
if (y != 0) {
a[x * m + y - 1][x * m + y] = 1;
}
if (y != m - 1) {
a[x * m + y + 1][x * m + y] = 1;
}
v[x * m + y] = 0;
}
tlast = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct Mat {
vector<vector<int> > M;
Mat(int n = 0, int m = 0) { M.assign(n, vector<int>(m, 0)); }
vector<int>& operator[](int x) { return M[x]; }
int size() { return M.size(); }
};
Mat operator*(Mat a, Mat b) {
int m = a.size(), n = b.size(), p = b[0].size();
Mat c = Mat(m, p);
for (int i = (int)(0); i < (int)(m); i++)
for (int j = (int)(0); j < (int)(p); j++)
for (int k = (int)(0); k < (int)(n); k++)
c[i][j] = (c[i][j] + (1ll * a[i][k] * b[k][j]) % mod) % mod;
return c;
}
Mat pw(Mat a, int n) {
int m = a.size();
Mat r = Mat(m, m);
for (int i = (int)(0); i < (int)(m); i++) r[i][i] = 1;
for (int i = 0; (1ll << i) <= n; i++) {
if (n & (1ll << i)) r = r * a;
a = a * a;
}
return r;
}
int n, m, q, sz;
Mat f, base;
const int dx[] = {0, 0, 0, -1, 1}, dy[] = {0, 1, -1, 0, 0};
bool outside(int x, int y) { return x < 0 || y < 0 || x >= n || y >= m; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
sz = n * m;
base = Mat(sz, sz);
for (int i = (int)(0); i < (int)(n); i++)
for (int j = (int)(0); j < (int)(m); j++) {
for (int k = (int)(0); k < (int)(5); k++) {
int x = i + dx[k], y = j + dy[k];
if (outside(x, y)) continue;
base[x * m + y][i * m + j] = 1;
}
}
f = Mat(1, sz);
f[0][0] = 1;
int cur = 1;
while (q--) {
int p, x, y, t;
cin >> p >> x >> y >> t;
x--;
y--;
f = f * pw(base, t - cur - 1);
if (p == 2) {
for (int i = (int)(0); i < (int)(5); i++) {
int X = x + dx[i], Y = y + dy[i];
if (outside(X, Y)) continue;
base[X * m + Y][x * m + y] = 0;
}
}
f = f * base;
if (p == 1) cout << f[0][x * m + y] << endl;
cur = t;
if (p == 3) {
for (int i = (int)(0); i < (int)(5); i++) {
int X = x + dx[i], Y = y + dy[i];
if (outside(X, Y)) continue;
base[X * m + Y][x * m + y] = 1;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int n, m, q;
int p, x, y, t, t_;
vector<long long> v;
vector<vector<long long> > a, b, bt;
int ii[5] = {0, 0, 0, 1, -1};
int jj[5] = {0, 1, -1, 0, 0};
void mult_Av(vector<vector<long long> >& a, vector<long long>& v);
void mult_AB(vector<vector<long long> >& a, vector<vector<long long> > b);
void mod_pow(vector<vector<long long> >& a, int n);
void fill();
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
fill();
t_ = 1;
for (int i = 0; i < q; ++i) {
cin >> p >> x >> y >> t;
--x;
--y;
t -= t_;
t_ += t;
bt.assign(b.begin(), b.end());
mod_pow(bt, t);
mult_Av(bt, v);
if (p == 1) {
cout << v[x * m + y] << endl;
} else if (p == 2) {
v[x * m + y] = 0;
for (int j = 0; j < n * m; ++j) b[x * m + y][j] = 0;
} else {
for (int j = 0; j < n * m; ++j) b[x * m + y][j] = a[x * m + y][j];
}
}
return 0;
}
void fill() {
a.resize(n * m, vector<long long>(n * m, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
for (int k = 0; k < 5; ++k) {
int i_ = i + ii[k];
int j_ = j + jj[k];
if (i_ >= 0 && i_ < n && j_ >= 0 && j_ < m)
a[i * m + j][i_ * m + j_] = 1;
}
}
}
b.assign(a.begin(), a.end());
v.assign(n * m, 0);
v[0] = 1;
}
void mult_Av(vector<vector<long long> >& a, vector<long long>& v) {
vector<long long> w(v.begin(), v.end());
for (int i = 0; i < m * n; ++i) {
v[i] = 0;
for (int j = 0; j < m * n; ++j) {
v[i] += a[i][j] * w[j];
v[i] %= mod;
}
}
}
void mult_AB(vector<vector<long long> >& a, vector<vector<long long> > b) {
vector<vector<long long> > c(a.begin(), a.end());
for (int i = 0; i < m * n; ++i) {
for (int j = 0; j < m * n; ++j) {
a[i][j] = 0;
for (int k = 0; k < m * n; ++k) {
a[i][j] += c[i][k] * b[k][j];
a[i][j] %= mod;
}
}
}
}
void mod_pow(vector<vector<long long> >& a, int n) {
if (n == 1) return;
if (n & 1) {
vector<vector<long long> > b(a.begin(), a.end());
mod_pow(a, n - 1);
mult_AB(a, b);
} else {
mult_AB(a, a);
mod_pow(a, n / 2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int M = 15;
const long long MOD = 1000000007LL;
const double EPS = 1e-8;
int n, m, q;
vector<vector<long long> > has_cat;
void init() {}
long long get_id(long long x, long long y) { return m * x + y; }
vector<pair<long long, long long> > get_conn(int x, int y) {
int dir[][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {0, 0}};
vector<pair<long long, long long> > ret;
for (int i = 0; i < 5; i++) {
int xx = x + dir[i][0];
int yy = y + dir[i][1];
if (xx < 0 || yy < 0 || xx >= n || yy >= m || has_cat[xx][yy]) {
continue;
}
ret.push_back(make_pair(xx, yy));
}
return ret;
}
vector<vector<long long> > build_transit() {
vector<vector<long long> > mat =
vector<vector<long long> >(n * m, vector<long long>(n * m, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
vector<pair<long long, long long> > conn = get_conn(i, j);
for (int k = 0; k < conn.size(); k++) {
int a = get_id(i, j);
int b = get_id(conn[k].first, conn[k].second);
mat[a][b] = 1;
}
}
}
return mat;
}
vector<vector<long long> > multi(vector<vector<long long> > m1,
vector<vector<long long> > m2) {
int len_n = m1.size(), len_m = m1[0].size();
vector<vector<long long> > ret =
vector<vector<long long> >(len_n, vector<long long>(len_m, 0));
for (int i = 0; i < len_n; i++) {
for (int j = 0; j < len_m; j++) {
ret[i][j] = 0;
for (int k = 0; k < len_m; k++) {
ret[i][j] += ((m1[i][k] * m2[k][j]) % MOD);
ret[i][j] %= MOD;
}
}
}
return ret;
}
vector<vector<long long> > quick_mul(vector<vector<long long> > m1,
vector<vector<long long> > m2, int t) {
vector<vector<long long> > ma = m1, mb = m2;
while (t >= 1) {
if (t & 1) {
ma = multi(ma, mb);
}
t >>= 1;
mb = multi(mb, mb);
}
return ma;
}
vector<vector<long long> > cal(vector<vector<long long> > mat, int t1, int t2) {
vector<vector<long long> > tran = build_transit();
return quick_mul(mat, tran, t2 - t1);
}
void solve() {
has_cat = vector<vector<long long> >(n, vector<long long>(m, 0));
vector<vector<long long> > mat =
vector<vector<long long> >(1, vector<long long>(n * m, 0));
mat[0][0] = 1;
int cur_time = 1;
while (q--) {
int o, x, y, t;
scanf("%d%d%d%d", &o, &x, &y, &t);
x--, y--;
if (o == 1) {
mat = cal(mat, cur_time, t);
cout << mat[0][get_id(x, y)] << endl;
cur_time = t;
}
if (o == 2) {
mat = cal(mat, cur_time, t - 1);
has_cat[x][y] = 1;
cur_time = t - 1;
}
if (o == 3) {
mat = cal(mat, cur_time, t);
has_cat[x][y] = 0;
cur_time = t;
}
}
}
int main() {
while (cin >> n >> m >> q) {
init();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
struct Matrix {
int mat[20][20];
};
int n, m, q, sz;
Matrix M, I;
int cats[20];
inline void add_edge(int i, int j, int i2, int j2) {
M.mat[i * m + j][i2 * m + j2] = 1;
}
inline void remove_edge(int i, int j, int i2, int j2) {
M.mat[i * m + j][i2 * m + j2] = 0;
}
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
Matrix matmul(Matrix a, Matrix b) {
Matrix c;
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) {
c.mat[i][j] = 0;
for (int k = 0; k < sz; k++) {
if (cats[k]) continue;
c.mat[i][j] =
(c.mat[i][j] + (long long)a.mat[i][k] * b.mat[k][j]) % MOD;
}
}
}
return c;
}
Matrix matexp(Matrix a, int b) {
if (b == 0) return I;
if (b & 1) {
return matmul(a, matexp(a, b - 1));
}
Matrix tmp = matexp(a, b / 2);
return matmul(tmp, tmp);
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
sz = n * m;
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++) I.mat[i][j] = (i == j);
memset(M.mat, 0, sizeof M.mat);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
add_edge(i, j, i, j);
for (int k = 0; k < 4; k++) {
int i2 = i + dx[k];
int j2 = j + dy[k];
if (i2 < 0 || i2 >= n || j2 < 0 || j2 >= m) continue;
add_edge(i, j, i2, j2);
}
}
}
Matrix res = I;
int cur = 1;
while (q--) {
int type, i, j, t;
cin >> type >> i >> j >> t;
i--;
j--;
res = matmul(res, matexp(M, t - cur));
if (type == 1) {
cout << res.mat[0][i * m + j] << "\n";
} else if (type == 2) {
remove_edge(i, j, i, j);
for (int k = 0; k < 4; k++) {
int i2 = i + dx[k];
int j2 = j + dy[k];
if (i2 < 0 || i2 >= n || j2 < 0 || j2 >= m) continue;
remove_edge(i2, j2, i, j);
remove_edge(i, j, i2, j2);
}
cats[i * m + j] = 1;
} else {
add_edge(i, j, i, j);
for (int k = 0; k < 4; k++) {
int i2 = i + dx[k];
int j2 = j + dy[k];
if (i2 < 0 || i2 >= n || j2 < 0 || j2 >= m) continue;
add_edge(i, j, i2, j2);
add_edge(i2, j2, i, j);
}
cats[i * m + j] = 0;
}
cur = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int MOD = 1e9 + 7;
int cur = 1;
int w, n, m;
int mp[21][21];
struct Matrix {
ll v[21][21];
Matrix() { memset(v, 0, sizeof v); }
void print() {
for (int i = 1; i <= w; i++)
for (int j = 1; j <= w; j++) printf("%I64d%c", v[i][j], " \n"[j == w]);
}
Matrix &operator*=(const Matrix &c) {
Matrix a = *this, b = c;
memset(v, 0, sizeof v);
for (int i = 1; i <= w; i++)
for (int j = 1; j <= w; j++)
for (int k = 1; k <= w; k++)
v[i][j] = (a.v[i][k] * b.v[k][j] + v[i][j]) % MOD;
return *this;
}
};
void update(Matrix &a) {
int t;
a = Matrix();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (!mp[i][j]) {
t = (i - 1) * m + j;
if (i != 1 && !mp[i - 1][j]) a.v[(i - 2) * m + j][t] = 1;
if (i != n && !mp[i + 1][j]) a.v[i * m + j][t] = 1;
if (j != 1 && !mp[i][j - 1]) a.v[t - 1][t] = 1;
if (j != m && !mp[i][j + 1]) a.v[t + 1][t] = 1;
a.v[t][t] = 1;
}
}
void pow_mod(Matrix &a, int p) {
Matrix r;
for (int i = 1; i <= w; i++) r.v[i][i] = 1;
while (p) {
if (p & 1) r *= a;
a *= a;
p >>= 1;
}
a = r;
}
int main() {
int q, tp, x, y, tm;
Matrix t, mi;
mi.v[1][1] = 1;
scanf("%d%d%d", &n, &m, &q);
w = n * m;
while (q--) {
update(t);
scanf("%d%d%d%d", &tp, &x, &y, &tm);
pow_mod(t, tm - cur);
mi *= t;
if (tp == 1)
printf("%I64d\n", mi.v[1][(x - 1) * m + y]);
else if (tp == 2)
mp[x][y] = true;
else
mp[x][y] = false;
cur = tm;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, tp, x, y, t;
struct Matrix {
int row, col;
int values[410][410];
Matrix(int _row = 0, int _col = 0) {
row = _row;
col = _col;
for (int i = 0; i < row; ++i)
for (int j = 0; j < col; ++j) values[i][j] = 0;
}
Matrix operator*(const Matrix &b) {
Matrix c(row, b.col);
for (int i = 0; i < row; ++i)
for (int j = 0; j < b.col; ++j)
for (int k = 0; k < col; ++k)
c.values[i][j] =
(c.values[i][j] + values[i][k] * 1ll * b.values[k][j]) %
1000000007;
return c;
}
Matrix operator^(int y) {
--y;
Matrix base, ans;
memcpy(base.values, values, sizeof(values));
memcpy(ans.values, values, sizeof(values));
base.row = ans.row = row;
base.col = ans.col = col;
while (y) {
if (y & 1) {
ans = ans * base;
}
y >>= 1;
base = base * base;
}
return ans;
}
void print() {
for (int i = 0; i < row; ++i) {
for (int j = 0; j < col; ++j) printf("%d ", values[i][j]);
printf("\n");
}
printf("\n");
}
};
int main() {
scanf("%d %d %d", &n, &m, &q);
Matrix base(n * m, n * m);
Matrix ans(n * m, 1);
ans.values[0][0] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int pos = i * m + j;
if (j + 1 < m) base.values[pos][pos + 1] = 1;
if (j > 0) base.values[pos][pos - 1] = 1;
if (i + 1 < n) base.values[pos][pos + m] = 1;
if (i > 0) base.values[pos][pos - m] = 1;
base.values[pos][pos] = 1;
}
int curT = 1;
for (int i = 0; i < q; ++i) {
scanf("%d %d %d %d", &tp, &x, &y, &t);
--x;
--y;
ans = (base ^ (t - curT)) * ans;
if (tp == 1) {
printf("%d\n", ans.values[x * m + y][0]);
}
if (tp == 2) {
int pos = x * m + y;
if (y + 1 < m) base.values[pos][pos + 1] = 0;
if (y > 0) base.values[pos][pos - 1] = 0;
if (x + 1 < n) base.values[pos][pos + m] = 0;
if (x > 0) base.values[pos][pos - m] = 0;
base.values[pos][pos] = 0;
ans.values[pos][0] = 0;
}
if (tp == 3) {
int pos = x * m + y;
if (y + 1 < m) base.values[pos][pos + 1] = 1;
if (y > 0) base.values[pos][pos - 1] = 1;
if (x + 1 < n) base.values[pos][pos + m] = 1;
if (x > 0) base.values[pos][pos - m] = 1;
base.values[pos][pos] = 1;
}
curT = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<vector<long long> > Identity(int n) {
vector<vector<long long> > A(n, vector<long long>(n, 0));
for (int i = 0; i < n; i++) A[i][i] = 1;
return A;
}
vector<vector<long long> > Multiply(vector<vector<long long> > &A,
vector<vector<long long> > B) {
vector<vector<long long> > C(A.size(), vector<long long>(B[0].size(), 0));
for (int i = 0; i < A.size(); i++)
for (int k = 0; k < A[0].size(); k++)
if (A[i][k])
for (int j = 0; j < B[0].size(); j++)
C[i][j] = (C[i][j] + (A[i][k] * B[k][j]) % mod) % mod;
return C;
}
vector<vector<long long> > FastPower(vector<vector<long long> > A,
long long p) {
vector<vector<long long> > R = Identity(A.size());
while (p) {
if (p & 1) R = Multiply(R, A);
A = Multiply(A, A);
p >>= 1;
}
return R;
}
int dx[] = {0, -1, 1, 0, 0};
int dy[] = {0, 0, 0, -1, 1};
int n, m, q;
bool ban[21][21];
bool valid(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && !ban[x][y]);
}
int main() {
cin >> n >> m >> q;
vector<vector<long long> > M = Identity(n * m), T;
vector<vector<long long> > lastT =
vector<vector<long long> >(n * m, vector<long long>(n * m, 0));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 5; k++) {
int x = i + dx[k];
int y = j + dy[k];
if (valid(x, y)) lastT[(i * m + j)][(x * m + y)] = 1;
}
int lastTime = 1;
while (q--) {
int type, x0, y0, t;
cin >> type >> x0 >> y0 >> t;
x0--;
y0--;
if (type == 1) {
M = Multiply(M, FastPower(lastT, t - lastTime));
cout << M[0][(x0 * m + y0)] << endl;
} else if (type == 2) {
M = Multiply(M, FastPower(lastT, t - lastTime - 1));
lastT.clear();
lastT.resize(n * m, vector<long long>(n * m, 0));
ban[x0][y0] = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!ban[i][j])
for (int k = 0; k < 5; k++) {
int x = i + dx[k];
int y = j + dy[k];
if (valid(x, y)) lastT[(i * m + j)][(x * m + y)] = 1;
}
T = lastT;
for (int k = 0; k < 5; k++) {
int x = x0 + dx[k];
int y = y0 + dy[k];
if (valid(x, y)) T[(x0 * m + y0)][(x * m + y)] = 1;
}
M = Multiply(M, T);
} else {
M = Multiply(M, FastPower(lastT, t - lastTime - 1));
lastT.clear();
lastT.resize(n * m, vector<long long>(n * m, 0));
ban[x0][y0] = false;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!ban[i][j])
for (int k = 0; k < 5; k++) {
int x = i + dx[k];
int y = j + dy[k];
if (valid(x, y)) lastT[(i * m + j)][(x * m + y)] = 1;
}
T = lastT;
for (int k = 0; k < 5; k++) {
int x = x0 + dx[k];
int y = y0 + dy[k];
if (valid(x, y)) T[(x * m + y)][(x0 * m + y0)] = 0;
}
M = Multiply(M, T);
}
lastTime = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
const int mod = 1000000007;
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, 1, 0, -1};
int add(int x, int y) { return (x + y) % mod; }
int mult(int x, int y) { return (long long)x * y % mod; }
int q;
int n, m;
bool c[maxn][maxn];
int ways[maxn][maxn];
int nways[maxn][maxn];
int tmp[maxn][maxn];
int cnt[maxn][maxn];
int sol[maxn][maxn];
void r(int p) {
if (p == 1) {
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) sol[i][j] = cnt[i][j];
return;
}
r(p / 2);
memset(tmp, 0, sizeof tmp);
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
for (int k = 0; k < n * m; k++)
tmp[i][j] = add(tmp[i][j], mult(sol[i][k], sol[k][j]));
if (p % 2 == 1) {
memset(sol, 0, sizeof sol);
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
for (int k = 0; k < n * m; k++)
sol[i][j] = add(sol[i][j], mult(tmp[i][k], cnt[k][j]));
} else
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) sol[i][j] = tmp[i][j];
}
int conv(int x, int y) { return x * m + y; }
void calc(int p) {
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (!c[i][j])
cnt[conv(i, j)][conv(i, j)] = 1;
else
continue;
for (int k = 0; k < 4; k++) {
int nx = i + cx[k];
int ny = j + cy[k];
if (nx >= 0 && nx < n && ny >= 0 && ny < m && !c[nx][ny])
cnt[conv(i, j)][conv(nx, ny)] = 1;
}
}
r(p);
memset(nways, 0, sizeof nways);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int di = 0; di < n; di++)
for (int dj = 0; dj < m; dj++)
nways[di][dj] = add(nways[di][dj],
mult(ways[i][j], sol[conv(i, j)][conv(di, dj)]));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ways[i][j] = nways[i][j];
}
int main(void) {
scanf("%d%d%d", &n, &m, &q);
int pt = 1;
ways[0][0] = 1;
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
int x, y, t;
scanf("%d%d%d", &x, &y, &t);
if (t != pt) calc(t - pt);
pt = t;
if (type == 2) c[--x][--y] = 1;
if (type == 1) printf("%d\n", ways[--x][--y]);
if (type == 3) c[--x][--y] = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<vector<long long>> a;
vector<vector<long long>> b;
vector<vector<long long>> c;
void multi() {
int n = a.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
c[i][j] = 0;
for (int k = 0; k < n; k++) {
c[i][j] = (c[i][j] + a[i][k] * b[k][j] % mod) % mod;
}
}
}
}
void print_mat(vector<vector<long long>> a) {
cout << endl;
for (vector<long long> b : a) {
for (int c : b) cout << c << " ";
cout << endl;
}
cout << endl;
}
vector<vector<long long>> d;
void pwr(int p) {
while (p) {
if (p % 2) {
a = d;
multi();
d = c;
}
p /= 2;
a = b;
multi();
b = c;
}
}
vector<vector<long long>> adj;
vector<vector<long long>> ans;
vector<vector<long long>> I;
int n, m;
void change_adj(int i, int j, int val) {
int ind = i * m + j;
int ind1 = -1, ind2 = -1, ind3 = -1, ind4 = -1;
if (i > 0) {
ind1 = (i - 1) * m + j;
adj[ind1][ind] += val;
}
if (i < n - 1) {
ind2 = (i + 1) * m + j;
adj[ind2][ind] += val;
}
if (j > 0) {
ind3 = i * m + (j - 1);
adj[ind3][ind] += val;
}
if (j < m - 1) {
ind4 = i * m + (j + 1);
adj[ind4][ind] += val;
}
adj[ind][ind] += val;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int q;
cin >> n >> m >> q;
adj = vector<vector<long long>>(n * m, vector<long long>(n * m, 0));
I = vector<vector<long long>>(n * m, vector<long long>(n * m, 0));
c = vector<vector<long long>>(n * m, vector<long long>(n * m, 0));
ans = vector<vector<long long>>(n * m, vector<long long>(n * m, 0));
ans[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int ind = i * m + j;
int ind1 = -1, ind2 = -1, ind3 = -1, ind4 = -1;
if (i > 0) {
ind1 = (i - 1) * m + j;
adj[ind][ind1] = 1;
}
if (i < n - 1) {
ind2 = (i + 1) * m + j;
adj[ind][ind2] = 1;
}
if (j > 0) {
ind3 = i * m + (j - 1);
adj[ind][ind3] = 1;
}
if (j < m - 1) {
ind4 = i * m + (j + 1);
adj[ind][ind4] = 1;
}
adj[ind][ind] = 1;
}
}
for (int i = 0; i < n * m; i++) {
I[i][i] = 1;
}
int cur_time = 1;
for (int i = 0; i < q; i++) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
x--;
y--;
int delta = t - cur_time;
cur_time = t;
d = I;
b = adj;
if (tp == 1) {
pwr(delta);
} else if (tp == 2) {
pwr(delta - 1);
change_adj(x, y, -1);
a = d;
b = adj;
multi();
d = c;
} else {
pwr(delta);
change_adj(x, y, 1);
}
a = ans;
b = d;
multi();
ans = c;
if (tp == 1) cout << ans[0][x * m + y] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int MxN = 20;
const int MxM = 20;
int n, m, sum, q, pre = 1;
template <typename T, int N, int M>
class Matrix {
public:
int n, m;
T A[N][M];
Matrix(int _n = 0, int _m = 0) : n(_n), m(_m) { memset(A, 0, sizeof A); }
friend Matrix<T, N, M> operator*(Matrix<T, N, M> a, Matrix<T, N, M> b) {
int _i = a.n, _j = b.m, _k = a.m;
Matrix<T, N, M> ans(_i, _j);
for (int i = 0; i < _i; i++)
for (int j = 0; j < _j; j++)
for (int k = 0; k < _k; k++)
ans.A[i][j] = (ans.A[i][j] + a.A[i][k] * b.A[k][j] % mod) % mod;
return ans;
}
void test() {
char ch[10];
if (typeid(T).name() == typeid(int).name()) sprintf(ch, "%%d ");
if (typeid(T).name() == typeid(long long).name()) sprintf(ch, "%%lld ");
printf("n:%d m:%d\n", n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf(ch, A[i][j]);
}
puts("");
}
}
};
Matrix<long long, MxN, MxM> ans, A;
bool b[20];
template <class T>
T Qpow(T a, int k) {
T ans;
ans = a;
k--;
while (k) {
if (k & 1) ans = ans * a;
a = a * a;
k >>= 1;
}
return ans;
}
void add(int id) {
if (id >= m && b[id - m] == 0) A.A[id][id - m] = A.A[id - m][id] = 1;
if (id % m != 0 && b[id - 1] == 0) A.A[id][id - 1] = A.A[id - 1][id] = 1;
if (id < sum - m && b[id + m] == 0) A.A[id][id + m] = A.A[id + m][id] = 1;
if (id % m != m - 1 && b[id + 1] == 0) A.A[id][id + 1] = A.A[id + 1][id] = 1;
A.A[id][id] = 1;
b[id] = 0;
}
void erase(int id) {
if (id >= m) A.A[id][id - m] = A.A[id - m][id] = 0;
if (id % m != 0) A.A[id][id - 1] = A.A[id - 1][id] = 0;
if (id < sum - m) A.A[id][id + m] = A.A[id + m][id] = 0;
if (id % m != m - 1) A.A[id][id + 1] = A.A[id + 1][id] = 0;
A.A[id][id] = 0;
b[id] = 1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
sum = n * m;
ans.m = A.n = A.m = sum;
ans.n = 1;
ans.A[0][0] = 1;
for (int i = 0; i < sum; i++) add(i);
for (int i = 1; i <= q; i++) {
int op, x, y, t;
scanf("%d%d%d%d", &op, &x, &y, &t);
int id = (x - 1) * m + y - 1;
switch (op) {
case 1:
ans = ans * Qpow<Matrix<long long, MxN, MxM> >(A, t - pre);
printf("%lld\n", ans.A[0][id]);
pre = t;
break;
case 2:
ans = ans * Qpow<Matrix<long long, MxN, MxM> >(A, t - pre);
pre = t;
erase(id);
break;
case 3:
ans = ans * Qpow<Matrix<long long, MxN, MxM> >(A, t - pre);
pre = t;
add(id);
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
struct Matrix {
int mat[20][20];
};
int n, m, q, sz;
Matrix M, I;
int cats[20];
void add_edge(int i, int j, int i2, int j2) {
M.mat[i * m + j][i2 * m + j2] = 1;
}
void remove_edge(int i, int j, int i2, int j2) {
M.mat[i * m + j][i2 * m + j2] = 0;
}
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
Matrix matmul(Matrix a, Matrix b) {
Matrix c;
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) {
c.mat[i][j] = 0;
for (int k = 0; k < sz; k++) {
if (cats[k]) continue;
c.mat[i][j] =
(c.mat[i][j] + (long long)a.mat[i][k] * b.mat[k][j]) % MOD;
}
}
}
return c;
}
Matrix matexp(Matrix a, int b) {
if (b == 0) return I;
if (b & 1) {
return matmul(a, matexp(a, b - 1));
}
Matrix tmp = matexp(a, b / 2);
return matmul(tmp, tmp);
}
int main() {
cin >> n >> m >> q;
sz = n * m;
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++) I.mat[i][j] = (i == j);
memset(M.mat, 0, sizeof M.mat);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
add_edge(i, j, i, j);
for (int k = 0; k < 4; k++) {
int i2 = i + dx[k];
int j2 = j + dy[k];
if (i2 < 0 || i2 >= n || j2 < 0 || j2 >= m) continue;
add_edge(i, j, i2, j2);
add_edge(i2, j2, i, j);
}
}
}
Matrix res = I;
int cur = 1;
while (q--) {
int type, i, j, t;
cin >> type >> i >> j >> t;
i--;
j--;
res = matmul(res, matexp(M, t - cur));
if (type == 1) {
cout << res.mat[0][i * m + j] << "\n";
} else if (type == 2) {
remove_edge(i, j, i, j);
for (int k = 0; k < 4; k++) {
int i2 = i + dx[k];
int j2 = j + dy[k];
if (i2 < 0 || i2 >= n || j2 < 0 || j2 >= m) continue;
remove_edge(i2, j2, i, j);
remove_edge(i, j, i2, j2);
}
cats[i * m + j] = 1;
} else {
add_edge(i, j, i, j);
for (int k = 0; k < 4; k++) {
int i2 = i + dx[k];
int j2 = j + dy[k];
if (i2 < 0 || i2 >= n || j2 < 0 || j2 >= m) continue;
add_edge(i, j, i2, j2);
add_edge(i2, j2, i, j);
}
cats[i * m + j] = 0;
}
cur = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
struct sett {
long long k[50][50];
} ans, base;
long long N, n, m, q;
long long mp[25][25];
sett mul(sett a, sett b) {
sett c;
memset(c.k, 0, sizeof(c.k));
for (long long i = 1; i <= N; i++)
for (long long r = 1; r <= N; r++)
for (long long p = 1; p <= N; p++)
c.k[i][r] = (c.k[i][r] + a.k[i][p] * b.k[p][r]) % mod;
return c;
}
void qpow(long long b) {
for (; b; b >>= 1, base = mul(base, base))
if (b & 1) ans = mul(base, ans);
}
void build() {
for (long long i = 1; i <= N; i++)
for (long long r = 1; r <= N; r++) {
long long a = ((i - 1) / m) + 1, b = (i - 1) % m + 1;
long long A = ((r - 1) / m) + 1, B = (r - 1) % m + 1;
long long dist = abs(A - a) + abs(B - b);
if (mp[a][b] == 0 && mp[A][B] == 0 && dist <= 1)
base.k[i][r] = 1;
else
base.k[i][r] = 0;
}
}
signed main() {
scanf("%lld%lld%lld", &n, &m, &q);
N = n * m;
ans.k[1][1] = 1;
long long plk = 1;
while (q--) {
build();
long long op, x, y, t;
scanf("%lld%lld%lld%lld", &op, &x, &y, &t);
qpow(t - plk);
plk = t;
if (op == 2) ans.k[(x - 1) * m + y][1] = 0, mp[x][y] = 1;
if (op == 3) ans.k[(x - 1) * m + y][1] = 0, mp[x][y] = 0;
if (op == 1) printf("%lld\n", ans.k[(x - 1) * m + y][1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20 + 5, P = 1e9 + 7;
struct matrix {
int a[N][N] = {};
matrix(int x = 1) {
for (int i = 0; i < N; i++) a[i][i] = x;
}
void set(int i, int j, int x = 1) { a[i][j] = a[j][i] = x; }
matrix operator*(matrix m) {
matrix ans(0);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
(ans.a[i][j] += 1LL * a[i][k] * m.a[k][j] % P) %= P;
return ans;
}
matrix operator^(int k) {
return k ? ((*this * *this) ^ (k / 2)) * (k & 1 ? *this : matrix())
: matrix();
}
} ed, dp;
int n, m, q, mark[N];
int id(int i, int j) { return i * m + j; }
int main() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int x : {-1, 1}) {
if (i + x >= 0 && i + x < n) ed.set(id(i, j), id(i + x, j));
if (j + x >= 0 && j + x < m) ed.set(id(i, j), id(i, j + x));
}
for (int prv = 1; q; q--) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
x--, y--, dp = dp * (ed ^ t - prv), prv = t;
if (!--tp) {
cout << dp.a[0][id(x, y)] << endl;
continue;
}
int p = id(x, y);
ed.set(p, p, mark[p]), mark[p] ^= 1;
for (auto i : {-1, 1}) {
if (x + i >= 0 && x + i < n)
ed.set(p, id(x + i, y), !mark[p] && !mark[id(x + i, y)]);
if (y + i >= 0 && y + i < m)
ed.set(p, id(x, y + i), !mark[p] && !mark[id(x, y + i)]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
const long long M = 1e9 + 7;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int n, m, q, tp;
class matrix {
public:
long long m[N][N];
matrix() { memset(m, 0, sizeof m); }
matrix operator*(matrix b) {
matrix tor;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
tor.m[i][j] = 0;
for (int k = 0; k < N; ++k) {
tor.m[i][j] = (tor.m[i][j] + m[i][k] * b.m[k][j]) % M;
}
}
}
return tor;
}
};
matrix ONE;
matrix pow(matrix a, int p) {
matrix res = ONE;
for (; p;) {
if (p & 1) res = res * a;
a = a * a;
p >>= 1;
}
return res;
}
bool good(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < m); }
matrix edge;
int cat[N][N];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < N; ++i) {
ONE.m[i][i] = 1;
}
matrix cur;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
edge.m[i * m + j][i * m + j] = 1;
for (int k = 0; k < 4; ++k) {
int ni = i + dx[k];
int nj = j + dy[k];
if (good(ni, nj)) {
edge.m[i * m + j][ni * m + nj] = 1;
}
}
}
}
cur = ONE;
int last = 1;
for (int i = 0; i < q; ++i) {
int x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
--x;
--y;
cur = cur * pow(edge, t - last);
if (tp == 1) {
printf("%I64d\n", cur.m[0][x * m + y]);
}
if (tp == 2) {
edge.m[x * m + y][x * m + y] = 0;
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (good(nx, ny)) {
edge.m[x * m + y][nx * m + ny] = 0;
edge.m[nx * m + ny][x * m + y] = 0;
}
}
cat[x][y] = 1;
}
if (tp == 3) {
edge.m[x * m + y][x * m + y] = 1;
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (good(nx, ny) && !cat[nx][ny]) {
edge.m[x * m + y][nx * m + ny] = 1;
edge.m[nx * m + ny][x * m + y] = 1;
}
}
cat[x][y] = 0;
}
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1e9 + 7;
template <class T, int N, int M>
class Matrix {
private:
char ch[10];
public:
T n, m, A[N][M];
Matrix(int _n = 0, int _m = 0) : n(_n), m(_m) { memset(A, 0, sizeof(A)); }
friend Matrix<T, N, M> operator*(Matrix<T, N, M> a, Matrix<T, N, M> b) {
Matrix<T, N, M> ans(a.n, b.m);
for (int i = 0; i < a.n; i++)
for (int j = 0; j < b.m; j++)
for (int k = 0; k < a.m; k++)
ans.A[i][j] = (ans.A[i][j] + a.A[i][k] * b.A[k][j] % P) % P;
return ans;
}
void pre() {
if (typeid(T).name() == typeid(int).name()) sprintf(ch, "%%d ");
if (typeid(T).name() == typeid(long long).name()) sprintf(ch, "%%lld ");
}
void scan() {
pre();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf(ch, &A[i][j]);
}
void print() {
pre();
for (int i = 0; i < n; i++, printf("\n"))
for (int j = 0; j < m; j++) printf(ch, A[i][j]);
}
};
int n, m, t, last;
int b[1000];
Matrix<long long, 50, 50> Std;
Matrix<long long, 50, 50> a;
Matrix<long long, 50, 50> an;
void wr(int x, int y, int z) {
if (b[y]) return;
Std.A[x][y] = z;
Std.A[y][x] = z;
}
void write(int i, int j, int z) {
int x = (i - 1) * m + j - 1;
Std.A[x][x] = z;
if (i > 1) wr(x, x - m, z);
if (i < n) wr(x, x + m, z);
if (j > 1) wr(x, x - 1, z);
if (j < m) wr(x, x + 1, z);
}
void work(int x) {
while (x) {
if (x & 1) an = a * an;
x >>= 1;
a = a * a;
}
}
void solve() {
int fl, x, y, z;
scanf("%d%d%d%d", &fl, &x, &y, &z);
a = Std;
work(z - last);
last = z;
if (fl == 2) {
write(x, y, 0);
an.A[(x - 1) * m + y - 1][0] = 0;
b[(x - 1) * m + y - 1] = 1;
}
if (fl == 3) {
write(x, y, 1);
b[(x - 1) * m + y - 1] = 0;
}
if (fl == 1) printf("%lld\n", an.A[(x - 1) * m + y - 1][0]);
}
int main() {
scanf("%d%d%d", &n, &m, &t);
an.n = Std.n = Std.m = n * m;
an.m = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
write(i, j, 1);
}
an.A[0][0] = 1;
last = 1;
for (; t; t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
struct Matrix {
int c[25][25];
} res, tmp;
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int vis[25][25];
int n, m, q;
Matrix Mul(Matrix A, Matrix B) {
Matrix res;
for (int i = 1; i <= n * m; i++) {
for (int j = 1; j <= n * m; j++) {
res.c[i][j] = 0;
for (int k = 1; k <= n * m; k++) {
res.c[i][j] = (res.c[i][j] + (long long)A.c[i][k] * B.c[k][j]) % M;
}
}
}
return res;
}
Matrix Solve(Matrix A, int n) {
while (n) {
if (n & 1) {
A = Mul(tmp, A);
}
tmp = Mul(tmp, tmp);
n >>= 1;
}
return A;
}
int GetId(int x, int y) { return (x - 1) * m + y; }
int main() {
scanf("%d%d%d", &n, &m, &q);
Matrix pre;
memset(pre.c, 0, sizeof(pre.c));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
pre.c[GetId(i, j)][GetId(i, j)] = 1;
int st, et;
for (int k = 0; k < 4; k++) {
st = i + dir[k][0];
et = j + dir[k][1];
if (st >= 1 && et >= 1 && st <= n && et <= m) {
pre.c[GetId(i, j)][GetId(st, et)] = 1;
}
}
}
}
tmp = pre;
memset(res.c, 0, sizeof(res.c));
res.c[1][1] = 1;
memset(vis, 0, sizeof(vis));
int pre_t = 1;
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
if (tp == 1) {
res = Solve(res, t - pre_t);
pre_t = t;
tmp = pre;
printf("%d\n", res.c[GetId(x, y)][1]);
} else if (tp == 2) {
res = Solve(res, t - pre_t);
pre_t = t;
res.c[GetId(x, y)][1] = 0;
pre.c[GetId(x, y)][GetId(x, y)] = 0;
for (int k = 0; k < 4; k++) {
int st, et;
st = x + dir[k][0];
et = y + dir[k][1];
if (st >= 1 && et >= 1 && st <= n && et <= m) {
pre.c[GetId(x, y)][GetId(st, et)] = 0;
pre.c[GetId(st, et)][GetId(x, y)] = 0;
}
}
tmp = pre;
vis[x][y] = 1;
} else {
res = Solve(res, t - pre_t);
pre_t = t;
res.c[GetId(x, y)][1] = 0;
pre.c[GetId(x, y)][GetId(x, y)] = 1;
vis[x][y] = 0;
for (int k = 0; k < 4; k++) {
int st, et;
st = x + dir[k][0];
et = y + dir[k][1];
if (st >= 1 && et >= 1 && st <= n && et <= m && !vis[st][et]) {
pre.c[GetId(st, et)][GetId(x, y)] = 1;
pre.c[GetId(x, y)][GetId(st, et)] = 1;
}
}
tmp = pre;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int M[44][44], Me[44][44], V[44], Ve[44], n;
void pow_M(int e) {
while (1) {
if (e & 1) {
memset(Ve, 0, sizeof(Ve));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
Ve[i] = (Ve[i] + M[j][i] * (long long)V[j]) % mod;
for (int i = 0; i < n; i++) V[i] = Ve[i];
}
e >>= 1;
if (e == 0) break;
memset(Me, 0, sizeof(Me));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
Me[i][j] = (Me[i][j] + M[i][k] * (long long)M[k][j]) % mod;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) M[i][j] = Me[i][j];
}
}
int C[44][44], x, y, q;
void build() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int a = i / y, b = i % y;
int A = j / y, B = j % y;
int k = abs(A - a) + abs(B - b);
if (k <= 1 && C[a][b] == 0 && C[A][B] == 0)
M[i][j] = 1;
else
M[i][j] = 0;
}
}
int main() {
while (scanf("%d%d%d", &x, &y, &q) != EOF) {
n = x * y;
int t = 1;
memset(V, 0, sizeof(V));
V[0] = 1;
memset(C, 0, sizeof(C));
while (q--) {
build();
int l, a, b, k;
scanf("%d%d%d%d", &l, &a, &b, &k);
--a;
--b;
pow_M(k - t);
t = k;
if (l == 3) {
V[a * y + b] = 0;
C[a][b] = 0;
}
if (l == 2) {
V[a * y + b] = 0;
C[a][b] = 1;
}
if (l == 1) printf("%d\n", V[a * y + b]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1000000;
int n, m, num, num_q;
bool init[100][100];
struct Matrix {
long long f[20][20];
} ini, dw, change;
Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix c;
for (int i = 0; i < num; i++)
for (int j = 0; j < num; j++) {
c.f[i][j] = 0;
for (int k = 0; k < num; k++)
c.f[i][j] = (c.f[i][j] + a.f[i][k] * b.f[k][j]) % MOD;
}
return c;
}
int get(int x, int y) { return x * m + y; }
Matrix mi(int x) {
if (x == 0) return dw;
Matrix tmp = mi(x / 2);
tmp = tmp * tmp;
if (x % 2 == 1) tmp = tmp * change;
return tmp;
}
void Print(Matrix a) {
for (int i = 0; i < num; i++) {
for (int j = 0; j < num; j++) cout << a.f[i][j] << " ";
cout << endl;
}
cout << endl;
}
int main() {
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
cin >> n >> m >> num_q;
num = n * m;
memset(ini.f, 0, sizeof(ini.f));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
for (int dir = 0; dir < 4; dir++) {
int xx = i + dx[dir];
int yy = j + dy[dir];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
ini.f[get(i, j)][get(xx, yy)] = 1;
}
}
ini.f[get(i, j)][get(i, j)] = 1;
}
int time = 1;
memset(dw.f, 0, sizeof(dw.f));
for (int i = 0; i < num; i++) dw.f[i][i] = 1;
Matrix now = dw;
change = ini;
for (int ii = 1; ii <= num_q; ii++) {
int type, x, y, t;
scanf("%d%d%d%d", &type, &x, &y, &t);
x--;
y--;
if (type == 2) {
now = now * mi(t - time);
time = t;
change = ini;
init[x][y] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (init[i][j]) {
for (int p = 0; p < num; p++) {
change.f[p][get(i, j)] = 0;
change.f[get(i, j)][p] = 0;
}
}
};
if (type == 3) {
now = now * mi(t - time);
time = t;
change = ini;
init[x][y] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (init[i][j]) {
for (int p = 0; p < num; p++) {
change.f[p][get(i, j)] = 0;
change.f[get(i, j)][p] = 0;
}
}
}
if (type == 1) {
now = now * mi(t - time);
time = t;
printf("%d\n", now.f[0][get(x, y)]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int LIMIT = int(1e9 + 7);
struct matrix {
int n;
int m;
vector<int> d;
matrix(int n_, int m_) : n(n_), m(m_), d(n_ * m_) {}
matrix(int n_, int m_, const vector<int>& d_) : n(n_), m(m_), d(d_) {}
matrix(matrix&& o) : n(o.n), m(o.m), d(move(o.d)) {}
matrix& operator=(matrix&& o) {
n = o.n;
m = o.m;
d = move(o.d);
return *this;
}
matrix copy() const { return matrix(n, m, d); }
inline int& val(int i, int j) { return d[i * m + j]; }
inline int val(int i, int j) const { return d[i * m + j]; }
matrix operator*(const matrix& rh) const {
int K = this->m;
matrix res(this->n, rh.m);
for (int i = 0; i < res.n; i++)
for (int j = 0; j < res.m; j++)
for (int k = 0; k < K; k++) {
res.val(i, j) =
(res.val(i, j) + (long long)(this->val(i, k)) * rh.val(k, j)) %
LIMIT;
}
return move(res);
}
};
matrix pow(const matrix& m, int p) {
if (p < 2) {
return m.copy();
}
matrix res = pow(m, p / 2);
res = res * res;
if (p % 2) res = res * m;
return res;
}
void flipTransVal(matrix& trans, int n, int m, int i, bool force) {
int val = (trans.val(i, i) + 1) % 2;
trans.val(i, i) = val;
auto d = div(i, m);
int row = d.quot;
int col = d.rem;
vector<int> neib;
neib.reserve(4);
if (row - 1 >= 0) neib.push_back(i - m);
if (row + 1 < n) neib.push_back(i + m);
if (col - 1 >= 0) neib.push_back(i - 1);
if (col + 1 < m) neib.push_back(i + 1);
for (auto j : neib) {
if (force || trans.val(j, j)) {
trans.val(i, j) = val;
trans.val(j, i) = val;
}
}
}
int main(int, char**) {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
int S = n * m;
matrix state(1, S);
matrix trans(S, S);
state.d[0] = 1;
for (int i = 0; i < S; i++) {
flipTransVal(trans, n, m, i, true);
}
int t_prev = 1;
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
int dt = t - t_prev;
x -= 1;
y -= 1;
if (dt == 1)
state = state * trans;
else
state = state * pow(trans, dt);
int i = x * m + y;
if (tp == 1) {
printf("%d\n", state.d[i]);
} else {
flipTransVal(trans, n, m, i, false);
state.d[i] = 0;
}
t_prev = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25, M = 10000007, lgN = 22, rootN = 500, mod = 1000000007;
const double eps = 1e-6, pi = acos(-1);
int m, n;
long long mt[N][N];
bool cat[N];
void addEdges(int r, int c) {
int v = (r - 1) * m + c;
mt[v][v] = 1;
if (r > 1 && !cat[v - m]) mt[v - m][v] = 1, mt[v][v - m] = 1;
if (r < n && !cat[v + m]) mt[v + m][v] = 1, mt[v][v + m] = 1;
if (c > 1 && !cat[v - 1]) mt[v - 1][v] = 1, mt[v][v - 1] = 1;
if (c < m && !cat[v + 1]) mt[v + 1][v] = 1, mt[v][v + 1] = 1;
}
void remEdges(int r, int c) {
int v = (r - 1) * m + c;
mt[v][v] = 0;
if (r > 1) mt[v - m][v] = 0, mt[v][v - m] = 0;
if (r < n) mt[v + m][v] = 0, mt[v][v + m] = 0;
if (c > 1) mt[v - 1][v] = 0, mt[v][v - 1] = 0;
if (c < m) mt[v + 1][v] = 0, mt[v][v + 1] = 0;
}
void multiplyPower(long long a[N][N], long long b[N][N], int s) {
long long cc[N][N];
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= s; ++j) cc[i][j] = 0;
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= s; ++j)
for (int k = 1; k <= s; ++k)
cc[i][k] = (cc[i][k] + a[i][j] * b[j][k]) % mod;
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= s; ++j) b[i][j] = cc[i][j];
}
void power(long long a[N][N], int p, int s, long long r[N][N]) {
long long cp[N][N];
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= s; ++j) r[i][j] = ((i == j) ? 1 : 0);
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= s; ++j) cp[i][j] = a[i][j];
while (p > 0) {
if (p & 1) multiplyPower(cp, r, s);
multiplyPower(cp, cp, s);
p >>= 1;
}
}
void mul(long long A[N][N], long long B[N][2], int a, int b, int c = 1) {
long long rr[N][2];
for (int i = 1; i <= a; ++i)
for (int j = 1; j <= c; ++j) rr[i][j] = 0;
for (int i = 1; i <= a; ++i)
for (int j = 1; j <= b; ++j)
for (int k = 1; k <= c; ++k)
rr[i][k] = (A[i][j] * B[j][k] + rr[i][k]) % mod;
for (int i = 1; i <= a; ++i)
for (int j = 1; j <= c; ++j) B[i][j] = rr[i][j];
}
long long b[N][2], r[N][N];
int main() {
int q;
scanf("%d %d %d", &n, &m, &q);
int d = n * m;
for (int x = 1; x <= n; ++x) {
for (int y = 1; y <= m; ++y) {
addEdges(x, y);
}
}
for (int i = 1; i <= d; ++i) cat[i] = false;
for (int i = 1; i <= d; ++i) b[i][1] = ((i == 1) ? 1 : 0);
int tp, x, y, t, last = 1;
for (int Q = 0; Q < q; ++Q) {
cin >> tp >> x >> y >> t;
power(mt, t - last, d, r);
mul(r, b, d, d, 1);
if (tp == 1) {
long long ans = b[(x - 1) * m + y][1];
printf("%lld\n", ans);
} else if (tp == 2) {
cat[(x - 1) * m + y] = true;
remEdges(x, y);
} else {
cat[(x - 1) * m + y] = false;
addEdges(x, y);
}
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
bool cat[25][25];
int n, m, q;
class Matrix {
public:
long long matrix[40][40];
int sz;
} way, dp;
Matrix mul(Matrix a, Matrix b) {
Matrix ans;
ans.sz = a.sz;
memset(ans.matrix, 0, sizeof ans.matrix);
for (int i = 0; i < a.sz; i++)
for (int j = 0; j < a.sz; j++)
for (int k = 0; k < a.sz; k++)
ans.matrix[i][j] =
(ans.matrix[i][j] + a.matrix[i][k] * b.matrix[k][j]) % mod;
return ans;
}
Matrix qpow(Matrix mat, int k) {
Matrix ans = mat;
k--;
for (; k; k >>= 1, mat = mul(mat, mat))
if (k & 1) ans = mul(ans, mat);
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
int tt = 1;
dp.matrix[0][0] = 1;
dp.sz = way.sz = n * m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
int xx = i + dx[k], yy = j + dy[k];
if (xx < 0 || xx >= n || yy < 0 || yy >= m) continue;
way.matrix[i * m + j][xx * m + yy] = 1;
}
way.matrix[i * m + j][i * m + j] = 1;
}
}
for (int i = 0; i < q; i++) {
int op, x, y, t;
scanf("%d%d%d%d", &op, &x, &y, &t);
x--, y--;
if (op == 1) {
dp = mul(dp, qpow(way, t - tt));
printf("%lld\n", dp.matrix[0][x * m + y]);
} else if (op == 2) {
dp = mul(dp, qpow(way, t - tt));
dp.matrix[0][x * m + y] = 0;
way.matrix[x * m + y][x * m + y] = 0;
cat[x][y] = 1;
for (int j = 0; j < 4; j++) {
int xx = x + dx[j], yy = y + dy[j];
if (xx < 0 || xx >= n || yy < 0 || yy >= m) continue;
int id1 = x * m + y, id2 = xx * m + yy;
way.matrix[id1][id2] = way.matrix[id2][id1] = 0;
}
} else {
dp = mul(dp, qpow(way, t - tt));
cat[x][y] = 0;
way.matrix[x * m + y][x * m + y] = 1;
for (int j = 0; j < 4; j++) {
int xx = x + dx[j], yy = y + dy[j];
if (xx < 0 || xx >= n || yy < 0 || yy >= m) continue;
int id1 = x * m + y, id2 = xx * m + yy;
if (cat[x][y] == 0 && cat[xx][yy] == 0)
way.matrix[id1][id2] = way.matrix[id2][id1] = 1;
}
}
tt = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct Matrix {
int m[22][22];
void standard(int n) {
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)n; j++) m[i][j] = (i == j);
}
void show(int n) {
for (int i = 0; i < (int)n; i++) {
for (int j = 0; j < (int)n; j++) cout << m[i][j] << " ";
cout << endl;
}
}
};
int n;
Matrix mul(Matrix A, Matrix B) {
Matrix C;
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)n; j++) {
C.m[i][j] = 0;
for (int k = 0; k < (int)n; k++)
C.m[i][j] = (C.m[i][j] + (long long)A.m[i][k] * B.m[k][j] % mod) % mod;
}
return C;
}
Matrix pow_(Matrix A, int c) {
Matrix ret;
ret.standard(n);
while (c > 0) {
if (c & 1) ret = mul(ret, A);
A = mul(A, A);
c >>= 1;
}
return ret;
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
int r, c, q;
int main() {
scanf("%d %d %d", &r, &c, &q);
n = r * c;
Matrix A;
A.standard(n);
for (int i = 0; i < (int)r; i++)
for (int j = 0; j < (int)c; j++) {
for (int d = 0; d < (int)4; d++) {
int ni = i + dx[d], nj = j + dy[d];
if (ni >= 0 && ni < r && nj >= 0 && nj < c)
A.m[i * c + j][ni * c + nj] = 1;
}
}
Matrix all, now;
all.standard(n);
int pret = 1, vis[22] = {0};
while (q--) {
int cmd, x, y, t;
scanf("%d %d %d %d", &cmd, &x, &y, &t), --x, --y;
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)n; j++) {
if (!vis[i] && !vis[j])
now.m[i][j] = A.m[i][j];
else
now.m[i][j] = 0;
}
if (cmd == 1) {
all = mul(all, pow_(now, t - pret));
cout << all.m[0][x * c + y] << endl;
pret = t;
} else if (cmd == 2) {
all = mul(all, pow_(now, t - pret));
pret = t;
vis[x * c + y] = 1;
} else {
all = mul(all, pow_(now, t - pret));
pret = t;
vis[x * c + y] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 1e9 + 7;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int flag[25][25], vis[25];
int upd(int x, int y) { return x + y >= mods ? x + y - mods : x + y; }
struct Matrix {
int A[25][25], n;
Matrix(int n1 = 0) {
n = n1;
memset(A, 0, sizeof A);
}
void Init() {
for (int i = 0; i < n; i++) A[i][i] = 1;
}
Matrix operator*(Matrix b) {
Matrix Ans(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
Ans.A[i][j] = upd(Ans.A[i][j], 1ll * A[i][k] * b.A[k][j] % mods);
return Ans;
}
Matrix operator^(int y) {
Matrix x = *this, ret(n);
ret.Init();
for (; y; y >>= 1) {
if (y & 1) ret = ret * x;
x = x * x;
}
return ret;
}
void print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << A[i][j] << " ";
cout << endl;
}
cout << endl;
}
} Ans;
signed main() {
int n = read(), m = read(), N = n * m, q = read();
Matrix g(N);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
if (abs(i - x) + abs(j - y) <= 1)
flag[i * m + j][x * m + y] = g.A[i * m + j][x * m + y] = 1;
Matrix Ans(N);
Ans.Init();
for (int i = 0; i < N; i++) vis[i] = 1;
for (int lst = 1; q; q--) {
int opt = read(), x = read() - 1, y = read() - 1, t = read();
Ans = Ans * (g ^ (t - 1 - lst));
if (opt == 2)
vis[x * m + y] = 0, lst = t - 1;
else if (opt == 3)
Ans = Ans * g, vis[x * m + y] = 1, lst = t;
else {
Ans = Ans * g, lst = t;
printf("%d\n", Ans.A[0][x * m + y]);
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) g.A[i][j] = flag[i][j] & vis[j];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T Dist(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Chkbit(int N, int pos) { return (bool)(N & (1 << pos)); }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
long long int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
struct Matrix {
long long int ar[22][22];
};
int k;
Matrix MUL(Matrix a, Matrix b) {
Matrix ans;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
ans.ar[i][j] = 0;
for (int kk = 0; kk < k; kk++) {
ans.ar[i][j] = (ans.ar[i][j] + a.ar[i][kk] * b.ar[kk][j]) % 1000000007;
}
}
}
return ans;
}
Matrix Unit;
Matrix Big_Mod(Matrix a, int n) {
Matrix ans = Unit;
while (n) {
if (n & 1) {
ans = MUL(ans, a);
}
a = MUL(a, a);
n /= 2;
}
return ans;
}
int a[22][22];
Matrix Base;
int dx[] = {1, -1, 0, 0, 0};
int dy[] = {0, 0, -1, 1, 0};
int n, m, q;
int Id[22][22];
void MakeBaseMatrix() {
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
Base.ar[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 0) continue;
for (int kk = 0; kk < 5; kk++) {
int first = i + dx[kk], second = j + dy[kk];
if (first >= 0 && first < n && second >= 0 && second < m &&
a[first][second]) {
Base.ar[Id[i][j]][Id[first][second]] = 1;
}
}
}
}
}
void Dekhi() {
int id = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
Id[i][j] = id++;
}
}
}
void Prnt(Matrix aa) {
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
cout << aa.ar[i][j] << " ";
}
printf("\n");
}
printf("\n");
}
int main() {
n = in<int>(), m = in<int>(), q = in<int>();
k = n * m;
Matrix now;
int pv = 1;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
a[i][j] = 1;
}
}
Dekhi();
memset(now.ar, 0, sizeof(now.ar));
for (int i = 0; i < k; i++) now.ar[i][i] = 1;
Unit = now;
for (int i = 0; i < q; i++) {
int tp, x, y, t;
tp = in<int>(), x = in<int>(), y = in<int>();
t = in<int>();
x--, y--;
int baki = (t - pv);
if (tp == 1) {
MakeBaseMatrix();
Matrix tp = Big_Mod(Base, baki);
now = MUL(tp, now);
printf("%lld\n", now.ar[Id[x][y]][0]);
pv = t;
} else if (tp == 2) {
MakeBaseMatrix();
Matrix tp = Big_Mod(Base, baki);
now = MUL(tp, now);
a[x][y] = 0;
pv = t;
} else {
MakeBaseMatrix();
Matrix tp = Big_Mod(Base, baki);
now = MUL(tp, now);
a[x][y] = 1;
pv = t;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
int mul(int a, int b) { return (a * 1LL * b) % MOD; }
int add(int a, int b) { return (a + b) % MOD; }
typedef int dim;
void setUnit(vector<vector<dim> > &mat) {
for (int i = 0; i < ((int)(mat).size()); i++) mat[i][i] = dim(1);
}
void setDimension(vector<vector<dim> > &mat, int n, int m) {
mat.clear();
mat.resize(n, vector<dim>(m, dim(0)));
}
vector<vector<dim> > addMat(vector<vector<dim> > A, vector<vector<dim> > B) {
int n = ((int)(A).size());
int m = ((int)(A[0]).size());
vector<vector<dim> > mat;
setDimension(mat, n, m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) mat[i][j] = add(A[i][j], B[i][j]);
return mat;
}
vector<vector<dim> > mulMat(vector<vector<dim> > A, vector<vector<dim> > B) {
int n = ((int)(A).size());
int m = ((int)(B[0]).size());
int nm = ((int)(A[0]).size());
vector<vector<dim> > mat;
setDimension(mat, n, m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < nm; k++)
mat[i][j] = add(mat[i][j], mul(A[i][k], B[k][j]));
return mat;
}
vector<vector<dim> > powMat(vector<vector<dim> > A, int b) {
int n = ((int)(A).size());
vector<vector<dim> > mat;
setDimension(mat, n, n);
setUnit(mat);
while (b) {
if (b & 1) mat = mulMat(mat, A);
A = mulMat(A, A);
b >>= 1;
}
return mat;
}
vector<vector<dim> > mulMat(vector<vector<dim> > A, dim r) {
int n = ((int)(A).size());
int m = ((int)(A[0]).size());
vector<vector<dim> > mat;
setDimension(mat, n, m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) mat[i][j] = mul(A[i][j], r);
return mat;
}
vector<vector<dim> > mat_zero, mat;
int n, m, q;
int dir_x[] = {+1, 0, -1, 0};
int dir_y[] = {0, +1, 0, -1};
bool forbidden[111][111];
void power(int p) {
mat = powMat(mat, p);
mat_zero = mulMat(mat_zero, mat);
}
inline bool inRange(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void buildMat() {
setDimension(mat, n * m, n * m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j)
if (!forbidden[i][j]) {
for (int k = 0; k < 4; ++k) {
int xx = i + dir_x[k];
int yy = j + dir_y[k];
if (inRange(xx, yy) && !forbidden[xx][yy]) {
mat[xx * m + yy][i * m + j] = 1;
}
}
mat[i * m + j][i * m + j] = 1;
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
setDimension(mat, n * m, n * m);
setDimension(mat_zero, 1, n * m);
mat_zero[0][0] = 1;
buildMat();
int cur_time = 1;
for (int i = 0; i < q; ++i) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
x--;
y--;
power(t - cur_time);
switch (tp) {
case 1: {
printf("%d\n", mat_zero[0][x * m + y]);
break;
}
case 2: {
forbidden[x][y] = true;
mat_zero[0][x * m + y] = 0;
break;
}
case 3: {
forbidden[x][y] = false;
mat_zero[0][x * m + y] = 0;
break;
}
}
buildMat();
cur_time = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
vector<vector<long long> > mul(const vector<vector<long long> >& A,
const vector<vector<long long> >& B) {
const int R = A.size(), C = B[0].size(), sz = B.size();
vector<vector<long long> > AB(R, vector<long long>(C));
for (int i = 0; i < R; ++i)
for (int j = 0; j < C; ++j)
for (int k = 0; k < sz; ++k) {
AB[i][j] += A[i][k] * B[k][j];
AB[i][j] %= MOD;
}
return AB;
}
vector<vector<long long> > powA(const vector<vector<long long> >& A, int n) {
const int N = A.size();
vector<vector<long long> > p(N, vector<long long>(N, 0)), w = A;
for (int i = 0; i < N; ++i) p[i][i] = 1;
while (n > 0) {
if (n & 1) p = move(mul(p, w));
w = move(mul(w, w));
n >>= 1;
}
return p;
}
int dx[] = {-1, 0, 1, 0, 0};
int dy[] = {0, -1, 0, 1, 0};
int R, C, Q, N;
bool tab[30][30];
vector<vector<long long> > f() {
vector<vector<long long> > mtx(N, vector<long long>(N, 0));
for (int y = (0); y < (R); ++y)
for (int x = (0); x < (C); ++x) {
if (!tab[y][x]) continue;
for (int i = (0); i < (5); ++i) {
int tx = x + dx[i], ty = y + dy[i];
if (tx < 0 || C <= tx || ty < 0 || R <= ty || !tab[ty][tx]) continue;
mtx[y * C + x][ty * C + tx] = 1;
}
}
return mtx;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> R >> C >> Q;
N = R * C;
vector<vector<long long> > num(N, vector<long long>(1, 0));
num[0][0] = 1;
fill((bool*)tab, (bool*)tab + 30 * 30, true);
int prvt = 1;
for (int q = (0); q < (Q); ++q) {
int tp, x, y, t;
cin >> tp >> y >> x >> t;
--x, --y;
if (tp == 1) {
vector<vector<long long> > m = move(f());
vector<vector<long long> > p = move(powA(m, t - prvt));
num = move(mul(p, num));
cout << num[y * C + x][0] << endl;
} else if (tp == 2) {
vector<vector<long long> > m = move(f());
vector<vector<long long> > p = move(powA(m, t - prvt));
num = move(mul(p, num));
tab[y][x] = false;
num[y * C + x][0] = 0;
} else {
vector<vector<long long> > m = move(f());
vector<vector<long long> > p = move(powA(m, t - prvt));
num = move(mul(p, num));
tab[y][x] = true;
}
prvt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25, P = 1000000007;
using ll = long long;
int n, m, q, l;
struct Matrix {
ll a[N][N] = {};
ll *operator[](const size_t &s) { return a[s]; }
const ll *operator[](const size_t &s) const { return a[s]; }
};
Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix c;
for (int i = 1; i <= l; i++)
for (int j = 1; j <= l; j++)
for (int k = 1; k <= l; k++)
c[i][j] = (c[i][j] + a[i][k] * b[k][j] % P) % P;
return c;
}
inline void output(Matrix &a) {
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= l; j++) cout << a[i][j] << ' ';
cout << endl;
}
}
Matrix qpow(Matrix a, int b) {
Matrix ret;
for (int i = 1; i <= l; i++) ret[i][i] = 1;
while (b) {
if (b & 1) {
ret = ret * a;
}
a = a * a;
b >>= 1;
}
return ret;
}
bool vis[N][N];
int main() {
cin >> n >> m >> q;
l = n * m;
Matrix ans, cur;
ans[1][1] = 1;
int tp, x, y, t, lt = 1;
for (int _ = 1; _ <= q; _++) {
cin >> tp >> x >> y >> t;
for (int i = 1; i <= l; i++)
for (int j = i; j <= l; j++) {
int x1 = (i - 1) / m + 1, y1 = (i - 1) % m + 1;
int x2 = (j - 1) / m + 1, y2 = (j - 1) % m + 1;
if (!vis[x1][y1] && !vis[x2][y2] && abs(x1 - x2) + abs(y1 - y2) < 2)
cur[i][j] = cur[j][i] = 1;
else
cur[i][j] = cur[j][i] = 0;
}
ans = ans * qpow(cur, t - lt);
if (tp == 1)
cout << ans[1][(x - 1) * m + y] << endl;
else if (tp == 2)
ans[1][(x - 1) * m + y] = 0, vis[x][y] = 1;
else if (tp == 3)
ans[1][(x - 1) * m + y] = 0, vis[x][y] = 0;
lt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, i, j, tp, x, y, t, dp[20], d[20][20], e[20][20],
yon[5][2] = {{0, 0}, {1, 0}, {0, 1}, {-1, 0}, {0, -1}}, q, last, res,
dp2[20], t1;
bool gez[20][20];
void build() {
memset(d, 0, sizeof d);
int i, j, l, x1, y1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
for (l = 0; l < 5; l++) {
x1 = i + yon[l][0];
y1 = j + yon[l][1];
if (x1 >= 0 and x1 < n and y1 >= 0 and y1 < m and !gez[i][j] and
!gez[x1][y1])
d[m * i + j][m * x1 + y1] = 1;
}
}
}
memcpy(e, d, sizeof d);
}
void crp() {
int i, j, l, tmp[20][20], res;
for (i = 0; i < k; i++) {
for (j = 0; j < k; j++) {
res = 0;
for (l = 0; l < k; l++)
res = (res + 1ll * d[i][l] * e[l][j]) % 1000000007;
tmp[i][j] = res;
}
}
memcpy(d, tmp, sizeof tmp);
}
void mrg() {
int i, j, l, tmp[20][20], res;
for (i = 0; i < k; i++) {
for (j = 0; j < k; j++) {
res = 0;
for (l = 0; l < k; l++)
res = (res + 1ll * d[i][l] * d[l][j]) % 1000000007;
tmp[i][j] = res;
}
}
memcpy(d, tmp, sizeof tmp);
}
void carp(int x) {
if (x == 1) return;
carp(x / 2);
mrg();
if (x % 2) crp();
}
int main() {
scanf("%d %d %d", &n, &m, &q);
k = n * m;
last = 1;
dp[0] = 1;
for (t1 = 0; t1 < q; t1++) {
scanf("%d %d %d %d", &tp, &x, &y, &t);
x--;
y--;
build();
carp(t - last);
last = t;
for (i = 0; i < k; i++) {
res = 0;
for (j = 0; j < k; j++) res = (res + 1ll * dp[j] * d[j][i]) % 1000000007;
dp2[i] = res;
}
for (i = 0; i < k; i++) dp[i] = dp2[i];
if (tp == 1)
printf("%d\n", dp[x * m + y]);
else if (tp == 2) {
gez[x][y] = 1;
dp[x * m + y] = 0;
} else
gez[x][y] = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int ts, kk = 1;
long long int q[25][25], fb[25][25], fr[25];
int sz;
void frmul() {
int j, k;
for (j = 0; j < sz; j++) {
q[0][j] = 0;
for (k = 0; k < sz; k++) {
q[0][j] += (fr[k] * fb[k][j]);
if (q[0][j] >= 1000000007LL) q[0][j] %= 1000000007LL;
}
}
for (j = 0; j < sz; j++) fr[j] = q[0][j];
}
void fbmul() {
int i, j, k;
for (i = 0; i < sz; i++) {
for (j = 0; j < sz; j++) {
q[i][j] = 0;
for (k = 0; k < sz; k++) {
q[i][j] += (fb[i][k] * fb[k][j]);
if (q[i][j] >= 1000000007LL) q[i][j] %= 1000000007LL;
}
}
}
for (i = 0; i < sz; i++)
for (j = 0; j < sz; j++) fb[i][j] = q[i][j];
}
void expo(int p) {
for (; p > 0; p >>= 1) {
if (p & 1) frmul();
fbmul();
}
}
int n, m;
int gr[23][23];
bool bl[23][23];
void bldfb() {
memset(fb, 0, sizeof(fb));
int i, j, k, x, y;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (bl[i][j] == 1) {
continue;
}
fb[gr[i][j]][gr[i][j]] = 1LL;
for (k = 0; k < 4; k++) {
x = i + dx[k];
y = j + dy[k];
if (x < 0 || y < 0 || x >= n || y >= m) continue;
fb[gr[x][y]][gr[i][j]] = 1LL;
}
}
}
}
int main() {
int t, i, j, k, q, x, y, ct, u, v;
memset(fr, 0, sizeof(fr));
fr[0] = 1LL;
ct = 1;
scanf("%d%d%d", &n, &m, &q);
sz = n * m;
k = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
bl[i][j] = 0;
gr[i][j] = k++;
}
}
while (q--) {
scanf("%d%d%d%d", &t, &x, &y, &k);
x--;
y--;
if (t == 1) {
bldfb();
expo(k - ct);
ct = k;
printf("%lld\n", fr[gr[x][y]]);
} else if (t == 2) {
bldfb();
expo(k - ct - 1);
bl[x][y] = 1;
bldfb();
expo(1);
ct = k;
} else if (t == 3) {
bldfb();
expo(k - ct);
ct = k;
bl[x][y] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int Mat_SIZE = 21;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int szz;
struct Matrix {
int mat[Mat_SIZE][Mat_SIZE];
void init() {
for (int i = 0; i < szz; i++)
for (int j = 0; j < szz; j++) mat[i][j] = 0;
}
void init_base() {
init();
for (int i = 0; i < szz; i++) mat[i][i] = 1;
}
void display() {
for (int i = 0; i < szz; i++) {
for (int j = 0; j < szz; j++) cout << mat[i][j] << ' ';
cout << endl;
}
}
} base, A;
Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix c;
for (int i = 0; i < szz; i++)
for (int j = 0; j < szz; j++) {
c.mat[i][j] = 0;
for (int k = 0; k < szz; k++)
c.mat[i][j] =
(c.mat[i][j] + (long long)a.mat[i][k] * b.mat[k][j] % MOD) % MOD;
}
return c;
}
Matrix operator^(Matrix a, int k) {
Matrix ret;
ret.init_base();
while (k) {
if (k & 1) ret = ret * a;
a = a * a;
k >>= 1;
}
return ret;
}
int n, m, q, ty, x, y, t;
int cat[Mat_SIZE][Mat_SIZE];
int dx[4] = {0, 0, -1, 1};
int dy[4] = {-1, 1, 0, 0};
int id(int x, int y) { return x * m + y; }
bool ing(int x, int y) {
if (x < 0 || x >= n) return false;
if (y < 0 || y >= m) return false;
return true;
}
void get_base() {
base.init();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (!cat[i][j]) base.mat[id(i, j)][id(i, j)] = 1;
for (int k = 0; k < 4; k++) {
int nx = i + dx[k];
int ny = j + dy[k];
if (!ing(nx, ny) || cat[nx][ny]) continue;
base.mat[id(i, j)][id(nx, ny)] = 1;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
szz = n * m;
get_base();
A.init();
A.mat[0][0] = 1;
int curx = 0, cury = 0, curt = 1;
for (int i = 0; i < q; i++) {
scanf("%d%d%d%d", &ty, &x, &y, &t);
x--;
y--;
if (ty == 1) {
A = A * (base ^ (t - curt));
printf("%d\n", A.mat[0][id(x, y)]);
} else if (ty == 2) {
A = A * (base ^ (t - curt - 1));
cat[x][y] = 1;
for (int k = 0; k < 4; k++) {
int nx = x + dx[k];
int ny = y + dy[k];
if (!ing(nx, ny)) continue;
base.mat[id(nx, ny)][id(x, y)] = 0;
base.mat[id(x, y)][id(nx, ny)] = cat[nx][ny] ^ 1;
}
base.mat[id(x, y)][id(x, y)] = 0;
A = A * base;
} else {
A = A * (base ^ (t - curt));
cat[x][y] = 0;
for (int k = 0; k < 4; k++) {
int nx = x + dx[k];
int ny = y + dy[k];
if (!ing(nx, ny)) continue;
base.mat[id(nx, ny)][id(x, y)] = 1;
base.mat[id(x, y)][id(nx, ny)] = cat[nx][ny] ^ 1;
}
base.mat[id(x, y)][id(x, y)] = 1;
get_base();
}
curx = x;
cury = y;
curt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAX_N = (int)1e5 + 123;
const double eps = 1e-6;
const int mod = (int)1e9 + 7;
using namespace std;
struct matrix {
int n, m;
int a[22][22];
matrix() {}
matrix(int _n, int _m) {
n = _n, m = _m;
memset(a, 0, sizeof a);
}
void init() {
for (int i = 0; i < min(n, m); i++) a[i][i] = 1;
}
matrix operator*(matrix b) {
matrix res = matrix(n, b.m);
for (int i = 0; i < n; i++)
for (int j = 0; j < b.m; j++) {
int sum = 0;
for (int k = 0; k < m; k++)
sum = (sum + 1ll * a[i][k] * b.a[k][j] % mod) % mod;
res.a[i][j] = sum;
}
return res;
}
} A, B;
matrix binpow(matrix a, int b) {
matrix res = matrix(a.n, a.m);
res.init();
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int n, m, q;
int tp, x, y, t;
int moves[5][2] = {{0, 0}, {1, 0}, {-1, 0}, {0, 1}, {0, -1}};
bool u[24][24];
int main() {
cin >> n >> m >> q;
A = matrix(1, n * m);
A.a[0][0] = 1;
B = matrix(n * m, n * m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 5; k++) {
int ni = i + moves[k][0], nj = j + moves[k][1];
if (ni >= 0 && ni < n && nj >= 0 && nj < m)
B.a[ni * m + nj][i * m + j] = 1;
}
for (int i = 1, now = 1; i <= q; i++) {
cin >> tp >> x >> y >> t;
A = A * binpow(B, t - now);
now = t;
x--, y--;
if (tp == 1)
cout << A.a[0][x * m + y] << endl;
else if (tp == 2) {
u[x][y] = 1;
A.a[0][x * m + y] = 0;
for (int k = 0; k < 5; k++) {
int nx = x + moves[k][0], ny = y + moves[k][1];
if (nx >= 0 && nx < n && ny >= 0 && ny < m)
B.a[x * m + y][nx * m + ny] = B.a[nx * m + ny][x * m + y] = 0;
}
} else {
u[x][y] = 0;
for (int k = 0; k < 5; k++) {
int nx = x + moves[k][0], ny = y + moves[k][1];
if (nx >= 0 && nx < n && ny >= 0 && ny < m && !u[nx][ny])
B.a[x * m + y][nx * m + ny] = B.a[nx * m + ny][x * m + y] = 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int M[44][44], Me[44][44], V[44], Ve[44], C[44][44];
int x, y, n;
void build() {
int a, b, A, B, i, j, k;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
a = i / y;
b = i % y;
A = j / y;
B = j % y;
k = abs(A - a) + abs(B - b);
if (k <= 1 && C[a][b] == 0 && C[A][B] == 0)
M[i][j] = 1;
else
M[i][j] = 0;
}
}
int main() {
int i, j, k, l, q, a, b, t = 1, e, mod = 1000000007;
V[0] = 1;
scanf("%d%d%d", &x, &y, &q);
n = x * y;
while (q--) {
build();
scanf("%d%d%d%d", &l, &a, &b, &k);
--a;
--b;
e = k - t;
t = k;
while (1) {
if (e & 1) {
for (i = 0; i < n; i++)
for (Ve[i] = j = 0; j < n; j++)
Ve[i] = (Ve[i] + M[i][j] * (long long)V[j]) % mod;
for (i = 0; i < n; i++) V[i] = Ve[i];
}
e >>= 1;
if (e == 0) break;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
for (Me[i][j] = k = 0; k < n; k++)
Me[i][j] = (Me[i][j] + M[i][k] * (long long)M[k][j]) % mod;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) M[i][j] = Me[i][j];
}
if (l == 3) {
V[a * y + b] = 0;
C[a][b] = 0;
}
if (l == 2) {
V[a * y + b] = 0;
C[a][b] = 1;
}
if (l == 1) printf("%d\n", V[a * y + b]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = 25, mod = (int)1e9 + 7;
unordered_map<int, long long> dp[maxn][maxn][maxn][maxn];
bool us[maxn][maxn];
int n, m;
void clear() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int t = 1; t <= n; t++) {
for (int k = 1; k <= m; k++) {
dp[i][j][t][k].clear();
}
}
}
}
}
long long go(int x1, int y1, int x2, int y2, int t) {
if (us[x1][y1] || us[x2][y2]) {
dp[x1][y1][x2][y2][t] = 0;
}
if (!dp[x1][y1][x2][y2].count(t)) {
if (t == 0) {
if (x1 == x2 && y1 == y2) {
dp[x1][y1][x2][y2][t] = 1;
} else {
dp[x1][y1][x2][y2][t] = 0;
}
} else if (t == 1) {
if (abs(x1 - x2) + abs(y1 - y2) <= 1) {
dp[x1][y1][x2][y2][t] = 1;
} else {
dp[x1][y1][x2][y2][t] = 0;
}
} else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!us[i][j]) {
dp[x1][y1][x2][y2][t] +=
go(x1, y1, i, j, t / 2) * go(i, j, x2, y2, t - t / 2);
dp[x1][y1][x2][y2][t] %= mod;
}
}
}
}
}
return dp[x1][y1][x2][y2][t];
}
long long cnt[maxn][maxn];
long long ncnt[maxn][maxn];
int main() {
int q;
scanf("%d %d %d", &n, &m, &q);
int last = 1;
cnt[1][1] = 1;
while (q--) {
int tp;
scanf("%d", &tp);
int x, y, tt;
scanf("%d %d %d", &x, &y, &tt);
clear();
memset(ncnt, 0, sizeof ncnt);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int t = 1; t <= n; t++) {
for (int k = 1; k <= m; k++) {
ncnt[i][j] += cnt[t][k] * go(t, k, i, j, tt - last);
ncnt[i][j] %= mod;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cnt[i][j] = ncnt[i][j];
}
}
if (tp == 2) {
cnt[x][y] = 0;
us[x][y] = true;
} else if (tp == 3) {
us[x][y] = false;
} else {
printf("%I64d\n", cnt[x][y]);
}
last = tt;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, N = 1e4 + 5;
int add(int a, int b) { return (a + b) % MOD; }
int multiply(int a, int b) { return 1LL * a * b % MOD; }
struct mat {
int a[20][20], h, w;
mat(int h = 0, int w = 0) : h(h), w(w) { memset(a, 0, sizeof(a)); }
};
mat operator*(const mat &a, const mat &b) {
mat res = mat(a.h, b.w);
for (int k = 0; k < a.w; ++k) {
for (int i = 0; i < a.h; ++i) {
for (int j = 0; j < b.w; ++j) {
res.a[i][j] = add(res.a[i][j], multiply(a.a[i][k], b.a[k][j]));
}
}
}
return res;
}
mat operator^(mat a, int n) {
mat ans = mat(a.h, a.w);
for (int i = 0; i < a.h; ++i) ans.a[i][i] = 1;
while (n) {
if (n & 1) ans = ans * a;
a = a * a;
n >>= 1;
}
return ans;
}
bool cat[25][25];
mat build(int n, int m) {
mat ans = mat(n * m, n * m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (cat[i][j]) continue;
int tmp = i * m + j;
ans.a[tmp][tmp] = 1;
if (i > 0 && !cat[i - 1][j]) ans.a[(i - 1) * m + j][tmp] = 1;
if (i < n - 1 && !cat[i + 1][j]) ans.a[(i + 1) * m + j][tmp] = 1;
if (j > 0 && !cat[i][j - 1]) ans.a[i * m + j - 1][tmp] = 1;
if (j < m - 1 && !cat[i][j + 1]) ans.a[i * m + j + 1][tmp] = 1;
}
}
return ans;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
mat ans = mat(1, n * m);
ans.a[0][0] = 1;
int last = 1;
for (int i = 1; i <= q; ++i) {
int type, x, y, t;
scanf("%d%d%d%d", &type, &x, &y, &t);
x--;
y--;
ans = ans * (build(n, m) ^ (t - last));
last = t;
if (type == 1) {
printf("%d\n", ans.a[0][x * m + y]);
} else if (type == 2) {
cat[x][y] = 1;
} else {
cat[x][y] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using uint8 = unsigned char;
using uint16 = unsigned short int;
using uint32 = unsigned int;
using uint64 = unsigned long long;
using int8 = signed char;
using int16 = short int;
using int32 = int;
using int64 = long long;
using int128 = __int128;
using pi32 = std::pair<int32, int32>;
namespace oct {
const int tn4[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int tn8[8][2] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1},
{-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
void sync();
template <typename _Tp>
_Tp &mad(_Tp &x, _Tp y);
template <typename _Tp>
_Tp &mid(_Tp &x, _Tp y);
template <typename _Tp>
bool in(_Tp x, _Tp l, _Tp r);
template <typename _Tp>
_Tp sqr(_Tp x);
inline void sync() {
std::ios::sync_with_stdio(0);
std::cin.tie(0), std::cout.tie(0);
}
template <typename _Tp>
inline _Tp &mad(_Tp &x, _Tp y) {
return x = std::max(x, y);
}
template <typename _Tp>
inline _Tp &mid(_Tp &x, _Tp y) {
return x = std::min(x, y);
}
template <typename _Tp>
inline bool in(_Tp x, _Tp l, _Tp r) {
return l <= x && x <= r;
}
template <typename _Tp>
inline _Tp sqr(_Tp x) {
return x * x;
}
} // namespace oct
class matrix;
const int C = 20;
const int64 mod = 1000000007;
class matrix {
public:
int64 d[C][C];
matrix();
int64 *operator[](int x);
};
matrix operator*(matrix x, matrix y);
void update(int x, int y);
int n, m, q, p, x, y, t, nx, ny, ti, tmp;
int can[C];
int id[C][C];
matrix now, put, e;
inline matrix::matrix() { memset(d, 0, sizeof(d)); }
inline int64 *matrix::operator[](int x) { return d[x]; }
inline matrix operator*(matrix x, matrix y) {
matrix ans;
register int i, j, k;
for (i = 0; i < C; ++i) {
for (j = 0; j < C; ++j) {
for (k = 0; k < C; ++k) ans[i][j] += x[i][k] * y[k][j] % mod;
ans[i][j] %= mod;
}
}
return ans;
}
inline void update(int x, int y) {
put[id[x][y]][id[x][y]] = can[id[x][y]];
for (int i = 0; i < 4; ++i) {
nx = x + oct::tn4[i][0];
ny = y + oct::tn4[i][1];
if (nx < 0 || nx == n || ny < 0 || ny == m) continue;
nx = id[nx][ny], ny = id[x][y];
put[nx][ny] = put[ny][nx] = can[nx] && can[ny];
}
}
inline matrix power(matrix x, int y) {
return y ? power(x * x, y / 2) * (y & 1 ? x : e) : e;
}
int main() {
oct::sync();
std::cin >> n >> m >> q;
now[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) id[i][j] = i * m + j;
}
for (int i = 0; i < n * m; ++i) can[i] = 1, e[i][i] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 1; j < m; ++j) {
x = id[i][j - 1], y = id[i][j];
put[x][y] = put[y][x] = 1;
}
}
for (int i = 1; i < n; ++i) {
for (int j = 0; j < m; ++j) {
x = id[i - 1][j], y = id[i][j];
put[x][y] = put[y][x] = 1;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) x = id[i][j], put[x][x] = 1;
}
ti = 1;
while (q--) {
std::cin >> p >> x >> y >> t;
--x, --y;
now = power(put, t - ti) * now;
if (p == 1) {
std::cout << now[id[x][y]][0] << '\n';
} else if (p == 2) {
can[id[x][y]] = 0;
update(x, y);
} else {
can[id[x][y]] = 1;
update(x, y);
}
ti = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
const int maxm = maxn * 4 + 10;
const int inf = 1e9;
const long long mod = 1e9 + 7;
int getint() {
char c;
while ((c = getchar()) && !(c >= '0' && c <= '9') && c != '-')
;
int ret = c - '0', sgn = 0;
if (c == '-') sgn = 1, ret = 0;
while ((c = getchar()) && c >= '0' && c <= '9') ret = ret * 10 + c - '0';
if (sgn) ret = -ret;
return ret;
}
struct matrix {
int r, c;
long long p[maxn][maxn];
matrix() { memset(p, 0, sizeof(p)); }
matrix operator*(matrix a) const {
matrix ret;
ret.r = r, ret.c = a.c;
for (int k = 0; k < c; k++) {
for (int i = 0; i < r; i++) {
if (p[i][k] == 0) continue;
for (int j = 0; j < a.c; j++) {
ret.p[i][j] += (p[i][k] * a.p[k][j]) % mod;
ret.p[i][j] %= mod;
}
}
}
return ret;
}
void show() {
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cout << p[i][j] << " ";
}
cout << endl;
}
}
};
matrix m_pow(matrix a, int k) {
matrix ans;
ans.r = ans.c = a.r;
for (int i = 0; i < ans.r; i++) ans.p[i][i] = 1;
while (k) {
if (k & 1) ans = ans * a;
a = a * a;
k >>= 1;
}
return ans;
}
int dx[4] = {0, 0, -1, 1}, dy[4] = {-1, 1, 0, 0};
matrix mx;
int vis[maxn][maxn];
int n, m, t;
void update() {
memset(mx.p, 0, sizeof(mx.p));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (vis[i][j]) continue;
mx.p[i * m + j][i * m + j] = 1;
for (int k = 0; k < 4; k++) {
int nx = i + dx[k];
int ny = j + dy[k];
if (nx >= 0 && nx < n && ny >= 0 && ny < m && !vis[nx][ny]) {
mx.p[i * m + j][nx * m + ny] = 1;
}
}
}
}
}
int main() {
while (scanf("%d%d%d", &n, &m, &t) == 3) {
memset(vis, 0, sizeof(vis));
mx.r = mx.c = n * m;
matrix st;
st.r = n * m, st.c = 1;
st.p[0][0] = 1;
int cur = 1;
while (t--) {
int op = getint(), x = getint(), y = getint(), tt = getint();
x--, y--;
if (op == 1) {
update();
st = m_pow(mx, tt - cur) * st;
cur = tt;
cout << st.p[x * m + y][0] << endl;
} else {
update();
st = m_pow(mx, tt - cur) * st;
cur = tt;
if (op == 2) st.p[x * m + y][0] = 0;
vis[x][y] = op == 2;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
const double INF = 1e18;
long long mod = 1e9 + 7;
struct matrix {
long long n, m;
vector<long long> mas;
matrix(long long n1 = 0, long long m1 = 0) : n(n1), m(m1) {
mas.assign(n * m, 0);
}
long long at(long long i, long long j) { return mas[i * m + j]; }
void setat(long long i, long long j, long long m, long long elem) {
mas[i * m + j] = elem;
}
long long at2(long long i, long long j, long long m) {
return mas[i * m + j];
}
matrix& operator*=(matrix& a) {
vector<long long> res(n * a.m, 0);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < a.m; j++) {
for (long long k = 0; k < m; k++) {
if (a.at(j, k) != -1)
res[i * a.m + j] =
(res[i * a.m + j] + at(i, k) * a.at(k, j) % mod) % mod;
}
}
}
swap(mas, res);
m = a.m;
return *this;
}
};
matrix operator*(matrix& a, matrix& b) {
matrix res = a;
res *= b;
return res;
}
void fib(matrix& res, matrix& a, long long n) {
while (n > 0) {
if (n & 1) {
res = a * res;
}
a *= a;
n >>= 1;
}
}
int main() {
ios::sync_with_stdio(false);
long long n, m, q;
cin >> n >> m >> q;
long long N = n * m;
matrix res(N, 1);
matrix a(N, N);
matrix c;
for (long long k = 0; k < N; k++) {
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
a.setat(k, k, a.m, 1);
if (k % m != 0) a.setat(k, k - 1, a.m, 1);
if ((k + 1) % m != 0) a.setat(k, k + 1, a.m, 1);
if (k + m < a.m) a.setat(k, k + m, a.m, 1);
if (k - m >= 0) a.setat(k, k - m, a.m, 1);
}
}
}
res.setat(0, 0, m, 1);
long long e, x, y, t;
long long timer = 1;
c = a;
matrix a1;
for (long long i = 0; i < q; i++) {
cin >> e >> x >> y >> t;
x--;
y--;
if (e == 1) {
a1 = a;
fib(res, a1, t - timer);
timer = t;
cout << res.at2(x, y, m) << endl;
}
if (e == 2) {
a1 = a;
fib(res, a1, t - timer);
res.setat(x, y, m, 0);
for (long long i = 0; i < N; i++) {
a.setat(x * m + y, i, N, 0);
}
timer = t;
}
if (e == 3) {
a1 = a;
fib(res, a1, t - timer);
for (long long i = 0; i < a.n; i++) {
a.setat(x * m + y, i, N, c.at2(x * m + y, i, N));
}
timer = t;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20, mod = 1000000007;
const int kombX[4] = {0, 0, 1, -1};
const int kombY[4] = {1, -1, 0, 0};
inline int add(int a, int b) { return (a + b) % mod; }
inline int mul(int a, int b) { return ((long long int)a * b) % mod; }
int n, m, q, trenutno = 1, N;
int mat[MAXN][MAXN];
int stanje[MAXN][MAXN];
int glavna[MAXN][MAXN], prijelaz[MAXN][MAXN], pomoc[MAXN][MAXN];
void postavi() {
N = n * m;
stanje[0][0] = 1;
}
int moze(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m) return 0;
if (mat[x][y]) return 0;
return 1;
}
void slozi() {
memset(glavna, 0, sizeof(glavna));
for (int i = 0; i < N; i++) glavna[i][i] = 1;
memset(prijelaz, 0, sizeof(prijelaz));
for (int i = 0; i < N; i++) {
int x = i / m;
int y = i % m;
if (mat[x][y] == 1) continue;
prijelaz[i][i] = 1;
for (int j = 0; j < 4; j++) {
int kamo_x = x + kombX[j];
int kamo_y = y + kombY[j];
if (moze(kamo_x, kamo_y)) {
int v = kamo_x * m + kamo_y;
prijelaz[i][v] = 1;
}
}
}
}
void mnozi() {
memset(pomoc, 0, sizeof(pomoc));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
pomoc[i][j] = add(pomoc[i][j], mul(glavna[i][k], prijelaz[k][j]));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) glavna[i][j] = pomoc[i][j];
}
void kvadriraj() {
memset(pomoc, 0, sizeof(pomoc));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
pomoc[i][j] = add(pomoc[i][j], mul(prijelaz[i][k], prijelaz[k][j]));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) prijelaz[i][j] = pomoc[i][j];
}
void posebno() {
memset(pomoc, 0, sizeof(pomoc));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
pomoc[i][j] = add(pomoc[i][j], mul(stanje[i][k], glavna[k][j]));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) stanje[i][j] = pomoc[i][j];
}
void potenciraj(int x) {
while (x) {
if (x & 1) mnozi();
kvadriraj();
x /= 2;
}
}
void obradi(int t) {
slozi();
potenciraj(t - trenutno);
trenutno = t;
posebno();
}
int upit(int x, int y, int t) {
obradi(t);
int ret = 0;
int trebam = x * m + y;
return stanje[0][trebam];
}
void dodaj(int x, int y, int t) {
obradi(t);
mat[x][y] = 1;
}
void makni(int x, int y, int t) {
obradi(t);
mat[x][y] = 0;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
postavi();
for (int br = 0; br < q; br++) {
int tip;
scanf("%d", &tip);
int x, y, t;
scanf("%d %d %d", &x, &y, &t);
x--;
y--;
if (tip == 1)
printf("%d\n", upit(x, y, t));
else if (tip == 2)
dodaj(x, y, t);
else if (tip == 3)
makni(x, y, t);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int sz;
int q;
bool bl[25];
long long prod[25][25];
void matmult(long long a[][25], long long b[][25], long long dest[][25]) {
memset(prod, 0, sizeof prod);
for (int i = (1); i <= (signed)(sz); i++) {
for (int j = (1); j <= (signed)(sz); j++) {
for (int k = (1); k <= (signed)(sz); k++) {
prod[i][j] += a[i][k] * b[k][j];
prod[i][j] %= 1000000007;
}
}
}
for (int i = (1); i <= (signed)(sz); i++) {
for (int j = (1); j <= (signed)(sz); j++) {
dest[i][j] = prod[i][j];
}
}
}
long long mat[25][25];
long long ans[25][25];
void matexp(long long ex) {
memset(ans, 0, sizeof ans);
for (int i = (1); i <= (signed)(sz); i++) {
ans[i][i] = 1;
}
while (ex > 0) {
if (ex % 2 == 0) {
matmult(mat, mat, mat);
ex /= 2;
} else {
matmult(ans, mat, ans);
ex--;
}
}
}
long long cur[25][25];
long long wtmoo[25][25];
vector<int> near[25];
int conv(int x, int y) { return x * m + y - m; }
int dx[5] = {0, 1, 0, -1, 0};
int dy[5] = {0, 0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
sz = n * m;
int pt = 1;
for (int i = (1); i <= (signed)(sz); i++) wtmoo[i][i] = 1;
for (int i = (1); i <= (signed)(n); i++) {
for (int j = (1); j <= (signed)(m); j++) {
int loc = conv(i, j);
for (int dir = 0; dir < (signed)(5); dir++) {
int nx = i + dx[dir], ny = j + dy[dir];
if (nx <= 0 || ny <= 0 || nx > n || ny > m) continue;
int loc2 = conv(nx, ny);
near[loc].push_back(loc2);
cur[loc][loc2] = 1;
}
}
}
for (int i = 0; i < (signed)(q); i++) {
int ct, tp, x, y;
cin >> tp >> x >> y >> ct;
int loc = x * m + y - m;
long long d = ct - pt;
pt = ct;
memcpy(mat, cur, sizeof mat);
matexp(d);
matmult(wtmoo, ans, wtmoo);
if (tp == 1) {
cout << wtmoo[1][loc] << "\n";
} else if (tp == 2) {
bl[loc] = true;
for (auto u : near[loc]) {
cur[u][loc] = 0;
cur[loc][u] = 0;
}
} else if (tp == 3) {
bl[loc] = false;
for (auto u : near[loc]) {
if (!bl[u]) {
cur[u][loc] = 1;
cur[loc][u] = 1;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int C = 21;
int n, m, cat[C];
int dx[] = {+1, -1, 0, 0, 0};
int dy[] = {0, 0, +1, -1, 0};
int mod(long long x) { return (x % 1000000007); }
struct matris {
int A[C][C];
matris() { memset(A, 0, sizeof A); }
matris operator*(matris B) const {
matris C;
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++)
for (int k = 1; k <= n * m; k++)
C.A[i][j] = mod(C.A[i][j] + mod(A[i][k] * 1LL * B.A[k][j]));
return C;
}
} cur;
int id(int x, int y) { return (x - 1) * m + y; }
matris Fe(matris x, int y) {
if (y == 1) return x;
matris h = Fe(x, y / 2);
h = h * h;
if (y & 1) h = h * x;
return h;
}
void solve(int x) {
matris now;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (cat[id(i, j)]) continue;
for (int k = 0; k < 5; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx < 1 or ny < 1 or nx > n or ny > m or cat[id(nx, ny)]) continue;
now.A[id(i, j)][id(nx, ny)] = 1;
}
}
cur = cur * Fe(now, x);
}
int main() {
int q, last = 1;
scanf("%d%d%d", &n, &m, &q);
cur.A[1][1] = 1;
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
solve(t - last);
last = t;
if (tp == 1)
printf("%d\n", cur.A[1][id(x, y)]);
else
cat[id(x, y)] = 3 - tp;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int N = 2105;
int dp[N], lcp[N][N], lcpr[N][N], lmatch[N];
pair<int, int> subs[N];
int par[N];
string s, t;
int n, m;
void print(int idx) {
if (idx != 0) print(par[idx]);
cout << subs[idx].first + 1 << " " << subs[idx].second + 1 << "\n";
}
int main() {
cin >> s >> t;
n = s.size();
m = t.size();
for (int i = m - 1; i >= 0; --i) {
for (int j = n - 1; j >= 0; --j) {
if (t[i] != s[j])
lcp[i][j] = 0;
else
lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
}
reverse(s.begin(), s.end());
for (int i = m - 1; i >= 0; --i) {
for (int j = n - 1; j >= 0; --j) {
if (t[i] != s[j])
lcpr[i][j] = 0;
else
lcpr[i][j] = lcpr[i + 1][j + 1] + 1;
}
}
for (int i = 0; i < m; ++i) {
int midx = max_element(lcp[i], lcp[i] + n) - lcp[i];
lmatch[i] = lcp[i][midx];
subs[i] = {midx, midx + lmatch[i] - 1};
midx = max_element(lcpr[i], lcpr[i] + n) - lcpr[i];
if (lmatch[i] < lcpr[i][midx]) {
lmatch[i] = lcpr[i][midx];
subs[i] = {n - 1 - midx, n - 1 - midx - lmatch[i] + 1};
}
}
fill(dp + 1, dp + m + 1, INF);
for (int i = 0; i < m; ++i) {
if (dp[i + lmatch[i]] > dp[i] + 1) {
dp[i + lmatch[i]] = dp[i] + 1;
par[i + lmatch[i]] = i;
}
}
if (dp[m] >= INF) {
puts("-1");
return 0;
}
cout << dp[m] << "\n";
print(par[m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
const int INF = 1e9;
const long long INF_LL = 4e18;
const double pi = acos(-1.0);
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int nxt[2101][2101], n, m;
char s[2][2101], t[2101];
vector<pair<int, int>> ans;
void init_nxt(char* str, int next[2101]) {
int i = 0, j = -1;
next[0] = -1;
for (i = 0; str[i];) {
while (j >= 0 && str[i] != str[j]) j = next[j];
i++;
j++;
next[i] = j;
}
}
pair<int, int> match(char* a, char* b, int next[2101]) {
int maxl = 0, lft = 0;
for (int i = 0, j = 0; i < n;) {
while (j >= 0 && a[i] != b[j]) j = next[j];
i++;
j++;
if (j > maxl) {
maxl = j;
lft = i - j;
}
}
return make_pair((lft), (maxl));
}
int main() {
scanf("%s%s", s[0], t);
n = (int)strlen(s[0]);
m = (int)strlen(t);
for (int i = 0; i < n; i++) s[1][i] = s[0][n - 1 - i];
for (int i = 0; i < m; i++) init_nxt(t + i, nxt[i]);
int cur = 0;
while (cur < m) {
pair<int, int> x = match(s[0], t + cur, nxt[cur]);
pair<int, int> y = match(s[1], t + cur, nxt[cur]);
if (x.second > 0 && x.second >= y.second) {
ans.push_back(make_pair((x.first + 1), (x.first + x.second)));
cur += x.second;
} else if (y.second > 0 && y.second > x.second) {
int l = n - 1 - y.first;
int r = n - 1 - (y.first + y.second - 1);
ans.push_back(make_pair((l + 1), (r + 1)));
cur += y.second;
} else
break;
}
if (cur == m) {
printf("%d\n", int((ans).size()));
for (auto i : ans) printf("%d %d\n", i.first, i.second);
} else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N6 = 1e6 + 6, N3 = 5e3 + 6, oo = 1e9 + 9, pr1 = 31, pr2 = 37,
bpr = 1e9 + 7;
const long long ool = 1e18 + 9;
int n, m;
char a[N3], b[N3];
long long hs1[N3], hs2[N3], rht1[N3], rht2[N3], ht1[N3], ht2[N3], p1[N3],
p2[N3];
pair<int, int> d[N3];
unordered_map<long long, pair<int, int> > ms1(3e6), ms2(3e6);
void calc(char *s, int sz, long long *hash, long long *pr) {
for (int i = 1; i <= sz; ++i) {
hash[i] = (hash[i - 1] + (s[i] - 'a' + 1) * pr[i]) % bpr;
}
}
pair<bool, pair<int, int> > ex(int l, int r) {
long long hasht1 = ht1[r] - ht1[l - 1];
hasht1 += bpr;
hasht1 %= bpr;
hasht1 = (hasht1 * p1[m - r] % bpr) * p1[n] % bpr;
long long hasht2 = ht2[r] - ht2[l - 1];
hasht2 += bpr;
hasht2 %= bpr;
hasht2 = (hasht2 * p2[m - r] % bpr) * p2[n] % bpr;
int ql = l, qr = r;
l = m - l + 1, r = m - r + 1;
swap(l, r);
long long rhasht1 = rht1[r] - rht1[l - 1];
rhasht1 += bpr;
rhasht1 %= bpr;
rhasht1 = (rhasht1 * p1[m - r] % bpr) * p1[n] % bpr;
long long rhasht2 = rht2[r] - rht2[l - 1];
rhasht2 += bpr;
rhasht2 %= bpr;
rhasht2 = (rhasht2 * p2[m - r] % bpr) * p2[n] % bpr;
swap(l, r);
l = ql, r = qr;
for (int i = 1, j = r - l + 1; j <= n; ++i, ++j) {
long long hashs1 = hs1[j] - hs1[i - 1];
hashs1 += bpr;
hashs1 %= bpr;
hashs1 = (hashs1 * p1[n - j] % bpr) * p1[m] % bpr;
long long hashs2 = hs2[j] - hs2[i - 1];
hashs2 += bpr;
hashs2 %= bpr;
hashs2 = (hashs2 * p2[n - j] % bpr) * p2[m] % bpr;
if (hasht1 == hashs1 && hasht2 == hashs2)
return make_pair(1, make_pair(i, j));
if (rhasht1 == hashs1 && rhasht2 == hashs2)
return make_pair(1, make_pair(j, i));
}
return make_pair(0, make_pair(0, 0));
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s;
cin >> t;
n = s.size();
m = t.size();
for (int i = 1; i <= n; ++i) {
a[i] = s[i - 1];
}
for (int i = 1; i <= m; ++i) {
b[i] = t[i - 1];
}
p2[0] = p1[0] = 1;
for (int i = 1; i <= max(n, m); ++i) {
p1[i] = (p1[i - 1] * pr1) % bpr;
p2[i] = (p2[i - 1] * pr2) % bpr;
}
calc(a, n, hs1, p1);
calc(a, n, hs2, p2);
calc(b, m, ht1, p1);
calc(b, m, ht2, p2);
reverse(b + 1, b + m + 1);
calc(b, m, rht1, p1);
calc(b, m, rht2, p2);
reverse(b + 1, b + m + 1);
int r = 1;
for (int l = 1; l <= m; ++l) {
if (l > r) {
cout << "-1\n";
return 0;
}
pair<bool, pair<int, int> > q = ex(l, r);
while (q.first) {
d[r++] = q.second;
if (r > m) break;
q = ex(l, r);
}
if (r > m) break;
}
if (!d[m].first) {
cout << "-1\n";
return 0;
}
vector<pair<int, int> > ans;
int pos = m;
while (pos) {
ans.push_back(d[pos]);
pos -= abs(d[pos].first - d[pos].second) + 1;
}
reverse(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto it : ans) cout << it.first << " " << it.second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char str[2102], t[2102], temp[2102];
pair<int, int> ok[2102][2102];
int mem[2102];
int dp(int pos) {
if (pos == n) return 0;
if (mem[pos] != -1) return mem[pos];
mem[pos] = 1000000007;
for (int i = pos; i < n; i++) {
if (ok[pos][i].first != -1)
mem[pos] = min(mem[pos], 1 + dp(i + 1));
else
break;
}
return mem[pos];
}
vector<pair<int, int> > rv;
void path(int pos) {
if (pos == n) return;
for (int i = pos; i < n; i++)
if (mem[pos] == (1 + dp(i + 1))) {
rv.push_back(ok[pos][i]);
path(i + 1);
break;
}
return;
}
int fail[2102];
void kmp(int len) {
fail[0] = -1;
int now = -1;
for (int i = 1; i < len; i++) {
while (now != -1 && temp[i] != temp[now + 1]) now = fail[now];
if (temp[i] != temp[now + 1])
fail[i] = -1;
else
fail[i] = ++now;
}
return;
}
int main() {
scanf("%s %s", str, t);
n = strlen(t);
int m = strlen(str);
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) ok[i][j] = {-1, -1};
for (int i = 0; i < n; i++) {
int k = 0;
for (int j = i; j < n; j++) temp[k++] = t[j];
temp[k] = '\0';
kmp(k);
int now = -1;
for (int j = 0; j < m; j++) {
while (now != -1 && str[j] != temp[now + 1]) now = fail[now];
if (str[j] == temp[now + 1]) ++now, ok[i][i + now] = {j - now, j};
}
}
for (int i = 0; i < n; i++) {
int k = 0;
for (int j = i; j < n; j++) temp[k++] = t[j];
temp[k] = '\0';
kmp(k);
int now = -1;
for (int j = m - 1; j >= 0; j--) {
while (now != -1 && str[j] != temp[now + 1]) now = fail[now];
if (str[j] == temp[now + 1]) ++now, ok[i][i + now] = {j + now, j};
}
}
memset(mem, -1, sizeof mem);
int res = dp(0);
if (res == 1000000007)
puts("-1");
else {
path(0);
printf("%d\n", res);
for (int i = 0; i < rv.size(); i++)
printf("%d %d\n", rv[i].first + 1, rv[i].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > anss;
int main() {
string s, t;
cin >> s >> t;
for (int x = 0; x < t.size();) {
int ans = 0, l = 0, r = 0;
for (int i = 0; i < s.size(); i++) {
int start = x;
int ans1 = 0, ans2 = 0;
for (int j = i; j < s.size() && start < t.size(); j++) {
if (s[j] == t[start])
start++, ans1++;
else
break;
}
start = x;
for (int j = i; j >= 0 && start < t.size(); j--) {
if (s[j] == t[start])
start++, ans2++;
else
break;
}
if (ans1 > ans2) {
if (ans1 > ans) {
ans = ans1;
l = i;
r = i + ans1 - 1;
}
} else {
if (ans2 > ans) {
ans = ans2;
l = i;
r = i - ans2 + 1;
}
}
}
if (ans == 0) return cout << -1, 0;
anss.push_back({l + 1, r + 1});
x += ans;
}
cout << anss.size() << "\n";
for (int i = 0; i < anss.size(); i++) {
cout << anss[i].first << " " << anss[i].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
using ll = long long;
const int inf = 1e9;
int dp[2222];
int pre[2222];
int lcp[2222][2222], lcp2[2222][2222];
int main() {
string s, t;
cin >> s >> t;
string u = s;
reverse(u.begin(), u.end());
int n = s.size();
int m = t.size();
for (int i = (m)-1; i >= (0); i--)
for (int j = (0); j < (n); j++)
if (t[i] == s[j]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
for (int i = (m)-1; i >= (0); i--)
for (int j = (0); j < (n); j++)
if (t[i] == u[j]) lcp2[i][j] = lcp2[i + 1][j + 1] + 1;
for (int i = (0); i < (2222); i++) dp[i] = inf, pre[i] = -1;
dp[0] = 0;
for (int i = (0); i < (m); i++) {
int p = 0, q = 0;
for (int j = (0); j < (n); j++) {
chmax(p, lcp[i][j]);
chmax(q, lcp2[i][j]);
}
for (int j = (1); j < (max(p, q) + 1); j++) {
if (chmin(dp[i + j], dp[i] + 1)) {
pre[i + j] = i;
}
}
}
int curr = m;
vector<pair<int, int>> ans;
while (pre[curr] != -1) {
int next = pre[curr];
int len = curr - next;
int p = -1, q = -1;
for (int j = (0); j < (n); j++) {
if (lcp[next][j] >= len) p = j;
if (lcp2[next][j] >= len) q = j;
}
if (p != -1) {
ans.emplace_back(p, p + len - 1);
} else {
q = n - q - 1;
ans.emplace_back(q, q - len + 1);
}
curr = next;
}
if (ans.size() == 0) {
cout << -1 << endl;
return 0;
}
cout << ans.size() << endl;
for (int i = (ans.size()) - 1; i >= (0); i--) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, s2;
bool flag = true;
int co = 0;
vector<pair<int, int> > poss;
int main() {
cin >> s >> t;
s2 = s;
reverse(s2.begin(), s2.end());
for (int i = 0; i < t.length() && flag;) {
int x, y;
flag = false;
int sz = 0;
for (int j = 0; j < s.length(); j++) {
if (t[i] == s[j]) {
flag = true;
int k = 0;
for (; k < min(s.length() - j, t.length() - i) && t[i + k] == s[j + k];
k++)
;
if (k > sz) {
x = j + 1;
y = j + k;
sz = k;
}
}
}
int siz = s2.length() + 1;
for (int j = 0; j < s2.length(); j++) {
if (t[i] == s2[j]) {
flag = true;
int k = 0;
for (;
k < min(s2.length() - j, t.length() - i) && t[i + k] == s2[j + k];
k++)
;
if (k > sz) {
x = siz - j - 1;
y = siz - j - k;
sz = k;
}
}
}
co++;
poss.push_back(make_pair(x, y));
i += sz;
}
if (!flag) {
cout << -1 << endl;
return 0;
} else {
cout << co << endl;
for (int i = 0; i < poss.size(); i++) {
cout << poss[i].first << " " << poss[i].second << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[2103], s2[2103];
char arr[4509];
int z[4509], sz;
void ZAlgo() {
int l = 0, r = 0;
for (int i = 1; i < sz; ++i) {
if (i > r) {
l = r = i;
while (r < sz && arr[r - l] == arr[r]) ++r;
z[i] = r - l;
--r;
} else {
int k = i - l;
if (z[k] < r - i + 1)
z[i] = z[k];
else {
l = i;
while (r < sz && arr[r - l] == arr[r]) ++r;
z[i] = r - l;
--r;
}
}
}
}
pair<int, int> ans[2103];
int main() {
int ansSz = 0;
scanf("%s", s1);
scanf("%s", s2);
int n = strlen(s1), m = strlen(s2);
int cur = 0;
while (cur < m) {
sz = 0;
for (int i = cur; i < m; ++i) arr[sz++] = s2[i];
arr[sz++] = '?';
for (int i = 0; i < n; ++i) arr[sz++] = s1[i];
ZAlgo();
int mx = 0, ind = -1;
for (int i = m - cur + 1; i < sz; ++i)
if (z[i] > mx) mx = z[i], ind = i - m + cur - 1;
if (ind == -1) {
puts("-1");
return 0;
}
reverse(arr + m - cur + 1, arr + sz);
ZAlgo();
bool rev = 0;
for (int i = m - cur + 1, j = n - 1; i < sz; ++i, --j)
if (z[i] > mx) mx = z[i], ind = j, rev = 1;
ans[ansSz++] =
rev ? make_pair(ind, ind - mx + 1) : make_pair(ind, ind + mx - 1);
cur += mx;
}
printf("%d\n", ansSz);
for (int i = 0; i < ansSz; ++i)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
string a, b, t, s;
cin >> a >> b;
t = a;
reverse(t.begin(), t.end());
long long int n = a.size(), x, y;
vector<pair<long long int, long long int>> ans;
for (long long int i = 0; i < b.size(); i++) {
s += b[i];
long long int k = a.find(s);
if (k == string::npos)
k = t.find(s);
else {
x = k + 1;
y = s.size() + x - 1;
continue;
}
if (k == string::npos) {
if (s.size() == 1) {
cout << -1;
return;
}
ans.push_back({x, y});
i--;
s.clear();
} else {
x = k + 1;
y = s.size() + x - 1;
x = n + 1 - x;
y = n + 1 - y;
}
}
ans.push_back({x, y});
cout << ans.size() << "\n";
for (auto x : ans) cout << x.first << " " << x.second << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(4105);
int pi[MAXN];
void Prefix_Function(string a) {
pi[1] = 0;
int k = 0;
for (int i = 2; i <= a.size(); i++) {
while (k > 0 && a[k] != a[i - 1]) k = pi[k];
if (a[k] == a[i - 1]) k++;
pi[i] = k;
}
}
bool KMP(string a, string b, int &x, int &y, int c) {
Prefix_Function(a);
int k = 0;
for (int i = 0; i < b.size(); i++) {
while (k > 0 && a[k] != b[i]) k = pi[k];
if (a[k] == b[i]) k++;
if (k == a.size()) {
x = i - k + 1;
y = i;
if (c) x = b.size() - 1 - x, y = b.size() - 1 - y;
return true;
}
}
return false;
}
int main() {
string a, b;
cin >> a >> b;
string d = a;
reverse(d.begin(), d.end());
vector<pair<int, int> > ans;
for (int i = 0, j = 0; i < b.size(); i = j) {
int x = -1, y = -1;
string s = "";
while (j < b.size()) {
s += b[j];
if (!KMP(s, a, x, y, 0) && !KMP(s, d, x, y, 1)) break;
j++;
}
if (x == -1) {
printf("-1");
return 0;
}
ans.push_back(pair<int, int>(x, y));
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long double EPS = 1e-8;
bool is_possible(string s, string t) {
int salpha[26] = {0};
int talpha[26] = {0};
for (char c : s) {
salpha[c - 'a']++;
}
for (char c : t) {
talpha[c - 'a']++;
}
for (int i = 0; i < (int)(26); i++) {
if (talpha[i] && !salpha[i]) return false;
}
return true;
}
pair<int, int> f(string s, string t, int pos) {
int n = s.length();
pair<int, int> res = make_pair(0, -1);
for (int i = 0; i < (int)(n); i++) {
int cnt = 0;
while (i + cnt < n && pos + cnt < t.length() &&
s[i + cnt] == t[pos + cnt]) {
cnt++;
}
if (cnt > res.second - res.first) {
res = make_pair(i, i + cnt - 1);
}
}
return res;
}
int main() {
string s, t;
cin >> s >> t;
if (is_possible(s, t)) {
string rs = s;
reverse((rs).begin(), (rs).end());
int cnt = 0;
vector<pair<int, int>> res;
for (int i = 0; i < t.length();) {
pair<int, int> ps = f(s, t, i);
pair<int, int> prs = f(rs, t, i);
if (ps.second - ps.first > prs.second - prs.first) {
res.push_back(ps);
i += ps.second - ps.first + 1;
} else {
res.push_back(
make_pair(s.length() - 1 - prs.first, s.length() - 1 - prs.second));
i += prs.second - prs.first + 1;
}
cnt++;
}
cout << cnt << endl;
for (pair<int, int> p : res) {
cout << p.first + 1 << " " << p.second + 1 << endl;
}
} else {
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[11000], l[11000], r[11000];
char s1[11000], s2[11000], st[11000];
int n, m;
void conduct() {
n = strlen(st);
m = strlen(s1);
for (int i = 0; i < m; ++i) s2[m - i - 1] = s1[i];
int ans = 0;
for (int i = 0; i < n; ++i, ++ans) {
int len = -1;
char* cur = st + i;
int res = n - i;
f[0] = -1;
for (int j = 1; j < res; ++j) {
f[j] = f[j - 1];
while (~f[j] && cur[f[j] + 1] != cur[j]) f[j] = f[f[j]];
if (cur[f[j] + 1] == cur[j]) f[j]++;
}
for (int j = 0, k = -1; j < m; ++j) {
while (k == res - 1 || (~k && cur[k + 1] != s1[j])) k = f[k];
if (cur[k + 1] == s1[j]) ++k;
if (k > len) {
len = k;
l[ans] = j - len;
r[ans] = j;
}
}
for (int j = 0, k = -1; j < m; ++j) {
while (k == res - 1 || (~k && cur[k + 1] != s2[j])) k = f[k];
if (cur[k + 1] == s2[j]) ++k;
if (k > len) {
len = k;
l[ans] = m - 1 - j + len;
r[ans] = m - 1 - j;
}
}
if (!~len) {
printf("-1\n");
return;
}
i += len;
}
int length = 0;
for (int i = 0; i < ans; ++i) length += abs(r[i] - l[i]) + 1;
printf("%d\n", ans);
for (int i = 0; i < ans; ++i) printf("%d %d\n", l[i] + 1, r[i] + 1);
}
int main() {
while (scanf("%s%s", s1, st) != EOF) conduct();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str, rstr, ans;
int dp[2110][2110][2], rdp[2110][2110];
vector<pair<int, int> > prin;
int rec(int ap, int sp, int t) {
if (ap == (int)ans.size() || (sp == (int)str.size() && !t) ||
(sp == (int)rstr.size() && t))
return 0;
if ((ans[ap] != str[sp]) && !t) return 0;
if ((ans[ap] != rstr[sp]) && t) return 0;
if (dp[ap][sp][t] != -1) return dp[ap][sp][t];
return dp[ap][sp][t] = 1 + rec(ap + 1, sp + 1, t);
}
int main() {
ios::sync_with_stdio(false);
memset(dp, -1, sizeof(dp));
memset(rdp, -1, sizeof(rdp));
int a, b, c = 1, n, d, px, py;
cin >> str;
cin >> ans;
n = str.size();
rstr = str;
reverse(rstr.begin(), rstr.end());
for (int i = 0; i <= (int)ans.size() - 1; i++) {
a = b = 0;
d = 0;
for (int j = 0; j <= (int)str.size() - 1; j++) {
a = max(a, rec(i, j, 0));
b = max(b, rec(i, j, 1));
if (a > d) d = a, px = j + 1, py = j + a;
if (b > d) d = b, py = ((n - j) - b) + 1, px = n - j;
}
prin.push_back(make_pair(px, py));
c = min(c, d);
i += (d - 1);
if (!d) break;
}
if (c) {
cout << prin.size() << endl;
for (int i = 0; i <= (int)prin.size() - 1; i++)
cout << prin[i].first << ' ' << prin[i].second << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k;
pair<int, int> prefix_function(string s) {
vector<int> p(s.size(), 0);
for (int i = 1; i < s.size(); i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
int best = 0;
pair<int, int> ans = make_pair(0, -1);
for (int i = k; i < s.size(); i++) {
if (p[i] > best) {
ans = make_pair(i - k - p[i] + 1, i - k);
best = p[i];
}
}
return ans;
}
pair<int, int> prefix_function_reverse(string s) {
vector<int> p(s.size(), 0);
for (int i = 1; i < s.size(); i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
int best = 0;
pair<int, int> ans = make_pair(0, -1);
for (int i = k; i < s.size(); i++) {
if (p[i] >= best) {
ans = make_pair(s.size() - i, s.size() - i + p[i] - 1);
best = p[i];
}
}
return ans;
}
int main() {
vector<pair<int, int> > ans;
pair<int, int> ans1, ans2;
string s1, s2, s3;
cin >> s2 >> s1;
s3 = s2;
k = s1.size();
reverse(s3.begin(), s3.end());
while (s1.size() > 0) {
ans1 = prefix_function(s1 + '#' + s2);
ans2 = prefix_function_reverse(s1 + '#' + s3);
if (ans1.second - ans1.first + 1 == 0 &&
ans2.second - ans2.first + 1 == 0) {
cout << -1 << endl;
return 0;
}
if (ans1.second - ans1.first + 1 > ans2.second - ans2.first + 1) {
ans.push_back(ans1);
s1 = s1.substr(ans1.second - ans1.first + 1, s1.size());
} else {
swap(ans2.first, ans2.second);
ans.push_back(ans2);
s1 = s1.substr(ans2.first - ans2.second + 1, s1.size());
}
k = s1.size();
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string st1, st2;
int a[3000], b[3000];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> st1;
cin >> st2;
int l1 = st1.size(), l2 = st2.size(), ans = 0;
for (int i = 0; i < l2;) {
int l = 0, z1, z2;
for (int j = 0; j < l1; ++j) {
int k;
for (k = j; k < l1 && i + k - j < l2; ++k)
if (st1[k] != st2[i + k - j]) break;
if (l < k - j) {
l = k - j;
z1 = j;
z2 = k - 1;
}
}
for (int j = l1 - 1; j >= 0; --j) {
int k;
for (k = j; k >= 0 && i + j - k < l2; --k)
if (st1[k] != st2[i + j - k]) break;
if (l < j - k) {
l = j - k;
z1 = j;
z2 = k + 1;
}
}
++ans;
a[ans] = z1;
b[ans] = z2;
i += l;
if (l == 0) {
printf("-1\n");
return 0;
}
}
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i) printf("%d %d\n", a[i] + 1, b[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3030;
int lcpts[maxN][maxN];
int lcprev[maxN][maxN];
int main() {
string s, t;
cin >> s >> t;
int n = s.size();
int m = t.size();
s = "&" + s + "@";
t = "$" + t + "^";
for (int i = m; i >= 1; i--) {
for (int j = n; j >= 1; j--) {
if (t[i] == s[j]) lcpts[i][j] = lcpts[i + 1][j + 1] + 1;
}
for (int j = 1; j <= n; j++) {
if (t[i] == s[j]) lcprev[i][j] = lcprev[i + 1][j - 1] + 1;
}
}
vector<pair<int, int> > ans;
for (int i = 1; i <= m;) {
int i1 = max_element(lcpts[i] + 1, lcpts[i] + n + 1) - lcpts[i];
int i2 = max_element(lcprev[i] + 1, lcprev[i] + n + 1) - lcprev[i];
int len = max(lcpts[i][i1], lcprev[i][i2]);
if (len == 0) {
cout << -1 << endl;
return 0;
}
if (len == lcpts[i][i1]) {
ans.push_back({i1, i1 + len - 1});
} else {
ans.push_back({i2, i2 - len + 1});
}
i += len;
}
cout << ans.size() << endl;
for (auto x : ans) {
cout << x.first << " " << x.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
string s, t;
int p[N];
vector<pair<int, int> > ans;
pair<int, int> get(string x, string s) {
string a = x + '#' + s;
pair<int, int> ans = make_pair(0, 0);
p[0] = 0;
for (int i = 1, was = 0; i < a.size(); i++) {
int j = p[i - 1];
while (j && a[j] != a[i]) j = p[j - 1];
if (a[j] == a[i]) j++;
p[i] = j;
if (was) {
int l = i - (x.size() + 1);
ans = max(ans, make_pair(p[i], l - p[i] + 1));
}
if (a[i] == '#') was = 1;
}
return ans;
}
void go(int cur = 0) {
if (cur == t.size()) return;
string nw = t.substr(cur);
pair<int, int> a = get(nw, s);
reverse(s.begin(), s.end());
pair<int, int> b = get(nw, s);
if (max(a.first, b.first) == 0) {
puts("-1");
exit(0);
}
reverse(s.begin(), s.end());
if (a.first >= b.first) {
ans.push_back(make_pair(a.second + 1, a.second + a.first));
go(cur + a.first);
} else {
int l = s.size() - b.second, r = l - b.first + 1;
ans.push_back(make_pair(l, r));
go(cur + b.first);
}
}
int main() {
cin >> s >> t;
go();
printf("%d\n", ans.size());
for (auto it : ans) printf("%d %d\n", it.first, it.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
string s, t;
string::iterator it;
char ch[N], ch2[N];
int z[N], n, n2, mx, p, p2;
vector<int> res, res2;
void zFunction(int frst, int lst, char ch[]) {
int lft = -1, rght = -1, t, i, j, k;
for (i = frst + 1; i <= lst; i++) {
if (ch[i] != ch[frst])
z[i] = 0;
else if (i > rght) {
lft = rght = i;
for (j = i, k = frst; j <= lst && ch[j] == ch[k]; j++, k++) rght = j;
z[i] = rght - lft + 1;
} else {
t = i - lft + frst;
if (z[t] < rght - i + 1)
z[i] = z[t];
else {
lft = i;
for (j = rght, k = rght - lft + frst; j <= lst && ch[j] == ch[k];
j++, k++)
rght = j;
z[i] = rght - lft + 1;
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> s >> t;
n = 0;
for (it = t.begin(); it != t.end(); it++) {
n++;
ch[n] = ch2[n] = (*it);
}
for (it = s.begin(); it != s.end(); it++) {
n++;
ch[n] = (*it);
}
n2 = n;
for (it = s.begin(); it != s.end(); it++) {
ch2[n2] = (*it);
n2--;
}
for (int i = 1; i <= n2;) {
zFunction(i, n, ch);
mx = 0;
for (int j = n2 + 1, k = 1; j <= n; j++, k++) {
if (z[j] >= n2 - i + 1) z[j] = n2 - i + 1;
if (z[j] > mx) {
mx = z[j];
p = k;
p2 = k + z[j] - 1;
}
}
zFunction(i, n, ch2);
for (int j = n2 + 1, k = n - n2; j <= n; j++, k--) {
if (z[j] >= n2 - i + 1) z[j] = n2 - i + 1;
if (z[j] > mx) {
mx = z[j];
p = k;
p2 = k - z[j] + 1;
}
}
if (mx == 0) {
cout << "-1\n";
return 0;
}
res.push_back(p);
res2.push_back(p2);
i += mx;
}
cout << res.size() << "\n";
for (int i = 0; i < res.size(); i++) {
cout << res[i] << " " << res2[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, p, t, rev;
int n, m;
vector<int> Failure(string& pat) {
int m = (int)pat.size();
vector<int> F(m, 0);
for (int i = 1, k = 0; i < m; i++) {
while (k > 0 && pat[i] != pat[k]) k = F[k - 1];
if (pat[i] == pat[k])
F[i] = ++k;
else
F[i] = k;
}
return F;
}
int idx[100000];
int main() {
cin >> s >> t;
n = (int)s.size();
m = (int)t.size();
rev = s;
reverse(rev.begin(), rev.end());
rev = s + "+" + rev;
for (int i = 0; i < n; i++) idx[i] = i + 1;
for (int i = n + 1, a = n; i < 2 * n + 1; i++) idx[i] = a--;
vector<pair<int, int> > ans;
while (true) {
if (!t.size()) break;
string pat = t + "#" + rev;
vector<int> F = Failure(pat);
int j = 0;
for (int i = (int)t.size(); i < (int)F.size(); i++) {
if (F[j] < F[i]) j = i;
}
if (j == 0) {
cout << -1 << endl;
return 0;
}
int len = F[j];
ans.push_back(make_pair(idx[j - (int)t.size() - 1 - len + 1],
idx[j - (int)t.size() - 1]));
t.erase(0, len);
}
cout << ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T mod_f(T num) {
if (num >= 0)
return num % 1000000007;
else
return ((num % 1000000007) + 1000000007) % 1000000007;
}
template <class T>
T fast_pow(T b, T p) {
if (p == 0) return 1;
if (p % 2) {
T x = mod_f(mod_f(b) * mod_f(fast_pow(b, p - 1)));
return x;
} else {
T x = mod_f(fast_pow(b, p / 2));
x = mod_f(mod_f(x) * mod_f(x));
return x;
}
}
template <class T>
T gcd(T a, T b) {
a = abs(a);
b = abs(b);
while (b) {
T r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
int sz = v.size() - 1;
for (int i = 0; i <= sz; i++) out << v[i] << " ";
return out;
}
template <class T>
ostream& operator,(ostream& out, T a) {
out << a << " ";
return out;
}
int main() {
string s, t, tm;
int i, j, in;
pair<int, int> p;
vector<pair<int, int> > v;
size_t found;
cin >> s >> t;
i = 0;
while (t[i]) {
in = 1;
while (1) {
if (!t[i + in - 1]) {
v.push_back(p);
i = i + in - 1;
break;
}
tm = t.substr(i, in);
found = s.find(tm);
if (found == string::npos and in == 1) {
cout << -1;
return 0;
}
if (found != string::npos) {
if (in == 1)
p = make_pair(found + 1, found + 1);
else
p = make_pair(found + 1, found + (int)tm.length());
} else {
reverse(tm.begin(), tm.end());
found = s.find(tm);
if (found == string::npos) {
v.push_back(p);
i = i + in - 1;
break;
}
p = make_pair(found + (int)tm.length(), found + 1);
}
++in;
}
}
j = v.size();
cout << j << "\n";
for (i = 0; i < j; i++) cout << v[i].first << " " << v[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int ns, nt, i, j, l, a;
string s, t, rs;
vector<pair<int, int>> ans;
cin >> s;
cin >> t;
rs = s;
reverse(rs.begin(), rs.end());
ns = s.size();
nt = t.size();
for (i = 0; i < nt;) {
int maior = 0;
int j2;
pair<int, int> cur = {-1, -1};
for (j = 0; j < ns; j++) {
if (s[j] == t[i]) {
l = i + 1;
j2 = j + 1;
while (j2 < ns && l < nt && s[j2] == t[l]) {
l++;
j2++;
}
if (l - i > maior) {
maior = l - i;
cur = {j + 1, j2};
}
}
}
for (j = 0; j < ns; j++) {
if (rs[j] == t[i]) {
l = i + 1;
j2 = j + 1;
while (j2 < ns && l < nt && rs[j2] == t[l]) {
l++;
j2++;
}
if (l - i > maior) {
maior = l - i;
cur = {ns - (j + 1) + 1, ns - j2 + 1};
}
}
}
if (!maior) {
printf("-1\n");
return 0;
}
ans.push_back(cur);
i += maior;
}
printf("%d\n", (int)ans.size());
for (auto x : ans) {
printf("%d %d\n", x.first, x.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
template <class T>
T powmod(T a, T b) {
T res = 1;
if (a >= 1000000007) a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= 1000000007) res %= 1000000007;
a = a * a;
if (a >= 1000000007) a %= 1000000007;
}
return res;
}
void getZarr(string str, int Z[]);
pair<int, int> search(string text, string pattern) {
string concat = pattern + "$" + text;
int l = concat.length();
int r = pattern.size();
int Z[l];
getZarr(concat, Z);
int pos, big = 0;
for (int i = r + 1; i < l; ++i) {
if (big < Z[i]) {
big = Z[i];
pos = i - r - 1;
}
}
return make_pair(big, pos);
}
void getZarr(string str, int Z[]) {
int n = str.length();
int L, R, k;
memset(Z, 0, sizeof(Z));
L = R = 0;
for (int i = 1; i < n; ++i) {
if (i > R) {
L = R = i;
while (R < n && str[R - L] == str[R]) R++;
Z[i] = R - L;
R--;
} else {
k = i - L;
if (Z[k] < R - i + 1)
Z[i] = Z[k];
else {
L = i;
while (R < n && str[R - L] == str[R]) R++;
Z[i] = R - L;
R--;
}
}
}
}
int main() {
int ct = 0;
vector<pair<int, int> > ans;
string text, rev, pattern;
cin >> text;
cin >> pattern;
rev = text;
reverse(rev.begin(), rev.end());
int l = pattern.size();
int m = text.size();
int j = 0, f = 0, h = 0;
while (h < l) {
pair<int, int> x = search(text, pattern);
pair<int, int> y = search(rev, pattern);
if (x.first == 0 && y.first == 0) {
f = 1;
break;
}
if (x.first >= y.first) {
ct++;
ans.push_back(make_pair(x.second + 1, x.second + x.first));
j = x.first;
pattern.erase(pattern.begin(), pattern.begin() + j);
} else {
ct++;
ans.push_back(make_pair(m - y.second, m - y.second - y.first + 1));
j = y.first;
pattern.erase(pattern.begin(), pattern.begin() + j);
}
h += j;
}
if (f)
cout << "-1";
else {
cout << ct << "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a;
string b;
int lena;
int lenb;
vector<pair<int, int>> R;
int lookup(int i, int j) {
while (b[++i] == a[++j] && i < lenb && j < lena)
;
return j - 1;
}
int lookdown(int i, int j) {
while (b[++i] == a[--j] && i < lenb && j >= 0)
;
return j + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> a >> b;
lena = a.length();
lenb = b.length();
for (int i = 0; i < lenb;) {
if (i < 0) break;
int best = 0;
int p, q;
for (int j = 0; j < lena; j++) {
if (a[j] != b[i]) continue;
int endup = lookup(i, j);
if (endup - j + 1 > best) {
best = endup - j + 1;
p = j;
q = endup;
}
if (i + best == lenb) break;
int enddown = lookdown(i, j);
if (j - enddown + 1 > best) {
best = j - enddown + 1;
p = j;
q = enddown;
}
if (i + best == lenb) break;
}
R.push_back(make_pair(p, q));
i += best;
if (best == 0) {
cout << -1 << endl;
return 0;
}
}
cout << R.size() << endl;
for (int i = 0; i < R.size(); i++) {
cout << R[i].first + 1 << " " << R[i].second + 1 << endl;
}
R.clear();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.