text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x1, x2;
} s[100], b[100];
int main() {
int n, m, nums[101000], numb[101000], i, p, q, cnt1, cnt2;
char c;
while (scanf("%d %d", &n, &m) != EOF) {
memset(nums, 0, sizeof(nums));
memset(numb, 0, sizeof(numb));
for (i = 0; i < n; i++) {
getchar();
scanf("%c ", &c);
if (c == 'S') {
scanf("%d %d", &p, &q);
nums[p] += q;
} else if (c == 'B') {
scanf("%d %d", &p, &q);
numb[p] += q;
}
}
cnt1 = 0;
for (i = 0; i < 100100; i++) {
if (cnt1 == m) break;
if (nums[i] != 0) {
s[cnt1].x1 = i;
s[cnt1].x2 = nums[i];
cnt1++;
}
}
cnt2 = 0;
for (i = 100100; i >= 0; i--) {
if (cnt2 == m) break;
if (numb[i] != 0) {
b[cnt2].x1 = i;
b[cnt2].x2 = numb[i];
cnt2++;
}
}
for (i = cnt1 - 1; i >= 0; i--) printf("S %d %d\n", s[i].x1, s[i].x2);
for (i = 0; i < cnt2; i++) printf("B %d %d\n", b[i].x1, b[i].x2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct elem {
int pret;
int volum;
};
int min(int a, int b) {
if (a < b) {
return a;
}
return b;
}
elem ans_sell[100001], ans_buy[100001];
int cnt_sell, cnt_buy;
int compareBUY(const void *a, const void *b) {
elem *aa = (elem *)a;
elem *bb = (elem *)b;
return bb->pret - aa->pret;
}
int compareSELL(const void *a, const void *b) {
elem *aa = (elem *)a;
elem *bb = (elem *)b;
return aa->pret - bb->pret;
}
int main() {
int n, s, i, p, q, buy[100001], sell[100001];
char c;
for (i = 0; i <= 100000; i++) {
buy[i] = sell[i] = -1;
}
cin >> n >> s;
for (i = 0; i < n; i++) {
cin >> c >> p >> q;
if (c == 'B') {
int pos = buy[p];
if (pos == -1) {
pos = cnt_buy;
ans_buy[pos].pret = p;
buy[p] = pos;
cnt_buy++;
}
ans_buy[pos].volum = ans_buy[pos].volum + q;
} else {
int pos = sell[p];
if (pos == -1) {
pos = cnt_sell;
ans_sell[pos].pret = p;
sell[p] = pos;
cnt_sell++;
}
ans_sell[pos].volum = ans_sell[pos].volum + q;
}
}
qsort(ans_sell, cnt_sell, sizeof(elem), compareSELL);
qsort(ans_buy, cnt_buy, sizeof(elem), compareBUY);
for (i = min(s - 1, cnt_sell - 1); i >= 0; i--) {
cout << "S " << ans_sell[i].pret << " " << ans_sell[i].volum << endl;
}
for (i = 0; i < min(s, cnt_buy); i++) {
cout << "B " << ans_buy[i].pret << " " << ans_buy[i].volum << endl;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
const int INF = 1e9;
const double cp = 2 * asin(1.0);
const double eps = 1e-9;
const long long mod = 1000000000;
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n, s;
cin >> n >> s;
map<pair<char, long long>, long long> a;
set<pair<char, long long> > f;
for (int(i) = 0; (i) < (n); i++) {
char x;
long long q, d;
cin >> x >> q >> d;
f.insert(make_pair(x, q));
a[make_pair(x, q)] += d;
}
vector<pair<long long, pair<char, long long> > > resa, resb;
for (set<pair<char, long long> >::iterator i = f.begin(); i != f.end(); i++) {
pair<char, long long> q = *i;
if (q.first == 'S')
resa.push_back(make_pair(q.second, make_pair(q.first, a[q])));
else
resb.push_back(make_pair(q.second, make_pair(q.first, a[q])));
}
sort((resa).begin(), (resa).end());
int i = 0, r = min(s - 1, (int)resa.size() - 1);
while (r >= 0)
cout << resa[r].second.first << ' ' << resa[r].first << ' '
<< resa[r].second.second << endl,
r--;
i = 0;
sort((resb).begin(), (resb).end());
reverse((resb).begin(), (resb).end());
while (i < s && i < resb.size())
cout << resb[i].second.first << ' ' << resb[i].first << ' '
<< resb[i].second.second << endl,
i++;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-6;
const int INF = (int)(INT_MAX - 100);
const long long mod = (int)(1e+9 + 7);
const int N = (int)(1e5);
int main() {
int n, s;
cin >> n >> s;
char d;
int p, k;
map<int, int, greater<int> > C;
map<int, int> V;
for (int i = 0; i < n; i++) {
cin >> d >> p >> k;
if (d == 'B')
C[p] += k;
else
V[p] += k;
}
k = 0;
vector<pair<int, int> > ans;
for (pair<int, int> x : V) {
if (k == s) break;
k++;
ans.push_back({x.first, x.second});
}
reverse(ans.begin(), ans.end());
for (pair<int, int> x : ans)
cout << "S " << x.first << " " << x.second << '\n';
k = 0;
for (pair<int, int> x : C) {
if (k == s) break;
k++;
cout << "B " << x.first << " " << x.second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s;
string d;
int p, q;
using pii = pair<int, int>;
map<int, int> sell, buy;
vector<pii> res;
int main() {
int i, j, k;
while (cin >> n >> s) {
sell.clear();
buy.clear();
for (i = 0; i < n; i++) {
cin >> d >> p >> q;
if (d == "S")
sell[p] += q;
else
buy[-p] += q;
}
int len1, len2;
len1 = len2 = 0;
res.clear();
auto st = sell.begin();
for (i = 0; i < s && st != sell.end(); ++i, ++st)
res.push_back(make_pair(st->first, st->second));
len1 = i;
for (i = len1 - 1; i >= 0; i--)
cout << "S " << res[i].first << " " << res[i].second << endl;
res.clear();
st = buy.begin();
for (i = 0; i < s && st != buy.end(); ++i, ++st)
res.push_back(make_pair(-(st->first), st->second));
len2 = i;
for (i = 0; i < len2; ++i)
cout << "B " << res[i].first << " " << res[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
int n, m, q, last, vi[N][N];
int dx[5] = {0, -1, 1, 0, 0};
int dy[5] = {0, 0, 0, -1, 1};
inline void add(int &a, int b) {
a = ((a + b >= 1000000007) ? a + b - 1000000007 : a + b);
}
inline void del(int &a, int b) {
a = ((a - b < 0) ? a - b + 1000000007 : a - b);
}
inline void mul(int &a, int b) { a = 1ll * a * b % 1000000007; }
inline int id(int x, int y) { return (x - 1) * m + y; }
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
struct matrix {
int n, a[N][N];
inline void clear() { memset(a, 0, sizeof(a)); }
inline void init() {
for (int i = 1; i <= n; i++) a[i][i] = 1;
}
inline void print() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d ", a[i][j]);
printf("\n");
}
}
} f;
matrix tr;
matrix operator*(matrix a, matrix b) {
matrix ans;
ans.n = a.n;
ans.clear();
for (int i = 1; i <= a.n; i++) {
for (int k = 1; k <= a.n; k++) {
for (int j = 1; j <= a.n; j++)
add(ans.a[i][j], 1ll * a.a[i][k] * b.a[k][j] % 1000000007);
}
}
return ans;
}
matrix m_pow(matrix a, int b) {
matrix ans;
ans.n = a.n;
ans.clear();
ans.init();
while (b) {
if (b & 1) ans = ans * a;
b >>= 1;
a = a * a;
}
return ans;
}
inline void get() {
tr.clear();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (vi[i][j]) continue;
tr.a[id(i, j)][id(i, j)] = 1;
for (int k = 1; k <= 4; k++) {
int x = i + dx[k], y = j + dy[k];
if (x <= 0 || y <= 0 || x > n || y > m || vi[x][y]) continue;
tr.a[id(i, j)][id(x, y)] = 1;
}
}
}
}
signed main() {
n = read();
m = read();
q = read();
last = 1;
f.n = tr.n = n * m;
f.a[1][1] = 1;
get();
while (q--) {
int op = read(), x = read(), y = read(), t = read();
f = f * m_pow(tr, t - last);
last = t;
if (op == 2) vi[x][y] = 1;
if (op == 3) vi[x][y] = 0;
if (op == 1) printf("%d\n", f.a[1][id(x, y)]);
get();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int T = 30;
bool isBan[20];
int adj[T][20][20];
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
void constructAdj(int n, int m) {
int id = 0, i, j, k, ni, nj;
int g = n * m;
for (i = 0; i < g; ++i) {
for (j = 0; j < g; ++j) {
adj[0][i][j] = 0;
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
if (isBan[i * m + j]) {
continue;
}
id = i * m + j;
adj[0][id][id] = 1;
for (k = 0; k < 4; ++k) {
ni = i + dx[k], nj = j + dy[k];
if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
if (!isBan[ni * m + nj]) {
adj[0][ni * m + nj][id] = 1;
}
}
}
}
}
}
const int mod = 1e9 + 7;
int add(int x, int y) { return ((x + y) % mod + mod) % mod; }
int mul(int x, int y) { return (long long)x * y % mod; }
void mul(int r[20][20], int x[20][20], int y[20][20], int tot) {
int i, j, k;
for (i = 0; i < tot; ++i) {
for (j = 0; j < tot; ++j) {
r[i][j] = 0;
}
}
for (i = 0; i < tot; ++i) {
for (j = 0; j < tot; ++j) {
for (k = 0; k < tot; ++k) {
r[i][j] = add(r[i][j], mul(x[i][k], y[k][j]));
}
}
}
}
int num[2][20];
void getNew(int bit, int ad[20][20], int tot) {
int nbit = bit ^ 1;
memset(num[nbit], 0, sizeof(num[nbit]));
for (int i = 0; i < tot; ++i) {
for (int j = 0; j < tot; ++j) {
num[nbit][j] = add(num[nbit][j], mul(num[bit][i], ad[i][j]));
}
}
}
void solve() {
int n, m, q;
scanf("%d %d %d ", &n, &m, &q);
int curTime = 1;
num[0][0] = 1;
constructAdj(n, m);
int bit = 0;
for (int i = 0; i < q; ++i) {
int type, x, y, t;
scanf(" %d %d %d %d ", &type, &x, &y, &t);
--x, --y;
int id = x * m + y;
int dt = t - curTime;
for (int ind = 1, t = 2; t <= dt; ++ind, t *= 2) {
memset(adj[ind], 0, sizeof(adj[ind]));
mul(adj[ind], adj[ind - 1], adj[ind - 1], n * m);
}
for (int ind = 0; ind < 30; ++ind) {
if (dt & (1 << ind)) {
getNew(bit, adj[ind], n * m);
bit ^= 1;
}
}
curTime = t;
if (type == 1) {
printf("%d\n", num[bit][id]);
} else if (type == 2) {
isBan[id] = 1;
constructAdj(n, m);
num[bit][id] = 0;
} else {
assert(type == 3);
isBan[id] = 0;
constructAdj(n, m);
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void prepare() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long mod = 1e9 + 7;
vector<vector<long long> > a;
long long binmno(long long a, long long b) {
long long ans = 0;
while (a) {
if (a & 1) {
ans = (ans + b % mod) % mod;
a--;
} else {
b = (b + b) % mod;
a /= 2;
}
}
return ans % mod;
}
vector<vector<long long> > operator*(vector<vector<long long> > a,
vector<vector<long long> > b) {
vector<vector<long long> > ans((long long)a.size(),
vector<long long>(a.size(), 0));
for (long long i = 0; i < a.size(); i++) {
for (long long j = 0; j < a.size(); j++) {
for (long long q = 0; q < a.size(); q++) {
ans[i][j] += binmno(a[i][q], b[q][j]);
ans[i][j] %= mod;
}
}
}
return ans;
}
vector<vector<long long> > binpow(long long k) {
vector<vector<long long> > ans(a.size(), vector<long long>(a.size(), 0));
for (int i = 0; i < a.size(); i++) ans[i][i] = 1;
while (k) {
if (k % 2 == 0) {
k /= 2;
a = a * a;
} else {
k--;
ans = a * ans;
}
}
return ans;
}
vector<long long> operator*(vector<vector<long long> > a, vector<long long> b) {
vector<long long> ans(b.size());
for (int i = 0; i < b.size(); i++) {
for (int j = 0; j < b.size(); j++) {
ans[i] += binmno(a[i][j], b[j]);
ans[i] %= mod;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
long long n, m, q;
cin >> n >> m >> q;
a.assign(n * m, vector<long long>(n * m));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
a[i * n + j][i * n + j] = 1;
if (j != 0) {
a[i * n + j][i * n + j - 1] = 1;
}
if (j != n - 1) {
a[i * n + j][i * n + j + 1] = 1;
}
if (i != 0) {
a[(i - 1) * n + j][i * n + j] = 1;
}
if (i != m - 1) {
a[(i + 1) * n + j][i * n + j] = 1;
}
}
}
vector<vector<long long> > lasta = a;
vector<vector<long long> > a1 = a;
vector<long long> pl(n * m, 0);
pl[0] = 1;
int lastt = 1;
for (int i = 0; i < q; i++) {
int t1, x, y, t;
cin >> t1 >> x >> y >> t;
a = a1;
x--;
y--;
a = binpow(t - lastt);
lastt = t;
pl = a * pl;
int place = y * n + x;
if (t1 == 1) {
cout << pl[place] << endl;
continue;
}
if (t1 == 2) {
pl[place] = 0;
for (int i = 0; i < n * m; i++) {
a1[place][i] = 0;
}
}
if (t1 == 3) {
for (int i = 0; i < n * m; i++) {
a1[place][i] = lasta[place][i];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int d[5][2] = {{0, 0}, {0, 1}, {1, 0}, {0, -1}, {-1, 0}};
const int Mod = 1000000007;
struct Matrix {
int a[20][20];
Matrix() { memset(a, 0, sizeof(a)); }
void init() {
for (int i = 0; i < 20; i++) a[i][i] = 1;
}
Matrix operator*(const Matrix &B) const {
Matrix C;
for (int i = 0; i < 20; i++)
for (int j = 0; j < 20; j++)
for (int k = 0; k < 20; k++)
C.a[i][j] = (C.a[i][j] + 1LL * a[i][k] * B.a[k][j]) % Mod;
return C;
}
Matrix operator^(const int &t) const {
int p = t;
Matrix A = (*this), res;
res.init();
while (p) {
if (p & 1) res = res * A;
A = A * A;
p >>= 1;
}
return res;
}
};
int get(int x, int y, int n, int m) { return (x - 1) * m + (y - 1); }
int cat[20][20];
int main() {
int n, m, q, la = 1;
scanf("%d%d%d", &n, &m, &q);
Matrix res, now;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 0; k < 5; k++) {
int ti = i + d[k][0];
int tj = j + d[k][1];
if (ti >= 1 && ti <= n && tj >= 1 && tj <= m)
now.a[get(i, j, n, m)][get(ti, tj, n, m)]++;
}
res.init();
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
res = res * (now ^ (t - la)), la = t;
if (tp == 1)
printf("%d\n", res.a[get(1, 1, n, m)][get(x, y, n, m)]);
else {
if (tp == 3) cat[x][y] = 0;
for (int k = 0; k < 5; k++) {
int tx = x + d[k][0];
int ty = y + d[k][1];
if (tx >= 1 && tx <= n && ty >= 1 && ty <= m && cat[tx][ty] == 0) {
now.a[get(x, y, n, m)][get(tx, ty, n, m)] = tp - 2;
now.a[get(tx, ty, n, m)][get(x, y, n, m)] = tp - 2;
}
}
if (tp == 2) cat[x][y] = 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nm = 52;
const long long mod = 1000000007;
const int x[] = {-1, 0, 0, 1};
const int y[] = {0, -1, 1, 0};
struct bg {
int k, x, y, t;
};
struct matrix {
int m, n;
long long a[nm][nm];
};
int m, n, q;
bg aaa[10010];
matrix c, v, mtdv, tmp;
int cat[nm][nm];
bool hople(int i, int j) { return i > 0 && i <= m && j > 0 && j <= n; }
void build() {
c.m = c.n = m * n;
for (int i = 1; i <= c.m; ++i) {
for (int j = 1; j <= c.n; ++j) c.a[i][j] = 0;
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
if (!cat[i][j]) {
c.a[(i - 1) * n + j][(i - 1) * n + j] = 1;
for (int k = 0; k < 4; ++k) {
int i2 = i + x[k], j2 = j + y[k];
if (hople(i2, j2) && !cat[i2][j2]) {
c.a[(i - 1) * n + j][(i2 - 1) * n + j2] = 1;
}
}
}
}
}
}
matrix mul(matrix a, matrix b) {
tmp.m = a.m;
tmp.n = b.n;
for (int i = 1; i <= tmp.m; ++i)
for (int j = 1; j <= tmp.n; ++j) {
tmp.a[i][j] = 0;
for (int k = 1; k <= a.n; ++k)
tmp.a[i][j] = (tmp.a[i][j] + (a.a[i][k] * b.a[k][j]) % mod) % mod;
}
return tmp;
}
matrix power(matrix a, int n) {
if (!n) return mtdv;
tmp = power(a, n >> 1);
tmp = mul(tmp, tmp);
if (n & 1) tmp = mul(tmp, a);
return tmp;
}
int main() {
scanf("%d%d%d", &m, &n, &q);
for (int i = 1; i <= q; ++i) {
scanf("%d%d%d%d", &aaa[i].k, &aaa[i].x, &aaa[i].y, &aaa[i].t);
}
v.m = m * n;
v.n = 1;
for (int i = 1; i <= v.m; ++i) v.a[i][1] = 0;
v.a[1][1] = 1;
mtdv.m = mtdv.n = m * n;
for (int i = 1; i <= mtdv.m; ++i)
for (int j = 1; j <= mtdv.n; ++j) mtdv.a[i][j] = (i == j);
aaa[0].t = 1;
for (int i = 1; i <= q; ++i) {
build();
c = power(c, aaa[i].t - aaa[i - 1].t);
v = mul(c, v);
if (aaa[i].k == 1) {
printf("%I64d\n", v.a[(aaa[i].x - 1) * n + aaa[i].y][1]);
} else if (aaa[i].k == 2) {
cat[aaa[i].x][aaa[i].y] = 1;
} else
cat[aaa[i].x][aaa[i].y] = 0;
}
}
|
#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;
}
if (o == 2) {
mat = cal(mat, cur_time, t - 1);
has_cat[x][y] = 1;
mat = cal(mat, t - 1, t);
}
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 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(int r) {
for (int i = 0; i <= r; 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; }
int id(int i, int j) { return i * m + j; }
void build(mat &mul) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int x = id(i, j);
for (int dir = 0; dir < 5; dir++) {
int u = i + dx[dir];
int v = j + dy[dir];
if (!check(u, v)) continue;
int y = id(u, v);
mul.f[x][y] = !a[u][v] && !a[i][j];
}
}
}
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 cur = 1; q > 0; q--) {
int op, i, j, t;
cin >> op >> i >> j >> t;
i--;
j--;
build(mul);
base = base * mul.binpow(t - cur);
cur = t;
if (op == 2) {
a[i][j] = true;
base.f[0][id(i, j)] = 0;
} else if (op == 3)
a[i][j] = false;
else
cout << base.f[0][id(i, j)] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long mod2 = 1LL * mod * mod;
int len;
int c[21][21];
void mul(int a[21][21], int b[21][21]) {
for (int i = 1; i <= len; i++) {
for (int j = 1; j <= len; j++) {
long long t = 0;
for (int k = 1; k <= len; k++) {
t += (long long)(a[i][k]) * b[k][j];
if (t > mod2) t -= mod2;
}
c[i][j] = t % mod;
}
}
for (int i = 1; i <= len; i++)
for (int j = 1; j <= len; j++) b[i][j] = c[i][j];
}
void mul_2(int a[21][21], int b[21][21]) {
for (int i = 1; i <= len; i++) {
long long t = 0;
for (int k = 1; k <= len; k++) {
t += (long long)(a[i][k]) * b[k][1];
if (t > mod2) t -= mod2;
}
c[i][1] = t % mod;
}
for (int i = 1; i <= len; i++) b[i][1] = c[i][1];
}
int n, m, q;
inline int id(int r, int c) { return (r - 1) * m + c; }
int mp[21][21];
int tra[21][21];
int out[21][21];
void fastpow_tra(int ti) {
while (ti) {
if (ti & 1) mul_2(tra, out);
mul(tra, tra);
ti >>= 1;
}
}
int xx[5] = {0, 0, 0, -1, 1}, yy[5] = {0, 1, -1, 0, 0};
void make_matrix() {
memset(tra, 0, sizeof(tra));
for (int i = 1; i <= len; i++) tra[i][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mp[i][j] == 0)
for (int t = 1; t <= 4; t++) {
int x1 = i + xx[t], y1 = j + yy[t];
if (x1 >= 1 && x1 <= n && y1 >= 1 && y1 <= m && mp[x1][y1] == 0)
tra[id(i, j)][id(x1, y1)] = 1;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
len = id(n, m);
out[1][1] = 1;
for (int i = 1, last = 1; i <= q; i++) {
int ins, x, y, ti;
scanf("%d%d%d%d", &ins, &x, &y, &ti);
make_matrix();
fastpow_tra(ti - last);
if (ins == 1) {
printf("%d\n", out[id(x, y)][1]);
} else if (ins == 2) {
mp[x][y]++;
out[id(x, y)][1] = 0;
} else if (ins == 3) {
mp[x][y]--;
}
last = ti;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000002;
const long long INFLL = 100000000000000000ll;
const long long MOD = 1000000007;
struct Matrix {
struct Array {
vector<int> p;
int sz;
int getSize() { return sz; }
Array(int _sz) {
p.resize(_sz, 0);
sz = _sz;
}
int& operator[](int idx) { return p[idx]; }
};
int sz;
vector<Array> v;
Matrix(int p1, int p2) {
sz = p1;
v.resize(p1, Array(p2));
}
int getSize() { return sz; }
Array& operator[](int idx) { return v[idx]; }
};
int C[405], H, W, Q;
long long DP[405], DP2[405];
Matrix mult(Matrix m1, Matrix m2) {
int n = m1.getSize();
Matrix ret(n, n);
for (int i = (0); i <= (n - 1); i++)
for (int j = (0); j <= (n - 1); j++)
for (int k = (0); k <= (n - 1); k++)
ret[i][j] =
((long long)ret[i][j] + (long long)m1[i][k] * m2[k][j]) % MOD;
return ret;
}
Matrix pow(Matrix m, long long e) {
int n = m.getSize();
Matrix ret(n, n);
for (int i = (0); i <= (n - 1); i++) ret[i][i] = 1;
while (e) {
if (e & 1) ret = mult(ret, m);
m = mult(m, m);
e /= 2;
}
return ret;
}
inline int idx(int i, int j) { return i * W + j; }
void work(Matrix& m, int i, int b) {
if (i >= W) m[i - W][i] = m[i][i - W] = b & (!C[i - W]);
if (i + W < H * W) m[i + W][i] = m[i][i + W] = b & (!C[i + W]);
if (i % W < W - 1) m[i + 1][i] = m[i][i + 1] = b & (!C[i + 1]);
if (i % W > 0) m[i - 1][i] = m[i][i - 1] = b & (!C[i - 1]);
m[i][i] = b;
}
int main() {
cin >> H >> W >> Q;
Matrix T(H * W, H * W);
for (int i = (0); i <= (H - 1); i++)
for (int j = (0); j <= (W - 1); j++) work(T, idx(i, j), 1);
DP[0] = 1;
long long last = 1;
while (Q--) {
int type;
scanf("%d", &type);
if (type == 2) {
int i, j;
long long t;
scanf("%d %d %I64d", &i, &j, &t);
i--, j--;
Matrix temp = pow(T, t - last);
for (int i = (0); i <= (H * W - 1); i++) DP2[i] = 0;
for (int i = (0); i <= (H * W - 1); i++)
for (int p = (0); p <= (H * W - 1); p++)
DP2[i] = (DP2[i] + DP[p] * temp[p][i]) % MOD;
for (int i = (0); i <= (H * W - 1); i++) DP[i] = DP2[i];
last = t;
C[idx(i, j)] = 1;
work(T, idx(i, j), 0);
}
if (type == 3) {
int i, j;
long long t;
scanf("%d %d %I64d", &i, &j, &t);
i--, j--;
Matrix temp = pow(T, t - last);
for (int i = (0); i <= (H * W - 1); i++) DP2[i] = 0;
for (int i = (0); i <= (H * W - 1); i++)
for (int p = (0); p <= (H * W - 1); p++)
DP2[i] = (DP2[i] + DP[p] * temp[p][i]) % MOD;
for (int i = (0); i <= (H * W - 1); i++) DP[i] = DP2[i];
last = t;
C[idx(i, j)] = 0;
work(T, idx(i, j), 1);
}
if (type == 1) {
int i, j;
long long t;
scanf("%d %d %I64d", &i, &j, &t);
i--, j--;
Matrix temp = pow(T, t - last);
for (int i = (0); i <= (H * W - 1); i++) DP2[i] = 0;
for (int i = (0); i <= (H * W - 1); i++)
for (int p = (0); p <= (H * W - 1); p++)
DP2[i] = (DP2[i] + DP[p] * temp[p][i]) % MOD;
for (int i = (0); i <= (H * W - 1); i++) DP[i] = DP2[i];
last = t;
printf("%I64d\n", DP[idx(i, j)]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int N;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
vector<vector<int> > A;
vector<vector<int> > B;
vector<vector<int> > C;
int D[20];
const int MOD = 1e9 + 7;
bool cats[20];
int F(int a, int b) { return a * m + b; }
void add(int a, int b, int c, int d) {
if (a >= 0 && a < n && c >= 0 && c < n && b >= 0 && b < m && d >= 0 &&
d < m) {
a = F(a, b);
b = F(c, d);
if (cats[b]) return;
A[a][b] = A[b][a] = 1;
}
}
void remove(int a, int b, int c, int d) {
if (a >= 0 && a < n && c >= 0 && c < n && b >= 0 && b < m && d >= 0 &&
d < m) {
a = F(a, b);
b = F(c, d);
A[a][b] = A[b][a] = 0;
}
}
void build() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
add(i, j, i + dx[k], j + dy[k]);
}
}
}
for (int i = 0; i < N; i++) {
A[i][i] = 1;
}
}
vector<vector<int> > mul(vector<vector<int> > &a, vector<vector<int> > &b) {
vector<vector<int> > res = a;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
res[i][j] = 0;
for (int k = 0; k < N; k++) {
res[i][j] += ((long long)a[i][k] * b[k][j]) % MOD;
res[i][j] %= MOD;
}
}
}
return res;
}
void binpow(int n) {
B = A;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (i == j)
C[i][j] = 1;
else
C[i][j] = 0;
}
}
if (n == 0) return;
while (n) {
if (n & 1) C = mul(C, B);
n >>= 1;
B = mul(B, B);
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
N = n * m;
A.resize(N, vector<int>(N));
B.resize(N, vector<int>(N));
C.resize(N, vector<int>(N));
D[0] = 1;
int tmp[20];
build();
int tp, x, y, t;
int last = 1;
for (int i = 0; i < q; i++) {
scanf("%d %d %d %d", &tp, &x, &y, &t);
x--;
y--;
binpow(t - last);
for (int i = 0; i < N; i++) {
tmp[i] = 0;
for (int k = 0; k < N; k++) {
tmp[i] += ((long long)D[k] * C[k][i]) % MOD;
tmp[i] %= MOD;
}
}
for (int i = 0; i < N; i++) {
D[i] = tmp[i];
}
if (tp == 1) {
printf("%d\n", D[F(x, y)]);
} else if (tp == 2) {
for (int k = 0; k < 4; k++) {
remove(x, y, x + dx[k], y + dy[k]);
}
D[F(x, y)] = 0;
cats[F(x, y)] = 1;
} else {
for (int k = 0; k < 4; k++) {
add(x, y, x + dx[k], y + dy[k]);
}
D[F(x, y)] = 0;
cats[F(x, y)] = 0;
}
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot;
bool ok(int i, int j) {
if (i < 0 or i >= n or j < 0 or j >= m) return 0;
return 1;
}
long long int c[20][20] = {0};
void matcpy(long long int a[20][20], long long int b[20][20]) {
for (int i = 0; i < tot; i++) {
for (int j = 0; j < tot; j++) {
a[i][j] = b[i][j];
}
}
}
void mul(long long int a[20][20], long long int b[20][20]) {
for (int i = 0; i < tot; i++) {
for (int j = 0; j < tot; j++) {
c[i][j] = 0;
for (int k = 0; k < tot; k++) {
c[i][j] += (a[i][k] * b[k][j]) % 1000000007;
c[i][j] %= 1000000007;
}
}
}
matcpy(a, c);
}
long long int id[20][20] = {0};
int cat[20][20] = {0};
void bpow(long long int a[20][20], int k) {
for (int i = 0; i < tot; i++) {
for (int j = 0; j < tot; j++) {
if (i == j)
id[i][j] = 1;
else
id[i][j] = 0;
}
}
while (k > 0) {
if (k & 1) mul(id, a);
mul(a, a);
k /= 2;
}
matcpy(a, id);
}
long long int mat[20][20] = {0};
long long int T[20][20] = {0};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q, x, y, t, tp;
cin >> n >> m >> q;
tot = n * m;
int prev = 1;
for (int i = 0; i < tot; i++) {
for (int j = 0; j < tot; j++) {
if (i == j)
mat[i][j] = 1;
else
mat[i][j] = 0;
}
}
while (q--) {
cin >> tp >> x >> y >> t;
x--;
y--;
for (int i1 = 0; i1 < n; i1++) {
for (int j1 = 0; j1 < m; j1++) {
for (int i2 = 0; i2 < n; i2++) {
for (int j2 = 0; j2 < m; j2++) {
if (!cat[i1][j1] and !cat[i2][j2] and
abs(i1 - i2) + abs(j1 - j2) <= 1) {
T[m * i1 + j1][m * i2 + j2] = 1;
} else {
T[m * i1 + j1][m * i2 + j2] = 0;
}
}
}
}
}
bpow(T, t - prev);
prev = t;
mul(mat, T);
if (tp == 1) {
cout << mat[0][m * x + y] << "\n";
} else if (tp == 2) {
cat[x][y] = 1;
} else {
cat[x][y] = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, tp, x, y, t, la, nx, ny, bz[25][25];
const int c[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
struct mat {
int a[25][25];
mat() { memset(a, 0, sizeof(a)); };
friend mat operator*(mat x, mat y) {
mat z;
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;
}
friend mat operator^(mat x, int y) {
mat s;
for (int i = 1; i <= n * m; i++) s.a[i][i] = 1;
for (; y; y /= 2, x = x * x)
if (y & 1) s = s * x;
return s;
}
} now;
int poi(int x, int y) { return (x - 1) * m + y; }
int main() {
scanf("%d%d%d", &n, &m, &q);
la = 1;
for (int i = 1; i <= n * m; i++) now.a[i][i] = 1;
for (int i = 1; i <= q; i++) {
scanf("%d%d%d%d", &tp, &x, &y, &t);
mat tmp;
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) {
for (int p = 0; p < 4; p++) {
nx = j + c[p][0], ny = k + c[p][1];
if (nx < 1 || ny < 1 || nx > n || ny > m) continue;
tmp.a[poi(j, k)][poi(nx, ny)] = 1 - (bz[j][k] || bz[nx][ny]);
}
tmp.a[poi(j, k)][poi(j, k)] = 1 - bz[j][k];
}
now = now * (tmp ^ (t - la));
if (tp == 2) bz[x][y] = 1;
if (tp == 3) bz[x][y] = 0;
if (tp == 1) printf("%d\n", now.a[1][poi(x, y)]);
la = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long mod = 1000000007;
struct mat {
unsigned long long m[25][25];
int f, c;
};
int cat[25][25];
mat operator*(mat a, mat b) {
mat d;
for (int i = 0; i < a.f; i++)
for (int h = 0; h < b.c; h++) {
unsigned long long r = 0;
for (int k = 0; k < a.c; k++) {
r = (r + (a.m[i][k] % mod) * (b.m[k][h]) % mod) % mod;
}
d.m[i][h] = r % mod;
}
d.f = a.f;
d.c = b.c;
return d;
}
mat square(mat a) { return a * a; }
mat pot(mat a, unsigned long long n) {
if (n == 1ll) return a;
if (n & 1ll)
return a * pot(a, n - 1ll);
else
return square(pot(a, n >> 1ll));
}
map<pair<int, int>, int> id;
int mf[4] = {1, -1, 0, 0};
int mc[4] = {0, 0, 1, -1};
int n, m, tq, a, b, idx, q;
unsigned long long t;
pair<int, int> pos[10005];
bool valid(int x, int y) {
if (x >= 1 && x <= n && y >= 1 && y <= m) return 1;
return 0;
}
mat rebuild() {
mat ma;
ma.c = idx;
ma.f = idx;
for (int i = 0; i < idx; i++)
for (int h = 0; h < idx; h++) ma.m[i][h] = 0;
for (int i = 0; i < idx; i++) {
pair<int, int> x = pos[i];
if (!cat[x.first][x.second]) {
ma.m[i][i] = 1;
for (int h = 0; h < 4; h++) {
int a = mf[h] + x.first;
int b = mc[h] + x.second;
if (valid(a, b) && !cat[a][b]) {
ma.m[id[make_pair(a, b)]][i] = 1;
}
}
}
}
return ma;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int h = 1; h <= m; h++) {
id[make_pair(i, h)] = idx;
pos[idx] = make_pair(i, h);
idx++;
}
}
mat actual;
actual.c = idx;
actual.f = idx;
mat trans;
trans.c = idx;
trans.f = idx;
for (int i = 0; i < idx; i++) {
pair<int, int> j = pos[i];
trans.m[i][i] = 1;
for (int h = 0; h < 4; h++) {
int x = j.first + mf[h];
int y = j.second + mc[h];
if (valid(x, y)) {
trans.m[id[make_pair(x, y)]][i] = 1;
}
}
}
actual.m[0][0] = 1;
scanf("%d", &q);
unsigned long long tactual = 1;
while (q--) {
scanf("%d %d %d %I64d", &tq, &a, &b, &t);
actual = pot(trans, t - tactual) * actual;
if (tq > 1) {
cat[a][b] ^= 1;
trans = rebuild();
} else {
printf("%I64d\n", actual.m[id[make_pair(a, b)]][0]);
}
tactual = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = 2 * acos(0);
const int MAXN = 21;
struct matrix {
int x[MAXN][MAXN];
matrix() { memset(x, 0, sizeof(x)); }
matrix unit() {
matrix res;
for (int i = 0; i < MAXN; i++) res.x[i][i] = 1;
return res;
}
matrix operator+(matrix A) {
matrix res;
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++) {
res.x[i][j] = (x[i][j] + A.x[i][j]) % MOD;
}
return res;
}
matrix operator*(matrix A) {
matrix res;
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++) {
for (int k = 0; k < MAXN; k++)
res.x[i][j] = (res.x[i][j] + 1LL * x[i][k] * A.x[k][j]) % MOD;
}
return res;
}
matrix operator^(long long k) {
if (!k) return unit();
matrix res, tmp;
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++) {
res.x[i][j] = tmp.x[i][j] = x[i][j];
}
k--;
while (k) {
if (k & 1) res = res * tmp;
tmp = tmp * tmp;
k >>= 1;
}
return res;
}
friend matrix sumpower(matrix A, long long k) {
if (k == 1) return A;
if (k & 1) return (A ^ k) + sumpower(A, k - 1);
k >>= 1;
matrix tmp = sumpower(A, k);
return tmp + (tmp * (A ^ k));
}
};
const int maxn = 21;
int n, m, q;
int g[maxn][maxn];
int get(int i, int j) { return i * m + j; }
void solve() {
scanf("%d%d%d", &n, &m, &q);
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
g[get(i, j)][get(i, j)] = 1;
if (i) g[get(i, j)][get(i - 1, j)] = 1;
if (i + 1 < n) g[get(i, j)][get(i + 1, j)] = 1;
if (j) g[get(i, j)][get(i, j - 1)] = 1;
if (j + 1 < m) g[get(i, j)][get(i, j + 1)] = 1;
}
int cur = 1;
matrix can, A;
can.x[0][0] = 1;
for (int i = (0); i < (maxn); i++)
for (int j = (0); j < (maxn); j++) A.x[i][j] = g[i][j];
while (q--) {
int op, x, y, t;
scanf("%d%d%d%d", &op, &x, &y, &t);
int k = get(x - 1, y - 1);
can = can * (A ^ (t - cur - 1));
if (op == 1) {
can = can * A;
printf("%d\n", can.x[0][k]);
} else if (op == 2) {
for (int i = (0); i < (maxn); i++) A.x[i][k] = 0;
can = can * A;
} else {
can = can * A;
for (int i = (0); i < (maxn); i++) A.x[i][k] = g[i][k];
}
cur = t;
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int M = 1e9 + 7;
int N, n, m;
bool valid(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
int hsh(int x, int y) { return m * x + y; }
void add(int& x, int y) {
x += y;
if (M <= x) x -= M;
}
using vi = vector<int>;
using V = vector<vi>;
V operator*(const V& a, const V& b) {
V c(N, vi(N, 0));
for (auto i = (0); i < (N); ++i)
for (auto j = (0); j < (N); ++j)
for (auto k = (0); k < (N); ++k) add(c[i][j], (ll)a[i][k] * b[k][j] % M);
return c;
}
V& operator*=(V& x, const V& y) { return x = x * y; }
V binpow(V a, int n) {
V res(N, vi(N, 0));
for (auto i = (0); i < (N); ++i) res[i][i] = 1;
for (; n; n >>= 1, a *= a)
if (n & 1) res *= a;
return res;
}
const int MX = 30;
bool dead[MX][MX];
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> n >> m >> q;
N = n * m;
V A;
auto g = [&](int u, int i, int j) {
if (valid(i, j) && !dead[i][j]) A[u][hsh(i, j)] = 1;
};
V C(N, vi(N, 0));
for (auto x = (0); x < (N); ++x) C[x][x] = 1;
int p = 1;
while (q--) {
int c, i, j, t;
cin >> c >> i >> j >> t;
--i;
--j;
A = V(N, vi(N, 0));
for (auto i = (0); i < (n); ++i) {
for (auto j = (0); j < (m); ++j) {
if (dead[i][j]) continue;
int u = hsh(i, j);
A[u][u] = 1;
g(u, i + 1, j);
g(u, i - 1, j);
g(u, i, j + 1);
g(u, i, j - 1);
}
}
C *= binpow(A, t - p);
if (c != 1)
dead[i][j] ^= 1;
else
cout << C[0][hsh(i, j)] << '\n';
p = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long row, col, query;
int cat[25][25];
vector<vector<long long> > unit(long long n) {
vector<vector<long long> > ret(n, vector<long long>(n));
for (long long i = 0; i < n; i++) ret[i][i] = 1;
return ret;
}
vector<vector<long long> > matrixAdd(const vector<vector<long long> > &a,
const vector<vector<long long> > &b) {
long long n = a.size();
long long m = a[0].size();
vector<vector<long long> > ret(n, vector<long long>(m));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) ret[i][j] = (a[i][j] + b[i][j]) % mod;
return ret;
}
vector<vector<long long> > matrixMul(const vector<vector<long long> > &a,
const vector<vector<long long> > &b) {
long long n = a.size();
long long m = a[0].size();
long long k = b[0].size();
vector<vector<long long> > ret(n, vector<long long>(k));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < k; j++)
for (long long p = 0; p < m; p++)
ret[i][j] = (ret[i][j] + (long long)a[i][p] * b[p][j]) % mod;
return ret;
}
vector<vector<long long> > matrixPow(const vector<vector<long long> > &a,
long long p) {
if (p == 0) return unit(a.size());
if (p & 1) return matrixMul(a, matrixPow(a, p - 1));
return matrixPow(matrixMul(a, a), p / 2);
}
long long getId(long long r, long long c) { return col * r + c; }
bool isCan(long long y, long long x) {
if (y >= 0 && y < row && x >= 0 && x < col) return true;
return false;
}
long long dy[4] = {0, 0, 1, -1};
long long dx[4] = {1, -1, 0, 0};
void addMatrix(long long y, long long x, vector<vector<long long> > &m) {
long long id = getId(y, x);
m[id][id] = 1;
for (long long k = 0; k < 4; k++) {
long long ny = y + dy[k];
long long nx = x + dx[k];
if (isCan(ny, nx)) {
long long nid = getId(ny, nx);
if (cat[ny][nx] == 0 && cat[y][x] == 0) {
m[nid][id] = 1;
m[id][nid] = 1;
}
}
}
}
void eraseMatrix(long long y, long long x, vector<vector<long long> > &m) {
long long id = getId(y, x);
m[id][id] = 0;
for (long long k = 0; k < 4; k++) {
long long ny = y + dy[k];
long long nx = x + dx[k];
if (isCan(ny, nx)) {
long long nid = getId(ny, nx);
m[nid][id] = 0;
m[id][nid] = 0;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> row >> col >> query;
long long n = row * col;
vector<vector<long long> > base;
vector<vector<long long> > m(n, vector<long long>(n));
vector<vector<long long> > init(n, vector<long long>(1));
init[0][0] = 1;
long long cur = 1;
base = m;
for (long long y = 0; y < row; y++) {
for (long long x = 0; x < col; x++) {
addMatrix(y, x, base);
}
}
vector<vector<long long> > A = init;
for (long long i = 0; i < query; i++) {
long long type, r, c, t;
cin >> type >> r >> c >> t;
r--, c--;
long long diff = t - cur;
if (type == 1) {
vector<vector<long long> > temp = matrixPow(base, diff);
A = matrixMul(temp, A);
long long id = getId(r, c);
long long ans = A[id][0];
cout << ans << "\n";
} else if (type == 2) {
vector<vector<long long> > temp = matrixPow(base, diff);
A = matrixMul(temp, A);
A[getId(r, c)][0] = 0;
cat[r][c] = 1;
eraseMatrix(r, c, base);
} else {
vector<vector<long long> > temp = matrixPow(base, diff);
;
A = matrixMul(temp, A);
cat[r][c] = 0;
addMatrix(r, c, base);
}
cur = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int obstacol[25][25];
int N, M, Q;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
int CoordToNr(const int &x, const int &y) { return (x - 1) * M + y; }
void NrToCoord(int nr, int &x, int &y) {
x = nr / M;
if (nr % M != 0) x++;
y = nr % M;
if (y == 0) y = M;
}
class Matrice {
public:
int a[25][25];
int N, M;
Matrice() {
N = 0;
M = 0;
memset(a, 0, sizeof(a));
}
Matrice(const int &N, const int &M) {
memset(a, 0, sizeof(a));
this->N = N;
this->M = M;
}
Matrice(const int &N, const int &M, const int _a[][25]) {
memset(a, 0, sizeof(a));
this->N = N;
this->M = M;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) this->a[i][j] = _a[i][j];
}
Matrice(const Matrice &other) {
memset(a, 0, sizeof(a));
this->N = other.N;
this->M = other.M;
for (int i = 1; i <= other.N; ++i)
for (int j = 1; j <= other.M; ++j) this->a[i][j] = other.a[i][j];
}
const Matrice &operator=(const Matrice &other) {
memset(a, 0, sizeof(a));
this->N = other.N;
this->M = other.M;
for (int i = 1; i <= other.N; ++i)
for (int j = 1; j <= other.M; ++j) this->a[i][j] = other.a[i][j];
return *this;
}
Matrice operator*(const Matrice &other) const {
Matrice ret(this->N, other.M);
for (int i = 1; i <= this->N; ++i)
for (int j = 1; j <= other.M; ++j) {
int nr = 0;
for (int k = 1; k <= this->M; ++k) {
nr = (1LL * nr + 1LL * this->a[i][k] * other.a[k][j]) % MOD;
}
ret.a[i][j] = nr;
}
return ret;
}
static Matrice GetIdentity(int nrLinii) {
Matrice ret = Matrice(nrLinii, nrLinii);
for (int i = 1; i <= nrLinii; ++i) ret.a[i][i] = 1;
return ret;
}
Matrice pow(int exp) const {
Matrice ret = GetIdentity(this->N);
Matrice baza(*this);
while (exp > 0) {
if (exp & 1) {
ret = ret * baza;
}
exp >>= 1;
baza = baza * baza;
}
return ret;
}
void Afisare() {
cout << "\nAfisare:\n";
for (int i = 1; i <= this->N; ++i, cout << "\n")
for (int j = 1; j <= this->M; ++j) cout << this->a[i][j] << " ";
cout << "\n";
}
};
bool Interior(const int &x, const int &y) {
return 1 <= x && x <= N && 1 <= y && y <= M;
}
void Afisare(Matrice A) {
cout << "\nAfisare:\n";
for (int i = 1; i <= A.N; ++i, cout << "\n")
for (int j = 1; j <= A.M; ++j) cout << A.a[i][j] << " ";
cout << "\n";
}
Matrice BuildMatrix() {
const int nrLinii = N * M;
Matrice ret(nrLinii, nrLinii);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
if (obstacol[i][j] == 1) continue;
int nr = CoordToNr(i, j);
for (int k = 0; k < 4; ++k) {
if (Interior(i + dx[k], j + dy[k]) &&
obstacol[i + dx[k]][j + dy[k]] == 0)
ret.a[CoordToNr(i + dx[k], j + dy[k])][nr] = 1;
}
ret.a[nr][nr] = 1;
}
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
if (obstacol[i][j] == 1) {
int nr = CoordToNr(i, j);
for (int k = 1; k <= nrLinii; ++k) ret.a[k][nr] = ret.a[nr][k] = 0;
}
return ret;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> N >> M >> Q;
int lastt = 1;
Matrice magicMatrix(Matrice::GetIdentity(N * M));
Matrice currentMatrix(BuildMatrix());
Matrice aux(1, N * M);
aux.a[1][1] = 1;
for (int i = 1; i <= Q; ++i) {
int cod, x, y, t;
cin >> cod >> x >> y >> t;
if (cod == 1) {
magicMatrix = magicMatrix * currentMatrix.pow(t - lastt);
Matrice aux(1, N * M);
aux.a[1][1] = 1;
aux = aux * magicMatrix;
cout << aux.a[1][CoordToNr(x, y)] << "\n";
}
if (cod == 2) {
magicMatrix = magicMatrix * currentMatrix.pow(t - lastt);
obstacol[x][y] = 1;
currentMatrix = BuildMatrix();
}
if (cod == 3) {
magicMatrix = magicMatrix * currentMatrix.pow(t - lastt);
obstacol[x][y] = 0;
currentMatrix = BuildMatrix();
}
lastt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = 1000000007;
const int dx[5] = {0, 0, 0, 1, -1};
const int dy[5] = {0, 1, -1, 0, 0};
int n, m, k, q, type, x, y, t;
struct Matrix {
int A[N + 5][N + 5];
};
inline int cell(int x, int y) { return x * m + y; }
Matrix initMatrix() {
Matrix ret;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
ret.A[i][j] = 0;
}
}
for (int i = 0; i < k; i++) {
ret.A[i][i] = 1;
}
return ret;
}
Matrix initEdgeMatrix() {
Matrix ret;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
ret.A[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 5; k++) {
int xx = i + dx[k];
int yy = j + dy[k];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
ret.A[cell(i, j)][cell(xx, yy)] = true;
}
}
}
}
return ret;
}
inline void add(int &w, int u) {
w += u;
if (w >= M) {
w -= M;
}
}
Matrix mul(Matrix a, Matrix b) {
Matrix ret;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
ret.A[i][j] = 0;
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
for (int l = 0; l < k; l++) {
ret.A[i][j] = (ret.A[i][j] + (long long)a.A[i][l] * b.A[l][j]) % M;
}
}
}
return ret;
}
Matrix power(Matrix a, int l) {
Matrix ret = initMatrix();
while (l >= 1) {
if (l % 2 == 1) {
ret = mul(ret, a);
}
a = mul(a, a);
l /= 2;
}
return ret;
}
void setCat(Matrix &a, int x, int y, int value) {
for (int i = 0; i < 5; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
a.A[cell(xx, yy)][cell(x, y)] = value;
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
k = n * m;
Matrix curResult = initMatrix();
Matrix edgeMatrix = initEdgeMatrix();
int lastCat = 1;
for (int i = 1; i <= q; i++) {
scanf("%d %d %d %d", &type, &x, &y, &t);
x--;
y--;
t--;
if (type == 1) {
curResult = mul(curResult, power(edgeMatrix, t - lastCat + 1));
printf("%d\n", curResult.A[0][cell(x, y)]);
lastCat = t + 1;
} else {
if (type == 3) {
t++;
}
curResult = mul(curResult, power(edgeMatrix, t - lastCat));
lastCat = t;
setCat(edgeMatrix, x, y, (type - 1) / 2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 410;
long long dp[maxn];
long long newdp[maxn];
bool cat[maxn];
int n, m, q;
long long ans[maxn][maxn];
long long tmp[maxn][maxn];
long long tmptmp[maxn][maxn];
int cal(int i, int j) { return (i - 1) * m + j; }
int judge(int i, int j) {
if (i >= 1 && i <= n && j >= 1 && j <= m && cat[cal(i, j)] == 0)
return 1;
else
return 0;
}
void work(int t) {
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++) tmp[i][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (judge(i, j)) tmp[cal(i, j)][cal(i, j)] = 1;
if (judge(i - 1, j)) tmp[cal(i, j)][cal(i - 1, j)] = 1;
if (judge(i + 1, j)) tmp[cal(i, j)][cal(i + 1, j)] = 1;
if (judge(i, j - 1)) tmp[cal(i, j)][cal(i, j - 1)] = 1;
if (judge(i, j + 1)) tmp[cal(i, j)][cal(i, j + 1)] = 1;
}
}
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++) ans[i][j] = (i == j);
while (t) {
if (t & 1) {
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++) tmptmp[i][j] = 0;
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++)
for (int k = 1; k <= n * m; k++)
tmptmp[i][j] = (tmptmp[i][j] + (ans[i][k] * tmp[k][j]) % mod) % mod;
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++) ans[i][j] = tmptmp[i][j];
}
t >>= 1;
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++) tmptmp[i][j] = 0;
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++)
for (int k = 1; k <= n * m; k++)
tmptmp[i][j] = (tmptmp[i][j] + (tmp[i][k] * tmp[k][j]) % mod) % mod;
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++) tmp[i][j] = tmptmp[i][j];
}
for (int i = 1; i <= n * m; i++) newdp[i] = 0;
for (int i = 1; i <= n * m; i++)
for (int j = 1; j <= n * m; j++)
newdp[i] = (newdp[i] + (ans[i][j] * dp[j]) % mod) % mod;
for (int i = 1; i <= n * m; i++) dp[i] = newdp[i];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
dp[cal(1, 1)] = 1;
int time = 1;
while (q--) {
int flag, x, y, t;
scanf("%d%d%d%d", &flag, &x, &y, &t);
if (flag == 1) {
work(t - time);
time = t;
printf("%I64d\n", dp[cal(x, y)]);
} else if (flag == 2) {
work(t - time);
time = t;
cat[cal(x, y)] = 1;
dp[cal(x, y)] = 0;
} else {
work(t - time);
time = t;
cat[cal(x, y)] = 0;
dp[cal(x, y)] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int N = 20, D = 31;
int n, r, c, q;
bool ma[N];
vector<pair<int, int>> adj({{0, 0}, {-1, 0}, {1, 0}, {0, -1}, {0, 1}});
const int mod = 1e9 + 7;
void fmod(int& first) { first += first >> 31 & mod; }
struct Matrix {
int a[N][N];
bool isv;
Matrix() {
for (int i(0); i < (n); ++i)
for (int j(0); j < (n); ++j) a[i][j] = 0;
isv = false;
}
void print() {
cout << "@Matrix:\n";
for (int i(0); i < (n); ++i)
for (int j(0); j < (n); ++j) cout << a[i][j] << " \n"[n - j == 1];
}
int* operator[](int i) { return a[i]; }
Matrix friend operator*(Matrix u, Matrix v) {
Matrix res;
if (u.isv) {
for (int j(0); j < (n); ++j)
for (int t(0); t < (n); ++t)
fmod(res[0][j] += 1ll * u[0][t] * v[t][j] % mod - mod);
} else {
for (int i(0); i < (n); ++i)
for (int j(0); j < (n); ++j)
for (int t(0); t < (n); ++t)
fmod(res[i][j] += 1ll * u[i][t] * v[t][j] % mod - mod);
}
return res;
}
} pre, now[D];
int mx;
void makemat() {
now[0] = Matrix(), mx = 0;
for (int i(0); i < (r); ++i)
for (int j(0); j < (c); ++j)
if (!ma[i * c + j])
for (pair<int, int> d : adj) {
int first = i + d.first, second = j + d.second;
if (first < 0 || first >= r || second < 0 || second >= c ||
ma[first * c + second])
continue;
now[0][i * c + j][first * c + second] = 1;
}
}
Matrix tonow(int first) {
Matrix res(pre);
for (int i((D)-1); i >= 0; --i)
if (first >> i & 1) {
while (mx < i) now[mx + 1] = now[mx] * now[mx], mx++;
res = res * now[i];
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> r >> c >> q, n = r * c, makemat();
int p = 0;
pre[0][0] = 1, pre.isv = true;
while (q--) {
int o, first, second, t;
cin >> o >> first >> second >> t, --o, --first, --second, --t;
if (o == 0)
cout << (tonow(t - p))[0][first * c + second] << '\n';
else if (o == 1)
pre = tonow(t - p), ma[first * c + second] = true, makemat(), p = t;
else if (o == 2)
pre = tonow(t - p), ma[first * c + second] = false, makemat(), p = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int 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));
cout << dp.matrix[0][x * m + y] << "\n";
} 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 N = 10010;
const int L = 20 + 3;
const long long MOD = 1e9 + 7;
const long long MM = 7e18;
int f[L][L];
int n, m, q;
struct Matrix {
int l;
long long f[L][L];
Matrix() { memset(f, 0, sizeof(f)), l = 0; }
} f1, f2;
struct Query {
int tp, x, y, t;
} g[N];
long long ans[N];
int l[5] = {0, 1, -1, 0, 0};
int r[5] = {0, 0, 0, 1, -1};
void print(Matrix a) {
for (int i = 1; i <= a.l; i++) {
for (int j = 1; j <= a.l; j++) cout << a.f[i][j] << " ";
cout << endl;
}
cout << "---------" << endl;
}
Matrix Mul(Matrix x, Matrix y) {
Matrix z;
z.l = x.l;
for (int i = 1; i <= z.l; i++)
for (int j = 1; j <= z.l; j++) {
z.f[i][j] = 0;
for (int k = 1; k <= z.l; k++) {
z.f[i][j] += x.f[i][k] * y.f[k][j];
if (z.f[i][j] >= MM) z.f[i][j] %= MOD;
}
z.f[i][j] %= MOD;
}
return z;
}
Matrix initial(int l) {
Matrix x;
x.l = l;
for (int i = 1; i <= l; i++)
for (int j = 1; j <= l; j++) x.f[i][j] = (i == j ? 1 : 0);
return x;
}
Matrix ksm(Matrix a, int b) {
Matrix x = initial(n * m);
while (b > 0) {
if (b & 1) x = Mul(x, a);
b >>= 1;
a = Mul(a, a);
}
return x;
}
bool outside(int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m) return true;
return false;
}
void add(int x, int y) {
int nx, ny;
f2.f[f[x][y]][f[x][y]] = 1;
for (int i = 1; i <= 4; i++) {
nx = x + l[i], ny = y + r[i];
if (outside(nx, ny)) continue;
f2.f[f[nx][ny]][f[x][y]] = 1;
}
}
void del(int x, int y) {
int nx, ny;
f2.f[f[x][y]][f[x][y]] = 0;
for (int i = 1; i <= 4; i++) {
nx = x + l[i], ny = y + r[i];
if (outside(nx, ny)) continue;
f2.f[f[nx][ny]][f[x][y]] = 0;
}
}
void init() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) f[i][j] = (i - 1) * m + j;
for (int i = 1; i <= q; i++)
scanf("%d%d%d%d", &g[i].tp, &g[i].x, &g[i].y, &g[i].t);
f1.l = f2.l = n * m;
f1.f[1][1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) add(i, j);
}
void work() {
int now;
g[0].t = 1;
for (int i = 1; i <= q; i++) {
f1 = Mul(f1, ksm(f2, g[i].t - g[i - 1].t));
now = f[g[i].x][g[i].y];
switch (g[i].tp) {
case 1:
ans[i] = f1.f[1][now];
ans[i] %= MOD;
break;
case 2:
del(g[i].x, g[i].y);
f1.f[1][now] = 0;
break;
case 3:
add(g[i].x, g[i].y);
break;
default:
break;
}
}
for (int i = 1; i <= q; i++)
if (g[i].tp == 1) printf("%I64d\n", ans[i]);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
vector<vector<long long> > data;
long long MOD = 1000000007;
int n;
Matrix(int n) {
this->n = n;
data.resize(n);
for (int i = 0; i < n; i++) {
data[i].resize(n, 0);
}
}
Matrix operator*(Matrix other) {
Matrix result(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) {
result.data[i][j] += data[i][k] * other.data[k][j];
result.data[i][j] %= MOD;
}
return result;
}
};
Matrix bin_pow(Matrix &base, int power) {
if (power == 0) {
Matrix result(base.data.size());
for (int i = 0; i < result.data.size(); i++) result.data[i][i] = 1;
return result;
}
if (power == 1) return base;
if (power % 2 != 0) return bin_pow(base, power - 1) * base;
Matrix temp = bin_pow(base, power / 2);
return temp * temp;
}
bool cats[1000];
void set_connection(Matrix &a, int from_i, int from_j, int to_i, int to_j,
int value, int n, int m) {
if (from_i < 0 || from_j < 0 || from_i >= n || from_j >= m) return;
if (to_i < 0 || to_j < 0 || to_i >= n || to_j >= m) return;
int index_from = from_i * m + from_j;
int index_to = to_i * m + to_j;
a.data[index_from][index_to] = value;
a.data[index_to][index_from] = value;
}
void set_connection_uncat(Matrix &a, int from_i, int from_j, int to_i, int to_j,
int value, int n, int m) {
if (from_i < 0 || from_j < 0 || from_i >= n || from_j >= m) return;
if (to_i < 0 || to_j < 0 || to_i >= n || to_j >= m) return;
int index_from = from_i * m + from_j;
int index_to = to_i * m + to_j;
if (!cats[index_to]) a.data[index_from][index_to] = value;
a.data[index_to][index_from] = value;
}
void set_cell(Matrix &a, int i, int j, int value, int n, int m) {
set_connection(a, i, j, i - 1, j, value, n, m);
set_connection(a, i, j, i, j - 1, value, n, m);
set_connection(a, i, j, i + 1, j, value, n, m);
set_connection(a, i, j, i, j + 1, value, n, m);
set_connection(a, i, j, i, j, value, n, m);
}
void set_cat(Matrix &a, int i, int j, int value, int n, int m) {
cats[i * m + j] = true;
set_connection(a, i, j, i - 1, j, value, n, m);
set_connection(a, i, j, i, j - 1, value, n, m);
set_connection(a, i, j, i + 1, j, value, n, m);
set_connection(a, i, j, i, j + 1, value, n, m);
set_connection(a, i, j, i, j, value, n, m);
}
void set_uncat(Matrix &a, int i, int j, int value, int n, int m) {
cats[i * m + j] = false;
set_connection_uncat(a, i, j, i - 1, j, value, n, m);
set_connection_uncat(a, i, j, i, j - 1, value, n, m);
set_connection_uncat(a, i, j, i + 1, j, value, n, m);
set_connection_uncat(a, i, j, i, j + 1, value, n, m);
set_connection_uncat(a, i, j, i, j, value, n, m);
}
long long get(Matrix &a, int x1, int y1, int x2, int y2, int n, int m) {
if (cats[x2 * m + y2]) return 0;
return a.data[x1 * m + y1][x2 * m + y2];
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
Matrix a(n * m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
set_cell(a, i, j, 1, n, m);
}
for (int i = 0; i < n * m; i++) cats[i] = false;
Matrix current_state(n * m);
set_connection(current_state, 0, 0, 0, 0, 1, n, m);
int current_time = 1;
for (int i = 0; i < q; i++) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
int delta_t = t - current_time;
if (tp == 1) {
current_state = current_state * bin_pow(a, delta_t);
cout << get(current_state, 0, 0, x - 1, y - 1, n, m) << endl;
}
if (tp == 2) {
delta_t--;
current_state = current_state * bin_pow(a, delta_t);
current_state = current_state * a;
set_cat(a, x - 1, y - 1, 0, n, m);
}
if (tp == 3) {
current_state = current_state * bin_pow(a, delta_t);
set_uncat(a, x - 1, y - 1, 1, n, m);
}
current_time = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mat[45][45] = {0}, id_mat[45][45] = {0};
int total;
void copym(long long int s[45][45], long long int des[45][45]) {
for (int i = 0; i < 45; i++)
for (int j = 0; j < 45; j++) des[i][j] = s[i][j];
}
void add(long long int &a, long long int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
void mul(long long int d[45][45], long long int mat1[45][45],
long long int mat2[45][45]) {
for (int i = 0; i < total; i++)
for (int j = 0; j < total; j++) d[i][j] = 0;
for (int i = 0; i < total; i++)
for (int j = 0; j < total; j++)
for (int k = 0; k < total; k++)
d[i][j] = (d[i][j] + (mat1[i][k] * mat2[k][j])) % 1000000007;
}
void cal(long long int ret[45][45], long long int t) {
if (t == 0) {
copym(id_mat, ret);
return;
}
if (t == 1) {
copym(mat, ret);
return;
}
cal(ret, t / 2);
long long int tem[45][45] = {0};
mul(tem, ret, ret);
if (t % 2 == 1)
mul(ret, tem, mat);
else
copym(tem, ret);
}
pair<int, int> get(int i, int m) {
pair<int, int> ret;
ret.first = i / m;
ret.second = i % m;
return ret;
}
int main() {
for (int i = 0; i < 45; i++) id_mat[i][i] = 1;
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
int prevt = 0;
total = n * m;
long long int ret[45][45] = {0};
copym(id_mat, ret);
int cat[45][45] = {0};
while (q--) {
for (int i = 0; i < 45; i++)
for (int j = 0; j < 45; j++) mat[i][j] = 0;
int type, x, y, t;
scanf("%d%d%d%d", &type, &x, &y, &t);
x--;
y--;
for (int i = 0; i < total; i++)
for (int j = 0; j < total; j++) {
pair<int, int> f = get(i, m), s = get(j, m);
if (abs(f.first - s.first) + abs(f.second - s.second) <= 1 &&
!cat[f.first][f.second] && !cat[s.first][s.second])
mat[i][j] = 1;
}
long long int tem[45][45] = {0};
if (type == 1) {
cal(tem, t - prevt - 1);
prevt = t - 1;
long long int tem1[45][45];
copym(ret, tem1);
mul(ret, tem1, tem);
printf("%lld\n", ret[0][x * m + y]);
} else {
cal(tem, t - prevt - 1);
prevt = t - 1;
long long int tem1[45][45];
copym(ret, tem1);
mul(ret, tem1, tem);
cat[x][y] = (cat[x][y] + 1) % 2;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct matrix {
int N;
vector<T> dat;
matrix<T>(int _N, T fill = T(0), T diag = T(0)) {
N = _N;
dat.resize(N * N, fill);
for (int i = 0; i < N; i++) (*this)(i, i) = diag;
}
T &operator()(int i, int j) { return dat[N * i + j]; }
matrix<T> operator*(matrix<T> &b) {
matrix<T> r(N);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++) r(i, j) = r(i, j) + (*this)(i, k) * b(k, j);
return r;
}
matrix<T> pow(long long expo) {
if (!expo) return matrix<T>(N, T(0), T(1));
matrix<T> r = (*this * *this).pow(expo / 2);
return expo & 1 ? r * *this : r;
}
friend ostream &operator<<(ostream &os, matrix<T> &m) {
os << "{";
for (int i = 0; i < m.N; i++) {
if (i) os << "},\n ";
os << "{";
for (int j = 0; j < m.N; j++) {
if (j) os << ", ";
os << setw(10) << m(i, j) << setw(0);
}
}
return os << "}}";
}
};
const int MOD = 1e9 + 7;
struct mll {
int val;
mll(int _val = 0) {
val = _val % MOD;
if (val < 0) val += MOD;
}
mll operator+(const mll &o) { return mll((val + o.val) % MOD); }
mll operator*(const mll &o) { return mll((val * 1ll * o.val) % MOD); }
friend ostream &operator<<(ostream &os, mll &m) { return os << m.val; }
};
int N, M, Q;
bool cat[20][20];
int dir[5][2] = {{0, 0}, {-1, 0}, {1, 0}, {0, -1}, {0, 1}};
bool go(int i, int j) {
if (i < 0 || j < 0 || i >= N || j >= M) return false;
return !cat[i][j];
}
void advance(matrix<mll> &cur, int steps) {
matrix<mll> mul(N * M);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (!go(i, j)) continue;
for (int d = 0; d < 5; d++) {
int ii = i + dir[d][0];
int jj = j + dir[d][1];
if (!go(ii, jj)) continue;
mul(i * M + j, ii * M + jj).val++;
}
}
}
mul = mul.pow(steps);
cur = cur * mul;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M >> Q;
matrix<mll> ans(N * M, mll(0), mll(1));
int CT = 1;
int T, first, second, TM;
for (int i = 0; i < Q; i++) {
cin >> T >> first >> second >> TM;
first--, second--;
if (T == 1) {
advance(ans, TM - CT);
cout << ans(0, first * M + second) << "\n";
CT = TM;
} else {
advance(ans, TM - CT);
if (T == 2)
cat[first][second] = true;
else
cat[first][second] = false;
CT = TM;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int N;
struct Mat {
long long a[22][22];
Mat() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) a[i][j] = 0;
}
Mat operator*(Mat other) {
Mat ret;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
ret.a[i][j] += a[i][k] * other.a[k][j], ret.a[i][j] %= 1000000007;
return ret;
}
};
Mat dnc(Mat now, int x) {
if (x == 0) {
Mat ret;
for (int i = 0; i < N; i++) ret.a[i][i] = 1;
return ret;
}
return x & 1 ? now * dnc(now * now, x >> 1) : dnc(now * now, x >> 1);
}
int konv(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m) return N;
return x * m + y;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
N = n * m;
int bef = 1;
Mat kali;
vector<int> now;
for (int i = 0; i < N; i++) now.push_back(0);
now[0] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
kali.a[konv(i, j)][konv(i, j)] = 1;
kali.a[konv(i, j)][konv(i - 1, j)] = 1;
kali.a[konv(i, j)][konv(i + 1, j)] = 1;
kali.a[konv(i, j)][konv(i, j - 1)] = 1;
kali.a[konv(i, j)][konv(i, j + 1)] = 1;
}
int tp, x, y, t;
while (q--) {
scanf("%d %d %d %d", &tp, &x, &y, &t);
x--, y--;
Mat tmp = dnc(kali, t - bef);
bef = t;
vector<int> next;
for (int i = 0; i < N; i++) {
long long sum = 0;
for (int j = 0; j < N; j++)
sum += tmp.a[i][j] * now[j], sum %= 1000000007;
next.push_back(sum);
}
now = next;
if (tp == 1) {
printf("%d\n", now[konv(x, y)]);
} else if (tp == 2) {
now[konv(x, y)] = 0;
kali.a[konv(x, y)][konv(x, y)] = 0;
kali.a[konv(x, y)][konv(x - 1, y)] = 0;
kali.a[konv(x, y)][konv(x + 1, y)] = 0;
kali.a[konv(x, y)][konv(x, y - 1)] = 0;
kali.a[konv(x, y)][konv(x, y + 1)] = 0;
} else if (tp == 3) {
kali.a[konv(x, y)][konv(x, y)] = 1;
kali.a[konv(x, y)][konv(x - 1, y)] = 1;
kali.a[konv(x, y)][konv(x + 1, y)] = 1;
kali.a[konv(x, y)][konv(x, y - 1)] = 1;
kali.a[konv(x, y)][konv(x, y + 1)] = 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
const int M = 25;
int tot;
struct Mat {
int v[M][M];
void clear() {
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) v[i][j] = 0;
}
}
Mat(int x = 1) {
clear();
if (x = 1) {
for (int i = 0; i < tot; ++i) v[i][i] = 1;
}
}
void operator*=(Mat b) {
Mat a = *this;
clear();
for (int i = 0; i < tot; ++i) {
for (int j = 0; j < tot; ++j) {
for (int k = 0; k < tot; ++k) {
v[i][j] = (v[i][j] + 1LL * a.v[i][k] * b.v[k][j] % P) % P;
}
}
}
}
};
int n, m, q;
int ID[M][M];
int ans[M];
Mat B(0);
void Add(int x, int y) {
B.v[ID[x][y]][ID[x][y]] ^= 1;
if (x >= 1) B.v[ID[x - 1][y]][ID[x][y]] ^= 1;
if (x < n - 1) B.v[ID[x + 1][y]][ID[x][y]] ^= 1;
if (y >= 1) B.v[ID[x][y - 1]][ID[x][y]] ^= 1;
if (y < m - 1) B.v[ID[x][y + 1]][ID[x][y]] ^= 1;
}
void calc(int t) {
Mat res;
Mat x = B;
while (t) {
if (t & 1) res *= x;
x *= x, t >>= 1;
}
int tmp[M];
for (int i = 0; i < tot; ++i) tmp[i] = ans[i], ans[i] = 0;
for (int i = 0; i < tot; ++i) {
for (int j = 0; j < tot; ++j) {
ans[j] = (ans[j] + 1LL * tmp[i] * res.v[i][j] % P) % P;
}
}
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) ID[i][j] = tot++;
}
int las = 1;
ans[0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) Add(i, j);
}
for (int i = 0; i < q; ++i) {
int k, x, y, t;
cin >> k >> x >> y >> t;
x--, y--;
if (k == 1) {
calc(t - las);
cout << ans[ID[x][y]] << endl;
} else if (k == 2) {
calc(t - las - 1);
Add(x, y);
calc(1);
} else {
calc(t - las);
Add(x, y);
}
las = t;
}
}
|
#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 i = 0; i < r; i++) {
for (int j = 0; j < a.c; j++) {
for (int k = 0; k < c; k++) {
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;
int n, m, q;
struct matrix {
int row, col;
long long int mat[20][20];
matrix() {
for (int i = 0; i < 20; i++)
for (int j = 0; j < 20; j++) {
mat[i][j] = 0;
}
}
matrix(int r, int c, bool identity = false) {
row = r;
col = c;
for (int i = 0; i < 20; i++)
for (int j = 0; j < 20; j++) {
if (i == j && identity)
mat[i][j] = 1;
else
mat[i][j] = 0;
}
}
matrix operator*(matrix &o) {
matrix ans = matrix(this->row, o.col);
for (int i = 0; i < this->row; i++)
for (int j = 0; j < o.col; j++) {
ans.mat[i][j] = 0;
for (int z = 0; z < this->col; z++)
ans.mat[i][j] =
(ans.mat[i][j] + 1ll * mat[i][z] * o.mat[z][j]) % ((int)1e9 + 7);
}
return ans;
}
void show() {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) printf("%lld ", mat[i][j]);
printf("\n");
}
cout << "\n";
}
void operator=(const matrix &o) {
for (int i = 0; i < o.row; i++)
for (int j = 0; j < col; j++) this->mat[i][j] = o.mat[i][j];
}
};
matrix power(matrix mat, int n) {
if (n == 0) {
int row = mat.row;
int col = mat.col;
matrix temp(row, col, true);
return temp;
}
if (n % 2 == 0) {
matrix temp = power(mat, n / 2);
return temp * temp;
} else {
matrix ans = power(mat, n - 1);
return mat * ans;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> q;
int curr = 1;
int mask = 0;
int obj = n * m;
matrix start(obj, 1);
start.mat[0][0] = 1;
int types[10502], xs[10502], ys[10502], ts[10502];
for (int i = 1; i < q + 1; i++) {
cin >> types[i] >> xs[i] >> ys[i] >> ts[i];
}
types[0] = 1, xs[0] = 1, ys[0] = 1, ts[0] = ts[1] - 1;
for (int i = 0; i < q + 1; i++) {
int type = types[i], x = xs[i], y = ys[i], t = ts[i];
x--, y--;
int diff = t - curr - 1;
if (diff < 0) continue;
curr = curr + diff;
matrix mat(obj, obj);
for (int to = 0; to < obj; to++) {
if (!(mask & (1 << to))) {
int x = to / m, y = to % m;
for (int from = 0; from < obj; from++) {
int x1 = (from / m), y1 = from % m;
if (abs(x - x1) + abs(y - y1) <= 1 && !(mask & (1 << from))) {
mat.mat[to][from] = 1;
}
}
} else {
}
}
start = power(mat, diff) * start;
long long int ans = 0;
if (1) {
int nMask = mask;
if (type == 2) nMask = mask | (1 << (x * m + y));
matrix nstart(obj, 1);
for (int from = 0; from < obj; from++) {
int a = from / m, b = from % m;
for (int to = 0; to < obj; to++) {
int c = to / m, d = to % m;
if (abs(a - c) + abs(d - b) <= 1 && !(nMask & (1 << to))) {
nstart.mat[to][0] =
(nstart.mat[to][0] + start.mat[from][0]) % ((int)1e9 + 7);
}
}
}
if (type == 3) nMask = mask ^ (1 << (x * m + y));
curr++;
mask = nMask;
for (int j = 0; j < obj; j++)
for (int k = 0; k < obj; k++) start.mat[j][0] = nstart.mat[j][0];
}
if (type == 1 && i != 0) {
ans = start.mat[x * m + y][0];
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
long long ways[2][20][20] = {0};
bool cats[20][20] = {0};
long long moves[32][20][20] = {0};
void init() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++) {
moves[0][m * i + j][m * k + l] =
abs(k - i) + abs(l - j) <= 1 && !cats[k][l];
}
}
}
}
}
void mult(long long m1[20][20], long long m2[20][20], long long r[20][20],
bool lazy) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++) r[m * i + j][m * k + l] = 0;
if (!lazy) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++) {
for (int o = 0; o < n; o++) {
for (int p = 0; p < m; p++) {
r[m * i + j][m * o + p] =
(((r[m * i + j][m * o + p]) +
(((m1[m * i + j][m * k + l]) *
(m2[m * k + l][m * o + p]) % 1000000007))) %
1000000007);
}
}
}
}
}
}
} else {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++) {
for (int o = 0; o < n; o++) {
for (int p = 0; p < m; p++) {
r[0][m * o + p] = (((r[0][m * o + p]) +
(((m1[0][m * k + l]) *
(m2[m * k + l][m * o + p]) % 1000000007))) %
1000000007);
}
}
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
init();
ways[0][0][0] = 1;
bool par = 0;
int start = 1;
for (int i = 0; i < q; i++) {
int ty, x, y, t;
scanf("%d %d %d %d", &ty, &x, &y, &t);
x--;
y--;
int ahead = t - start;
start = t;
for (int j = 0; (ahead >> j) != 0; j++) {
if (j >= 1) mult(moves[j - 1], moves[j - 1], moves[j], 0);
if ((ahead >> j) & 1) {
mult(ways[par], moves[j], ways[!par], 1);
par = !par;
}
}
if (ty == 1) {
long long sum = 0;
cout << ways[par][0][m * x + y] << '\n';
} else if (ty == 2) {
cats[x][y] = 1;
init();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) ways[par][m * i + j][m * x + y] = 0;
}
} else {
cats[x][y] = 0;
init();
}
}
}
|
#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;
long long mat[411][411], cur[411][411];
long long y[411][411], c[411][411], d[411], ans[411];
int sz, mark[411], orgmat[411][411];
void multiply(long long a[][411], long long b[][411]) {
int i, j, k;
for (i = 0; i < sz; i++)
for (j = 0; j < sz; j++) {
c[i][j] = 0;
for (k = 0; k < sz; k++)
c[i][j] = (c[i][j] + (a[i][k] * b[k][j])) % 1000000007LL;
}
for (i = 0; i < sz; i++)
for (j = 0; j < sz; j++) a[i][j] = c[i][j];
}
void mul(int b) {
int i, j;
for (i = 0; i < sz; i++)
for (j = 0; j < sz; j++)
if (i == j)
cur[i][j] = 1;
else
cur[i][j] = 0;
for (i = 0; i < sz; i++)
for (j = 0; j < sz; j++) y[i][j] = mat[i][j];
while (b > 0) {
if (b & 1) multiply(cur, y);
multiply(y, y);
b /= 2;
}
for (i = 0; i < sz; i++) {
d[i] = 0LL;
for (j = 0; j < sz; j++)
d[i] = (d[i] + (ans[j] * cur[j][i])) % 1000000007LL;
}
for (i = 0; i < sz; i++) ans[i] = d[i];
}
int main() {
int n, m, q, i, j;
scanf("%d %d %d", &n, &m, &q);
sz = n * m;
for (i = 0; i < sz; i++) {
for (j = 0; j < sz; j++) {
int r1 = i / m, r2 = j / m, c1 = i % m, c2 = j % m;
if ((abs(r1 - r2) + abs(c1 - c2)) <= 1) mat[j][i] = 1, orgmat[i][j] = 1;
}
}
ans[0] = 1LL;
for (i = 1; i < sz; i++) ans[i] = 0LL;
int prev = 1;
while (q--) {
int ty, i, j, t;
scanf("%d %d %d %d", &ty, &i, &j, &t);
mul(t - prev);
prev = t;
i--;
j--;
if (ty == 1)
printf("%lld\n", ans[i * m + j]);
else if (ty == 2) {
i = i * m + j;
for (int k = 0; k < sz; k++) mat[k][i] = 0;
for (int k = 0; k < sz; k++) mat[i][k] = 0;
mark[i] = 1;
ans[i] = 0LL;
} else {
i = i * m + j;
mark[i] = 0;
for (int k = 0; k < sz; k++)
if (mark[k] == 0) mat[k][i] = orgmat[i][k];
for (int k = 0; k < sz; k++)
if (mark[k] == 0) mat[i][k] = orgmat[i][k];
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2")
#pragma GCC optimize("O3")
int get_id() {
static int id = 0;
return id++;
}
template <typename T>
struct Matrix {
private:
T *data;
size_t m_size;
int id;
public:
Matrix() : data(nullptr) {}
Matrix(size_t size) : data(new T[size * size]), m_size(size) {
std::fill(data, data + m_size * m_size, T());
}
Matrix(const Matrix &other) {
m_size = other.m_size;
data = new T[m_size * m_size];
std::copy(other.data, other.data + m_size * m_size, data);
}
Matrix(Matrix &&other) {
m_size = other.m_size;
data = new T[m_size * m_size];
std::copy(other.data, other.data + m_size * m_size, data);
}
void operator=(Matrix &&other) {
this->~Matrix();
m_size = other.m_size;
data = new T[m_size * m_size];
std::copy(other.data, other.data + m_size * m_size, data);
}
inline T *operator[](size_t pos) {
if (pos >= m_size) {
exit(34526);
}
return data + pos * m_size;
}
inline const T *operator[](size_t pos) const {
if (pos >= m_size) {
exit(34526);
}
return data + pos * m_size;
}
size_t size() const { return m_size; }
~Matrix() {
if (data != nullptr) {
delete[] data;
} else {
}
}
};
constexpr int mod = 1e9 + 7;
Matrix<uint32_t> operator*(const Matrix<uint32_t> &a,
const Matrix<uint32_t> &b) {
if (a.size() != b.size()) {
exit(325);
}
size_t n = a.size();
Matrix<uint32_t> res(n);
for (int i = 0; i < n; i++) {
std::fill(res[i], res[i] + n, 0u);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
res[i][j] = (res[i][j] + a[i][k] * 1ull * b[k][j]) % mod;
}
}
}
return res;
}
template <typename T>
T power(T base, uint64_t exp) {
if (exp == 0) {
exit(325352);
}
exp--;
T res = base;
for (uint64_t k = 0; (1ull << k) <= exp; k++) {
if ((exp >> k) & 1) {
res = res * base;
}
base = base * base;
}
return res;
}
int n, m, q;
uint32_t cnt[25], cnt2[25];
bool cat[25];
Matrix<uint32_t> get() {
Matrix<uint32_t> res(n * m);
for (int i = 0; i < (n * m); i++) {
for (int j = 0; j < (n * m); j++) {
if (cat[i] || cat[j]) {
res[i][j] = 0;
continue;
}
int x1 = i / m, y1 = i % m;
int x2 = j / m, y2 = j % m;
res[i][j] = 0;
res[i][j] += i == j;
res[i][j] += (x1 == x2) && (((y1 - y2) == 1) || ((y1 - y2) == -1));
res[i][j] += (y1 == y2) && (((x1 - x2) == 1) || ((x1 - x2) == -1));
}
}
return res;
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
std::cin >> n >> m >> q;
cnt[0] = 1;
int lastTime = 1;
for (int qr = 0; qr < q; qr++) {
int type, x, y, time;
std::cin >> type >> x >> y >> time;
x--;
y--;
int p = x * m + y;
if (type > 1) {
Matrix<uint32_t> chg = get();
if (lastTime == time) {
;
} else {
chg = power(chg, time - lastTime);
std::fill(cnt2, cnt2 + n * m, 0);
for (int i = 0; i < (n * m); i++) {
for (int j = 0; j < (n * m); j++) {
cnt2[j] = (cnt2[j] + chg[i][j] * 1ull * cnt[i]) % mod;
}
}
std::copy(cnt2, cnt2 + n * m, cnt);
}
if (type == 2) {
cat[p] = true;
cnt[p] = 0;
} else {
cat[p] = false;
}
} else {
Matrix<uint32_t> chg = get();
if (lastTime == time) {
;
} else {
chg = power(chg, time - lastTime);
std::fill(cnt2, cnt2 + n * m, 0);
for (int i = 0; i < (n * m); i++) {
for (int j = 0; j < (n * m); j++) {
cnt2[j] = (cnt2[j] + chg[i][j] * 1ull * cnt[i]) % mod;
}
}
std::copy(cnt2, cnt2 + n * m, cnt);
}
std::cout << cnt[x * m + y] << '\n';
}
lastTime = time;
}
std::cout.flush();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 22, max_q = 11111, mod = 1000000007;
struct matrix {
vector<vector<int> > v;
matrix() {}
matrix(int n, int m) { v.resize(n, vector<int>(m, 0)); }
matrix operator*(const matrix &m) const {
matrix res(v.size(), m.v[0].size());
for (int i = 0; i < res.v.size(); ++i) {
for (int j = 0; j < res.v[i].size(); ++j) {
for (int k = 0; k < v[i].size(); ++k) {
res.v[i][j] += (1LL * v[i][k] * m.v[k][j]) % mod;
res.v[i][j] %= mod;
}
}
}
return res;
}
};
matrix power(matrix a, int b) {
if (b == 0) {
matrix res(a.v.size(), a.v.size());
for (int i = 0; i < res.v.size(); ++i) {
res.v[i][i] = 1;
}
return res;
}
if (b % 2 == 0) {
return power(a * a, b / 2);
}
return a * power(a, b - 1);
}
const int dx[] = {-1, 1, 0, 0, 0};
const int dy[] = {0, 0, -1, 1, 0};
int n, m, q, tp[max_q], x[max_q], y[max_q], t[max_q], f[max_q], a[max_n][max_n];
matrix dp, p;
bool is_in(int x, int y) { return 0 <= x && 0 <= y && x < n && y < m; }
void get_p() {
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 (is_in(x, y)) {
p.v[i * m + j][x * m + y] = 0;
if (a[x][y] == 0) {
p.v[i * m + j][x * m + y] = 1;
}
}
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d%d%d", &tp[i], &x[i], &y[i], &t[i]);
--x[i];
--y[i];
if (tp[i] == 3) {
++t[i];
}
}
dp = matrix(1, n * m);
p = matrix(n * m, n * m);
get_p();
dp.v[0][0] = 1;
int nt = 1;
for (int i = 0; i < q; ++i) {
if (t[i] != nt) {
dp = dp * power(p, t[i] - nt - 1);
}
while (i + 1 < q && t[i] == t[i + 1]) {
if (tp[i] == 2) {
a[x[i]][y[i]] = 1;
}
if (tp[i] == 3) {
a[x[i]][y[i]] = 0;
}
++i;
}
if (tp[i] == 2) {
a[x[i]][y[i]] = 1;
}
if (tp[i] == 3) {
a[x[i]][y[i]] = 0;
}
get_p();
if (t[i] != nt) {
dp = dp * p;
}
nt = t[i];
if (tp[i] == 1) {
printf("%d\n", dp.v[0][x[i] * m + y[i]]);
}
}
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(int a[MAXN][MAXN], int b[MAXN][MAXN]) {
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(a[i][k], b[k][j]));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) a[i][j] = pomoc[i][j];
}
void potenciraj(int x) {
while (x) {
if (x & 1) mnozi(glavna, prijelaz);
mnozi(prijelaz, prijelaz);
x /= 2;
}
}
void obradi(int t) {
slozi();
potenciraj(t - trenutno);
trenutno = t;
mnozi(stanje, glavna);
}
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;
bool cats[21][21];
struct matrix {
int column, row;
long long grid[21][21];
};
const int MOD = 1000000007;
void matrix_prod(const matrix& matrix1, const matrix& matrix2,
matrix& new_matrix) {
if (matrix1.column != matrix2.row) {
new_matrix.column = 0;
new_matrix.row = 0;
return;
}
new_matrix.column = matrix2.column;
new_matrix.row = matrix1.row;
for (int i = 0; i < matrix1.row; i++) {
for (int j = 0; j < matrix2.column; j++) {
long long cur = 0;
for (int k = 0; k < matrix1.column; k++) {
cur += matrix1.grid[i][k] * matrix2.grid[k][j];
cur %= MOD;
}
new_matrix.grid[i][j] = cur % MOD;
}
}
return;
}
matrix matrix_exp(const matrix& base_matrix, long long exp) {
matrix new_matrix;
if (exp == 0) {
new_matrix.column = base_matrix.column;
new_matrix.row = base_matrix.row;
for (int i = 0; i < new_matrix.row; i++) {
for (int j = 0; j < new_matrix.column; j++) {
if (j == i) {
new_matrix.grid[i][j] = 1;
} else {
new_matrix.grid[i][j] = 0;
}
}
}
return new_matrix;
}
if (exp == 1) {
return base_matrix;
}
matrix matrix_squared;
matrix_squared.column = base_matrix.column;
matrix_squared.row = base_matrix.row;
matrix_prod(base_matrix, base_matrix, matrix_squared);
if (exp % 2 == 0) {
return matrix_exp(matrix_squared, exp / 2);
} else {
matrix_prod(base_matrix, matrix_exp(matrix_squared, exp / 2), new_matrix);
return new_matrix;
}
}
int main() {
ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
matrix A;
A.row = n * m;
A.column = n * m;
memset(&(A.grid), 0, sizeof(A.grid));
for (int i = 0; i < n * m; i++) {
A.grid[i][i] = 1;
if (i % m != m - 1) {
A.grid[i][i + 1] = 1;
A.grid[i + 1][i] = 1;
}
if (i + m < n * m) {
A.grid[i][i + m] = 1;
A.grid[i + m][i] = 1;
}
}
int input[10001][4];
for (int i = 0; i < q; i++) {
cin >> input[i][0] >> input[i][2] >> input[i][1] >> input[i][3];
--input[i][1];
--input[i][2];
}
matrix dp1, dp2;
dp1.column = 1;
dp1.row = n * m;
dp2.column = 1;
dp2.row = n * m;
memset(&(dp1.grid), 0, sizeof(dp1.grid));
dp1.grid[0][0] = 1;
matrix_prod(matrix_exp(A, input[0][3] - 1), dp1, dp2);
for (int i = 0; i < q - 1; i++) {
if (input[i][0] == 1) {
if (i % 2 == 0) {
cout << dp2.grid[input[i][1] + input[i][2] * m][0] << "\n";
} else {
cout << dp1.grid[input[i][1] + input[i][2] * m][0] << "\n";
}
} else if (input[i][0] == 2) {
cats[input[i][1]][input[i][2]] = true;
for (int j = 0; j < n * m; j++)
A.grid[input[i][1] + input[i][2] * m][j] = 0;
for (int j = 0; j < n * m; j++)
A.grid[j][input[i][1] + input[i][2] * m] = 0;
} else {
cats[input[i][1]][input[i][2]] = false;
int x = input[i][1] + input[i][2] * m;
A.grid[x][x] = 1;
if (input[i][1] != m - 1 && !cats[input[i][1] + 1][input[i][2]]) {
A.grid[x][x + 1] = 1;
A.grid[x + 1][x] = 1;
}
if (input[i][1] != 0 && !cats[input[i][1] - 1][input[i][2]]) {
A.grid[x][x - 1] = 1;
A.grid[x - 1][x] = 1;
}
if (input[i][2] != n - 1 && !cats[input[i][1]][input[i][2] + 1]) {
A.grid[x][x + m] = 1;
A.grid[x + m][x] = 1;
}
if (input[i][2] != 0 && !cats[input[i][1]][input[i][2] - 1]) {
A.grid[x][x - m] = 1;
A.grid[x - m][x] = 1;
}
}
if (i % 2 == 0) {
matrix_prod(matrix_exp(A, input[i + 1][3] - input[i][3]), dp2, dp1);
} else {
matrix_prod(matrix_exp(A, input[i + 1][3] - input[i][3]), dp1, dp2);
}
}
if (input[q - 1][0] == 1) {
if ((q - 1) % 2 == 0) {
cout << dp2.grid[input[q - 1][1] + input[q - 1][2] * m][0];
} else {
cout << dp1.grid[input[q - 1][1] + input[q - 1][2] * m][0];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 20;
int adjl[20][20];
long long res[20][20];
long long ansm[20][20];
long long prod[20][20];
int n, m, k;
int mod = 1e9 + 7;
struct event {
int ty, x, y, time, ind;
};
bool compare(event a, event b) {
return a.time == b.time ? a.ty < b.ty : a.time < b.time;
}
void mul(long long a[][mxn], long long b[][mxn]) {
memset(res, 0, sizeof res);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
for (int k = 0; k < n * m; k++) {
res[i][j] = (res[i][j] + a[i][k] * b[k][j]) % mod;
}
}
}
}
void mult(long long a[][mxn], int t) {
memset(prod, 0, sizeof prod);
for (int i = 0; i < n * m; i++) {
prod[i][i] = 1;
}
while (t > 0) {
if ((t & 1) == 0) {
mul(a, a);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
a[i][j] = res[i][j];
}
}
t >>= 1;
} else {
mul(prod, a);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
prod[i][j] = res[i][j];
}
}
t--;
}
}
}
event evnts[10001];
int main() {
cin >> n >> m >> k;
int red = 0;
for (int i = 0; i < k; i++) {
int ty, x, y, time;
cin >> ty >> x >> y >> time;
if (ty == 1) red++;
evnts[i] = {ty, x - 1, y - 1, time, red - 1};
}
int c[n][m];
int r = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c[i][j] = r++;
}
}
int dx[5] = {-1, 1, 0, 0, 0};
int dy[5] = {0, 0, -1, 1, 0};
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int d = 0; d < 5; d++) {
if (i + dx[d] >= 0 && i + dx[d] < n && j + dy[d] >= 0 &&
j + dy[d] < m) {
adjl[c[i][j]][c[i + dx[d]][j + dy[d]]]++;
}
}
}
}
long long ans[red];
for (int i = 0; i < n * m; i++) {
ansm[i][i] = 1;
}
int lasttime = 1;
bool free[20];
for (int i = 0; i < 20; i++) {
free[i] = 1;
}
for (int i = 0; i < k; i++) {
event ev = evnts[i];
if (ev.ty == 1) {
long long cpy[mxn][mxn];
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
cpy[i][j] = adjl[i][j];
}
}
mult(cpy, ev.time - lasttime);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
cpy[i][j] = res[i][j];
}
}
mul(ansm, cpy);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
ansm[i][j] = res[i][j];
}
}
ans[ev.ind] = ansm[0][c[ev.x][ev.y]];
lasttime = ev.time;
} else if (ev.ty == 3) {
long long cpy[mxn][mxn];
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
cpy[i][j] = adjl[i][j];
}
}
mult(cpy, ev.time - lasttime);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
cpy[i][j] = res[i][j];
}
}
mul(ansm, cpy);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
ansm[i][j] = res[i][j];
}
}
free[c[ev.x][ev.y]] = true;
for (int d = 0; d < 5; d++) {
if (ev.x + dx[d] >= 0 && ev.x + dx[d] < n && ev.y + dy[d] >= 0 &&
ev.y + dy[d] < m) {
if (free[c[ev.x + dx[d]][ev.y + dy[d]]]) {
adjl[c[ev.x][ev.y]][c[ev.x + dx[d]][ev.y + dy[d]]] = 1;
adjl[c[ev.x + dx[d]][ev.y + dy[d]]][c[ev.x][ev.y]] = 1;
}
}
}
lasttime = ev.time;
} else {
long long cpy[mxn][mxn];
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
cpy[i][j] = adjl[i][j];
}
}
mult(cpy, ev.time - lasttime);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
cpy[i][j] = res[i][j];
}
}
mul(ansm, cpy);
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
ansm[i][j] = res[i][j];
}
}
free[c[ev.x][ev.y]] = false;
for (int d = 0; d < 5; d++) {
if (ev.x + dx[d] >= 0 && ev.x + dx[d] < n && ev.y + dy[d] >= 0 &&
ev.y + dy[d] < m) {
adjl[c[ev.x][ev.y]][c[ev.x + dx[d]][ev.y + dy[d]]] = 0;
adjl[c[ev.x + dx[d]][ev.y + dy[d]]][c[ev.x][ev.y]] = 0;
}
}
lasttime = ev.time;
}
}
for (int i = 0; i < red; i++) {
cout << ans[i] << endl;
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma comment(linker, "/STACK:2000000")
using namespace std;
template <int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
static_assert(D >= 1, "Vector dimension must be greater than zero!");
template <typename... Args>
Vec(int n = 0, Args... args)
: vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {}
};
template <typename T>
struct Vec<1, T> : public vector<T> {
Vec(int n = 0, T val = T()) : vector<T>(n, val) {}
};
using ll = long long;
using db = long double;
using ii = pair<int, int>;
const int N = 2e5 + 5, LG = 19, MOD = 1e9 + 7;
const int SQ = 320;
const long double EPS = 1e-7;
int n, m, q;
struct MAT {
int a[22][22];
MAT(int r = 0) {
memset(a, 0, sizeof a);
for (int i = 0; i < 22; i++) a[i][i] = r;
}
MAT operator*(MAT b) {
MAT res = MAT();
for (int k = 0; k < 22; k++)
for (int i = 0; i < 22; i++)
for (int j = 0; j < 22; j++)
res.a[i][j] = (res.a[i][j] + 1ll * a[i][k] * b.a[k][j]) % MOD;
return res;
}
};
MAT fast(MAT b, int e) {
MAT res = MAT(1);
for (; e; e >>= 1, b = b * b)
if (e & 1) {
res = res * b;
}
return res;
}
int getHash(int x, int y) { return x * m + y; }
bool cat[22][22];
bool in(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
MAT build() {
MAT res = MAT();
static const int dx[] = {-1, 1, 0, 0};
static const int dy[] = {0, 0, -1, 1};
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
res.a[getHash(i, j)][getHash(i, j)] = 1;
for (int k = 0; k < 4; k++) {
int ni = i + dx[k];
int nj = j + dy[k];
if (in(ni, nj) && !cat[ni][nj]) {
res.a[getHash(i, j)][getHash(ni, nj)] = 1;
}
}
}
return res;
}
int poss[22];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
int curT = 1;
MAT cur = build();
poss[getHash(0, 0)] = 1;
for (int i = 0; i < q; i++) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
--x, --y;
MAT HE5A = fast(cur, t - curT - 1);
curT = t;
int tmp[22] = {};
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (!cat[j / m][j % m]) {
tmp[j] = (tmp[j] + 1ll * poss[i] * HE5A.a[i][j]) % MOD;
}
for (int i = 0; i < n * m; i++) poss[i] = tmp[i];
if (tp == 2) {
memset(tmp, 0, sizeof tmp);
cat[x][y] ^= 1;
cur = build();
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (!cat[j / m][j % m]) {
tmp[j] = (tmp[j] + 1ll * poss[i] * cur.a[i][j]) % MOD;
}
for (int i = 0; i < n * m; i++) poss[i] = tmp[i];
} else if (tp == 3) {
memset(tmp, 0, sizeof tmp);
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (!cat[j / m][j % m]) {
tmp[j] = (tmp[j] + 1ll * poss[i] * cur.a[i][j]) % MOD;
}
cat[x][y] ^= 1;
cur = build();
for (int i = 0; i < n * m; i++) poss[i] = tmp[i];
} else {
memset(tmp, 0, sizeof tmp);
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (!cat[j / m][j % m]) {
tmp[j] = (tmp[j] + 1ll * poss[i] * cur.a[i][j]) % MOD;
}
for (int i = 0; i < n * m; i++) poss[i] = tmp[i];
cout << poss[getHash(x, y)] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20 + 5, P = 1e9 + 7;
struct matrix {
int dp[N][N];
matrix(int x = 1) {
memset(dp, 0, sizeof dp);
for (int i = 0; i < N; i++) dp[i][i] = x;
}
inline void set(int i, int j, int x = 1) { dp[i][j] = dp[j][i] = x; }
inline matrix operator*(const matrix &a) const {
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.dp[i][j] += 1LL * dp[i][k] * a.dp[k][j] % P) %= P;
return ans;
}
matrix operator^(const int &k) const {
return k ? ((*this * *this) ^ (k / 2)) * (k & 1 ? *this : matrix())
: matrix();
}
} ed, dp;
int n, m, q, mark[N];
inline int id(int i, int j) { return i * m + j; }
inline void flip(int x, int y) {
ed.set(id(x, y), id(x, y), mark[id(x, y)]), mark[id(x, y)] ^= 1;
for (auto i : {-1, 1}) {
if (x + i >= 0 && x + i < n)
ed.set(id(x, y), id(x + i, y), !mark[id(x, y)] && !mark[id(x + i, y)]);
if (y + i >= 0 && y + i < m)
ed.set(id(x, y), id(x, y + i), !mark[id(x, y)] && !mark[id(x, y + i)]);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
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)
flip(x, y);
else
cout << dp.dp[0][id(x, y)] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct ab {
long long a[22][22];
} ans;
long long xx[4] = {0, 0, 1, -1};
long long yy[4] = {1, -1, 0, 0};
long long n, m, mp[5005][5005];
ab mul(ab x, ab y) {
ab z;
for (long long i = 1; i <= n * m; i++) {
for (long long j = 1; j <= n * m; j++) {
z.a[i][j] = 0;
for (long long k = 1; k <= n * m; k++) {
z.a[i][j] = (z.a[i][j] + x.a[i][k] * y.a[k][j] % mod) % mod;
}
}
}
return z;
}
ab pow(ab x, long long y) {
ab z;
for (long long i = 1; i <= n * m; i++) {
for (long long j = 1; j <= n * m; j++) {
z.a[i][j] = 0;
if (i == j) z.a[i][j] = 1;
}
}
while (y) {
if (y & 1) z = mul(z, x);
x = mul(x, x);
y >>= 1;
}
return z;
}
signed main() {
long long q, t1 = 1;
scanf("%lld%lld%lld", &n, &m, &q);
for (long long i = 1; i <= n * m; i++) {
for (long long j = 1; j <= n * m; j++) {
ans.a[i][j] = 0;
if (i == j) ans.a[i][j] = 1;
}
}
while (q--) {
long long k, x, y, t;
scanf("%lld%lld%lld%lld", &k, &x, &y, &t);
ab tt;
for (long long i = 1; i <= n * m; i++) {
for (long long j = 1; j <= n * m; j++) {
tt.a[i][j] = 0;
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
for (long long k = 0; k <= 3; k++) {
long long x1 = i + xx[k], y1 = j + yy[k];
if (x1 <= 0 || x1 > n || y1 <= 0 || y1 > m) continue;
if (mp[x1][y1] == 0 && mp[i][j] == 0)
tt.a[(x1 - 1) * m + y1][(i - 1) * m + j] = 1;
}
if (mp[i][j] == 0) tt.a[(i - 1) * m + j][(i - 1) * m + j] = 1;
}
}
for (long long i = 1; i <= t; i++) {
}
ans = mul(ans, pow(tt, t - t1));
if (k == 1) printf("%lld\n", ans.a[1][(x - 1) * m + y]);
if (k == 2) mp[x][y] = 1;
if (k == 3) mp[x][y] = 0;
t1 = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1.01e9;
const long double EPS = 1e-9;
const int MOD = (int)1e9 + 7;
void add(int &x, int y) {
if ((x += y) >= MOD) {
x -= MOD;
}
}
int mult(int x, int y) { return (long long)x * y % MOD; }
const int maxn = 20 + 5;
struct Matrix {
int a[maxn][maxn];
int n;
Matrix() {}
Matrix(int _n, int q = 1) : n(_n) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] = (i == j) ? q : 0;
}
}
}
inline Matrix operator*(const Matrix &m) const {
Matrix res(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
long long cur = 0;
for (int k = 0; k < n; ++k) {
cur += (long long)a[i][k] * m.a[k][j];
if (cur >= (long long)8e18) {
cur %= MOD;
}
}
res.a[i][j] = cur % MOD;
}
}
return res;
}
inline Matrix operator^(long long pw) const {
Matrix x = *this;
Matrix res(n);
for (; pw; pw >>= 1) {
if (pw & 1) {
res = res * x;
}
x = x * x;
}
return res;
}
};
void precalc() {}
int w, h, q;
bool read() {
if (scanf("%d%d%d", &w, &h, &q) < 3) {
return 0;
}
return 1;
}
const int maxg = 4;
const int go[maxg][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int gs[maxn][maxg + 1];
int getId(int x, int y) { return x * h + y; }
void solve() {
for (int i = 0; i < w; ++i) {
for (int j = 0; j < h; ++j) {
int v = getId(i, j);
for (int g = 0; g <= maxg; ++g) {
int ni = i, nj = j;
if (g < maxg) {
ni += go[g][0], nj += go[g][1];
}
if (0 <= ni && ni < w && 0 <= nj && nj < h) {
int u = getId(ni, nj);
gs[v][g] = u;
} else {
gs[v][g] = -1;
}
}
}
}
int n = w * h;
Matrix cur(n, 0);
for (int i = 0; i < n; ++i) {
for (int g = 0; g <= maxg; ++g) {
int j = gs[i][g];
if (j == -1) {
continue;
}
cur.a[i][j] = 1;
}
}
Matrix res(n);
int t = 1;
for (int iter = 0; iter < q; ++iter) {
int type, x, y, nt;
scanf("%d%d%d%d", &type, &x, &y, &nt);
--x, --y;
int pos = getId(x, y);
if (type == 2) {
--nt;
}
res = ((cur ^ (nt - t)) * res);
t = nt;
if (type == 1) {
printf("%d\n", res.a[pos][0]);
} else {
for (int g = 0; g <= maxg; ++g) {
int j = gs[pos][g];
if (j == -1) {
continue;
}
cur.a[pos][j] ^= 1;
}
}
}
}
int main() {
srand(rdtsc());
precalc();
while (1) {
if (!read()) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
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<unsigned long long, 20> A;
inline int first(int a, int b) { return a * m + b; }
void mul(array<array<unsigned long long, 20>, 20> &c,
array<array<unsigned long long, 20>, 20> a,
array<array<unsigned 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<unsigned 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<unsigned 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<unsigned 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 double pi = acos(-1);
const double eps = 1e-10;
const int MAXN = 21;
const int MAXM = 21;
struct Matrix {
int n, m;
long long a[MAXN][MAXM];
void clear() {
n = m = 0;
memset(a, 0, sizeof(a));
}
Matrix operator*(const Matrix &b) const {
Matrix tmp;
tmp.clear();
tmp.n = n;
tmp.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++)
tmp.a[i][j] += a[i][k] * b.a[k][j], tmp.a[i][j] %= 1000000007;
return tmp;
}
};
int read() {
char ch = getchar();
int data = 0;
while (ch < '0' || ch > '9') ch = getchar();
do {
data = data * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return data;
}
Matrix quickpow(Matrix M, int p) {
Matrix tmp;
tmp.clear();
tmp.n = M.n;
tmp.m = M.m;
for (int i = 1; i <= tmp.n; i++) tmp.a[i][i] = 1;
while (p > 1) {
if (p % 2) tmp = tmp * M;
M = M * M;
p /= 2;
}
tmp = tmp * M;
return tmp;
}
int cat[21][21], dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
Matrix ans, T;
int main() {
int n, m, q, i, j, k, x, y, p, t, last = 1, px, py;
n = read();
m = read();
q = read();
ans.n = 1;
ans.m = n * m;
ans.a[1][1] = 1;
T.n = n * m;
T.m = n * m;
while (q--) {
T.clear();
T.n = n * m;
T.m = n * m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (cat[i][j] == 0) {
for (k = 0; k <= 3; k++) {
px = i + dx[k];
py = j + dy[k];
if (px > 0 && px <= n && py > 0 && py <= m && cat[px][py] == 0) {
T.a[i * m - m + j][px * m - m + py] = 1;
T.a[px * m - m + py][i * m - m + j] = 1;
}
}
T.a[i * m - m + j][i * m - m + j] = 1;
}
p = read();
x = read();
y = read();
t = read();
Matrix T1 = quickpow(T, t - last);
last = t;
ans = ans * T1;
if (p == 1) printf("%I64d\n", ans.a[1][x * m - m + y]);
if (p == 2) cat[x][y]++;
if (p == 3) cat[x][y]--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LEN = 25;
const long long MOD = (long long)1e9 + 7;
long long N;
struct Matrix {
long long M[LEN][LEN];
Matrix() { memset(M, 0, sizeof M); }
void prll() {
for (long long i = 0; i < LEN; i++) {
for (long long j = 0; j < LEN; j++) cout << M[i][j] << " ";
cout << '\n';
}
}
};
Matrix ONE() {
Matrix mat;
for (long long i = 0; i < LEN; i++) mat.M[i][i] = 1;
return mat;
}
Matrix MUL(Matrix a, Matrix b) {
Matrix sol;
for (long long k = 0; k < LEN; k++)
for (long long i = 0; i < LEN; i++)
for (long long j = 0; j < LEN; j++)
sol.M[i][j] = (sol.M[i][j] + 1LL * a.M[i][k] * b.M[k][j]) % MOD;
return sol;
}
Matrix POW(Matrix a, long long n) {
if (!n) return ONE();
if (n & 1) return MUL(a, POW(a, n - 1));
Matrix b = POW(a, n >> 1);
return MUL(b, b);
}
vector<long long> Solve(Matrix &a, vector<long long> &v) {
vector<long long> solution(LEN, 0);
for (long long i = 0; i < LEN; i++) {
long long sum = 0;
for (long long j = 0; j < LEN; j++)
sum = (sum + 1LL * a.M[i][j] * v[j]) % MOD;
solution[i] = sum;
}
return solution;
}
long long M, q;
long long ini[LEN];
long long id[LEN][LEN];
bool cat[LEN][LEN];
long long x[5] = {0, 0, 1, -1, 0};
long long y[5] = {1, -1, 0, 0, 0};
bool inIN(long long a, long long b) {
return a >= 0 && a < N && b >= 0 && b < M;
}
Matrix build_mat() {
Matrix res;
for (long long i = 0; i < N; i++)
for (long long j = 0; j < M; j++) {
if (cat[i][j]) continue;
for (long long k = 0; k < 5; k++) {
long long xx = x[k] + i;
long long yy = y[k] + j;
if (inIN(xx, yy)) {
res.M[id[i][j]][id[xx][yy]] = 1;
}
}
}
return res;
}
const long long MAXQ = 20000;
long long OPS[MAXQ], XX[MAXQ], YY[MAXQ], TI[MAXQ];
void test(Matrix MAT) {
Matrix X = MAT;
vector<long long> ini(LEN, 0);
ini[0] = 1;
vector<long long> sol = Solve(X, ini);
for (long long i = 0; i < LEN; i++) cout << sol[i] << " ";
cout << '\n';
}
int main() {
scanf("%d %d %d", &N, &M, &q);
long long it = 0;
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < M; j++) {
id[i][j] = it++;
}
}
for (long long i = 0; i < q; i++) {
scanf("%d %d %d %d", OPS + i, XX + i, YY + i, TI + i);
}
Matrix MAT = ONE();
long long currtime = 1;
for (long long i = 0; i < q; i++) {
long long op = OPS[i], xx = XX[i], yy = YY[i], ti = TI[i];
xx--;
yy--;
if (op == 1) {
vector<long long> ini(LEN, 0);
ini[0] = 1;
Matrix aux = build_mat();
aux = POW(aux, ti - currtime);
MAT = MUL(aux, MAT);
vector<long long> res = Solve(MAT, ini);
printf("%lld\n", res[id[xx][yy]]);
} else if (op == 2) {
Matrix aux = build_mat();
aux = POW(aux, ti - currtime - 1);
MAT = MUL(aux, MAT);
cat[xx][yy] = true;
aux = build_mat();
MAT = MUL(aux, MAT);
} else {
Matrix aux = build_mat();
aux = POW(aux, ti - currtime);
MAT = MUL(aux, MAT);
cat[xx][yy] = false;
}
currtime = ti;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
const int dx[5] = {1, -1, 0, 0, 0};
const int dy[5] = {0, 0, 1, -1, 0};
const int mod = 1e9 + 7;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int mul(int x, int y) { return 1ll * x * y % mod; }
struct MAT {
int n, m, a[N][N];
MAT() {}
MAT(int _n, int _m, bool b) {
n = _n;
m = _m;
memset(a, 0, sizeof(a));
if (b)
for (int i = 1; i <= n; ++i) a[i][i] = 1;
}
MAT operator*(MAT u) {
if (m != u.n) return MAT(0, 0, 0);
MAT ret(n, u.m, 0);
for (int k = 1; k <= m; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= u.m; ++j)
add(ret.a[i][j], mul(a[i][k], u.a[k][j]));
return ret;
}
MAT operator^(int p) {
if (n != m) return MAT(0, 0, 0);
MAT ret(n, m, 1), x = *this;
while (p) {
if (p & 1) ret = ret * x;
x = x * x;
p >>= 1;
}
return ret;
}
void print() {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%d ", a[i][j]);
puts("");
}
}
};
int n, m, nm, q;
MAT now, tr;
void Upd(int i, int j, int val) {
int id = (i - 1) * m + j;
for (int k = 0; k < 5; ++k) {
int ni = i + dx[k];
int nj = j + dy[k];
if (ni < 1 || ni > n || nj < 1 || nj > m) continue;
int nid = (ni - 1) * m + nj;
tr.a[nid][id] = val;
}
}
void Init() {
nm = n * m;
now = MAT(1, nm, 0);
now.a[1][1] = 1;
tr = MAT(nm, nm, 0);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) Upd(i, j, 1);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
Init();
for (int pret = 1; q--;) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
now = now * (tr ^ (t - pret));
pret = t;
if (tp == 1) {
printf("%d\n", now.a[1][(x - 1) * m + y]);
} else if (tp == 2) {
Upd(x, y, 0);
now.a[1][(x - 1) * m + y] = 0;
} else if (tp == 3) {
Upd(x, y, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 20, M = 1e4 + 10, msiz = N * N;
const int dx[5] = {1, -1, 0, 0, 0}, dy[5] = {0, 0, 1, -1, 0};
int base[msiz][msiz], n, m, k, f[msiz], a[M][4], cur[msiz][msiz],
tmp[msiz][msiz], cb[msiz][msiz], siz, h[N][N];
bool check(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && !h[x][y]);
}
void modified(int x, int y, int type) {
if (!type) f[x * m + y] = 0;
h[x][y] = type ^ 1;
for (auto i = 0; i <= 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (check(nx, ny))
base[x * m + y][nx * m + ny] = base[nx * m + ny][x * m + y] = type;
}
}
void init() {
for (auto x = 0; x < n; x++)
for (auto y = 0; y < m; y++) modified(x, y, 1);
siz = n * m;
f[0] = 1;
}
void upmatrix(int x) {
memset(cur, 0, sizeof(cur));
for (auto i = 0; i < siz; i++) cur[i][i] = 1;
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++) cb[i][j] = base[i][j];
while (x) {
if (x & 1) {
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++) tmp[i][j] = cur[i][j], cur[i][j] = 0;
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++)
for (auto k = 0; k < siz; k++)
cur[i][j] = (cur[i][j] + 1LL * tmp[i][k] * cb[k][j]) % MOD;
}
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++) tmp[i][j] = cb[i][j], cb[i][j] = 0;
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++)
for (auto k = 0; k < siz; k++)
cb[i][j] = (cb[i][j] + 1LL * tmp[i][k] * tmp[k][j]) % MOD;
x >>= 1;
}
for (auto i = 0; i < siz; i++) tmp[0][i] = f[i];
memset(f, 0, sizeof(f));
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++)
f[i] = (f[i] + 1LL * tmp[0][j] * cur[j][i]) % MOD;
}
void solve() {
init();
for (auto i = 1; i <= k; i++) {
upmatrix(a[i][3] - a[i - 1][3]);
if (a[i][0] == 0) printf("%d\n", f[a[i][1] * m + a[i][2]]);
if (a[i][0] == 1) modified(a[i][1], a[i][2], 0);
if (a[i][0] == 2) modified(a[i][1], a[i][2], 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (auto i = 1; i <= k; i++)
for (auto j = 0; j <= 3; j++) scanf("%d", a[i] + j), a[i][j]--;
solve();
}
|
#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;
get_base();
A = A * base;
} else {
A = A * (base ^ (t - curt));
cat[x][y] = 0;
get_base();
}
curx = x;
cury = y;
curt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:9759095000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,abm,mmx,tune=native")
using namespace std;
long long gcd(long long i, long long j) {
if (j == 0)
return i;
else
return gcd(j, i % j);
}
template <typename T>
inline T getint() {
T val = 0;
char c;
bool neg = false;
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
neg |= c == '-';
}
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val * (neg ? -1 : 1);
}
const long long INF = 1e18;
const int mod = 1000000007;
const long double eps = 1e-9, pi = acos(-1);
const int maxN = 300100, maxT = 2001;
void file_inc() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
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()));
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) {
ans[i][j] = (ans[i][j] + a[i][k] * b[k][j]) % mod;
}
}
}
return ans;
}
vector<vector<long long>> bin_pow(long long b, vector<vector<long long>> et) {
if (b == 0) {
vector<vector<long long>> ans(et.size(), vector<long long>(et.size()));
for (int i = 0; i < et.size(); ++i) ans[i][i] = 1;
return ans;
}
vector<vector<long long>> ans = bin_pow(b / 2, et);
ans = ans * ans;
if (b % 2 == 1) ans = ans * et;
return ans;
}
int n, m;
bool val(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
int get_code(int x, int y) { return x * m + y; }
pair<int, int> get_coord(int code) { return make_pair(code / m, code % m); }
int32_t main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cout.precision(15);
int q;
cin >> n >> m >> q;
vector<vector<long long>> st(m * n, vector<long long>(1));
st[get_code(0, 0)][0] = 1;
vector<vector<long long>> et(m * n, vector<long long>(m * n, 0));
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
et[get_code(x, y)][get_code(x, y)] = 1;
if (val(x - 1, y)) et[get_code(x, y)][get_code(x - 1, y)] = 1;
if (val(x + 1, y)) et[get_code(x, y)][get_code(x + 1, y)] = 1;
if (val(x, y - 1)) et[get_code(x, y)][get_code(x, y - 1)] = 1;
if (val(x, y + 1)) et[get_code(x, y)][get_code(x, y + 1)] = 1;
}
}
vector<vector<long long>> et1 = et;
vector<int> used(n * m);
int tt = 1;
while (q--) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
--x;
--y;
if (tp == 1) {
vector<vector<long long>> tmp = bin_pow(t - tt, et1);
tt = t;
st = tmp * st;
cout << st[get_code(x, y)][0] << "\n";
}
if (tp == 2) {
vector<vector<long long>> tmp = bin_pow(t - tt, et1);
tt = t;
st = tmp * st;
int ver = get_code(x, y);
used[ver] = 1;
for (int i = 0; i < n * m; ++i) {
if (used[ver] == 0 && used[i] == 0) {
et1[i][ver] = et[i][ver];
et1[ver][i] = et[ver][i];
} else {
et1[i][ver] = 0;
et1[ver][i] = 0;
}
}
}
if (tp == 3) {
vector<vector<long long>> tmp = bin_pow(t - tt, et1);
tt = t;
st = tmp * st;
int ver = get_code(x, y);
used[ver] = 0;
for (int i = 0; i < n * m; ++i) {
if (used[ver] == 0 && used[i] == 0) {
et1[i][ver] = et[i][ver];
et1[ver][i] = et[ver][i];
} else {
et1[i][ver] = 0;
et1[ver][i] = 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const int mod = 1e9 + 7;
int dx[] = {1, 0, -1, 0, 0};
int dy[] = {0, -1, 0, 1, 0};
int n, m, q;
struct matrix {
int n, m, a[21][21];
matrix() {
n = m = 0;
memset(a, 0, sizeof a);
}
};
int sum(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
int mult(int a, int b) { return (1ll * a * b) % mod; }
matrix operator*(matrix a, matrix b) {
matrix ans;
ans.n = a.n, ans.m = b.m;
for (int i = 1; i <= ans.n; i++)
for (int j = 1; j <= ans.m; j++)
for (int k = 1; k <= a.m; k++)
ans.a[i][j] = sum(ans.a[i][j], mult(a.a[i][k], b.a[k][j]));
return ans;
}
matrix bp(matrix a, int n) {
matrix ans;
ans.n = ans.m = a.n;
for (int i = 1; i <= ans.n; i++) ans.a[i][i] = 1;
while (n) {
if (n & 1) ans = ans * a;
a = a * a;
n >>= 1;
}
return ans;
}
bool valid(int x, int y) {
if (x >= 1 && x <= n && y >= 1 && y <= m) return 1;
return 0;
}
int id(int x, int y) { return (x - 1) * m + y; }
int main() {
scanf("%d%d%d", &n, &m, &q);
matrix a, dp;
dp.n = 1, dp.m = n * m;
dp.a[1][1] = 1;
a.n = a.m = n * m;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
for (int i = 0; i < 5; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (valid(nx, ny))
a.a[id(x, y)][id(nx, ny)] = a.a[id(nx, ny)][id(x, y)] = 1;
}
for (int i = 1, type, x, y, t, prev = 1; i <= q; i++) {
scanf("%d%d%d%d", &type, &x, &y, &t);
dp = dp * bp(a, t - prev);
prev = t;
if (type == 1) printf("%d\n", dp.a[1][id(x, y)]);
if (type == 2)
for (int j = 0; j < 5; j++) {
int nx = x + dx[j];
int ny = y + dy[j];
if (valid(nx, ny))
a.a[id(nx, ny)][id(x, y)] = a.a[id(x, y)][id(nx, ny)] = 0;
}
if (type == 3)
for (int j = 0; j < 5; j++) {
int nx = x + dx[j];
int ny = y + dy[j];
if (valid(nx, ny) &&
(a.a[id(nx, ny)][id(nx, ny)] != 0 || id(nx, ny) == id(x, y)))
a.a[id(nx, ny)][id(x, y)] = a.a[id(x, y)][id(nx, ny)] = 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, b[22][22], pre;
struct Matrix {
int a[22][22];
} a, ans, tmp;
Matrix buildm() {
Matrix ret;
for (int p = 1; p <= n * m; p++)
for (int q = 1; q <= n * m; q++) {
int px = (p - 1) / m + 1, py = p - m * (px - 1);
int qx = (q - 1) / m + 1, qy = q - m * (qx - 1);
if (b[px][py] || b[qx][qy]) {
ret.a[p][q] = 0;
continue;
}
if (abs(px - qx) + abs(py - qy) <= 1)
ret.a[p][q] = 1;
else
ret.a[p][q] = 0;
}
return ret;
}
Matrix cheng(Matrix a, Matrix b) {
Matrix ret;
memset(ret.a, 0, sizeof(ret.a));
for (int i = 1; i <= n * m; i++)
for (int k = 1; k <= n * m; k++)
if (a.a[i][k])
for (int j = 1; j <= n * m; j++)
(ret.a[i][j] += ((long long)a.a[i][k] * b.a[k][j]) % 1000000007) %=
1000000007;
return ret;
}
Matrix mypow(Matrix a, int k) {
Matrix ret;
memset(ret.a, 0, sizeof(ret.a));
for (int i = 1; i <= n * m; i++) ret.a[i][i] = 1;
while (k) {
if (k & 1) ret = cheng(ret, a);
a = cheng(a, a);
k >>= 1;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
ans.a[1][1] = 1;
pre = 1;
for (int i = 1; i <= q; i++) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
if (tp == 2) {
int tt = t - pre - 1;
Matrix la = buildm();
la = mypow(la, tt);
ans = cheng(ans, la);
memset(tmp.a, 0, sizeof(tmp.a));
for (int q = 1; q <= n * m; q++) {
int qx = (q - 1) / m + 1, qy = q - m * (qx - 1);
if (b[qx][qy] || (qx == x && qy == y)) continue;
tmp.a[1][q] = ans.a[1][q];
if (qx - 1 > 0 && b[qx - 1][qy] == 0)
(tmp.a[1][q] += ans.a[1][(qx - 2) * m + qy]) %= 1000000007;
if (qy - 1 > 0 && b[qx][qy - 1] == 0)
(tmp.a[1][q] += ans.a[1][(qx - 1) * m + qy - 1]) %= 1000000007;
if (qx + 1 <= n && b[qx + 1][qy] == 0)
(tmp.a[1][q] += ans.a[1][qx * m + qy]) %= 1000000007;
if (qy + 1 <= m && b[qx][qy + 1] == 0)
(tmp.a[1][q] += ans.a[1][(qx - 1) * m + qy + 1]) %= 1000000007;
}
ans = tmp;
b[x][y] = 1;
pre = t;
}
if (tp == 3) {
int tt = t - pre - 1;
Matrix la = buildm();
la = mypow(la, tt);
ans = cheng(ans, la);
memset(tmp.a, 0, sizeof(tmp.a));
b[x][y] = 0;
for (int q = 1; q <= n * m; q++) {
int qx = (q - 1) / m + 1, qy = q - m * (qx - 1);
if (b[qx][qy] || (qx == x && qy == y)) continue;
tmp.a[1][q] = ans.a[1][q];
if (qx - 1 > 0 && b[qx - 1][qy] == 0)
(tmp.a[1][q] += ans.a[1][(qx - 2) * m + qy]) %= 1000000007;
if (qy - 1 > 0 && b[qx][qy - 1] == 0)
(tmp.a[1][q] += ans.a[1][(qx - 1) * m + qy - 1]) %= 1000000007;
if (qx + 1 <= n && b[qx + 1][qy] == 0)
(tmp.a[1][q] += ans.a[1][qx * m + qy]) %= 1000000007;
if (qy + 1 <= m && b[qx][qy + 1] == 0)
(tmp.a[1][q] += ans.a[1][(qx - 1) * m + qy + 1]) %= 1000000007;
}
ans = tmp;
pre = t;
}
if (tp == 1) {
int tt = t - pre;
Matrix la = buildm();
la = mypow(la, tt);
ans = cheng(ans, la);
printf("%d\n", ans.a[1][(x - 1) * m + y]);
pre = t;
}
}
return 0;
}
|
#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;
}
all = mul(all, pow_(now, t - pret));
pret = t;
if (cmd == 2)
vis[x * c + y] = 1;
else if (cmd == 3)
vis[x * c + y] = 0;
else if (cmd == 1)
printf("%d\n", all.m[0][x * c + y]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
template <typename T>
struct matrix : vector<vector<T>> {
int n, m;
void print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << (*this)[i][j] << " ";
cout << '\n';
}
}
matrix(int n_, int m_, bool ident = false)
: vector<vector<T>>(n_, vector<T>(m_, 0)), n(n_), m(m_) {
if (ident) {
assert(n == m);
for (int i = 0; i < n; i++) (*this)[i][i] = 1;
}
}
matrix(const vector<vector<T>>& c)
: vector<vector<T>>(c), n(c.size()), m(c[0].size()) {}
matrix(const initializer_list<initializer_list<T>>& c) {
vector<vector<T>> val;
for (auto& i : c) val.push_back(i);
*this = matrix(val);
}
matrix<T> operator*(matrix<T>& r) {
assert(m == r.n);
matrix<T> M(n, r.m);
for (int i = 0; i < n; i++)
for (int k = 0; k < m; k++)
for (int j = 0; j < r.m; j++) {
T add = (*this)[i][k] * r[k][j];
M[i][j] += add;
}
return M;
}
matrix<T> operator^(long long e) {
matrix<T> M(n, n, true), at = *this;
while (e) {
if (e & 1) M = M * at;
e >>= 1;
at = at * at;
}
return M;
}
};
int n, m;
int pos(int a, int b) { return b + a * m; }
pair<int, int> cord(int x) { return {x / m, x % n}; }
vector<pair<int, int>> dx = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> n >> m >> q;
vector<tuple<int, int, int, int, int>> ev(q);
int cnt = 0;
for (auto& [t, tp, x, y, id] : ev) {
cin >> tp >> x >> y >> t;
x--, y--;
if (tp == 1) id = cnt++;
}
matrix<long long> A(n * m, n * m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
for (auto [x, y] : dx) {
x += i, y += j;
if (x >= 0 and x < n and y >= 0 and y < m) A[pos(i, j)][pos(x, y)] = 1;
}
}
int t_at = 1;
vector<int> cats(n * m);
matrix<long long> at(n * m, n * m, 1);
vector<int> ans(cnt);
for (auto [t, tp, x, y, id] : ev) {
if (t > t_at) {
if (tp == 1 or tp == 2 or tp == 3) {
matrix<long long> A2 = A ^ (t - t_at);
at = at * A2;
t_at = t;
} else {
matrix<long long> A2 = A ^ (t - 1 - t_at);
at = at * A2;
t_at = t - 1;
}
}
if (tp == 1) {
ans[id] = at[pos(0, 0)][pos(x, y)];
} else if (tp == 2) {
cats[pos(x, y)] = 1;
for (auto [xx, yy] : dx) {
xx += x, yy += y;
if (xx >= 0 and xx < n and yy >= 0 and yy < m)
A[pos(x, y)][pos(xx, yy)] = 0, A[pos(xx, yy)][pos(x, y)] = 0;
}
} else {
cats[pos(x, y)] = 0;
for (auto [xx, yy] : dx) {
xx += x, yy += y;
if (xx >= 0 and xx < n and yy >= 0 and yy < m and !cats[pos(xx, yy)])
A[pos(x, y)][pos(xx, yy)] = 1, A[pos(xx, yy)][pos(x, y)] = 1;
}
}
}
for (auto u : ans) cout << u << '\n';
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool RD(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1, ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
const int N = 22;
const int MOD = 1e9 + 7;
struct mat {
int a[N][N];
mat() { memset(a, 0, sizeof(a)); }
int r, c;
mat operator*(const mat &m) const {
mat ans;
ans.r = r;
ans.c = m.c;
for (int i = 1; i <= int(r); i++)
for (int j = 1; j <= int(ans.c); j++)
for (int k = 1; k <= int(c); k++) {
ans.a[i][j] += ((unsigned long long)a[i][k] * m.a[k][j]) % MOD;
if (ans.a[i][j] >= MOD) ans.a[i][j] -= MOD;
}
return ans;
}
} all[1111];
int top;
mat mul(mat &m1, mat &m2) {
mat ans = all[top++];
memset(ans.a, 0, sizeof(ans.a));
ans.r = m1.r;
ans.c = m2.c;
for (int i = 1; i <= int(ans.r); i++)
for (int j = 1; j <= int(ans.c); j++)
for (int k = 1; k <= int(m1.c); k++) {
ans.a[i][j] += ((unsigned long long)m1.a[i][k] * m2.a[k][j]) % MOD;
if (ans.a[i][j] >= MOD) ans.a[i][j] -= MOD;
}
top--;
return ans;
}
void quickpow(mat &ans, mat m, int k) {
if (k == 1) {
ans = m;
return;
}
if (k % 2 == 0) {
quickpow(ans, m, k / 2);
ans = ans * ans;
return;
}
quickpow(ans, m, k / 2);
ans = ans * ans;
ans = ans * m;
}
int r, c, Q;
bool mp[N][N];
mat A, M;
inline int f(int x, int y) { return (x - 1) * c + y; }
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
bool ok(int x, int y) {
return x >= 1 && x <= r && y >= 1 && y <= c && !mp[x][y];
}
void build() {
memset(M.a, 0, sizeof(M.a));
M.r = r * c;
M.c = r * c;
for (int x = 1; x <= int(r); x++)
for (int y = 1; y <= int(c); y++) {
for (int k = 0; k < int(4); k++) {
int nx = x + dx[k];
int ny = y + dy[k];
if (ok(nx, ny) && !mp[x][y]) M.a[f(x, y)][f(nx, ny)] = 1;
}
if (!mp[x][y]) M.a[f(x, y)][f(x, y)] = 1;
}
}
int main() {
scanf("%d%d%d", &r, &c, &Q);
int last = 1;
A.r = r * c;
A.c = 1;
A.a[1][1] = 1;
for (int i = 1; i <= int(Q); i++) {
int op;
RD(op);
int x, y, t;
RD(x), RD(y), RD(t);
build();
mat tmp;
quickpow(tmp, M, t - last);
A = tmp * A;
last = t;
if (op == 1)
printf("%d\n", A.a[f(x, y)][1]);
else if (op == 2)
A.a[f(x, y)][1] = 0, mp[x][y] = 1;
else
mp[x][y] = 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int mod = (int)1e9 + 7;
int N;
struct matrix {
int a[22][22];
matrix(int x) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
a[i][j] = 0;
if (i == j) a[i][j] = x;
}
}
}
matrix operator+(const matrix& o) {
matrix C = matrix(0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
C.a[i][j] = a[i][j] + o.a[i][j];
if (C.a[i][j] >= mod) C.a[i][j] -= mod;
}
}
return C;
}
matrix operator*(const matrix& o) {
matrix C = matrix(0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
C.a[i][j] = 0;
for (int k = 0; k < N; k++) {
C.a[i][j] += a[i][k] * 1ll * o.a[k][j] % mod;
if (C.a[i][j] >= mod) C.a[i][j] -= mod;
}
}
}
return C;
}
void makeFull() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) a[i][j] = 1;
}
void show() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
for (int i = 0; i < 2 * N; i++) printf("-");
printf("\n");
}
};
int n, m, q;
int dx[] = {1, 0, -1, 0, 0};
int dy[] = {0, 1, 0, -1, 0};
matrix binpow(matrix A, int n) {
matrix res = matrix(1);
while (n) {
if (n & 1) res = res * A;
A = A * A;
n >>= 1;
}
return res;
}
bool check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
int main() {
scanf("%d%d%d", &n, &m, &q);
matrix A = matrix(0);
N = n * m;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
int x1 = i / m, stupid_y1 = i % m;
int x2 = j / m, y2 = j % m;
bool ok = false;
for (int k = 0; k < 5; k++) {
int tox = x1 + dx[k];
int toy = stupid_y1 + dy[k];
if (tox == x2 && toy == y2) ok = true;
}
A.a[i][j] = ok;
}
}
int prev = 1;
matrix T = matrix(0);
matrix C = matrix(0);
matrix C2 = matrix(0);
C2.a[0][0] = 1;
for (int iter = 0; iter < q; iter++) {
int type, x, y, t;
scanf("%d%d%d%d", &type, &x, &y, &t);
int diff = t - prev;
x--;
y--;
T = binpow(A, diff);
C = C2 * T;
C2 = C;
if (type == 1) {
printf("%d\n", C.a[0][x * m + y]);
} else if (type == 2) {
int I = x * m + y;
for (int k = 0; k < 5; k++) {
int tox = x + dx[k];
int toy = y + dy[k];
if (!check(tox, toy)) continue;
int J = tox * m + toy;
A.a[I][J] = A.a[J][I] = 0;
}
} else if (type == 3) {
int I = x * m + y;
A.a[I][I] = 1;
for (int k = 0; k < 5; k++) {
int tox = x + dx[k];
int toy = y + dy[k];
if (!check(tox, toy)) continue;
int J = tox * m + toy;
if (!A.a[J][J]) continue;
A.a[I][J] = A.a[J][I] = 1;
}
}
prev = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int inc[5][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}, {0, 0}};
const int MAXN = 20, MOD = 1e9 + 7;
int add(int x, int y) { return (x + y) % MOD; }
void addeq(int &x, int y) { x = add(x, y); }
int mult(int x, int y) { return ll(x) * y % MOD; }
int N, M, S, Q;
bool inside(int x, int y) { return 0 <= x && x < N && 0 <= y && y < M; }
struct matrix {
int data[MAXN][MAXN];
int *operator[](int x) { return data[x]; }
const int *operator[](int x) const { return data[x]; }
} zero, one;
matrix operator*(const matrix &m1, const matrix &m2) {
matrix res = zero;
for (int k = 0; k < S; k++) {
for (int i = 0; i < S; i++) {
for (int j = 0; j < S; j++) {
addeq(res[i][j], mult(m1[i][k], m2[k][j]));
}
}
}
return res;
}
void operator*=(matrix &m1, const matrix &m2) { m1 = m1 * m2; }
matrix pow(matrix m1, int p) {
matrix res = one;
for (; p; p >>= 1) {
if (p & 1) {
res *= m1;
}
m1 *= m1;
}
return res;
}
matrix mat, trans;
void settrans(int i, int j, int val) {
int ij = M * i + j;
for (int k = 0; k < 5; k++) {
int ni = i + inc[k][0], nj = j + inc[k][1];
if (inside(ni, nj)) {
trans[ij][M * ni + nj] = val;
}
}
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d %d %d", &N, &M, &Q);
S = N * M;
for (int i = 0; i < S; i++) {
one[i][i] = 1;
}
mat = one;
trans = zero;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
settrans(i, j, 1);
}
}
int pt = 1;
while (Q--) {
int type, x, y, t;
scanf("%d %d %d %d", &type, &x, &y, &t);
x--;
y--;
mat = pow(trans, t - pt - 1) * mat;
pt = t;
if (type == 1) {
mat = trans * mat;
printf("%d\n", mat[M * x + y][0]);
} else if (type == 2) {
settrans(x, y, 0);
mat = trans * mat;
} else {
mat = trans * mat;
settrans(x, y, 1);
}
}
}
|
#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<unsigned long long, 20> A;
inline int first(int a, int b) { return a * m + b; }
void mul(array<array<unsigned long long, 20>, 20> &c,
array<array<unsigned long long, 20>, 20> a,
array<array<unsigned 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<unsigned 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<unsigned 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<unsigned 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 = 20 + 5;
const int MOD = 1e9 + 7;
long long C[N][N];
void multiply(long long A[N][N], long long B[N][N], int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
A[i][j] = C[i][j];
C[i][j] = 0;
}
}
}
int dx[] = {0, 0, 0, 1, -1};
int dy[] = {0, 1, -1, 0, 0};
long long A[N][N], B[N][N], D[N][N];
void power(int n, int sz) {
if (n == 0) return;
power(n >> 1, sz);
multiply(A, A, sz);
if (n & 1) multiply(A, B, sz);
}
int cat[N];
long long ways[N], temp[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
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], y = j + dy[k];
if (x >= 0 and y >= 0 and x < n and y < m) {
D[i * m + j][x * m + y] = 1;
}
}
}
}
ways[0] = 1;
int last = 1;
for (int query = 1; query <= q; query++) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
x--, y--;
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
if (cat[j])
B[i][j] = 0;
else
B[i][j] = D[i][j];
A[i][j] = 0;
}
A[i][i] = 1;
}
power(t - last, n * m);
last = t;
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
temp[j] = (temp[j] + ways[i] * A[i][j]) % MOD;
}
}
for (int i = 0; i < n * m; i++) {
ways[i] = temp[i];
temp[i] = 0;
}
if (tp == 1) {
cout << ways[x * m + y] << "\n";
} else if (tp == 2) {
cat[x * m + y] = 1;
ways[x * m + y] = 0;
} else {
cat[x * m + y] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, m, q;
struct Matrix {
int sz;
vector<vector<int> > a;
Matrix() {
sz = 0;
a.clear();
}
Matrix(int _sz, vector<vector<int> > _a) {
a = _a;
sz = _sz;
}
Matrix(int _sz) {
sz = _sz;
vector<int> temp(sz, 0);
a.assign(sz, temp);
}
void print() {
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
Matrix const operator*(Matrix o) {
Matrix res = Matrix(sz);
for (int i = 0; i < sz; i++) {
for (int j = 0; j < sz; j++) {
int cur = 0;
for (int k = 0; k < sz; k++) {
int p = 1ll * a[i][k] * o.a[k][j] % mod;
cur += p;
if (cur >= mod) cur -= mod;
}
res.a[i][j] = cur;
}
}
return res;
}
} d, zero, A;
int dx[5] = {0, -1, 1, 0, 0};
int dy[5] = {0, 0, 0, -1, 1};
int a[30][30];
int _x[100100], _y[100100], _type[100100], _t[100100];
Matrix make_matrix() {
Matrix res = Matrix(n * m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j]) continue;
for (int d = 0; d < 5; d++) {
int x = i + dx[d];
int y = j + dy[d];
if (x >= 0 && x < n && y >= 0 && y < m) {
if (a[x][y]) continue;
res.a[i * m + j][x * m + y]++;
}
}
}
}
return res;
}
Matrix binpow(Matrix a, int k) {
if (k == 0) return zero;
Matrix ans = binpow(a, k / 2);
ans = ans * ans;
if (k % 2) ans = ans * a;
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < q; i++) {
scanf("%d%d%d%d", _type + i, _x + i, _y + i, _t + i);
_x[i]--;
_y[i]--;
}
zero = Matrix(n * m);
for (int i = 0; i < n * m; i++) {
zero.a[i][i] = 1;
}
A = Matrix(n * m);
A.a[0][0] = 1;
d = make_matrix();
int prev_time = 1;
for (int i = 0; i < q; i++) {
int x = _x[i], y = _y[i];
int type = _type[i], t = _t[i];
int delta = t - prev_time - 1;
d = make_matrix();
d = binpow(d, delta);
A = A * d;
if (type == 2) a[x][y]++;
d = make_matrix();
if (type == 2) {
for (int dd = 0; dd < 5; dd++) {
int xx = x + dx[dd];
int yy = y + dy[dd];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
if (!a[xx][yy]) {
int from = x * m + y;
int to = xx * m + yy;
d.a[from][to]++;
}
}
}
} else if (type == 3) {
for (int dd = 0; dd < 5; dd++) {
int xx = x + dx[dd];
int yy = y + dy[dd];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
if (!a[xx][yy]) {
int from = x * m + y;
int to = xx * m + yy;
d.a[to][from] = 0;
}
}
}
}
if (type == 3) a[x][y]--;
A = A * d;
if (type == 1) printf("%d\n", A.a[0][x * m + y]);
prev_time = t;
}
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) {
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 - 1);
now = MUL(tp, now);
a[x][y] = 0;
pv = t - 1;
} 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;
int n, m, q;
int a[22][22], cur[22], tmp[22][22], tmp2[22][22], cat[22];
int dx[5] = {0, 0, 0, 1, -1};
int dy[] = {0, 1, -1, 0, 0};
map<pair<int, int>, int> ma;
int mod = 1000000007;
void mul(int p) {
for (int i = 1; i < n * m + 1; ++i)
for (int j = 1; j < n * m + 1; ++j) {
tmp[i][j] = a[i][j];
}
while (p > 0) {
if (p & 1) {
for (int i = 1; i < n * m + 1; ++i) {
int s = 0;
for (int k = 1; k < n * m + 1; ++k) {
s += (tmp[i][k] * 1ll * cur[k]) % mod;
if (s >= mod) s -= mod;
}
tmp2[i][1] = s;
}
for (int i = 1; i < n * m + 1; ++i) {
cur[i] = tmp2[i][1];
}
}
p /= 2;
for (int i = 1; i < 1 + n * m; ++i)
for (int j = 1; j < 1 + n * m; ++j) {
int s = 0;
for (int k = 1; k < n * m + 1; ++k) {
s += (tmp[i][k] * 1ll * tmp[k][j]) % mod;
if (s >= mod) s -= mod;
}
tmp2[i][j] = s;
}
for (int i = 1; i < n * m + 1; ++i)
for (int j = 1; j < 1 + n * m; ++j) {
tmp[i][j] = tmp2[i][j];
}
}
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
int x = 0;
for (int i = 1; i < 1 + n; ++i)
for (int j = 1; j < 1 + m; ++j) {
ma[make_pair(i, j)] = ++x;
}
for (int i = 1; i < 1 + n; ++i)
for (int j = 1; j < 1 + m; ++j) {
for (int k = 0; k < 5; ++k)
if (i + dx[k] > 0 && i + dx[k] <= n && j + dy[k] >= 1 &&
j + dy[k] <= m) {
a[ma[make_pair(i, j)]][ma[make_pair(i + dx[k], j + dy[k])]] = 1;
}
}
int curt = 1;
cur[1] = 1;
for (int i = 0; i < q; ++i) {
int tp, x, y, t;
scanf("%d", &tp);
scanf("%d", &x);
scanf("%d", &y);
scanf("%d", &t);
int len = t - curt;
curt = t;
mul(len);
if (tp == 1) {
printf("%d\n", cur[ma[make_pair(x, y)]]);
} else if (tp == 2) {
for (int k = 0; k < 5; ++k)
if (x + dx[k] > 0 && x + dx[k] <= n && y + dy[k] >= 1 &&
y + dy[k] <= m) {
int p1 = ma[make_pair(x, y)];
int p2 = ma[make_pair(x + dx[k], y + dy[k])];
a[p1][p2] = a[p2][p1] = 0;
}
cat[ma[make_pair(x, y)]] = 1;
cur[ma[make_pair(x, y)]] = 0;
} else {
cat[ma[make_pair(x, y)]] = 0;
for (int k = 0; k < 5; ++k)
if (x + dx[k] > 0 && x + dx[k] <= n && y + dy[k] >= 1 &&
y + dy[k] <= m) {
int p1 = ma[make_pair(x, y)];
int p2 = ma[make_pair(x + dx[k], y + dy[k])];
if (!cat[p2]) a[p1][p2] = a[p2][p1] = 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int BASE = 1e9 + 7;
const int N = 25;
int n, m, q;
bool ban[N];
int dx[] = {0, -1, +0, +1, +0};
int dy[] = {0, +0, +1, +0, -1};
long long dp[N], f[N];
struct Matrix {
static const int N = 23;
int n;
long long a[N][N];
void Init(int _n, int v) {
n = _n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) a[i][j] = v;
}
Matrix operator*(const Matrix &that) const {
Matrix ans;
ans.Init(n, 0);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k)
if (!ban[i] && !ban[j] && !ban[k])
ans.a[i][j] = (ans.a[i][j] + a[i][k] * that.a[k][j]) % BASE;
return ans;
}
void Write() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) printf("%d ", a[i][j]);
printf("\n");
}
}
};
Matrix a;
int ID(int x, int y) { return x * m + y; }
bool Inside(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
void Update(int x, int y, int add) {
for (int k = 0; k <= 4; ++k) {
int i = x + dx[k], j = y + dy[k];
if (Inside(i, j)) {
int u = ID(x, y), v = ID(i, j);
if (add == 1 && (ban[u] || ban[v])) continue;
a.a[u][v] = add;
a.a[v][u] = add;
}
}
}
Matrix Pow(Matrix a, long long p) {
Matrix ans;
ans = a;
--p;
while (p) {
if (p & 1) ans = ans * a;
a = a * a;
p >>= 1;
}
return ans;
}
void Restore(Matrix ans) {
memset(f, 0, sizeof f);
for (int i = 0; i < n * m; ++i)
for (int j = 0; j < n * m; ++j) f[i] = (f[i] + dp[j] * ans.a[j][i]) % BASE;
for (int i = 0; i < n * m; ++i) dp[i] = f[i];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
a.Init(n * m, 0);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) Update(i, j, 1);
int pret = 1;
dp[0] = 1;
while (q--) {
int op, x, y, t;
scanf("%d%d%d%d", &op, &x, &y, &t);
--x;
--y;
Matrix ans = Pow(a, t - pret);
Restore(ans);
if (op == 1)
printf("%I64d\n", dp[ID(x, y)]);
else {
ban[ID(x, y)] ^= 1;
Update(x, y, op == 2 ? 0 : 1);
}
pret = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
int n, m, q;
int check(int x, int y) { return (0 < x) && (x <= n) && (0 < y) && (y <= m); }
int id(int x, int y) { return (x - 1) * m + y - 1; }
int add_mod(long long a, long long b) { return (a + b) % MOD; }
int mul_mod(long long a, long long b) { return a * b % MOD; }
struct Matrix {
int r, c;
vector<vector<int> > a;
Matrix(int r, int c, int d = 0) : r(r), c(c) {
a.assign(r, vector<int>(c, 0));
for (int i = 0; (i < r) && (i < c); i++) a[i][i] = d;
}
vector<int>& operator[](int i) { return a[i]; }
const vector<int>& operator[](int i) const { return a[i]; }
Matrix operator*(const Matrix& B) const {
Matrix ans(r, B.c);
for (int i = 0; i < r; i++)
for (int j = 0; j < B.c; j++)
for (int k = 0; k < c; k++)
ans[i][j] = add_mod(ans[i][j], mul_mod(a[i][k], B[k][j]));
return ans;
}
Matrix pow(int p) const {
Matrix ans(r, c, 1), a(*this);
for (; p > 0; p >>= 1) {
if (p & 1) ans = ans * a;
a = a * a;
}
return ans;
}
void set(int x, int y) {
a[id(x, y)][id(x, y)] = 1;
for (int k = 0; k < 4; k++)
if (check(x + dx[k], y + dy[k]))
a[id(x, y)][id(x + dx[k], y + dy[k])] = 1;
}
void clear(int x, int y) {
for (int i = 0; i < c; i++) a[id(x, y)][i] = 0;
}
};
int main() {
scanf("%d%d%d", &n, &m, &q);
Matrix f(n * m, n * m);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++) f.set(x, y);
int cur = 1;
Matrix a(n * m, 1);
a[0][0] = 1;
while (q--) {
int k, x, y, t;
scanf("%d%d%d%d", &k, &x, &y, &t);
t -= cur;
cur += t;
if (k == 1) {
a = f.pow(t) * a;
printf("%d\n", a[id(x, y)][0]);
} else if (k == 2) {
a = f.pow(t) * a;
f.clear(x, y);
a[id(x, y)][0] = 0;
} else {
a = f.pow(t) * a;
f.set(x, y);
}
}
}
|
#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]);
if (ans.ar[i][j] >= 1000000007) ans.ar[i][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 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;
}
curx = x;
cury = y;
curt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long int asdfa = 1000000007;
array<array<long long int, 20>, 20> id;
array<array<long long int, 20>, 20> operator*(
array<array<long long int, 20>, 20> a,
array<array<long long int, 20>, 20> b) {
array<array<long long int, 20>, 20> ret;
for (int i = 0; i < 20; ++i) {
for (int j = 0; j < 20; ++j) {
ret[i][j] = 0;
for (int k = 0; k < 20; ++k) {
ret[i][j] += a[i][k] * b[k][j];
ret[i][j] %= asdfa;
}
}
}
return ret;
}
array<array<long long int, 20>, 20> mpow(array<array<long long int, 20>, 20> x,
int e) {
if (e == 0) return id;
array<array<long long int, 20>, 20> s = mpow(x, e / 2);
s = s * s;
if (e & 1) s = s * x;
return s;
}
int n, m, q;
bool cat[20];
array<array<long long int, 20>, 20> mat;
int di[5] = {-1, 0, 1, 0, 0};
int dj[5] = {0, -1, 0, 1, 0};
void recomp() {
for (int i = 0; i < 20; ++i) {
for (int j = 0; j < 20; ++j) {
mat[i][j] = 0;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (cat[m * i + j]) continue;
for (int d = 0; d < 5; ++d) {
int i2 = i + di[d];
int j2 = j + dj[d];
if (i2 == -1 || i2 == n || j2 == -1 || j2 == m) continue;
mat[m * i2 + j2][m * i + j] = 1;
}
}
}
}
int main() {
cin.sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> q;
array<array<long long int, 20>, 20> xd;
for (int i = 0; i < 20; ++i) {
for (int j = 0; j < 20; ++j) {
id[i][j] = (i == j ? 1 : 0);
xd[i][j] = ((i == j && j == 0) ? 1 : 0);
}
}
int oldt = 1;
recomp();
for (int i = 0; i < q; ++i) {
int tp, x, y, t;
cin >> tp >> x >> y >> t;
--x;
--y;
xd = mpow(mat, t - oldt) * xd;
for (int i = 0; i < n * m; ++i) {
if (cat[i]) {
for (int j = 0; j < n * m; ++j) {
xd[i][j] = 0;
}
}
}
if (tp == 1) {
cout << xd[m * x + y][0] << '\n';
} else if (tp == 2) {
cat[m * x + y] = true;
recomp();
} else {
cat[m * x + y] = false;
recomp();
}
oldt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
const int L = 20 + 3;
const long long MOD = 1e9 + 7;
const long long MM = 8e18;
int f[L][L];
int n, m, q;
struct Matrix {
int l;
long long f[L][L];
Matrix() { memset(f, 0, sizeof(f)), l = 0; }
} f1, f2;
struct Query {
int tp, x, y, t;
} g[N];
long long ans[N];
int l[5] = {0, 1, -1, 0, 0};
int r[5] = {0, 0, 0, 1, -1};
Matrix Mul(Matrix x, Matrix y) {
Matrix z;
z.l = x.l;
for (int i = 1; i <= z.l; i++)
for (int j = 1; j <= z.l; j++) {
z.f[i][j] = 0;
for (int k = 1; k <= z.l; k++) {
z.f[i][j] += x.f[i][k] * y.f[k][j];
if (z.f[i][j] >= MM) z.f[i][j] %= MOD;
}
if (z.f[i][j] >= MOD) z.f[i][j] %= MOD;
}
return z;
}
Matrix initial(int l) {
Matrix x;
x.l = l;
for (int i = 1; i <= l; i++)
for (int j = 1; j <= l; j++) x.f[i][j] = (i == j ? 1 : 0);
return x;
}
Matrix ksm(Matrix a, int b) {
Matrix x = initial(n * m);
while (b > 0) {
if (b & 1) x = Mul(x, a);
b >>= 1;
a = Mul(a, a);
}
return x;
}
bool outside(int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m) return true;
return false;
}
void add(int x, int y) {
int nx, ny;
f2.f[f[x][y]][f[x][y]] = 1;
for (int i = 1; i <= 4; i++) {
nx = x + l[i], ny = y + r[i];
if (outside(nx, ny)) continue;
f2.f[f[nx][ny]][f[x][y]] = 1;
}
}
void del(int x, int y) {
int nx, ny;
f2.f[f[x][y]][f[x][y]] = 0;
for (int i = 1; i <= 4; i++) {
nx = x + l[i], ny = y + r[i];
if (outside(nx, ny)) continue;
f2.f[f[nx][ny]][f[x][y]] = 0;
}
}
void init() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) f[i][j] = (i - 1) * m + j;
for (int i = 1; i <= q; i++)
scanf("%d%d%d%d", &g[i].tp, &g[i].x, &g[i].y, &g[i].t);
f1.l = f2.l = n * m;
f1.f[1][1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) add(i, j);
}
void work() {
int now;
g[0].t = 1;
for (int i = 1; i <= q; i++) {
f1 = Mul(f1, ksm(f2, g[i].t - g[i - 1].t));
now = f[g[i].x][g[i].y];
switch (g[i].tp) {
case 1:
ans[i] = f1.f[1][now];
ans[i] %= MOD;
break;
case 2:
del(g[i].x, g[i].y);
f1.f[1][now] = 0;
break;
case 3:
add(g[i].x, g[i].y);
break;
default:
break;
}
}
for (int i = 1; i <= q; i++)
if (g[i].tp == 1) printf("%I64d\n", ans[i]);
}
int main() {
init();
work();
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;
template <class T>
inline bool RD(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1, ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
const int N = 22;
const int MOD = 1e9 + 7;
struct mat {
int a[N][N];
mat() { memset(a, 0, sizeof(a)); }
int r, c;
mat operator*(const mat &m) const {
mat ans;
ans.r = r;
ans.c = m.c;
for (int i = 1; i <= int(r); i++)
for (int j = 1; j <= int(ans.c); j++)
for (int k = 1; k <= int(c); k++) {
ans.a[i][j] += ((unsigned long long)a[i][k] * m.a[k][j]) % MOD;
if (ans.a[i][j] >= MOD) ans.a[i][j] -= MOD;
}
return ans;
}
};
void quickpow(mat &ans, mat m, int k) {
if (k == 1) {
ans = m;
return;
}
if (k % 2 == 0) {
quickpow(ans, m, k / 2);
ans = ans * ans;
return;
}
quickpow(ans, m, k / 2);
ans = ans * ans;
ans = ans * m;
}
int r, c, Q;
bool mp[N][N];
mat A, M;
inline int f(int x, int y) { return (x - 1) * c + y; }
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
bool ok(int x, int y) {
return x >= 1 && x <= r && y >= 1 && y <= c && !mp[x][y];
}
void build() {
memset(M.a, 0, sizeof(M.a));
M.r = r * c;
M.c = r * c;
for (int x = 1; x <= int(r); x++)
for (int y = 1; y <= int(c); y++) {
for (int k = 0; k < int(4); k++) {
int nx = x + dx[k];
int ny = y + dy[k];
if (ok(nx, ny) && !mp[x][y]) M.a[f(x, y)][f(nx, ny)] = 1;
}
if (!mp[x][y]) M.a[f(x, y)][f(x, y)] = 1;
}
}
int main() {
scanf("%d%d%d", &r, &c, &Q);
int last = 1;
A.r = r * c;
A.c = 1;
A.a[1][1] = 1;
for (int i = 1; i <= int(Q); i++) {
int op;
RD(op);
int x, y, t;
RD(x), RD(y), RD(t);
build();
mat tmp;
quickpow(tmp, M, t - last);
A = tmp * A;
last = t;
if (op == 1)
printf("%d\n", A.a[f(x, y)][1]);
else if (op == 2)
A.a[f(x, y)][1] = 0, mp[x][y] = 1;
else
mp[x][y] = 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int M[44][44], Me[44][44], V[44], Ve[44], C[44][44], 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>
using namespace std;
const long long mod = 1e9 + 7;
struct Mat {
long long m[20][20];
void init() { memset(m, 0, sizeof(m)); }
};
struct Vector {
long long m[20];
void init() { memset(m, 0, sizeof(m)); }
};
int md;
Mat operator*(const Mat &a, const Mat &b) {
Mat ans;
ans.init();
for (int i = 0; i < md; i++)
for (int j = 0; j < md; j++)
for (int k = 0; k < md; k++)
ans.m[i][j] = (ans.m[i][j] + a.m[i][k] * b.m[k][j]) % mod;
return ans;
}
Vector operator*(const Mat &a, const Vector &b) {
Vector tmp;
tmp.init();
for (int i = 0; i < md; i++)
for (int j = 0; j < md; j++)
tmp.m[i] = (tmp.m[i] + a.m[i][j] * b.m[j]) % mod;
return tmp;
}
Mat operator^(Mat &a, int n) {
Mat ans;
ans.init();
for (int i = 0; i < md; i++) ans.m[i][i] = 1;
while (n) {
if (n & 1) ans = ans * a;
a = a * a;
n /= 2;
}
return ans;
}
int dir[5][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}, {0, 0}};
int mp[20][20], n, m;
void generate_matrix(Mat &a) {
a.init();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (mp[i][j]) continue;
for (int k = 0; k < 5; k++) {
int nx = i + dir[k][0], ny = j + dir[k][1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || mp[nx][ny]) continue;
a.m[i * m + j][nx * m + ny] = 1;
}
}
}
int main() {
int q;
scanf("%d%d%d", &n, &m, &q);
md = n * m;
memset(mp, 0, sizeof(mp));
int lasttime = 1;
Mat a;
Vector ans;
ans.init();
ans.m[0] = 1;
while (q--) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
--x, --y;
generate_matrix(a);
ans = (a ^ (t - lasttime)) * ans;
lasttime = t;
if (tp == 1)
printf("%I64d\n", ans.m[x * m + y]);
else if (tp == 2)
mp[x][y] = 1, ans.m[x * m + y] = 0;
else
mp[x][y] = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[5] = {0, 0, 1, -1, 0};
const int dy[5] = {1, -1, 0, 0, 0};
const int MOD = 1e9 + 7;
const int L = 20 + 1;
int n, m, q, D;
int aux[L][L], res[L][L], crt[L][L], C[L][L], mat[L][L];
int v[L], cv[L];
bool mode[L];
int code(int i, int j) { return (m * (i - 1) + j); }
void copiaza(int A[L][L], int B[L][L]) {
for (int i = 1; i <= D; ++i)
for (int j = 1; j <= D; ++j) A[i][j] = B[i][j];
}
void init(int A[L][L]) {
for (int i = 1; i <= D; ++i)
for (int j = 1; j <= D; ++j) A[i][j] = (i == j);
}
void inm(int A[L][L], int B[L][L], int C[L][L]) {
for (int i = 1; i <= D; ++i)
for (int j = 1; j <= D; ++j) {
A[i][j] = 0;
for (int it = 1; it <= D; ++it)
A[i][j] = (A[i][j] + 1LL * B[i][it] * C[it][j]) % MOD;
}
}
void putere(int P) {
init(res);
copiaza(crt, mat);
for (int i = 0; (1 << i) <= P; ++i) {
if (P & (1 << i)) {
inm(aux, res, crt);
copiaza(res, aux);
}
inm(aux, crt, crt);
copiaza(crt, aux);
}
copiaza(mat, res);
}
void build() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
for (int k = 0; k < 5; ++k) {
int newl = i + dx[k];
int newc = j + dy[k];
if (1 <= newl && newl <= n && 1 <= newc && newc <= m)
mat[code(i, j)][code(newl, newc)] =
(!mode[code(i, j)] && !mode[code(newl, newc)]);
}
}
void makeDp() {
memset(cv, 0, sizeof(cv));
for (int i = 1; i <= D; ++i)
for (int j = 1; j <= D; ++j) cv[i] = (cv[i] + 1LL * mat[i][j] * v[j]) % MOD;
for (int i = 1; i <= D; ++i) v[i] = cv[i];
}
int main() {
scanf("%d %d %d", &n, &m, &q);
D = n * m;
build();
v[1] = 1;
for (int tip, x, y, tmp, lastTmp = 1; q; --q) {
scanf("%d %d %d %d", &tip, &x, &y, &tmp);
copiaza(C, mat);
putere(tmp - lastTmp);
makeDp();
copiaza(mat, C);
if (tip == 1)
printf("%d\n", v[code(x, y)]);
else {
mode[code(x, y)] ^= 1;
build();
}
lastTmp = tmp;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ri() {
int x;
scanf("%d", &x);
return x;
}
const int V = 20, P = 1000000007;
int n, m, v, S[V], A[V][V], B[V][V], T[V][V];
void change(int x, int y) {
A[x][x] = y;
if (x % m) A[x][x - 1] = y;
if (x % m + 1 < m) A[x][x + 1] = y;
if (x >= m) A[x][x - m] = y;
if (x + m < v) A[x][x + m] = y;
}
void move(int p) {
for (int i = 0; i < (v); i++) copy_n(A[i], v, B[i]);
for (; p; p >>= 1) {
if (p & 1) {
for (int i = 0; i < (v); i++) {
T[0][i] = 0;
for (int j = 0; j < (v); j++)
T[0][i] = (T[0][i] + int64_t(B[i][j]) * S[j]) % P;
}
copy_n(T[0], v, S);
}
for (int i = 0; i < (v); i++) fill_n(T[i], v, 0);
for (int i = 0; i < (v); i++)
for (int k = 0; k < (v); k++)
for (int j = 0; j < (v); j++)
T[i][j] = (T[i][j] + int64_t(B[i][k]) * B[k][j]) % P;
for (int i = 0; i < (v); i++) copy_n(T[i], v, B[i]);
}
}
int main() {
n = ri();
m = ri();
v = n * m;
int q = ri(), tt = 1;
S[0] = 1;
for (int i = 0; i < (v); i++) change(i, 1);
while (q--) {
int op = ri(), x = ri() - 1, y = ri() - 1, t = ri();
move(t - tt);
tt = t;
if (op == 1)
printf("%d\n", S[x * m + y]);
else if (op == 2) {
change(x * m + y, 0);
S[x * m + y] = 0;
} else
change(x * m + y, 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
static inline void _mod(long long &x) {
if (x >= 1000000007) {
if (x < 2 * 1000000007)
x -= 1000000007;
else
x %= 1000000007;
}
}
static inline long long madd(long long x, long long y) {
x += y;
_mod(x);
return x;
}
static inline long long mmul(long long x, long long y) {
x *= y;
_mod(x);
return x;
}
struct M {
int n;
int a[20][20];
inline M() { memset(a, 0, sizeof(a)); }
inline M(int x) {
n = x;
memset(a, 0, sizeof(a));
for (int i = (0); i < (n); i++) a[i][i] = 1;
}
void inline operator*=(M p) {
int ret[20][20];
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] = madd(ret[i][j], mmul(a[i][k], p.a[k][j]));
}
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++) a[i][j] = ret[i][j];
}
void prt() {
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (n); j++) printf("%d ", a[i][j]);
puts("");
}
}
} ans, a;
static inline M pow(M a, int p) {
M ret = M(a.n);
for (; p; p >>= 1) {
if (p & 1) ret *= a;
a *= a;
}
return ret;
}
int n, m, cat[20][20], q;
int dx[5] = {0, 0, 0, 1, -1};
int dy[5] = {0, 1, -1, 0, 0};
static inline int in(int x, int y) {
return 0 <= x && x < n && 0 <= y && y < m;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
a.n = ans.n = n * m;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
for (int k = (0); k < (5); k++) {
int nx = i + dx[k], ny = j + dy[k];
if (in(nx, ny)) a.a[i * m + j][nx * m + ny] = 1;
}
}
ans.a[0][0] = 1;
int ct = 1;
for (int i = (0); i < (q); i++) {
int t, x, y, z, dt, cell;
scanf("%d%d%d%d", &t, &x, &y, &z);
x--;
y--;
cell = x * m + y;
dt = z - ct;
ct = z;
ans *= pow(a, dt);
if (t == 1) {
printf("%d\n", ans.a[0][cell]);
} else if (t == 2) {
cat[x][y] = 1;
for (int i = (0); i < (5); i++) {
int nx = x + dx[i], ny = y + dy[i];
int tmp = nx * m + ny;
if (in(nx, ny)) a.a[cell][tmp] = a.a[tmp][cell] = 0;
}
a.a[cell][cell] = 0;
} else if (t == 3) {
cat[x][y] = 0;
for (int i = (0); i < (5); i++) {
int nx = x + dx[i], ny = y + dy[i];
int tmp = nx * m + ny;
if (in(nx, ny) && !cat[nx][ny]) a.a[cell][tmp] = a.a[tmp][cell] = 1;
}
a.a[cell][cell] = 1;
}
}
return 0;
}
|
#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;
}
}
inline 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;
}
inline 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;
}
inline 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;
}
inline 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;
const int MOD = int(1e9) + 7;
int n, m, q;
int a[20], has[20][20], w[20][20], s[20][20], t[20][20], _a[20];
int p[5][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {0, 0}};
void go(int len) {
memset(t, 0, sizeof(t));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 5; k++) {
int x = i + p[k][0];
int y = j + p[k][1];
if (x < 0 || x >= n || y < 0 || y >= m) continue;
if (has[x][y]) continue;
t[i * m + j][x * m + y]++;
}
memset(s, 0, sizeof(s));
for (int i = 0; i < n * m; i++) s[i][i] = 1;
for (; len; len >>= 1) {
if (len & 1) {
memset(w, 0, sizeof(w));
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
for (int k = 0; k < n * m; k++)
w[i][j] = ((long long)s[i][k] * t[k][j] + w[i][j]) % MOD;
memcpy(s, w, sizeof(w));
}
if (len > 1) {
memset(w, 0, sizeof(w));
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
for (int k = 0; k < n * m; k++)
w[i][j] = ((long long)t[i][k] * t[k][j] + w[i][j]) % MOD;
memcpy(t, w, sizeof(w));
}
}
memset(_a, 0, sizeof(_a));
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
_a[i] = ((long long)a[j] * s[j][i] + _a[i]) % MOD;
memcpy(a, _a, sizeof(_a));
}
int main() {
cin >> n >> m >> q;
int cnt = 1;
a[0] = 1;
vector<int> res;
for (int i = 0; i < q; i++) {
int opt, x, y, t;
cin >> opt >> x >> y >> t;
x--;
y--;
if (opt == 1) {
go(t - cnt);
cnt = t;
res.push_back(a[x * m + y]);
} else if (opt == 2) {
go(t - cnt - 1);
cnt = t - 1;
has[x][y] = 1;
} else {
go(t - cnt);
cnt = t;
has[x][y] = 0;
}
}
for (auto x : res) cout << x << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
vector<vector<int> > mult(vector<vector<int> > A, vector<vector<int> > B) {
vector<vector<int> > ans(A.size(), vector<int>(B[0].size()));
for (int i = 0; i < A.size(); i++)
for (int j = 0; j < B[0].size(); j++) {
for (int k = 0; k < A[0].size(); k++)
ans[i][j] = (ans[i][j] + (long long)A[i][k] * B[k][j]) % MOD;
}
return ans;
}
vector<vector<int> > pow(vector<vector<int> > cur, int p) {
vector<vector<int> > ans(cur.size(), vector<int>(cur.size()));
for (int i = 0; i < cur.size(); i++) ans[i][i] = 1;
while (p) {
if (p % 2) ans = mult(ans, cur);
cur = mult(cur, cur);
p /= 2;
}
return ans;
}
int n, m, q;
bool bad[20][20];
vector<vector<int> > cur;
vector<vector<int> > adj;
void makeAdj() {
adj = vector<vector<int> >(n * m, vector<int>(n * m));
for (int i = 0; i < n * m; i++)
if (!bad[i / m][i % m]) {
adj[i][i] = 1;
if (i / m > 0 && !bad[i / m - 1][i % m]) adj[i][i - m] = 1;
if (i / m < n - 1 && !bad[i / m + 1][i % m]) adj[i][i + m] = 1;
if (i % m > 0 && !bad[i / m][i % m - 1]) adj[i][i - 1] = 1;
if (i % m < m - 1 && !bad[i / m][i % m + 1]) adj[i][i + 1] = 1;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
cur = vector<vector<int> >(1, vector<int>(n * m));
cur[0][0] = 1;
int prevT = 1;
for (int Q = 0; Q < q; Q++) {
int type, x, y, t;
scanf("%d%d%d%d", &type, &x, &y, &t);
x -= 1;
y -= 1;
makeAdj();
cur = mult(cur, pow(adj, t - prevT));
if (type == 1)
printf("%d\n", cur[0][x * m + y]);
else
bad[x][y] ^= 1;
prevT = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dx[5] = {0, 1, 0, -1, 0};
long long dy[5] = {0, 0, 1, 0, -1};
bool cant[30][30];
struct mat {
long long s_x, s_y;
long long a[30][30];
mat() { memset(a, 0, sizeof a); }
} A;
long long mo = 1000000007;
long long n, m, k, opt, x, y, t, l;
mat mul(mat x, mat y) {
mat tmp;
tmp.s_x = x.s_x;
tmp.s_y = y.s_y;
for (long long i = 1; i <= tmp.s_x; i++)
for (long long k = 1; k <= y.s_x; k++)
if (x.a[i][k])
for (long long j = 1; j <= tmp.s_y; j++)
tmp.a[i][j] += x.a[i][k] * y.a[k][j], tmp.a[i][j] %= mo;
return tmp;
}
mat ksm(mat x, long long y) {
mat sum = x;
y--;
for (; y; y /= 2) {
if (y & 1) sum = mul(sum, x);
x = mul(x, x);
}
return sum;
}
inline long long change(long long x, long long y) { return (x - 1) * m + y; }
int main() {
scanf("%d%d%d", &n, &m, &k);
A.s_x = A.s_y = n * m;
l = 1;
for (long long i = 1; i <= n * m; i++) A.a[i][i] = 1;
for (long long ii = 1; ii <= k; ii++) {
scanf("%d%d%d%d", &opt, &x, &y, &t);
mat cube;
cube.s_x = cube.s_y = n * m;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
for (long long d = 1; d <= 4; d++) {
long long tx = i + dx[d], ty = j + dy[d];
if (tx <= 0 || ty <= 0 || tx > n || ty > m) continue;
if (cant[i][j] || cant[tx][ty])
cube.a[change(i, j)][change(tx, ty)] = 0;
else
cube.a[change(i, j)][change(tx, ty)] = 1;
}
if (cant[i][j])
cube.a[change(i, j)][change(i, j)] = 0;
else
cube.a[change(i, j)][change(i, j)] = 1;
}
A = mul(A, ksm(cube, t - l));
if (opt == 2) cant[x][y] = 1;
if (opt == 3) cant[x][y] = 0;
if (opt == 1) printf("%d\n", A.a[1][change(x, y)]);
l = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int n, m, q, opt, x, y, t, last_t, d[30][30];
struct Mat {
int n, m;
long long a[30][30];
Mat(int n, int m) {
this->n = n;
this->m = m;
memset(a, 0, sizeof(a));
}
Mat(int n = 0) {
this->n = this->m = n;
memset(a, 0, sizeof(a));
for (int i = (0); i <= (n - 1); ++i) a[i][i] = 1;
}
void print() {
for (int i = (0); i <= (n - 1); ++i) {
for (int j = (0); j <= (m - 1); ++j) printf("%lld ", a[i][j]);
puts("");
}
}
};
Mat operator*(Mat A, Mat B) {
Mat C(A.n, B.m);
for (int i = (0); i <= (A.n - 1); ++i)
for (int j = (0); j <= (B.m - 1); ++j)
for (int k = (0); k <= (A.m - 1); ++k)
(C.a[i][j] += A.a[i][k] * B.a[k][j] % P) %= P;
return C;
}
Mat operator^(Mat a, int b) {
Mat ans(a.n);
for (; b; b >>= 1, a = a * a)
if (b & 1) ans = ans * a;
return ans;
}
void build(Mat &T) {
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j)
for (int k = (0); k <= (3); ++k) {
int x = i + dx[k], y = j + dy[k];
if (x >= 0 && x < n && y >= 0 && y < m)
T.a[(i * m + j)][(x * m + y)] = 1;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
Mat T(n * m);
build(T);
Mat v(n * m, 1);
v.a[0][0] = 1;
last_t = 1;
for (int i = (1); i <= (q); ++i) {
scanf("%d%d%d%d", &opt, &x, &y, &t);
--x;
--y;
v = (T ^ (t - last_t)) * v;
if (opt == 1) printf("%lld\n", v.a[(x * m + y)][0]);
if (opt == 2) {
d[x][y] = 1;
v.a[(x * m + y)][0] = 0;
for (int k = (0); k <= (3); ++k) {
int px = x + dx[k], py = y + dy[k];
if (px >= 0 && px < n && py >= 0 && py < m)
T.a[(px * m + py)][(x * m + y)] = 0,
T.a[(x * m + y)][(px * m + py)] = 0;
}
T.a[(x * m + y)][(x * m + y)] = 0;
}
if (opt == 3) {
d[x][y] = 0;
for (int k = (0); k <= (3); ++k) {
int px = x + dx[k], py = y + dy[k];
if (px >= 0 && px < n && py >= 0 && py < m && !d[px][py])
T.a[(px * m + py)][(x * m + y)] = 1,
T.a[(x * m + y)][(px * m + py)] = 1;
}
T.a[(x * m + y)][(x * m + y)] = 1;
}
last_t = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cat[20][20];
inline long long mod(long long x) { return x % 1000000007LL; }
struct mat {
vector<vector<long long> > m;
int r;
int c;
mat(int r, int c) : r(r), c(c), m(r, vector<long long>(c, 0)) {}
const vector<long long>& operator[](int i) const { return m[i]; }
vector<long long>& operator[](int i) { return m[i]; }
mat operator*(const mat& a) const {
assert(c == a.r);
mat ans(r, a.c);
for (int i = 0; i < r; ++i) {
for (int j = 0; j < a.c; ++j) {
for (int k = 0; k < c; ++k) {
ans[i][j] += mod(m[i][k] * a[k][j]);
}
ans[i][j] = mod(ans[i][j]);
}
}
return ans;
}
mat operator^(int e) const {
assert(r == c);
mat ans(r, c);
for (int i = 0; i < r; ++i) {
ans[i][i] = 1;
}
mat pw = *this;
for (; e; e /= 2) {
if (e & 1) {
ans = ans * pw;
}
pw = pw * pw;
}
return ans;
}
};
int rv[] = {-1, 1, 0, 0};
int cv[] = {0, 0, -1, 1};
inline int to_id(int i, int j, int m) { return i * m + j; }
inline bool valid(int i, int j, int n, int m) {
return 0 <= i && i < n && 0 <= j && j < m;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
int sz = n * m;
mat ma(sz, sz);
mat nw(sz, 1);
nw[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int q = to_id(i, j, m);
ma[q][q] = 1;
for (int d = 0; d < 4; ++d) {
int ni = i + rv[d];
int nj = j + cv[d];
if (valid(ni, nj, n, m)) {
ma[q][to_id(ni, nj, m)] = 1;
}
}
}
}
int lt = 1;
for (int i = 0; i < q; ++i) {
int tp, x, y, t;
scanf("%d%d%d%d", &tp, &x, &y, &t);
--x, --y;
nw = (ma ^ (t - lt)) * nw;
if (tp == 1) {
printf("%d\n", (int)nw[to_id(x, y, m)][0]);
} else {
cat[x][y] = tp == 2;
int q = to_id(x, y, m);
ma[q][q] = !cat[x][y];
for (int d = 0; d < 4; ++d) {
int nx = x + rv[d];
int ny = y + cv[d];
if (valid(nx, ny, n, m) && !cat[nx][ny]) {
int p = to_id(nx, ny, m);
ma[q][p] = ma[p][q] = !cat[x][y];
}
}
}
lt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
struct _ {
int A[20][20];
friend _ operator*(_ a, _ b) {
_ r;
for (int i = 0; i != 20; ++i)
for (int j = 0; j != 20; ++j) {
unsigned long long t = 0;
for (int k = 0; k != 10; ++k)
t += (unsigned long long)a.A[i][k] * b.A[k][j];
t %= mod;
for (int k = 10; k != 20; ++k)
t += (unsigned long long)a.A[i][k] * b.A[k][j];
r.A[i][j] = t % mod;
}
return r;
}
};
int mat[20][20];
int can[20];
int n, m;
void pow(_ a, int b, _& r) {
for (; b; b >>= 1, a = a * a)
if (b & 1) r = a * r;
}
_ get() {
_ r;
memset(&r, 0, sizeof r);
for (int i = 0; i != n; ++i)
for (int j = 0; j != m; ++j) {
const int u = mat[i][j];
if (!can[u]) continue;
r.A[u][u] = 1;
static const int dx[4] = {1, -1, 0, 0};
static const int dy[4] = {0, 0, 1, -1};
for (int k = 0; k != 4; ++k) {
int x = i + dx[k], y = j + dy[k];
if (x < 0 || y < 0 || x >= n || y >= m) continue;
if (!can[mat[x][y]]) continue;
r.A[u][mat[x][y]] = 1;
}
}
return r;
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
int Q;
std::cin >> n >> m >> Q;
for (int i = 0, t = 0; i < n; ++i)
for (int j = 0; j < m; ++j) can[mat[i][j] = t++] = true;
int lst = 1;
_ v;
memset(&v, 0, sizeof v);
v.A[mat[0][0]][0] = 1;
while (Q-- > 0) {
int opt, x, y, tim;
std::cin >> opt >> x >> y >> tim;
--x, --y;
pow(get(), tim - lst, v);
lst = tim;
if (opt == 1) {
std::cout << v.A[mat[x][y]][0] << '\n';
} else if (opt == 2) {
can[mat[x][y]] = false;
} else {
can[mat[x][y]] = true;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20 + 10;
const long long MOD = 1e9 + 7;
const int d[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
inline long long in() {
long long x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * flag;
}
struct Matrix {
int R, C;
long long val[MAXN][MAXN];
Matrix() {}
Matrix(int _R, int _C) { R = _R, C = _C, memset(val, 0, sizeof val); }
Matrix(int _R, int _C, bool flag) {
R = _R, C = _C;
memset(val, 0, sizeof val);
for (int i = 1; i <= R; ++i) val[i][i] = 1;
}
Matrix operator*(const Matrix& B) const {
Matrix ret(R, B.C);
for (int i = 1; i <= R; i++)
for (int j = 1; j <= B.C; j++)
for (int k = 1; k <= C; k++)
(ret.val[i][j] += val[i][k] * B.val[k][j] % MOD) %= MOD;
return ret;
}
void print() {
for (int i = 1; i <= R; ++i, puts(""))
for (int j = 1; j <= C; printf("%lld ", val[i][j]), ++j)
;
}
} O, G;
Matrix fpow(Matrix A, long long b) {
if (!b) return A;
Matrix ret(A.R, A.C, true);
while (b) {
if (b & 1)
ret = ret * A, b ^= 1;
else
A = A * A, b >>= 1;
}
return ret;
}
int n, m, q;
int pam[MAXN][MAXN];
bool vld[MAXN];
void solve(int t) {
Matrix ret = fpow(G, t);
O = O * ret;
}
int main() {
n = in(), m = in();
q = in();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) pam[i][j] = (i - 1) * m + j;
O = Matrix(1, n * m);
O.val[1][1] = 1LL;
G = Matrix(n * m, n * m);
memset(vld, true, sizeof vld);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
for (int i = 0; i <= 3; i++) {
int nx = x + d[i][0], ny = y + d[i][1];
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m)
G.val[pam[x][y]][pam[nx][ny]] = 1;
G.val[pam[x][y]][pam[x][y]] = 1;
}
long long pret = 1;
while (q--) {
int opt = in(), x = in(), y = in(), t = in();
int id = pam[x][y];
if (opt == 1) {
solve(t - pret);
printf("%lld\n", O.val[1][id]);
} else if (opt == 2) {
solve(t - pret);
vld[id] = false;
for (int i = 0; i <= 3; i++) {
int nx = x + d[i][0], ny = y + d[i][1];
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m)
G.val[id][pam[nx][ny]] = G.val[pam[nx][ny]][id] = 0;
}
G.val[id][id] = 0;
O.val[1][id] = 0;
} else if (opt == 3) {
solve(t - pret);
vld[id] = true;
for (int i = 0; i <= 3; i++) {
int nx = x + d[i][0], ny = y + d[i][1];
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && vld[pam[nx][ny]])
G.val[id][pam[nx][ny]] = G.val[pam[nx][ny]][id] = 1;
}
G.val[id][id] = 1;
}
pret = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mo = 1000000007;
struct S {
long long k[50][50];
} ans, base;
long long N, n, m, q;
long long mp[25][25];
S mul(S a, S b) {
S 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]) % mo;
return c;
}
void qpow(long long b) {
while (b) {
if (b & 1) ans = mul(base, ans);
b >>= 1;
base = mul(base, base);
}
}
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 p = 1;
while (q--) {
build();
long long op, x, y, t;
scanf("%lld%lld%lld%lld", &op, &x, &y, &t);
qpow(t - p);
p = 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;
int n, m, q;
int N;
int steps[5][2] = {{0, 0}, {1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int ns = 5;
const int MOD = int(1e9) + 7;
inline int add(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline int sub(int a, int b) { return (a - b < 0) ? (a - b + MOD) : (a - b); }
inline void inc(int &a, int b) { a = add(a, b); }
inline int negate(int a) { return MOD - a; }
inline int mul(int a, int b) { return (a * 1ll * b) % MOD; }
const int MAX = 401;
typedef int mx[MAX][MAX];
typedef int row[MAX];
void mul(mx a, mx b, mx r) {
memset(r, 0, sizeof(mx));
for (size_t i = 0; i < N; i++)
for (size_t j = 0; j < N; j++)
for (size_t k = 0; k < N; k++)
r[i][j] = add(r[i][j],
b[k][j] <= 0 || a[i][k] <= 0 ? 0 : mul(a[i][k], b[k][j]));
}
void mul(row a, mx b, row r) {
memset(r, 0, sizeof(row));
for (size_t j = 0; j < N; j++)
for (size_t k = 0; k < N; k++)
r[j] = add(r[j], b[k][j] <= 0 ? 0 : mul(a[k], b[k][j]));
}
void ones(mx a) {
memset(a, 0, sizeof(mx));
for (size_t i = 0; i < N; i++) a[i][i] = 1;
}
void binPow(mx a, int p, mx r) {
ones(r);
mx b;
memcpy(b, a, sizeof(b));
mx t;
while (p) {
if (p & 1) {
mul(r, b, t);
memcpy(r, t, sizeof(mx));
}
mul(b, b, t);
memcpy(b, t, sizeof(mx));
p >>= 1;
}
}
int toIdx(int i, int j) { return i * m + j; }
pair<int, int> fromIdx(int idx) { return pair<int, int>(idx / m, idx % m); }
void composeG(mx g) {
memset(g, 0, sizeof(mx));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int cellIdx = toIdx(i, j);
for (int s = 0; s < ns; s++) {
int ni = i + steps[s][0];
int nj = j + steps[s][1];
if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue;
int otherCellIdx = toIdx(ni, nj);
g[cellIdx][otherCellIdx] = g[otherCellIdx][cellIdx] = 1;
}
}
}
void enable(mx g, int i, int j) {
int cellIdx = toIdx(i, j);
for (int s = 0; s < ns; s++) {
int ni = i + steps[s][0];
int nj = j + steps[s][1];
if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue;
int otherCellIdx = toIdx(ni, nj);
g[cellIdx][otherCellIdx] += 1;
g[otherCellIdx][cellIdx] += 1;
}
}
void disable(mx g, int i, int j) {
int cellIdx = toIdx(i, j);
for (int s = 0; s < ns; s++) {
int ni = i + steps[s][0];
int nj = j + steps[s][1];
if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue;
int otherCellIdx = toIdx(ni, nj);
g[cellIdx][otherCellIdx] -= 1;
g[otherCellIdx][cellIdx] -= 1;
}
}
void clear() {}
void solve() {
N = n * m;
row currentAns;
memset(currentAns, 0, sizeof(row));
currentAns[0] = 1;
mx g;
composeG(g);
int time = 1;
while (q--) {
int type, x, y, t;
scanf("%d%d%d%d", &type, &x, &y, &t);
x--, y--;
mx tg, mulMx;
memcpy(tg, g, sizeof(mx));
binPow(tg, t - time, mulMx);
row tmp;
mul(currentAns, mulMx, tmp);
memcpy(currentAns, tmp, sizeof(row));
time = t;
if (type == 2)
disable(g, x, y);
else if (type == 3)
enable(g, x, y);
else
printf("%d\n", currentAns[toIdx(x, y)]);
}
}
int main() {
while (scanf("%d%d%d", &n, &m, &q) == 3) {
clear();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const mod = 1e9 + 7;
int const maxn = 22;
struct Mat {
vector<vector<int> > _data;
Mat() : _data(maxn, vector<int>(maxn, 0)) {}
};
int n, m;
Mat operator*(const Mat& a, const Mat& b) {
Mat ans;
int mn = n * m;
for (int i = 0; i < mn; ++i)
for (int j = 0; j < mn; ++j)
for (int k = 0; k < mn; ++k)
ans._data[i][k] =
(ans._data[i][k] + a._data[i][j] * 1LL * b._data[j][k]) % mod;
return ans;
}
Mat powMat(const Mat& a, int b) {
Mat ans;
for (int i = 0; i < n * m; ++i) ans._data[i][i] = 1;
Mat tmp = a;
while (b) {
if (b & 1) ans = ans * tmp;
tmp = tmp * tmp;
b >>= 1;
}
return ans;
}
Mat stepMat;
int ans[maxn];
int bad[maxn];
void bad_cat(int x, int y) {
int index = x * m + y;
for (int i = 0; i < n * m; ++i)
stepMat._data[i][index] = stepMat._data[index][i] = 0;
ans[index] = 0;
bad[index] = 1;
}
void good_free(int x, int y) {
int index = x * m + y;
bad[index] = 0;
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;
int ny = y + dy;
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
int nindex = nx * m + ny;
if (!bad[nindex])
stepMat._data[index][nindex] = stepMat._data[nindex][index] = 1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int q;
cin >> n >> m >> q;
ans[0] = 1;
int curTime = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) good_free(i, j);
for (int step = 0; step < q; ++step) {
int type, x, y, t;
cin >> type >> x >> y >> t;
--x;
--y;
Mat tmp = powMat(stepMat, t - curTime);
vector<int> nAns(n * m, 0);
for (int i = 0; i < n * m; ++i)
for (int j = 0; j < n * m; ++j)
nAns[i] = (nAns[i] + ans[j] * 1LL * tmp._data[i][j]) % mod;
for (int i = 0; i < n * m; ++i) ans[i] = nAns[i];
curTime = t;
if (type == 1) cout << ans[x * m + y] << "\n";
if (type == 2) bad_cat(x, y);
if (type == 3) good_free(x, y);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {0, 1, 0, -1, 0};
const int dc[] = {1, 0, -1, 0, 0};
int n, m;
const int rows = 20;
const int cols = 20;
struct Matrix {
int r, c;
long long m[rows][cols];
Matrix(int row = 0, int col = 0) {
r = row;
c = col;
memset(m, 0, sizeof(m));
}
Matrix(vector<vector<long long> > v) {
r = v.size();
c = 0;
if (v.size()) c = v[0].size();
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
m[i][j] = v[i][j];
}
}
}
void iden() {
for (int i = 0; i < r; i++) m[i][i] = 1;
}
Matrix multiply(Matrix B) {
if (c != B.r) printf("--- Can't multiply ---\n");
Matrix C = Matrix(r, B.c);
for (int i = 0; i < C.r; i++) {
for (int j = 0; j < C.c; j++) {
long long val = 0;
for (int k = 0; k < c; k++) {
val += m[i][k] * B.m[k][j];
val %= 1000000007;
}
C.m[i][j] = val;
}
}
return C;
}
Matrix exp(long long p) {
if (p == 1) return *this;
Matrix C = exp(p / 2);
C = C.multiply(C);
if (p & 1) C = C.multiply(*this);
return C;
}
Matrix add(const Matrix& B) {
if (r != B.r || c != B.c) printf("--- Can't add ---\n");
Matrix C = Matrix(r, c);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
C.m[i][j] = m[i][j] + B.m[i][j];
}
}
return C;
}
void print() {
printf("------ %d x %d ------\n", r, c);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (j) printf(" ");
printf("%lld", m[i][j]);
}
printf("\n");
}
printf("\n");
printf("-------- end --------\n", r, c);
}
};
Matrix M;
int ar[20][20];
void update() {
M = Matrix(n * m, n * m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ar[i][j]) continue;
for (int k = 0; k < 5; k++) {
int p = i + dr[k], q = j + dc[k];
if (p >= 0 and q >= 0 and p < n and q < m and !ar[p][q]) {
M.m[i * m + j][p * m + q] = 1;
}
}
}
}
}
int main() {
int q;
scanf("%d %d %d", &n, &m, &q);
Matrix one(n * m, n * m);
one.iden();
int last = 1;
while (q--) {
int tp, r, c, t;
scanf("%d %d %d %d", &tp, &r, &c, &t);
r--, c--;
if (tp == 1) {
update();
Matrix x = M.exp(t - last);
one = one.multiply(x);
printf("%lld\n", one.m[0][r * m + c] % 1000000007);
} else if (tp == 2) {
update();
Matrix x = M.exp(t - last);
one = one.multiply(x);
ar[r][c] = 1;
} else {
update();
Matrix x = M.exp(t - last);
one = one.multiply(x);
ar[r][c] = 0;
}
last = t;
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 30;
const long long MOD = 1e9 + 7;
using namespace std;
int n, R, C, Q, cnt = 0, lt = 1, vis[N][N];
long long f[30], g[N];
int ex[5] = {0, 0, 0, 1, -1}, ey[5] = {0, 1, -1, 0, 0};
struct nn {
long long a[30][30];
void PRT() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%lld ", a[i][j]);
printf("\n");
}
printf("\n");
}
};
nn T, las;
nn INIT() {
nn res;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) res.a[i][j] = 0;
for (int i = 1; i <= R; i++) {
for (int j = 1; j <= C; j++) {
if (vis[i][j]) continue;
int now = (i - 1) * C + j;
for (int k = 0; k <= 4; k++) {
int nx = i + ex[k], ny = j + ey[k];
if (nx < 1 || ny < 1 || nx > R || ny > C) continue;
if (vis[nx][ny]) continue;
int pos = (nx - 1) * C + ny;
res.a[now][pos] = 1;
}
}
}
return res;
}
nn MUL(nn A, nn B) {
nn res;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) res.a[i][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
res.a[i][j] += A.a[i][k] * B.a[k][j] % MOD;
res.a[i][j] %= MOD;
}
}
}
return res;
}
nn KSM(nn A, int y) {
nn res;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) res.a[i][j] = 0;
res.a[i][i] = 1;
}
while (y) {
if (y % 2 == 1) res = MUL(res, A);
A = MUL(A, A);
y /= 2;
}
return res;
}
void MMUL(nn A) {
for (int i = 1; i <= n; i++) g[i] = 0;
for (int i = 1; i <= n; i++) {
if (i % C == 0 && vis[i / C][C]) continue;
if (i % C != 0 && vis[i / C + 1][i % C]) continue;
for (int j = 1; j <= n; j++) {
g[i] += f[j] * A.a[j][i] % MOD;
g[i] %= MOD;
}
}
for (int i = 1; i <= n; i++) f[i] = g[i];
}
void SOLVE() {
int pd, x, y, t;
scanf("%d%d%d%d", &pd, &x, &y, &t);
int dt = t - lt;
lt = t;
MMUL(KSM(las, dt));
if (pd == 2) {
vis[x][y]++;
cnt++;
f[(x - 1) * C + y] = 0;
las = INIT();
}
if (pd == 3) {
vis[x][y]--;
cnt--;
if (cnt == 0)
las = T;
else
las = INIT();
}
if (pd == 1) printf("%lld\n", f[(x - 1) * C + y]);
}
int main() {
scanf("%d%d%d", &R, &C, &Q);
n = R * C;
T = INIT();
f[1] = 1;
lt = 1;
las = T;
while (Q--) SOLVE();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int N = 25;
int matSize;
int n, m, q;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int cat[N][N];
bool legal(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
int trans(int x, int y) { return x * m + y; }
struct matrix {
int d[N][N];
matrix(bool flag = 0) {
memset(d, 0, sizeof(d));
if (flag)
for (int i = 0; i < matSize; i++) d[i][i] = 1;
}
matrix operator*(const matrix &I) const {
matrix ans;
for (int i = 0; i < matSize; i++) {
for (int j = 0; j < matSize; j++) {
for (int k = 0; k < matSize; k++) {
ans.d[i][j] += (long long)d[i][k] * I.d[k][j] % MOD;
ans.d[i][j] %= MOD;
}
}
}
return ans;
}
};
matrix modExp(matrix a, int b) {
matrix t = matrix(1);
while (b) {
if (b & 1) t = t * a;
a = a * a;
b >>= 1;
}
return t;
}
matrix rebuild() {
matrix ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (cat[i][j]) continue;
int u = trans(i, j);
ans.d[u][u] = 1;
for (int k = 0; k < 4; k++) {
int p = i + dx[k];
int q = j + dy[k];
if (legal(p, q) && !cat[p][q]) ans.d[u][trans(p, q)] = 1;
}
}
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
matSize = n * m;
int t, p, x, y, pre = 1;
matrix now, go = rebuild();
now.d[0][0] = 1;
while (q--) {
scanf("%d%d%d%d", &p, &x, &y, &t);
x--;
y--;
now = now * modExp(go, t - pre);
if (p > 1) {
cat[x][y] ^= 1;
}
if (p == 1) {
int ret = 0;
for (int i = 0; i < matSize; i++) {
ret += now.d[i][trans(x, y)];
ret %= MOD;
}
printf("%d\n", ret);
}
pre = t;
go = rebuild();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 7, maxn = 25;
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int n, m, q, last, bz[maxn][maxn];
struct mat {
int a[maxn][maxn];
friend mat operator*(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]) % mo;
return z;
}
} now;
inline int boom(int x, int y) { return (x - 1) * m + y; }
inline mat ksm(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 = x * x)
if (y & 1) ret = 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 <= (3); ++k) {
int xx = i + dx[k], yy = j + dy[k];
if (xx <= 0 || yy <= 0 || xx > n || yy > m) continue;
if (bz[i][j] || bz[xx][yy])
tmp.a[boom(i, j)][boom(xx, yy)] = 0;
else
tmp.a[boom(i, j)][boom(xx, yy)] = 1;
}
if (bz[i][j])
tmp.a[boom(i, j)][boom(i, j)] = 0;
else
tmp.a[boom(i, j)][boom(i, j)] = 1;
}
now = now * ksm(tmp, t - last);
if (tp == 1) printf("%d\n", now.a[1][boom(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;
template <class T>
inline void Min(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void Max(T &a, T b) {
if (a < b) a = b;
}
typedef long long arr[20][20];
int sz;
void mul(arr &a, arr &b) {
arr c;
memset(c, 0, sizeof(c));
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++) {
for (int k = 0; k < sz; k++) c[i][j] += a[i][k] * b[k][j] % 1000000007;
c[i][j] %= 1000000007;
}
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++) a[i][j] = c[i][j];
}
void pow(arr &a, int n) {
arr b;
memset(b, 0, sizeof(b));
for (int i = 0; i < sz; i++) b[i][i] = 1;
while (n) {
if (n & 1) mul(b, a);
mul(a, a);
n >>= 1;
}
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++) a[i][j] = b[i][j];
}
arr a;
int v[21], n, m, d[][2] = {-1, 0, 1, 0, 0, -1, 0, 1};
void cal(arr &a) {
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (v[i * m + j] == 0) {
int first = i * m + j;
a[first][first]++;
for (int k = 0; k < 4; k++) {
int ii = i + d[k][0], jj = j + d[k][1];
if (ii >= 0 && ii < n && jj >= 0 && jj < m && !v[ii * m + jj]) {
int second = ii * m + jj;
a[first][second]++;
}
}
}
}
long long b[22], c[22];
void mul1(long long *b, arr &a) {
memset(c, 0, sizeof(c));
for (int i = 0; i < sz; i++)
if (b[i]) {
for (int j = 0; j < sz; j++) c[j] += b[i] * a[i][j] % 1000000007;
}
for (int i = 0; i < sz; i++) {
b[i] = c[i] % 1000000007;
}
}
int main() {
int T, i, j, k;
int q;
scanf("%d%d%d", &n, &m, &q);
sz = n * m;
memset(v, 0, sizeof(v));
memset(b, 0, sizeof(b));
b[0] = 1;
int tt = 1, t, first, second, tp;
while (q--) {
scanf("%d%d%d%d", &tp, &first, &second, &t);
first--, second--;
cal(a);
pow(a, t - tt - 1);
mul1(b, a);
if (tp == 2) v[first * m + second] = 1;
memcpy(c, b, sizeof(c));
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (b[i * m + j]) {
for (k = 0; k < 4; k++) {
int ii = i + d[k][0], jj = j + d[k][1];
if (ii >= 0 && ii < n && jj >= 0 && jj < m && !v[ii * m + jj]) {
int second = ii * m + jj;
c[second] += b[i * m + j];
}
}
}
if (tp == 3)
v[first * m + second] = 0;
else if (tp == 2)
c[first * m + second] = 0;
for (i = 0; i < sz; i++) b[i] = c[i] % 1000000007;
if (tp == 1) {
printf("%d\n", (int)b[first * m + second]);
}
tt = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7, Q = 1e4 + 5, NM = 21;
int n, m, q;
long long t, vec[NM], adj[NM][NM], vectmp[NM], tmp[2][NM][NM];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
bool cat[NM];
long long T = 1;
struct event {
int tp, x, y;
long long t;
} e[Q];
inline bool inbounds(const int x, const int y) {
return 0 <= x && x < n && 0 <= y && y < m;
}
inline int getidx(const int x, const int y) { return x * m + y; }
inline pair<int, int> getpos(const int idx) { return {idx / m, idx % m}; }
void upd(long long t) {
if (t <= 0) return;
long long p = t - T;
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
tmp[0][i][j] = adj[i][j];
}
}
while (p > 0) {
if (p & 1) {
for (int i = 0; i < n * m; i++) {
vectmp[i] = 0;
for (int j = 0; j < n * m; j++) {
vectmp[i] = (vectmp[i] + tmp[0][i][j] * vec[j]) % M;
}
}
for (int i = 0; i < n * m; i++) {
vec[i] = vectmp[i];
}
}
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
tmp[1][i][j] = 0;
for (int k = 0; k < n * m; k++) {
tmp[1][i][j] = (tmp[1][i][j] + tmp[0][i][k] * tmp[0][k][j]) % M;
}
}
}
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
tmp[0][i][j] = tmp[1][i][j];
}
}
p /= 2;
}
T = t;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
cin >> e[i].tp >> e[i].x >> e[i].y >> e[i].t;
e[i].x--;
e[i].y--;
}
vec[0] = 1;
int idx1, idx2;
for (int i = 0; i < n * m; i++) {
auto [x, y] = getpos(i);
for (int d = 0; d < 4; d++) {
if (inbounds(x + dx[d], y + dy[d])) {
int j = getidx(x + dx[d], y + dy[d]);
adj[i][j] = adj[j][i] = 1;
}
}
adj[i][i] = 1;
}
for (int i = 0; i < q; i++) {
switch (e[i].tp) {
case 1:
upd(e[i].t);
cout << vec[getidx(e[i].x, e[i].y)] << endl;
break;
case 2:
upd(e[i].t);
idx1 = getidx(e[i].x, e[i].y);
cat[idx1] = true;
vec[idx1] = 0;
for (int d = 0; d < 4; d++) {
if (inbounds(e[i].x + dx[d], e[i].y + dy[d])) {
idx2 = getidx(e[i].x + dx[d], e[i].y + dy[d]);
adj[idx1][idx2] = adj[idx2][idx1] = 0;
}
}
adj[idx1][idx1] = 0;
break;
case 3:
upd(e[i].t);
idx1 = getidx(e[i].x, e[i].y);
cat[idx1] = false;
for (int d = 0; d < 4; d++) {
if (inbounds(e[i].x + dx[d], e[i].y + dy[d])) {
idx2 = getidx(e[i].x + dx[d], e[i].y + dy[d]);
if (!cat[idx2]) {
adj[idx1][idx2] = adj[idx2][idx1] = 1;
}
}
}
adj[idx1][idx1] = 1;
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void getint(int &v) {
char ch, fu = 0;
for (ch = '*'; (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') fu = 1, ch = getchar();
for (v = 0; ch >= '0' && ch <= '9'; ch = getchar()) v = v * 10 + ch - '0';
if (fu) v = -v;
}
const int MO = 1e9 + 7;
struct mat {
int a[20][20];
mat() { memset(a, 0, sizeof(a)); }
mat operator*(const mat &A) const {
mat B;
for (int i = 0; i <= 19; i++)
for (int j = 0; j <= 19; j++)
for (int k = 0; k <= 19; k++)
(B.a[i][k] += (long long)a[i][j] * A.a[j][k] % MO) %= MO;
return B;
}
};
mat pw(mat x, int y) {
mat t;
for (int i = 0; i <= 19; i++) t.a[i][i] = 1;
for (; y; y >>= 1) {
if (y & 1) t = t * x;
x = x * x;
}
return t;
}
const int dx[] = {-1, 0, 0, 1, 0};
const int dy[] = {0, -1, 1, 0, 0};
int n, m, q, tp, x, y, t, l;
mat A, B;
inline int tra(int x, int y) { return (x - 1) * m + y - 1; }
int main() {
scanf("%d%d%d", &n, &m, &q);
l = 1;
A.a[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int d = 0; d <= 4; d++) {
int ti = i + dx[d], tj = j + dy[d];
if (ti < 1 || ti > n || tj < 1 || tj > m) continue;
B.a[tra(i, j)][tra(ti, tj)] = 1;
}
while (q--) {
getint(tp), getint(x), getint(y), getint(t);
A = A * pw(B, t - l);
if (tp == 1)
printf("%d\n", A.a[0][tra(x, y)]);
else if (tp == 2) {
A.a[0][tra(x, y)] = 0;
for (int d = 0; d <= 4; d++) {
int tx = x + dx[d], ty = y + dy[d];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
B.a[tra(tx, ty)][tra(x, y)] = 0;
}
} else if (tp == 3) {
for (int d = 0; d <= 4; d++) {
int tx = x + dx[d], ty = y + dy[d];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
B.a[tra(tx, ty)][tra(x, y)] = 1;
}
}
l = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
struct matrix {
long long m[32][32];
} A, I;
const int mod = 1e9 + 7;
int dir[6][2] = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}, {0, 0}};
int cat[31][31];
int n, m, w, x, type, y, t, lastt;
int q;
inline matrix mul(matrix a, matrix b) {
matrix c;
for (int i = 0; i < w; i++)
for (int j = 0; j < w; j++) {
c.m[i][j] = 0;
for (int k = 0; k < w; k++)
c.m[i][j] = (c.m[i][j] + a.m[i][k] * b.m[k][j]) % mod;
}
return c;
}
matrix pow(matrix a, int k) {
matrix ret = I;
for (; k; k >>= 1, a = mul(a, a))
if (k & 1) ret = mul(ret, a);
return ret;
}
int main() {
scanf("%d%d", &n, &m);
w = n * m;
scanf("%d", &q);
int lastt = 1;
matrix trans;
for (int i = 0; i < w; i++) I.m[i][i] = 1;
A = I;
for (int i = 1; i <= q; i++) {
scanf("%d%d%d%d", &type, &x, &y, &t);
x--;
y--;
matrix b;
for (int i = 0; i < w; i++)
for (int j = 0; j < w; j++) b.m[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!cat[i][j]) {
for (int k = 0; k < 5; k++) {
int dx = i + dir[k][0];
int dy = j + dir[k][1];
if (dx >= 0 && dx < n && dy >= 0 && dy < m && !cat[dx][dy])
b.m[dx * m + dy][i * m + j] = 1;
}
}
A = mul(A, pow(b, t - lastt));
if (type == 1)
printf("%lld\n", A.m[0][x * m + y]);
else if (type == 2) {
cat[x][y] = 1;
trans = I;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (cat[i][j]) trans.m[i * m + j][i * m + j] = 0;
A = mul(A, trans);
} else
cat[x][y] = 0;
lastt = t;
}
}
|
#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(const Matrix& a, int k) {
if (k == 0) return I;
if (k == 1) return a;
Matrix mid = power(a, k >> 1);
mid = mid * mid;
if (k & 1) return mid * a;
return mid;
}
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>
int n, m, i, j, k, flag[25][25], x[4] = {0, 1, 0, -1}, y[4] = {1, 0, -1, 0}, q;
int tmp, a, b, c, d;
struct matrix {
int n;
long long a[25][25];
matrix() { memset(a, 0, sizeof(a)); }
} g, ans;
matrix operator*(const matrix &A, const matrix &B) {
matrix C;
C.n = A.n;
int i, j, k;
for (i = 1; i <= A.n; i++)
for (j = 1; j <= A.n; j++)
for (k = 1; k <= A.n; k++)
C.a[i][j] = (C.a[i][j] + A.a[i][k] * B.a[k][j]) % 1000000007;
return C;
}
matrix ksm(matrix g, int x) {
matrix ans;
ans.n = n * m;
if (x == 1) return g;
ans = ksm(g, x / 2);
ans = ans * ans;
if (x & 1) ans = ans * g;
return ans;
}
int o(int x, int y) { return (x - 1) * m + y; }
void gz() {
int i, j, k, X, Y;
for (i = 1; i <= n * m; i++)
for (j = 1; j <= n * m; j++) g.a[i][j] = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (flag[i][j]) {
g.a[o(i, j)][o(i, j)] = 1;
for (k = 0; k < 4; k++) {
X = i + x[k];
Y = j + y[k];
if (flag[X][Y]) g.a[o(i, j)][o(X, Y)] = 1;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
tmp = 1;
for (i = 1; i <= n * m; i++) ans.a[i][i] = 1;
ans.n = n * m;
g.n = n * m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) flag[i][j] = 1;
for (i = 1; i <= q; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a == 1) {
gz();
ans = ans * ksm(g, d - tmp);
tmp = d;
printf("%I64d\n", ans.a[o(1, 1)][o(b, c)]);
} else if (a == 2) {
gz();
ans = ans * ksm(g, d - tmp);
tmp = d;
flag[b][c] = 0;
} else {
gz();
ans = ans * ksm(g, d - tmp);
tmp = d;
flag[b][c] = 1;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, x, y, ty, ti, w[21][21], tot;
struct matrix {
int x[21][21];
int *operator[](int a) { return x[a]; }
} S, T, p;
void inc(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
matrix operator*(matrix &a, matrix &b) {
memset(p.x, 0, sizeof(p.x));
for (int i = 0; i <= tot; i++)
for (int j = 0; j <= tot; j++)
for (int k = 0; k <= tot; k++)
inc(p[i][j], (long long)a[i][k] * b[k][j] % 1000000007);
return p;
}
void change(int t) {
matrix U = T;
for (; t; t >>= 1, U = U * U)
if (t & 1) S = U * S;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) w[i][j] = ++tot;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int X = w[i][j];
T[X][X] = 1;
if (i > 1) T[w[i - 1][j]][X] = 1;
if (i < n) T[w[i + 1][j]][X] = 1;
if (j > 1) T[w[i][j - 1]][X] = 1;
if (j < m) T[w[i][j + 1]][X] = 1;
}
S[1][1] = 1;
for (int t = 1, lt = 1; t <= q; t++) {
scanf("%d%d%d%d", &ty, &x, &y, &ti);
change(ti - lt - 1);
if (ty == 1) {
change(1);
printf("%d\n", S[w[x][y]][1]);
lt = ti;
} else {
if (ty == 3) change(1);
int X = w[x][y];
if (x > 1) T[X][w[x - 1][y]] ^= 1;
if (x < n) T[X][w[x + 1][y]] ^= 1;
if (y > 1) T[X][w[x][y - 1]] ^= 1;
if (y < m) T[X][w[x][y + 1]] ^= 1;
T[X][X] ^= 1;
lt = ti - (ty == 2);
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.