solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 200, M = 1e4, S = 1010;
int gi() {
int w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
int e0[N][N], e1[N][N];
int f[N][N][2], g[2][2][N][N][N], q[M];
int len[M], e[M][S], u[M], v[M];
const int mod = 1e9 + 7;
int main() {
int n = gi(), m = gi(), i, j, a, b, t, p, ans, l, r, k, o, O;
for (i = 1; i <= m; i++) {
a = u[i] = gi(), b = v[i] = gi();
e0[a][b] = e1[b][a] = i;
if (len[i] = gi())
for (j = 1; j <= len[i]; j++) e[i][j] = gi();
else
g[0][0][a][b][1] = 1;
}
for (t = 1; t <= m; t++)
for (p = 1; p <= len[t]; p++) {
if (e[t][p] == u[t]) {
l = 1, r = 0;
for (i = p; i; i--) q[++r] = e[t][i];
for (k = q[1]; l != r;) {
if (!(j = e1[k][q[++l]])) goto over;
for (i = len[j]; i; i--) q[++r] = e[j][i];
k = q[l];
if (r > (n << 1)) goto over;
}
reverse(q + 1, q + 1 + r);
if (p == len[t])
g[1][0][q[1]][v[t]][r]++;
else if (e[t][p + 1] == v[t]) {
for (i = p + 1; i <= len[t]; i++) q[++r] = e[t][i];
for (k = v[t], ++l; l != r;) {
if (!(j = e0[k][q[++l]])) goto over;
for (i = 1; i <= len[j]; i++) q[++r] = e[j][i];
k = q[l];
if (r > (n << 1)) goto over;
}
g[1][1][q[1]][q[r]][r - 1]++;
}
} else if (p == 1 && e[t][1] == v[t]) {
l = 1, r = 0;
for (i = 1; i <= len[t]; i++) q[++r] = e[t][i];
for (k = q[1]; l != r;) {
if (!(j = e0[k][q[++l]])) goto over;
for (i = 1; i <= len[j]; i++) q[++r] = e[j][i];
k = q[l];
if (r > (n << 1)) goto over;
}
g[0][1][u[t]][q[r]][r]++;
}
over:;
}
for (i = 1; i <= n; i++) f[0][i][0] = 1;
for (t = 0; t <= (n << 1); t++) {
ans = 0;
for (i = 1; i <= n; i++) {
(ans += f[t][i][1]) %= mod;
for (o = 0; o < 2; o++)
if (f[t][i][o])
for (j = 1; j + t <= (n << 1); j++)
for (k = 1; k <= n; k++)
for (O = 0; O < 2; O++)
f[j + t][k][O] =
(f[j + t][k][O] + 1LL * f[t][i][o] * g[!o][O][i][k][j]) %
mod;
}
if (t) printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const char lf = '\n';
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
template <typename T1, typename T2>
inline T1 gmax(T1 &a, T2 b) {
return a = a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 gmin(T1 &a, T2 b) {
return a = a < b ? a : b;
}
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0, b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + (c - 48), c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 53, __ = _ << 1, mo = 1000000007;
template <typename T1, typename T2>
inline T1 ad(T1 &a, T2 b) {
return a = a + b >= mo ? a + b - mo : a + b;
}
template <typename T1, typename T2>
inline T1 dl(T1 &a, T2 b) {
return a = a >= b ? a - b : a - b + mo;
}
template <typename T1, typename T2>
inline T1 add(T1 a, T2 b) {
return a + b >= mo ? a + b - mo : a + b;
}
template <typename T1, typename T2>
inline T1 del(T1 a, T2 b) {
return a >= b ? a - b : a - b + mo;
}
int n, nn, m, e[_][_] = {0};
vector<int> hav[_][_];
int pusheen(deque<int> &q, deque<int>::iterator x, int dir) {
int got = 1;
if (dir < 0) {
while (x != q.begin() && ((int)((q).size())) <= nn) {
auto pre = prev(x);
got &= e[*pre][*x],
q.insert(q.begin(), hav[*pre][*x].begin(), hav[*pre][*x].end());
x = pre;
}
} else {
while (next(x) != q.end() && ((int)((q).size())) <= nn) {
auto nex = next(x);
got &= e[*x][*nex],
q.insert(q.end(), hav[*x][*nex].begin(), hav[*x][*nex].end());
x = nex;
}
}
if (((int)((q).size())) > nn) got = 0;
return got;
}
long long f[2][_][__] = {0};
vector<int> trans[2][2][_][_];
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty(), nn = n + n;
for (int i = 1, a, b; i <= m; i++) {
a = ty(), b = ty(), e[a][b] = 1, hav[a][b].resize(ty());
for (auto &j : hav[a][b]) j = ty();
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (!hav[i][j].empty() && hav[i][j].back() == i) {
cerr << "found : " << i << " " << j << endl;
deque<int> temp(hav[i][j].begin(), hav[i][j].end());
if (pusheen(temp, prev(temp.end()), -1))
trans[0][0][temp.front()][j].emplace_back(((int)((temp).size())));
}
int got = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
auto x = find(hav[i][j].begin(), hav[i][j].end(), i);
if (x == hav[i][j].end()) continue;
if (++x == hav[i][j].end()) continue;
if (*x != j) continue;
deque<int> temp(hav[i][j].begin(), hav[i][j].end());
auto a = find(temp.begin(), temp.end(), i);
if (pusheen(temp, a, -1) && pusheen(temp, a + 1, 1)) {
trans[0][1][temp.front()][temp.back()].emplace_back(
((int)((temp).size())) - 1);
if (!got) {
got = 1, cout << ((int)((temp).size())) << lf;
for (auto p : temp) cout << p << ' ';
cout << lf;
}
}
}
if (!got) cout << 0 << lf << lf;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (e[i][j] && hav[i][j].empty()) trans[1][0][i][j].emplace_back(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (!hav[i][j].empty() && hav[i][j].front() == j) {
deque<int> temp(hav[i][j].begin(), hav[i][j].end());
if (pusheen(temp, temp.begin(), 1))
trans[1][1][i][temp.back()].emplace_back(((int)((temp).size())));
}
for (int i = 1; i <= n; i++) f[0][i][0] = 1;
for (int len = 0; len < nn; len++) {
for (int i = 0; i < 2; i++)
for (int j = 1; j <= n; j++) {
if (!f[i][j][len]) continue;
for (int a = 0; a < 2; a++)
for (int b = 1; b <= n; b++)
for (auto x : trans[i][a][j][b])
if (x + len <= nn) ad(f[a][b][x + len], f[i][j][len]);
}
}
for (int i = 1; i <= nn; i++) {
long long ans = 0;
for (int j = 1; j <= n; j++) ad(ans, f[1][j][i]);
cout << ans << lf;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const char lf = '\n';
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
template <typename T1, typename T2>
inline T1 gmax(T1 &a, T2 b) {
return a = a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 gmin(T1 &a, T2 b) {
return a = a < b ? a : b;
}
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0, b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + (c - 48), c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 53, __ = _ << 1, mo = 1000000007;
template <typename T1, typename T2>
inline T1 ad(T1 &a, T2 b) {
return a = a + b >= mo ? a + b - mo : a + b;
}
template <typename T1, typename T2>
inline T1 dl(T1 &a, T2 b) {
return a = a >= b ? a - b : a - b + mo;
}
template <typename T1, typename T2>
inline T1 add(T1 a, T2 b) {
return a + b >= mo ? a + b - mo : a + b;
}
template <typename T1, typename T2>
inline T1 del(T1 a, T2 b) {
return a >= b ? a - b : a - b + mo;
}
int n, nn, m, e[_][_] = {0};
vector<int> hav[_][_];
int pusheen(deque<int> &q, deque<int>::iterator x, int dir) {
int got = 1;
if (dir < 0) {
while (x != q.begin() && ((int)((q).size())) <= nn) {
auto pre = prev(x);
got &= e[*pre][*x],
q.insert(q.begin(), hav[*pre][*x].begin(), hav[*pre][*x].end());
x = pre;
}
} else {
while (next(x) != q.end() && ((int)((q).size())) <= nn) {
auto nex = next(x);
got &= e[*x][*nex],
q.insert(q.end(), hav[*x][*nex].begin(), hav[*x][*nex].end());
x = nex;
}
}
if (((int)((q).size())) > nn) got = 0;
return got;
}
long long f[2][_][__] = {0};
vector<int> trans[2][2][_][_];
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty(), nn = n + n;
for (int i = 1, a, b; i <= m; i++) {
a = ty(), b = ty(), e[a][b] = 1, hav[a][b].resize(ty());
for (auto &j : hav[a][b]) j = ty();
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (!hav[i][j].empty() && hav[i][j].back() == i) {
deque<int> temp(hav[i][j].begin(), hav[i][j].end());
if (pusheen(temp, prev(temp.end()), -1))
trans[0][0][temp.front()][j].emplace_back(((int)((temp).size())));
}
int got = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
auto x = hav[i][j].end();
for (auto ps = hav[i][j].begin(); ps != hav[i][j].end(); ps++) {
if (next(ps) == hav[i][j].end()) break;
if (*ps == i && *next(ps) == j) {
x = ps;
break;
}
}
if (x == hav[i][j].end()) continue;
if (next(x) == hav[i][j].end()) continue;
deque<int> temp(hav[i][j].begin(), hav[i][j].end());
auto a = temp.begin() + (x - hav[i][j].begin());
if (pusheen(temp, a, -1) && pusheen(temp, a + 1, 1)) {
trans[0][1][temp.front()][temp.back()].emplace_back(
((int)((temp).size())) - 1);
if (!got) {
got = 1, cout << ((int)((temp).size())) << lf;
for (auto p : temp) cout << p << ' ';
cout << lf;
}
}
}
if (!got) cout << 0 << lf << lf;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (e[i][j] && hav[i][j].empty()) trans[1][0][i][j].emplace_back(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (!hav[i][j].empty() && hav[i][j].front() == j) {
deque<int> temp(hav[i][j].begin(), hav[i][j].end());
if (pusheen(temp, temp.begin(), 1))
trans[1][1][i][temp.back()].emplace_back(((int)((temp).size())));
}
for (int i = 1; i <= n; i++) f[0][i][0] = 1;
for (int len = 0; len < nn; len++) {
for (int i = 0; i < 2; i++)
for (int j = 1; j <= n; j++) {
if (!f[i][j][len]) continue;
for (int a = 0; a < 2; a++)
for (int b = 1; b <= n; b++)
for (auto x : trans[i][a][j][b])
if (x + len <= nn) ad(f[a][b][x + len], f[i][j][len]);
}
}
for (int i = 1; i <= nn; i++) {
long long ans = 0;
for (int j = 1; j <= n; j++) ad(ans, f[1][j][i]);
cout << ans << lf;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, u, U, L, S, T, ans;
int l[200][200], p[200][200][200], dl[200], a[200][200][200], b[200][200][200];
vector<int> R[200], Rw[200], A[200], Aw[200], B[200], Bw[200], G[200];
inline void upd(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); i++) b[i][i][0] = 1;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) l[i][j] = -1;
for (int i = (1); i <= (m); i++) {
scanf("%d%d", &x, &y);
scanf("%d", &l[x][y]);
if (!l[x][y]) G[x].push_back(y);
for (int j = (1); j <= (l[x][y]); j++) scanf("%d", &p[x][y][j]);
}
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) {
u = 0;
for (int k = (1); k <= (l[i][j] - 1); k++)
if (p[i][j][k] == i && p[i][j][k + 1] == j) u = k;
if (!u) continue;
L = 1;
S = 1;
T = 0;
U = 0;
dl[0] = p[i][j][u];
for (int k = (u - 1); k >= (1); k--) dl[++T] = p[i][j][k], L++;
for (; S <= T; S++) {
if (L > 2 * n) break;
int X = dl[S - 1], Y = dl[S];
if (l[Y][X] == -1) {
U = 1;
break;
}
for (int k = (l[Y][X]); k >= (1); k--) dl[++T] = p[Y][X][k], L++;
}
if (U) continue;
x = dl[T];
S = 1;
T = 0;
dl[0] = p[i][j][u + 1];
for (int k = (u + 2); k <= (l[i][j]); k++) dl[++T] = p[i][j][k], L++;
for (; S <= T; S++) {
if (L > 2 * n) break;
int X = dl[S - 1], Y = dl[S];
if (l[X][Y] == -1) {
U = 1;
break;
}
for (int k = (1); k <= (l[X][Y]); k++) dl[++T] = p[X][Y][k], L++;
}
if (U) continue;
if (L <= 2 * n) {
R[x].push_back(dl[T]);
Rw[x].push_back(L);
}
}
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (p[i][j][l[i][j]] == i) {
L = 1;
S = 1;
T = 0;
u = 0;
dl[0] = i;
for (int k = (l[i][j] - 1); k >= (1); k--) dl[++T] = p[i][j][k], L++;
for (; S <= T; S++) {
if (L > 2 * n) break;
int X = dl[S - 1], Y = dl[S];
if (l[Y][X] == -1) {
u = 1;
break;
}
for (int k = (l[Y][X]); k >= (1); k--) dl[++T] = p[Y][X][k], L++;
}
if (u) continue;
if (L <= 2 * n) {
A[dl[T]].push_back(j);
Aw[dl[T]].push_back(L);
}
}
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (p[i][j][1] == j) {
L = 1;
S = 1;
T = 0;
u = 0;
dl[0] = j;
for (int k = (2); k <= (l[i][j]); k++) dl[++T] = p[i][j][k], L++;
for (; S <= T; S++) {
if (L > 2 * n) break;
int X = dl[S - 1], Y = dl[S];
if (l[X][Y] == -1) {
u = 1;
break;
}
for (int k = (1); k <= (l[X][Y]); k++) dl[++T] = p[X][Y][k], L++;
}
if (u) continue;
if (L <= 2 * n) {
B[i].push_back(dl[T]);
Bw[i].push_back(L);
}
}
for (int le = (0); le <= (2 * n); le++)
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) {
int sz;
sz = R[j].size() - 1;
for (int k = (0); k <= (sz); k++)
upd(a[i][R[j][k]][le + Rw[j][k]], b[i][j][le]);
sz = A[j].size() - 1;
for (int k = (0); k <= (sz); k++)
upd(b[i][A[j][k]][le + Aw[j][k]], b[i][j][le]);
sz = B[j].size() - 1;
for (int k = (0); k <= (sz); k++)
upd(a[i][B[j][k]][le + Bw[j][k]], a[i][j][le]);
sz = G[j].size() - 1;
for (int k = (0); k <= (sz); k++)
upd(b[i][G[j][k]][le + 1], a[i][j][le]);
}
for (int l = (1); l <= (2 * n); l++) {
ans = 0;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) upd(ans, a[i][j][l]);
printf("%d\n", ans);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int A[4][4] = {{0, 0, 1, 1}, {1, 1, 0, 0}, {0, 0, 1, 1}, {1, 1, 0, 0}};
const int p = 1000000007;
int f[110][55][55][4];
int c[55][55][55];
int num[55][55];
bool a[55][55], b[55][55];
int len[10050], tail[10050], next[10050];
int s[400];
int head[55][4];
int n, m, tot;
void add(int x, int t, int y, int l) {
tot++;
tail[tot] = y;
len[tot] = l;
next[tot] = head[x][t];
head[x][t] = tot;
}
void add(int &x, int y) {
x += y;
if (x > p) x -= p;
}
void get(int x, int y, int z) {
int i, l, r, L, R;
L = 105;
R = 104;
for (i = 1; i <= num[x][y]; i++) {
R++;
s[R] = c[x][y][i];
if (i == z) {
l = R;
r = R + 1;
}
}
while (l > L) {
if (R - L > 2 * n) return;
if (!a[s[l - 1]][s[l]]) return;
for (i = num[s[l - 1]][s[l]]; i >= 1; i--) {
L--;
s[L] = c[s[l - 1]][s[l]][i];
}
l--;
}
while (r < R) {
if (R - L > 2 * n) return;
if (!a[s[r]][s[r + 1]]) return;
for (i = 1; i <= num[s[r]][s[r + 1]]; i++) {
R++;
s[R] = c[s[r]][s[r + 1]][i];
}
r++;
}
add(s[L], 0, s[R], R - L);
}
void findtail1(int x, int y) {
int i, l, r, L, R;
L = 105;
R = 104;
for (i = 1; i <= num[x][y]; i++) {
R++;
s[R] = c[x][y][i];
}
l = R;
r = R;
while (l > L) {
if (R - L > 2 * n) return;
if (!a[s[l - 1]][s[l]]) return;
for (i = num[s[l - 1]][s[l]]; i >= 1; i--) {
L--;
s[L] = c[s[l - 1]][s[l]][i];
}
l--;
}
add(s[L], 1, y, R - L + 1);
}
void findtail2(int x, int y) {
int i, l, r, L, R;
L = 105;
R = 104;
for (i = 1; i <= num[x][y]; i++) {
R++;
s[R] = c[x][y][i];
}
l = L;
r = L;
while (r < R) {
if (R - L > 2 * n) return;
if (!a[s[r]][s[r + 1]]) return;
for (i = 1; i <= num[s[r]][s[r + 1]]; i++) {
R++;
s[R] = c[s[r]][s[r + 1]][i];
}
r++;
}
add(x, 2, s[R], R - L + 1);
}
int main() {
int i, j, k, l, t0, t1, x, y, z, ans;
scanf("%d%d", &n, &m);
memset(b, false, sizeof(b));
memset(a, false, sizeof(a));
memset(head, 0, sizeof(head));
tot = 0;
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
a[x][y] = true;
num[x][y] = z;
for (k = 1; k <= z; k++) scanf("%d", &c[x][y][k]);
for (k = 1; k <= z - 1; k++)
if ((c[x][y][k] == x) && (c[x][y][k + 1] == y)) {
b[x][y] = true;
break;
}
if (z == 0) add(x, 3, y, 1);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
if (b[i][j])
for (k = 1; k <= num[i][j] - 1; k++)
if ((c[i][j][k] == i) && (c[i][j][k + 1] == j)) get(i, j, k);
if (num[i][j] && (c[i][j][num[i][j]] == i)) findtail1(i, j);
if (num[i][j] && (c[i][j][1] == j)) findtail2(i, j);
}
memset(f, 0, sizeof(f));
for (i = 1; i <= n; i++)
for (j = 0; j <= 1; j++) {
k = head[i][j];
while (k != 0) {
f[len[k]][i][tail[k]][j]++;
k = next[k];
}
}
for (i = 1; i <= 2 * n - 1; i++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++)
for (t0 = 0; t0 <= 3; t0++)
if (f[i][j][k][t0])
for (t1 = 0; t1 <= 3; t1++)
if (A[t0][t1]) {
l = head[k][t1];
while (l != 0) {
if (i + len[l] <= 2 * n)
add(f[i + len[l]][j][tail[l]][t1], f[i][j][k][t0]);
l = next[l];
}
}
for (i = 1; i <= 2 * n; i++) {
ans = 0;
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++) {
add(ans, f[i][j][k][0]);
add(ans, f[i][j][k][2]);
}
printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const int mod = 1e9 + 7;
int n, m, num, have[51][51], f[101][2][51];
vector<int> e[51][51], te[51][51], tmp, ans, trans[2][2][51][51];
inline void inc(int& x, int y) { x = x + y < mod ? x + y : x + y - mod; }
int dfs_0(int u, int len, vector<int>& E) {
if (len >= (int)(E).size()) return u * (len == (int)(E).size());
int v = E[len];
if (!have[v][u]) return 0;
E.insert(E.end(), te[u][v].begin(), te[u][v].end());
return dfs_0(v, len + 1, E);
}
int dfs_1(int u, int len, vector<int>& E) {
if (len >= (int)(E).size()) return u * (len == (int)(E).size());
int v = E[len];
if (!have[u][v]) return 0;
E.insert(E.end(), e[u][v].begin(), e[u][v].end());
return dfs_1(v, len + 1, E);
}
void get_00() {
for (int i = (1), _ed = (n); i <= _ed; ++i)
for (int j = (1), _ed = (n); j <= _ed; ++j)
if ((int)(e[i][j]).size() && e[i][j].back() == i) {
tmp.clear();
tmp.insert(tmp.end(), te[j][i].begin(), te[j][i].end());
int s = dfs_0(i, 1, tmp);
if (s) trans[0][0][s][j].push_back((int)(tmp).size());
}
}
void get_01() {
static vector<int> res;
for (int i = (1), _ed = (n); i <= _ed; ++i)
for (int j = (1), _ed = (n); j <= _ed; ++j)
if ((int)(e[i][j]).size() > 1) {
int a = -1;
while (a < (int)(e[i][j]).size() - 1) {
for (++a; a < (int)(e[i][j]).size() - 1; ++a)
if (e[i][j][a] == i && e[i][j][a + 1] == j) break;
if (a >= (int)(e[i][j]).size() - 1) break;
tmp.clear();
tmp.insert(tmp.end(), e[i][j].begin(), e[i][j].begin() + a + 1);
reverse(tmp.begin(), tmp.end());
int s = dfs_0(i, 1, tmp);
res = tmp, reverse(res.begin(), res.end());
tmp.clear();
tmp.insert(tmp.end(), e[i][j].begin() + a + 1, e[i][j].end());
int t = dfs_1(j, 1, tmp);
res.insert(res.end(), tmp.begin(), tmp.end());
if (s && t) {
trans[0][1][s][t].push_back((int)(res).size() - 1);
if (!(int)(ans).size()) ans = res;
}
}
}
}
void get_10() {
for (int i = (1), _ed = (n); i <= _ed; ++i)
for (int j = (1), _ed = (n); j <= _ed; ++j)
if (have[i][j] && !(int)(e[i][j]).size()) trans[1][0][i][j].push_back(1);
}
void get_11() {
for (int i = (1), _ed = (n); i <= _ed; ++i)
for (int j = (1), _ed = (n); j <= _ed; ++j)
if ((int)(e[i][j]).size() && e[i][j][0] == j) {
tmp.clear();
tmp.insert(tmp.end(), e[i][j].begin(), e[i][j].end());
int s = dfs_1(j, 1, tmp);
if (s) trans[1][1][i][s].push_back((int)(tmp).size());
}
}
int main() {
n = read(), m = read();
for (int i = (1), _ed = (m); i <= _ed; ++i) {
int u = read(), v = read(), k = read();
have[u][v] = 1;
for (int i = (1), _ed = (k); i <= _ed; ++i) e[u][v].push_back(read());
te[v][u] = e[u][v];
reverse(te[v][u].begin(), te[v][u].end());
}
get_00(), get_01(), get_10(), get_11();
for (int i = (1), _ed = (n); i <= _ed; ++i) f[0][0][i] = 1;
for (int l = (0), _ed = (n + n - 1); l <= _ed; ++l)
for (int p = (0), _ed = (1); p <= _ed; ++p)
for (int u = (1), _ed = (n); u <= _ed; ++u)
if (f[l][p][u]) {
for (int q = (0), _ed = (1); q <= _ed; ++q)
for (int v = (1), _ed = (n); v <= _ed; ++v)
if ((int)(trans[p][q][u][v]).size())
for (int x : trans[p][q][u][v])
if (l + x <= n + n) inc(f[l + x][q][v], f[l][p][u]);
}
for (int l = (1), _ed = (n + n); l <= _ed; ++l) {
int ans = 0;
for (int i = (1), _ed = (n); i <= _ed; ++i) inc(ans, f[l][1][i]);
printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l[85][85], dp1[85][85][85 * 4], dp2[85][85][85 * 4];
vector<int> ken[85], yume[85][85];
vector<int> r[85], rw[85], a[85], aw[85], b[85], bw[85];
int main() {
cin >> n >> m;
memset(l, -1, sizeof l);
for (int x, y, t, i = 1; i <= m; ++i) {
cin >> x >> y, cin >> l[x][y];
if (l[x][y] == 0) ken[x].push_back(y);
for (int j = 1; j <= l[x][y]; ++j) cin >> t, yume[x][y].push_back(t);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
int pos = -1;
for (int k = 0; k < l[i][j] - 1; ++k)
if (yume[i][j][k] == i && yume[i][j][k + 1] == j) pos = k;
if (pos == -1) continue;
deque<int> q;
int len = 0;
for (int k = pos; k >= 0; --k) q.push_back(yume[i][j][k]), ++len;
while (q.size() > 1) {
if (len > 2 * n) {
pos = -1;
break;
}
if (l[q[1]][q[0]] == -1) {
pos = -1;
break;
}
for (int k = l[q[1]][q[0]] - 1; k >= 0; --k)
q.push_back(yume[q[1]][q[0]][k]), ++len;
q.pop_front();
}
if (pos == -1) continue;
int op = q[0];
while (!q.empty()) q.pop_back();
for (int k = pos + 1; k < l[i][j]; ++k) q.push_back(yume[i][j][k]), ++len;
while (q.size() > 1) {
if (len > 2 * n) {
pos = -1;
break;
}
if (l[q[0]][q[1]] == -1) {
pos = -1;
break;
}
for (int k = 0; k < l[q[0]][q[1]]; ++k)
q.push_back(yume[q[0]][q[1]][k]), ++len;
q.pop_front();
}
if (pos == -1) continue;
r[op].push_back(q[0]), rw[op].push_back(len - 1);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (l[i][j] > 0 && yume[i][j].back() == i) {
int pos = 0;
deque<int> q;
int len = 0;
for (int k = l[i][j] - 1; k >= 0; --k)
q.push_back(yume[i][j][k]), ++len;
while (q.size() > 1) {
if (len > 2 * n) {
pos = -1;
break;
}
if (l[q[1]][q[0]] == -1) {
pos = -1;
break;
}
for (int k = l[q[1]][q[0]] - 1; k >= 0; --k)
q.push_back(yume[q[1]][q[0]][k]), ++len;
q.pop_front();
}
if (pos == -1) continue;
a[q[0]].push_back(j), aw[q[0]].push_back(len);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (l[i][j] > 0 && yume[i][j][0] == j) {
int pos = 0;
deque<int> q;
int len = 0;
for (int k = 0; k < l[i][j]; ++k) q.push_back(yume[i][j][k]), ++len;
while (q.size() > 1) {
if (len > 2 * n) {
pos = -1;
break;
}
if (l[q[0]][q[1]] == -1) {
pos = -1;
break;
}
for (int k = 0; k < l[q[0]][q[1]]; ++k)
q.push_back(yume[q[0]][q[1]][k]), ++len;
q.pop_front();
}
if (pos == -1) continue;
b[i].push_back(q[0]), bw[i].push_back(len);
}
for (int i = 1; i <= n; ++i) dp2[i][i][0] = 1;
for (int len = 0; len <= n * 2; ++len) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
for (int k = 0; k < (int)r[j].size(); ++k)
(dp1[i][r[j][k]][len + rw[j][k]] += dp2[i][j][len]) %= 1000000007;
for (int k = 0; k < (int)a[j].size(); ++k)
(dp2[i][a[j][k]][len + aw[j][k]] += dp2[i][j][len]) %= 1000000007;
for (int k = 0; k < (int)b[j].size(); ++k)
(dp1[i][b[j][k]][len + bw[j][k]] += dp1[i][j][len]) %= 1000000007;
for (int k = 0; k < (int)ken[j].size(); ++k)
(dp2[i][ken[j][k]][len + 1] += dp1[i][j][len]) %= 1000000007;
}
}
for (int len = 1; len <= n * 2; ++len) {
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) (ans += dp1[i][j][len]) %= 1000000007;
cout << ans << endl;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
inline int Get() {
char ch;
while ((ch = getchar()) < '0' || ch > '9')
;
int Num = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9')
Num = (Num << 3) + (Num << 1) + ch - '0';
return Num;
}
const int N = 105;
const int M = 2505;
const int mod = 1e9 + 7;
int n, m, w[N][N], que[N];
int tx[M], ty[M], seq[M][N], g[2][2][N][N][N], dp[N][N][2];
int main() {
n = Get(), m = Get();
for (int i = 1; i <= m; ++i) {
tx[i] = Get(), ty[i] = Get(), w[tx[i]][ty[i]] = i;
seq[i][0] = Get();
for (int k = 1; k <= seq[i][0]; ++k) seq[i][k] = Get();
if (!seq[i][0]) g[0][0][tx[i]][ty[i]][1] = 1;
}
for (int id = 1, nxt; id <= m; ++id)
for (int j = 1; j <= seq[id][0]; ++j) {
if (seq[id][j] == tx[id]) {
int ql = 1, qr = 0;
for (int i = j; i; --i) que[++qr] = seq[id][i];
for (int i = que[ql]; ql != qr; i = que[++ql]) {
if (!(nxt = w[que[ql + 1]][i])) goto GG;
for (int k = seq[nxt][0]; k; --k) que[++qr] = seq[nxt][k];
if (qr > (n << 1)) goto GG;
}
std ::reverse(que + 1, que + qr + 1);
if (j == seq[id][0])
++g[1][0][que[1]][ty[id]][qr];
else {
if (seq[id][j + 1] != ty[id]) goto GG;
for (int i = j + 1; i <= seq[id][0]; ++i) que[++qr] = seq[id][i];
for (int i = que[++ql]; ql != qr; i = que[++ql]) {
if (!(nxt = w[i][que[ql + 1]])) goto GG;
for (int k = 1; k <= seq[nxt][0]; ++k) que[++qr] = seq[nxt][k];
if (qr - 1 > (n << 1)) goto GG;
}
++g[1][1][que[1]][que[qr]][qr - 1];
}
} else if (j == 1 && seq[id][1] == ty[id]) {
int ql = 1, qr = 0;
for (int i = j; i <= seq[id][0]; ++i) que[++qr] = seq[id][i];
for (int i = que[ql]; ql != qr; i = que[++ql]) {
if (!(nxt = w[i][que[ql + 1]])) goto GG;
for (int k = 1; k <= seq[nxt][0]; ++k) que[++qr] = seq[nxt][k];
if (qr > (n << 1)) goto GG;
}
++g[0][1][tx[id]][que[qr]][qr];
}
GG:;
}
for (int i = 1; i <= n; ++i) dp[0][i][0] = 1;
for (int i = 0; i < n * 2; ++i)
for (int u = 1; u <= n; ++u)
for (int a = 0; a < 2; ++a)
if (dp[i][u][a])
for (int j = 1; i + j <= n * 2; ++j)
for (int v = 1; v <= n; ++v)
for (int b = 0; b < 2; ++b)
if (g[!a][b][u][v][j])
dp[i + j][v][b] =
((long long)dp[i][u][a] * g[!a][b][u][v][j] +
dp[i + j][v][b]) %
mod;
for (int i = 1; i <= n * 2; ++i) {
int ans = 0;
for (int u = 1; u <= n; ++u) ans = (ans + dp[i][u][1]) % mod;
printf("%d\n", ans);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int N = 55, P = 1000000007;
int n, m, lim;
bool ex[N][N];
std::vector<int> a[N][N];
int f[2 * N][2][N];
std::vector<int> trans[2][2][N][N];
bool extend_front(std::deque<int> &Q, std::deque<int>::iterator it) {
while (it != Q.begin() && (int)Q.size() <= lim) {
auto nit = it - 1;
if (!ex[*nit][*it] || (int)(Q.size() + a[*nit][*it].size()) > lim) {
return false;
}
Q.insert(Q.begin(), a[*nit][*it].begin(), a[*nit][*it].end());
it = nit;
}
return (int)Q.size() <= lim;
}
bool extend_back(std::deque<int> &Q, std::deque<int>::iterator it) {
while (it + 1 != Q.end() && (int)Q.size() <= lim) {
auto nit = it + 1;
if (!ex[*it][*nit] || (int)(Q.size() + a[*it][*nit].size()) > lim) {
return false;
}
Q.insert(Q.end(), a[*it][*nit].begin(), a[*it][*nit].end());
it = nit;
}
return (int)Q.size() <= lim;
}
void init() {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (ex[i][j] && !a[i][j].empty() && a[i][j].back() == i) {
std::deque<int> Q(a[i][j].begin(), a[i][j].end());
if (extend_front(Q, --Q.end())) {
trans[0][0][Q.front()][j].push_back(Q.size());
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (ex[i][j] && !a[i][j].empty() && a[i][j].front() == j) {
std::deque<int> Q(a[i][j].begin(), a[i][j].end());
if (extend_back(Q, Q.begin())) {
trans[1][1][i][Q.back()].push_back(Q.size());
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (ex[i][j] && !a[i][j].empty()) {
std::deque<int> Q(a[i][j].begin(), a[i][j].end());
auto p = std::find(Q.begin(), Q.end(), i);
if (p != Q.end() && (p + 1) != Q.end() && *(p + 1) == j) {
if (extend_front(Q, p) && extend_back(Q, p + 1)) {
trans[0][1][Q.front()][Q.back()].push_back(Q.size() - 1);
}
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (ex[i][j] && a[i][j].empty()) {
trans[1][0][i][j].push_back(1);
}
}
}
}
void inc(int &a, int b) { a + b >= P ? a += b - P : a += b; }
void DP() {
for (int i = 1; i <= n; ++i) {
f[0][0][i] = 1;
}
for (int len = 0; len < 2 * n; ++len) {
for (int p = 0; p < 2; ++p) {
for (int i = 1; i <= n; ++i) {
if (f[len][p][i]) {
for (int q = 0; q < 2; ++q) {
for (int j = 1; j <= n; ++j) {
for (int t : trans[p][q][i][j]) {
if (len + t <= 2 * n) {
inc(f[len + t][q][j], f[len][p][i]);
}
}
}
}
}
}
}
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> m;
lim = 2 * n + 1;
for (int i = 1; i <= m; ++i) {
int u, v, k;
std::cin >> u >> v >> k;
ex[u][v] = true;
a[u][v].resize(k);
for (int &id : a[u][v]) {
std::cin >> id;
}
}
init();
DP();
for (int len = 1; len <= 2 * n; ++len) {
int ans = 0;
for (int i = 1; i <= n; ++i) {
inc(ans, f[len][1][i]);
}
std::cout << ans << "\n";
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
int n, m, num[110][110], v[110];
int top, s[21000];
vector<int> vec[21000];
struct node {
int x, y, k;
} a[21000];
char Getchar() {
static char now[1 << 20], *S, *T;
if (T == S) {
T = (S = now) + fread(now, 1, 1 << 20, stdin);
if (T == S) return EOF;
}
return *S++;
}
int read() {
int x = 0, f = 1;
char ch = Getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = Getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = Getchar();
return x * f;
}
pair<int, int> get_path(int x, bool rev) {
int now = 0, y, e;
for (int i = 1; i <= top && top <= 2 * n; i++) {
y = s[i];
e = num[x][y];
if (!e || (rev && e <= m) || (!rev && e > m))
return pair<int, int>(2 * n + 1, 2 * n + 1);
for (int j = 0; j < (int)vec[e].size(); j++) s[++top] = vec[e][j];
x = y;
now++;
}
return pair<int, int>(top, x);
}
int dp1[2][2][55][55][110], dp2[110][55][2];
int f[55][55][110], g[55][55][110];
void work(bool rev) {
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
for (int i = 1; i <= m * 2; i++) {
if (rev && i <= m || !rev && i > m) continue;
for (int j = 0; j < (int)vec[i].size(); j++)
if (vec[i][j] == a[i].x) {
top = 0;
for (int k = j - 1; k >= 0; k--) s[++top] = vec[i][k];
pair<int, int> res = get_path(a[i].x, !rev);
if (res.first + 1 > 2 * n) continue;
if (j + 1 == (int)vec[i].size())
g[res.second][a[i].y][res.first + 1]++;
else {
if (vec[i][j + 1] != a[i].y) continue;
top = 0;
for (int k = j + 2; k < (int)vec[i].size(); k++) s[++top] = vec[i][k];
pair<int, int> res2 = get_path(a[i].y, rev);
if (res2.first + 1 + res.first <= 2 * n)
f[res.second][res2.second][res2.first + 1 + res.first]++;
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
int x, y, k;
for (int i = 1; i <= m; i++) {
x = read();
y = read();
k = read();
for (int j = 1; j <= k; j++) v[j] = read();
a[i].x = x;
a[i].y = y;
a[i].k = k;
num[x][y] = i;
for (int j = 1; j <= k; j++) vec[i].push_back(v[j]);
a[i + m].x = y;
a[i + m].y = x;
a[i + m].k = k;
num[y][x] = i + m;
for (int j = 1; j <= k; j++) vec[i + m].push_back(v[k - j + 1]);
if (!k) dp1[0][0][x][y][1]++;
}
work(false);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) {
dp1[1][1][i][j][k] = f[i][j][k];
dp1[1][0][i][j][k] = g[i][j][k];
}
work(true);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) dp1[0][1][i][j][k] = g[j][i][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) {
dp2[k][j][0] = (dp2[k][j][0] + dp1[1][0][i][j][k]) % Mod;
dp2[k][j][1] = (dp2[k][j][1] + dp1[1][1][i][j][k]) % Mod;
}
for (int p = 1; p <= n * 2; p++) {
int res = 0;
for (int i = 1; i <= n; i++) {
res = (res + dp2[p][i][1]) % Mod;
for (int m = 0; m <= 1; m++)
if (dp2[p][i][m]) {
for (int s = 0; s <= 1; s++)
for (int x = 1; x <= n; x++)
for (int q = 1; q <= n * 2 - p; q++)
dp2[p + q][x][s] =
(dp2[p + q][x][s] +
1ll * dp2[p][i][m] * dp1[m ^ 1][s][i][x][q]) %
Mod;
}
}
printf("%d\n", res);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const double pi = acos(-1);
int n, m;
int trans[2][2][55][55][2 * 55], f[2 * 55][55][2];
int E[55][55], A[55][55][2 * 55], B[55][55][2 * 55], X[55 * 55], Y[55 * 55];
vector<int> V[55 * 55];
void Plus(int &x, int y) {
x += y;
if (x >= mo) x -= mo;
}
pair<int, int> Get_chain(vector<int> t, int x, bool flag) {
int i = 0;
while (i + 1 <= t.size()) {
int y = t[i], p = E[x][y];
if (!p || t.size() > 2 * n || (p > m) != flag)
return make_pair(1 << 20, -1);
for (int j = 0; j < V[p].size(); ++j) t.push_back(V[p][j]);
x = y;
i++;
}
return make_pair(t.size(), x);
}
void work(bool flag) {
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int i = 1; i <= 2 * m; ++i)
if ((i > m) == flag) {
int j;
for (j = 0; j < V[i].size(); ++j)
if (V[i][j] == X[i]) break;
if (j >= V[i].size()) continue;
vector<int> t1, t2;
for (int k = j - 1; k >= 0; --k) t1.push_back(V[i][k]);
pair<int, int> tmp1 = Get_chain(t1, X[i], flag ^ 1);
if (tmp1.first > 2 * n) continue;
if (j + 1 == V[i].size()) {
B[tmp1.second][Y[i]][tmp1.first + 1]++;
} else {
if (V[i][j + 1] != Y[i]) continue;
for (int k = j + 2; k < V[i].size(); ++k) t2.push_back(V[i][k]);
pair<int, int> tmp2 = Get_chain(t2, Y[i], flag);
if (tmp1.first + tmp2.first + 1 <= 2 * n)
A[tmp1.second][tmp2.second][tmp1.first + tmp2.first + 1]++;
}
}
}
void solve() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= 2 * n; ++k) {
Plus(f[k][j][0], trans[1][0][i][j][k]);
Plus(f[k][j][1], trans[1][1][i][j][k]);
}
for (int k = 1; k <= 2 * n; ++k) {
int ans = 0;
for (int i = 1; i <= n; ++i) {
Plus(ans, f[k][i][1]);
for (int j = 0; j <= 1; ++j)
if (f[k][i][j]) {
for (int v = 0; v <= 1; ++v) {
for (int x = 1; x <= n; ++x)
for (int len = 1; len <= 2 * n - k; ++len)
if (trans[j ^ 1][v][i][x][len])
Plus(f[k + len][x][v],
1ll * f[k][i][j] * trans[j ^ 1][v][i][x][len] % mo);
}
}
}
printf("%d\n", ans);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &X[i], &Y[i]);
E[X[i]][Y[i]] = i;
int x, k;
scanf("%d", &k);
for (int j = 1; j <= k; ++j) {
scanf("%d", &x);
V[i].push_back(x);
}
if (!k) trans[0][0][X[i]][Y[i]][1]++;
X[i + m] = Y[i];
Y[i + m] = X[i];
E[Y[i]][X[i]] = i + m;
V[i + m] = V[i];
reverse(V[i + m].begin(), V[i + m].end());
}
work(0);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= 2 * n; ++k) {
trans[1][1][i][j][k] = A[i][j][k];
trans[1][0][i][j][k] = B[i][j][k];
}
work(1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= 2 * n; ++k) {
assert(trans[1][1][j][i][k] == A[i][j][k]);
trans[0][1][j][i][k] = B[i][j][k];
}
solve();
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m, f[2 * 55][2 * 55];
bool g[55][55];
vector<int> G[55][55], Path;
vector<pair<int, int>> tr[2 * 55][2 * 55];
int find_cross(vector<int>& a, int x, int y) {
for (int i = 0, lim = a.size(); i < lim - 1; i++)
if (a[i] == x && a[i + 1] == y) return i;
return -1;
}
int walk(vector<int>& a, int x, bool rev) {
for (int i = 0; a.size() < 2 * n && i < a.size(); x = a[i], i++) {
if ((!rev && !g[x][a[i]]) || (rev && !g[a[i]][x])) return -1;
if (!rev)
a.insert(a.end(), G[x][a[i]].begin(), G[x][a[i]].end());
else
a.insert(a.end(), G[a[i]][x].rbegin(), G[a[i]][x].rend());
}
if (a.size() >= 2 * n) return -1;
return x;
}
void add_trans(int x, int y, int len) {
for (int i = 0; i + len <= 2 * n; i++)
tr[i][x].push_back(make_pair(i + len, y));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y, k, t; i <= m; i++) {
scanf("%d%d%d", &x, &y, &k), g[x][y] = 1;
while (k--) scanf("%d", &t), G[x][y].push_back(t);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (g[i][j]) {
int pos;
if (~(pos = find_cross(G[i][j], i, j))) {
vector<int> L(G[i][j].begin(), G[i][j].begin() + pos);
reverse(L.begin(), L.end());
int pL = walk(L, i, 1);
if (~pL) {
vector<int> R(G[i][j].begin() + pos + 2, G[i][j].end());
int pR = walk(R, j, 0);
if (~pR && L.size() + R.size() + 1 <= 2 * n) {
if (Path.empty()) {
Path.insert(Path.end(), L.rbegin(), L.rend());
Path.push_back(i), Path.push_back(j);
Path.insert(Path.end(), R.begin(), R.end());
}
add_trans(pL, pR + n, L.size() + R.size() + 1);
}
}
}
if (G[i][j].empty())
add_trans(i + n, j, 1);
else {
if (G[i][j].front() == j) {
vector<int> R(G[i][j].begin() + 1, G[i][j].end());
int pR = walk(R, j, 0);
if (~pR) add_trans(i + n, pR + n, R.size() + 1);
}
if (G[i][j].back() == i) {
vector<int> L(G[i][j].rbegin() + 1, G[i][j].rend());
int pL = walk(L, i, 1);
if (~pL) add_trans(pL, j, L.size() + 1);
}
}
}
for (int i = 1; i <= n; i++) f[0][i] = 1;
for (int l = 0; l <= 2 * n; l++)
for (int i = 1; i <= 2 * n; i++)
if (f[l][i])
for (auto w : tr[l][i]) (f[w.first][w.second] += f[l][i]) %= mod;
for (int l = 1; l <= 2 * n; l++) {
int s = 0;
for (int i = 1; i <= n; i++) (s += f[l][i + n]) %= mod;
printf("%d\n", s);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, a[55][55];
vector<int> w[55][55];
int extend(deque<int> &q, deque<int>::iterator it, int opt) {
int flag = 1;
if (opt == 1)
for (deque<int>::iterator nxt = next(it);
nxt != q.end() && q.size() <= 2 * n; it = nxt, nxt = next(it))
flag &= a[*it][*nxt],
q.insert(q.end(), w[*it][*nxt].begin(), w[*it][*nxt].end());
else
for (deque<int>::iterator pre = prev(it);
it != q.begin() && q.size() <= 2 * n; it = pre, pre = prev(it))
flag &= a[*pre][*it],
q.insert(q.begin(), w[*pre][*it].begin(), w[*pre][*it].end());
return flag && (q.size() <= 2 * n);
}
int f[2][55][205];
vector<int> trans[2][2][55][55];
void solve() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (w[i][j].size() && w[i][j][w[i][j].size() - 1] == i) {
deque<int>::iterator it;
deque<int> q(w[i][j].begin(), w[i][j].end());
it = prev(q.end());
if (extend(q, it, -1)) trans[0][0][q.front()][j].push_back(q.size());
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
vector<int>::iterator it = find(w[i][j].begin(), w[i][j].end(), i);
if (it == w[i][j].end() || (++it) == w[i][j].end() || *it != j) continue;
deque<int> q(w[i][j].begin(), w[i][j].end());
deque<int>::iterator it2 = q.begin() + (it - w[i][j].begin()) - 1;
if (extend(q, it2, -1) && extend(q, it2 + 1, 1))
trans[0][1][q.front()][q.back()].push_back(q.size() - 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] && !w[i][j].size()) trans[1][0][i][j].push_back(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (w[i][j].size() && w[i][j][0] == j) {
deque<int> q(w[i][j].begin(), w[i][j].end());
if (extend(q, q.begin(), 1))
trans[1][1][i][q.back()].push_back(q.size());
}
}
int Add(int x) { return (x >= 1000000007) ? x - 1000000007 : x; }
signed main() {
n = Read(), m = Read();
for (int i = 1; i <= m; i++) {
int x = Read(), y = Read(), k = Read();
a[x][y] = 1;
w[x][y].resize(k);
for (int j = 0; j < k; j++) w[x][y][j] = Read();
}
solve();
for (int i = 1; i <= n; i++) f[0][i][0] = 1;
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < 2; j++)
for (int k = 1; k <= n; k++)
if (f[j][k][i])
for (int p = 0; p < 2; p++)
for (int q = 1; q <= n; q++)
for (int l = 0; l < trans[j][p][k][q].size(); l++)
f[p][q][i + trans[j][p][k][q][l]] =
Add(f[p][q][i + trans[j][p][k][q][l]] + f[j][k][i]);
for (int i = 1; i <= n * 2; i++) {
int sum = 0;
for (int j = 1; j <= n; j++) sum = Add(sum + f[1][j][i]);
cout << sum << endl;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, m, a[105 * 105], b[105 * 105], c[105 * 105][105], g1[105][105],
g2[105][105], cnt[105][105][105], dp[105][105], len[105 * 105];
queue<int> q;
vector<int> a1, a2;
bool flag;
void upd(int &x, long long y) { x = (x + y) % mod; }
void solve(int t, int k) {
int L = 0;
q = queue<int>();
for (int i = k + 1; i <= len[t]; ++i) {
q.push(c[t][i]);
if (++L > n * 2 + 1) return;
}
int x = 0, y = 0;
a1.clear();
int u = b[t];
if (q.empty()) {
x = u * 2 + 1;
} else {
if (q.front() != u) return;
q.pop();
while (1) {
a1.push_back(u);
if (q.empty()) {
x = u * 2;
break;
}
int v = q.front();
q.pop();
int i = g1[u][v];
if (!i) return;
for (int j = 1; j <= len[i]; ++j) {
q.push(c[i][j]);
if (++L > n * 2 + 1) return;
}
u = v;
}
}
q = queue<int>();
for (int i = k; i; --i) {
q.push(c[t][i]);
if (++L > n * 2 + 1) return;
}
a2.clear();
u = a[t];
if (q.empty()) {
y = u * 2 + 1;
} else {
if (q.front() != u) return;
q.pop();
for (int u = a[t];;) {
a2.push_back(u);
if (q.empty()) {
y = u * 2;
break;
}
int v = q.front();
q.pop();
int i = g2[u][v];
if (!i) return;
for (int j = len[i]; j; --j) {
q.push(c[i][j]);
if (++L > n * 2 + 1) return;
}
u = v;
}
}
++cnt[y][x][L];
if (x % 2 == 0 && y % 2 == 0 && !flag) {
flag = 1;
printf("%d\n", L);
reverse(a2.begin(), a2.end());
for (size_t i = 0; i < a2.size(); ++i) {
printf("%d ", a2[i]);
}
for (size_t i = 0; i < a1.size(); ++i) {
printf("%d ", a1[i]);
}
puts("");
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", a + i, b + i, len + i);
g1[a[i]][b[i]] = i;
g2[b[i]][a[i]] = i;
for (int j = 1; j <= len[i]; ++j) {
int x;
scanf("%d", &x);
c[i][j] = x;
}
}
flag = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= len[i]; ++j) {
solve(i, j);
}
}
if (!flag) {
puts("0");
puts("");
}
for (int i = 1; i <= n; ++i) {
dp[0][i * 2 + 1] = 1;
}
for (int i = 0; i <= n * 2 + 1; ++i) {
for (int k = 0; i + k <= n * 2 + 1; ++k) {
for (int j = 1; j <= n * 2 + 1; ++j) {
if (!dp[i][j]) continue;
for (int l = 1; l <= n * 2 + 1; ++l) {
upd(dp[i + k][l], (long long)dp[i][j] * cnt[j ^ 1][l][k]);
}
}
}
}
for (int i = 2; i <= n * 2 + 1; ++i) {
int ans = 0;
for (int j = 2; j <= n * 2; j += 2) upd(ans, dp[i][j]);
printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
const int mod = 1e9 + 7;
int n, m, ql, qr;
int que[maxn * 2];
int cntl[maxn][maxn][maxn * 2], cntr[maxn][maxn][maxn * 2],
cntm[maxn][maxn][maxn * 2], cnte[maxn][maxn];
int dpe[maxn][maxn * 2], dpl[maxn][maxn * 2], dpr[maxn][maxn * 2],
dpm[maxn][maxn * 2];
bool ext[maxn][maxn];
vector<int> val[maxn][maxn];
pair<int, int> expandL(int s) {
int cnt = 0;
while (ql < qr) {
int x = que[ql++];
cnt++;
if (cnt > 2 * n || !ext[x][s]) return make_pair(-1, 2 * n + 1);
for (int i = int(val[x][s].size()) - 1; i >= 0; i--)
que[qr++] = val[x][s][i];
s = x;
}
return make_pair(s, cnt);
}
pair<int, int> expandR(int s) {
int cnt = 0;
while (ql < qr) {
int x = que[ql++];
cnt++;
if (cnt > 2 * n || !ext[s][x]) return make_pair(-1, 2 * n + 1);
for (int i = 0; i < int(val[s][x].size()); i++) que[qr++] = val[s][x][i];
s = x;
}
return make_pair(s, cnt);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y, k, v;
scanf("%d%d%d", &x, &y, &k);
x--;
y--;
ext[x][y] = true;
while (k--) {
scanf("%d", &v);
v--;
val[x][y].push_back(v);
}
if (val[x][y].empty()) cnte[x][y]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (ext[i][j] && int(val[i][j].size()) <= 2 * n) {
for (int p = 0; p + 1 < int(val[i][j].size()); p++)
if (val[i][j][p] == i && val[i][j][p + 1] == j) {
ql = qr = 0;
for (int q = p - 1; q >= 0; q--) que[qr++] = val[i][j][q];
pair<int, int> vl = expandL(i);
ql = qr = 0;
for (int q = p + 2; q < int(val[i][j].size()); q++)
que[qr++] = val[i][j][q];
pair<int, int> vr = expandR(j);
if (vl.second + vr.second + 1 <= 2 * n)
cntm[vl.first][vr.first][vl.second + vr.second + 1]++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (ext[i][j] && !val[i][j].empty() && val[i][j][0] == j) {
ql = qr = 0;
for (int p = 1; p < int(val[i][j].size()); p++)
que[qr++] = val[i][j][p];
pair<int, int> vr = expandR(j);
if (vr.second + 1 <= 2 * n) cntr[i][vr.first][vr.second + 1]++;
}
for (int j = 0; j < n; j++)
if (ext[j][i] && !val[j][i].empty() && val[j][i].back() == j) {
ql = qr = 0;
for (int p = int(val[j][i].size()) - 2; p >= 0; p--)
que[qr++] = val[j][i][p];
pair<int, int> vl = expandL(j);
if (vl.second + 1 <= 2 * n) cntl[vl.first][i][vl.second + 1]++;
}
}
for (int t = 0; t <= 2 * n; t++) {
if (t == 0) {
for (int i = 0; i < n; i++) dpl[i][t] = 1;
} else {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dpe[i][t] = (dpe[i][t] + 1LL * dpr[j][t - 1] * cnte[j][i]) % mod;
for (int i = 0; i < n; i++) {
dpl[i][t] = dpe[i][t];
for (int j = 0; j < n; j++)
for (int k = 1; k <= t; k++)
dpl[i][t] = (dpl[i][t] + 1LL * dpl[j][t - k] * cntl[j][i][k]) % mod;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 1; k <= t; k++)
dpm[i][t] = (dpm[i][t] + 1LL * dpl[j][t - k] * cntm[j][i][k]) % mod;
for (int i = 0; i < n; i++) {
dpr[i][t] = dpm[i][t];
for (int j = 0; j < n; j++)
for (int k = 1; k <= t; k++)
dpr[i][t] = (dpr[i][t] + 1LL * dpr[j][t - k] * cntr[j][i][k]) % mod;
}
}
int ans = 0;
for (int i = 0; i < n; i++) ans = (ans + dpr[i][t]) % mod;
if (t) printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 55, mod = 1e9 + 7;
int trans(int &x, int v) {
x += v;
return x >= mod ? x -= mod : x;
}
bool G[MaxN][MaxN];
int f[MaxN << 1][MaxN], g[MaxN << 1][MaxN][MaxN], s[MaxN << 1][MaxN][MaxN];
vector<int> edge[MaxN][MaxN];
vector<pair<int, int> > path[MaxN], ph[MaxN], pt[MaxN];
int n, m;
bool go_tail(vector<int> &vt) {
for (unsigned int i = 0; i + 1 < vt.size(); ++i) {
int x = vt[i], y = vt[i + 1];
if (!G[x][y]) return 0;
for (auto j : edge[x][y]) vt.push_back(j);
if ((int)vt.size() > 2 * n) return 0;
}
return 1;
}
bool go_head(vector<int> &vh) {
reverse(vh.begin(), vh.end());
for (unsigned int i = 0; i + 1 < vh.size(); ++i) {
int x = vh[i], y = vh[i + 1];
if (!G[y][x]) return 0;
for (int k = edge[y][x].size() - 1; k >= 0; --k)
vh.push_back(edge[y][x][k]);
if ((int)vh.size() > 2 * n) return 0;
}
return 1;
}
void work_cross(int u, int v) {
vector<int> vt, vh;
bool flag;
flag = 0;
for (unsigned int k = 1; k < edge[u][v].size(); ++k) {
if (edge[u][v][k - 1] == u && edge[u][v][k] == v) flag = 1;
if (flag) vt.push_back(edge[u][v][k]);
}
if (!go_tail(vt)) return;
for (unsigned int k = 0; k + 1 < edge[u][v].size(); ++k) {
vh.push_back(edge[u][v][k]);
if (edge[u][v][k] == u && edge[u][v][k + 1] == v) break;
}
if (!go_head(vh)) return;
int sz = vh.size() + vt.size() - 1;
if (sz > 2 * n) return;
int s = *vh.rbegin(), t = *vt.rbegin();
path[s].push_back(make_pair(t, sz));
}
void work_tail(int u, int v) {
vector<int> vt = edge[u][v];
if (!go_tail(vt)) return;
int sz = vt.size();
if (sz > 2 * n) return;
pt[u].push_back(make_pair(*vt.rbegin(), sz));
}
void work_head(int u, int v) {
vector<int> vh = edge[u][v];
if (!go_head(vh)) return;
int sz = vh.size();
if (sz > 2 * n) return;
ph[*vh.rbegin()].push_back(make_pair(v, sz));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v, k;
scanf("%d%d%d", &u, &v, &k);
G[u][v] = 1;
vector<int> &vec = edge[u][v];
vec.resize(k);
for (int j = 0; j < k; ++j) scanf("%d", &vec[j]);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (G[i][j] && edge[i][j].size()) {
int cnt = 0;
for (unsigned int k = 1; k < edge[i][j].size(); ++k)
if (edge[i][j][k - 1] == i && edge[i][j][k] == j) ++cnt;
if (cnt == 1) work_cross(i, j);
if (*edge[i][j].begin() == j) work_tail(i, j);
if (*edge[i][j].rbegin() == i) work_head(i, j);
}
for (int i = 1; i <= n; ++i) g[0][i][i] = 1;
for (int l = 0; l < 2 * n; ++l)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (g[l][i][j])
for (auto k : ph[j])
if (l + k.second <= 2 * n)
trans(g[l + k.second][i][k.first], g[l][i][j]);
for (int l = 2 * n; l >= 0; --l) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (g[l][i][j])
for (auto k : path[j])
if (l + k.second <= 2 * n)
trans(g[l + k.second][i][k.first], g[l][i][j]);
memset(g[l], 0, sizeof(g[l]));
}
for (int l = 0; l < 2 * n; ++l)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (g[l][i][j])
for (auto k : pt[j])
if (l + k.second <= 2 * n)
trans(g[l + k.second][i][k.first], g[l][i][j]);
for (int l = 1; l <= 2 * n; ++l)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
trans(f[l][j], g[l][i][j]);
for (int k = 1; k <= n; ++k)
if (G[i][j] == 1 && !edge[i][j].size()) trans(s[l][i][k], g[l][j][k]);
}
for (int l = 0; l < 2 * n; ++l) {
for (int i = 1; i <= n; ++i)
if (f[l][i])
for (int t = 1; t + l + 1 <= 2 * n; ++t)
for (int k = 1; k <= n; ++k)
trans(f[l + t + 1][k], 1ll * f[l][i] * s[t][i][k] % mod);
}
for (int l = 1; l <= 2 * n; ++l) {
int ans = 0;
for (int i = 1; i <= n; ++i) trans(ans, f[l][i]);
printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55, M = N * N - 1, mod = 1e9 + 7;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
void ad(int &x, int y) { x += y, x -= x >= mod ? mod : 0; }
int n, m, a[M][N], e[M][2], ta[M], mp[N][N], d[N << 1], td, s1[N << 1], t1,
s2[N << 1], t2, f[N << 1][N][2];
int to[M << 1], nt[M << 1], hd[N], tot;
void adde(int x, int y) { ++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot; }
struct node {
int y, l;
};
vector<node> pa[N], pz[N], ps[N];
int main() {
n = rd(), m = rd();
int mk = n + n + n;
for (int i = 1; i <= m; ++i) {
e[i][0] = rd(), e[i][1] = rd();
adde(e[i][0], e[i][1]), mp[e[i][0]][e[i][1]] = i;
ta[i] = rd(), mk = min(mk, ta[i]);
for (int j = 1; j <= ta[i]; ++j) a[i][j] = rd();
}
bool ok = 0;
for (int i = 1; i <= m; ++i) {
int x = e[i][0], y = e[i][1];
int zl = 1, zr = ta[i];
while (zl <= ta[i] && a[i][zl] != x) ++zl;
while (zr >= 1 && a[i][zr] != y) --zr;
if (zl + 1 == zr) {
t1 = t2 = 0;
td = 0;
for (int j = zl; j; --j) d[++td] = a[i][j];
s1[++t1] = x;
while (t1 < td && t1 + t2 <= n + n + 1) {
++t1, s1[t1] = d[t1];
if (!mp[s1[t1]][s1[t1 - 1]]) {
t1 = -1;
break;
}
int k = mp[s1[t1]][s1[t1 - 1]];
for (int l = ta[k]; l; --l) d[++td] = a[k][l];
}
if (t1 < 0) continue;
td = 0;
for (int j = zr; j <= ta[i]; ++j) d[++td] = a[i][j];
s2[++t2] = y;
while (t2 < td && t1 + t2 <= n + n + 1) {
++t2, s2[t2] = d[t2];
if (!mp[s2[t2 - 1]][s2[t2]]) {
t2 = -1;
break;
}
int k = mp[s2[t2 - 1]][s2[t2]];
for (int l = 1; l <= ta[k]; ++l) d[++td] = a[k][l];
}
if (t2 < 0 || t1 + t2 > n + n + 1) continue;
x = s1[t1], y = s2[t2];
pa[x].push_back((node){y, t1 + t2});
}
}
for (int x = 1; x <= n; ++x)
for (int i = hd[x]; i; i = nt[i]) {
int y = to[i];
if (a[i][ta[i]] == x) {
t1 = td = 0;
for (int j = ta[i]; j; --j) d[++td] = a[i][j];
s1[++t1] = x;
while (t1 < td && t1 + 1 <= n + n + 1) {
++t1, s1[t1] = d[t1];
if (!mp[s1[t1]][s1[t1 - 1]]) {
t1 = -1;
break;
}
int k = mp[s1[t1]][s1[t1 - 1]];
for (int l = ta[k]; l; --l) d[++td] = a[k][l];
}
if (t1 < 0 || t1 + 1 >= n + n + 1) continue;
pz[s1[t1]].push_back((node){y, t1 + 1});
}
}
for (int x = 1; x <= n; ++x)
for (int i = hd[x]; i; i = nt[i]) {
int y = to[i];
if (a[i][1] == y) {
t1 = td = 0;
for (int j = 1; j <= ta[i]; ++j) d[++td] = a[i][j];
s1[++t1] = y;
while (t1 < td && t1 + 1 <= n + n + 1) {
++t1, s1[t1] = d[t1];
if (!mp[s1[t1 - 1]][s1[t1]]) {
t1 = -1;
break;
}
int k = mp[s1[t1 - 1]][s1[t1]];
for (int l = 1; l <= ta[k]; ++l) d[++td] = a[k][l];
}
if (t1 < 0 || t1 + 1 >= n + n + 1) continue;
ps[x].push_back((node){s1[t1], t1 + 1});
}
}
for (int i = 1; i <= n; ++i) f[1][i][0] = 1;
for (int i = 1; i <= n + n; ++i)
for (int x = 1; x <= n; ++x) {
int nn = pa[x].size();
for (int j = 0; j < nn; ++j) {
int y = pa[x][j].y, l = pa[x][j].l;
if (i + l - 1 <= n + n + 1) ad(f[i + l - 1][y][1], f[i][x][0]);
}
int mm = pz[x].size();
for (int j = 0; j < mm; ++j) {
int y = pz[x][j].y, l = pz[x][j].l;
if (i + l - 1 <= n + n + 1) ad(f[i + l - 1][y][0], f[i][x][0]);
}
int oo = ps[x].size();
for (int j = 0; j < oo; ++j) {
int y = ps[x][j].y, l = ps[x][j].l;
if (i + l - 1 <= n + n + 1) ad(f[i + l - 1][y][1], f[i][x][1]);
}
for (int j = hd[x]; j; j = nt[j]) {
int y = to[j];
if (!ta[j]) ad(f[i + 1][y][0], f[i][x][1]);
}
}
for (int i = 2; i <= n + n + 1; ++i) {
int an = 0;
for (int x = 1; x <= n; ++x) ad(an, f[i][x][1]);
printf("%d\n", an);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 2 + 10, MOD = (int)1e9 + 7;
int n, m, Tohka[MAXN], f[MAXN][2][MAXN];
bool g[MAXN][MAXN];
vector<int> e[MAXN][MAXN];
vector<pair<int, pair<int, int> > > a[4];
pair<int, int> Ext(vector<int> v, int ty) {
int p = 0, len = 0;
for (; p < ((int)(v).size()) - 1 && len <= n * 2 &&
((int)(v).size()) <= n * 2 + 1;
++len, ++p) {
int first = v[p], second = v[p + 1];
if (!ty) swap(first, second);
if (!g[first][second]) return make_pair(-1, 0);
vector<int> t = e[first][second];
if (!ty) reverse((t).begin(), (t).end());
v.insert(v.end(), (t).begin(), (t).end());
}
if (p == ((int)(v).size()) - 1 && len <= n * 2) return make_pair(len, v[p]);
return make_pair(-1, 0);
}
void Work(vector<int> &v, int first, int second) {
int p = 0;
for (; p < ((int)(v).size()) - 1; ++p)
if (v[p] == first && v[p + 1] == second) break;
if (p < ((int)(v).size()) - 1) {
vector<int> l, r;
l.insert(l.end(), v.begin(), v.begin() + p + 1);
reverse((l).begin(), (l).end());
r.insert(r.end(), v.begin() + p + 1, v.end());
pair<int, int> fl = Ext(l, 0), fr = Ext(r, 1);
if (fl.first == -1 || fr.first == -1) return;
a[3].push_back(
make_pair(fl.first + fr.first + 1, make_pair(fl.second, fr.second)));
return;
}
if (v[((int)(v).size()) - 1] == first) {
vector<int> w = v;
reverse((w).begin(), (w).end());
pair<int, int> fl = Ext(w, 0);
if (fl.first != -1)
a[2].push_back(make_pair(fl.first + 1, make_pair(fl.second, second)));
}
if (v[0] == second) {
vector<int> w = v;
pair<int, int> fr = Ext(w, 1);
if (fr.first != -1)
a[1].push_back(make_pair(fr.first + 1, make_pair(first, fr.second)));
}
}
void Plus(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
void Dp() {
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; ++i) f[0][0][i] = 1;
for (int i = 0; i <= n * 2; ++i) {
for (int k = 0; k < 2; ++k)
for (int p = 0; p <= 3; ++p)
if ((k ^ (p >> 1)) == 1)
for (int j = 0; j < ((int)(a[p]).size()); ++j) {
pair<int, pair<int, int> > t = a[p][j];
if (f[i][k][t.second.first] && i + t.first <= n * 2)
Plus(f[i + t.first][p & 1][t.second.second],
f[i][k][t.second.first]);
}
for (int j = 1; j <= n; ++j) {
Plus(Tohka[i], f[i][1][j]);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int first, second, k, z;
scanf("%d%d%d", &first, &second, &k);
g[first][second] = 1;
vector<int> v;
for (int j = 1; j <= k; ++j) scanf("%d", &z), v.push_back(z);
e[first][second] = v;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (((int)(e[i][j]).size()))
Work(e[i][j], i, j);
else if (g[i][j])
a[0].push_back(make_pair(1, make_pair(i, j)));
Dp();
for (int i = 1; i <= n * 2; ++i) printf("%d\n", Tohka[i]);
fclose(stdin);
fclose(stdout);
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105, mod = 1e9 + 7;
int n, m;
int head[N], ce, f[N][N][2], ok[N][N], ans[N];
bool flag;
struct edge {
int fr, to, nxt;
vector<int> w;
} e[N * N];
vector<int> pot, lans, rans, G[N][N];
struct point {
int p, v, q, len;
};
vector<point> trans[N];
bool stretch(int u, deque<int> need, int o) {
while (need.size()) {
int x = need.front();
need.pop_front();
o ? rans.push_back(x) : lans.push_back(x);
if ((int)rans.size() > 2 * n + 1 || (int)lans.size() > 2 * n + 1) return 0;
if ((o && !ok[u][x]) || (!o && !ok[x][u])) return 0;
if (o)
for (auto v : G[u][x]) need.push_back(v);
else
for (int j = (int)G[x][u].size() - 1; ~j; --j) need.push_back(G[x][u][j]);
u = x;
}
return 1;
}
void print() {
flag = 1;
printf("%d\n", (int)lans.size() + (int)rans.size());
for (int i = (int)lans.size() - 1; i >= 0; --i) printf("%d ", lans[i]);
for (int i = 0; i < rans.size(); ++i) printf("%d ", rans[i]);
puts("");
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v, K, x; i <= m; ++i) {
scanf("%d%d%d", &u, &v, &K);
pot.clear();
for (int j = 1; j <= K; ++j) scanf("%d", &x), pot.push_back(x);
e[++ce] = (edge){u, v, head[u], pot}, head[u] = ce, G[u][v] = pot,
ok[u][v] = 1;
}
for (int i = 1; i <= m; ++i) {
deque<int> ql, qr;
bool fl;
for (int j = 0; j < (int)e[i].w.size() - 1; ++j)
if (e[i].w[j] == e[i].fr && e[i].w[j + 1] == e[i].to) {
ql.clear(), lans.clear(), qr.clear(), rans.clear();
for (int k = 0; k < j; ++k) ql.push_front(e[i].w[k]);
lans.push_back(e[i].fr), fl = stretch(e[i].fr, ql, 0);
for (int k = (int)e[i].w.size() - 1; k > j + 1; --k)
qr.push_front(e[i].w[k]);
rans.push_back(e[i].to), fl &= stretch(e[i].to, qr, 1);
if (fl) {
trans[lans.back()].push_back((point){
1, rans.back(), 0, (int)lans.size() + (int)rans.size() - 1});
}
break;
}
if (!e[i].w.size()) trans[e[i].fr].push_back((point){0, e[i].to, 1, 1});
if (e[i].w.size() && e[i].w[0] == e[i].to) {
qr.clear(), rans.clear(), rans.push_back(e[i].to);
for (int j = 1; j < e[i].w.size(); ++j) qr.push_back(e[i].w[j]);
fl = stretch(e[i].to, qr, 1);
if (fl)
trans[e[i].fr].push_back((point){0, rans.back(), 0, (int)rans.size()});
}
if (e[i].w.size() && e[i].w.back() == e[i].fr) {
ql.clear(), lans.clear(), lans.push_back(e[i].fr);
for (int j = 0; j < (int)e[i].w.size() - 1; ++j) ql.push_front(e[i].w[j]);
fl = stretch(e[i].fr, ql, 0);
if (fl)
trans[lans.back()].push_back((point){1, e[i].to, 1, (int)lans.size()});
}
}
for (int i = 0; i <= n; ++i) f[0][i][1] = 1;
for (int i = 0; i < 2 * n; ++i) {
for (int j = 1; j <= n; ++j)
for (auto T : trans[j])
if (i + T.len <= 2 * n)
f[i + T.len][T.v][T.q] =
(f[i + T.len][T.v][T.q] + f[i][j][T.p]) % mod;
}
for (int i = 1; i <= 2 * n; ++i) {
for (int j = 1; j <= n; ++j) ans[i] = (ans[i] + f[i][j][0]) % mod;
printf("%d\n", ans[i]);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int Sn = 100;
const int mod = (int)1e9 + 7;
int n, m;
int G[Sn][Sn];
vector<int> V[Sn][Sn];
int T[Sn * 4], tT;
int Ms[Sn][Sn], Mo[Sn][Sn];
int bf[Sn][Sn][Sn * 2];
int dp[Sn][Sn * 2];
int suf[Sn][Sn * 2];
vector<pair<int, int> > trP[Sn];
int trC[Sn][Sn * Sn * 2];
int trN[Sn];
bool contain(int u, int v, int& pu, int& pv) {
int sz = V[u][v].size();
for (int l = 0; l <= sz - 2; l++)
if (V[u][v][l] == u && V[u][v][l + 1] == v) return pu = l, pv = l + 1, 1;
return 0;
}
int find(int d, int q, int wk) {
if (q == tT) return d;
if (tT > 2 * n + 1) return -1;
int k = T[q + 1], sz = V[d][k].size();
if (G[d][k] == wk) {
for (int l = 0; l <= sz - 1; l++) T[++tT] = V[d][k][l];
return find(k, q + 1, wk);
} else
return -1;
}
void add(int& a, int b) { a = (a + b) % mod; }
void transform(int i, int j, vector<pair<int, int> >& P, int C[]) {
int N = P.size();
for (int l = 0; l <= N - 1; l++)
if (j >= P[l].second)
add(dp[i][j],
(long long)C[l + 1] * suf[P[l].first][j - P[l].second] % mod);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v, sz, x; i <= m; i++) {
scanf("%d%d%d", &u, &v, &sz);
G[u][v] = 1, G[v][u] = -1;
for (int l = 1; l <= sz; l++) scanf("%d", &x), V[u][v].push_back(x);
for (int l = 1; l <= sz; l++) V[v][u].push_back(V[u][v][sz - l]);
}
for (int u = 1; u <= n; u++)
for (int v = 1; v <= n; v++)
if (G[u][v] == 1 && V[u][v].size()) {
int sz = V[u][v].size();
if (V[u][v][0] != v) continue;
tT = 0;
for (int l = 0; l <= sz - 1; l++) T[++tT] = V[u][v][l];
int vt = find(v, 1, 1);
if (vt != -1) Ms[u][v] = tT, Mo[u][v] = vt;
}
for (int i = 1; i <= n; i++) bf[i][i][0] = 1;
for (int j = 1; j <= 2 * n; j++) {
for (int i = 1; i <= n; i++)
for (int k = 1; k <= n; k++)
if (G[i][k] == -1 && V[i][k].size()) {
int sz = V[i][k].size();
if (V[i][k][0] != k) continue;
tT = 0;
for (int l = 0; l <= sz - 1; l++) T[++tT] = V[i][k][l];
int vt = find(k, 1, -1);
if (vt != -1 && j >= tT)
for (int o = 1; o <= n; o++) add(bf[i][o][j], bf[vt][o][j - tT]);
}
}
int pu, pv, ld, lx, rd, rx, sz;
for (int u = 1; u <= n; u++)
for (int v = 1; v <= n; v++) {
sz = V[u][v].size();
if (G[u][v] == 1 && contain(u, v, pu, pv)) {
tT = 0;
for (int l = pu; l >= 0; l--) T[++tT] = V[u][v][l];
ld = find(u, 1, -1), lx = tT - 1;
tT = 0;
for (int l = pv; l <= sz - 1; l++) T[++tT] = V[u][v][l];
rd = find(v, 1, 1), rx = tT - 1;
int len = lx + rx + 1;
if (ld == -1 || rd == -1 || len > 2 * n) continue;
int cc;
for (int i = 1; i <= n; i++)
for (int j0 = 0; j0 <= 2 * n - len; j0++)
if (cc = bf[ld][i][j0], cc) {
trP[i].push_back(make_pair(rd, j0 + len));
trC[i][++trN[i]] = cc;
}
}
}
for (int i = 1; i <= n; i++) suf[i][0] = 1;
for (int j = 1; j <= 2 * n; j++) {
for (int i = 1; i <= n; i++)
for (int k = 1; k <= n; k++)
if (Ms[i][k] && j >= Ms[i][k])
add(suf[i][j], suf[Mo[i][k]][j - Ms[i][k]]);
int ansj = 0;
for (int i = 1; i <= n; i++) {
transform(i, j, trP[i], trC[i]);
add(ansj, dp[i][j]);
for (int k = 1; k <= n; k++)
if (G[k][i] == 1 && !V[k][i].size()) add(suf[k][j + 1], dp[i][j]);
}
printf("%d\n", ansj);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
const int mod = 1e9 + 7;
int n, m, i, j, a, b, c, d, f[2][55][105], e[55][55];
vector<int> g[55][55];
vector<int> trs[2][2][55][55];
void init() {
int i, j, k;
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
for (((j)) = (1); ((j)) <= ((n)); ((j))++) {
if (e[i][j] && !g[i][j].empty() && g[i][j].back() == i) {
int cnt = 1, lst = i;
queue<int> qx;
for (k = ((int)g[i][j].size()) - 2; k >= 0; k--) {
qx.push(g[i][j][k]);
}
while (!qx.empty()) {
int x = qx.front();
qx.pop();
cnt++;
if (!e[x][lst] || cnt > n + n) {
cnt = -1;
break;
}
for (k = ((int)g[x][lst].size()) - 1; k >= 0; k--) {
qx.push(g[x][lst][k]);
}
lst = x;
}
if (cnt != -1) trs[0][0][lst][j].push_back(cnt);
}
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
for (((j)) = (1); ((j)) <= ((n)); ((j))++) {
if (e[i][j] && !g[i][j].empty() && g[i][j][0] == j) {
int cnt = 1, lst = j;
queue<int> qx;
for (k = 1; k < g[i][j].size(); k++) {
qx.push(g[i][j][k]);
}
while (!qx.empty()) {
int x = qx.front();
qx.pop();
cnt++;
if (!e[lst][x] || cnt > n + n) {
cnt = -1;
break;
}
for (((k)) = (0); ((k)) <= (((int)(g[lst][x].size())) - 1); ((k))++) {
qx.push(g[lst][x][k]);
}
lst = x;
}
if (cnt != -1) trs[1][1][i][lst].push_back(cnt);
}
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
for (((j)) = (1); ((j)) <= ((n)); ((j))++) {
if (e[i][j] && g[i][j].empty()) {
trs[1][0][i][j].push_back(1);
}
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
for (((j)) = (1); ((j)) <= ((n)); ((j))++) {
if (e[i][j]) {
int p;
for (p = 0; p + 1 < g[i][j].size(); p++) {
if (g[i][j][p] == i && g[i][j][p + 1] == j) break;
}
if (p + 1 >= g[i][j].size()) continue;
int cnt = 1, lst = i;
queue<int> qx;
for (k = p - 1; k >= 0; k--) {
qx.push(g[i][j][k]);
}
while (!qx.empty()) {
int x = qx.front();
qx.pop();
cnt++;
if (!e[x][lst] || cnt > n + n) {
cnt = -1;
break;
}
for (k = ((int)g[x][lst].size()) - 1; k >= 0; k--) {
qx.push(g[x][lst][k]);
}
lst = x;
}
if (cnt == -1) continue;
int mem = lst;
lst = j;
for (k = p + 2; k < g[i][j].size(); k++) {
qx.push(g[i][j][k]);
}
while (!qx.empty()) {
int x = qx.front();
qx.pop();
cnt++;
if (!e[lst][x] || cnt > n + n) {
cnt = -1;
break;
}
for (((k)) = (0); ((k)) <= (((int)(g[lst][x].size())) - 1); ((k))++) {
qx.push(g[lst][x][k]);
}
lst = x;
}
if (cnt != -1) trs[0][1][mem][lst].push_back(cnt);
}
}
}
int main() {
read(n);
read(m);
for (((i)) = (1); ((i)) <= ((m)); ((i))++) {
int x, y, z;
read(x);
read(y);
read(z);
e[x][y] = 1;
while (z--) {
int t;
read(t);
g[x][y].push_back(t);
}
}
init();
for (((i)) = (1); ((i)) <= ((n)); ((i))++) f[0][i][0] = 1;
for (((i)) = (0); ((i)) <= (((int)(n + n)) - 1); ((i))++) {
for (((a)) = (0); ((a)) <= (((int)(2)) - 1); ((a))++)
for (((b)) = (1); ((b)) <= ((n)); ((b))++)
if (f[a][b][i]) {
for (((c)) = (0); ((c)) <= (((int)(2)) - 1); ((c))++)
for (((d)) = (1); ((d)) <= ((n)); ((d))++)
for (__typeof((trs[a][c][b][d]).begin()) it =
(trs[a][c][b][d]).begin();
it != (trs[a][c][b][d]).end(); it++) {
if (i + *it <= n + n)
f[c][d][i + *it] = (f[c][d][i + *it] + f[a][b][i]) % mod;
}
}
}
for (((i)) = (1); ((i)) <= ((n + n)); ((i))++) {
int sum = 0;
for (((j)) = (1); ((j)) <= ((n)); ((j))++) (sum += f[1][j][i]) %= mod;
cout << sum << endl;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
template <class T>
void cxk(T& a, T b) {
a = a > b ? a : b;
}
template <class T>
void cnk(T& a, T b) {
a = a < b ? a : b;
}
long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
bool debug = 0;
int n, m, A[10000], B[10000], E[51][51], rE[51][51];
std::vector<int> w[10000], rw[10000], G[51], rG[51];
void inc(int& x, int y) {
x = x + y >= 1000000007 ? x + y - 1000000007 : x + y;
}
void dec(int& x, int y) { x = x >= y ? x - y : x + 1000000007 - y; }
int sub(int x, int y) { return x >= y ? x - y : x + 1000000007 - y; }
std::vector<int> path[51][51][2][2];
int f[110][51][2], ans[110];
std::vector<int> seq, rseq;
bool extend(int p, std::vector<int>& seq, int E[51][51],
std::vector<int> w[10000]) {
if (p == seq.size() - 1) return seq.size() <= n + n;
int y = seq[p + 1], x = seq[p];
if (E[x][y]) {
for (int i : w[E[x][y]]) seq.push_back(i);
return seq.size() <= n + n && extend(p + 1, seq, E, w);
} else
return 0;
}
int main() {
n = gi(), m = gi();
for (int i = 1; i <= m; ++i) {
int u = gi(), v = gi();
A[i] = u, B[i] = v;
G[u].push_back(v), G[v].push_back(u);
E[u][v] = rE[v][u] = i;
w[i].resize(gi());
for (int j = 0; j < w[i].size(); ++j) w[i][j] = gi();
rw[i] = w[i], std::reverse((rw[i]).begin(), (rw[i]).end());
}
for (int i = 1; i <= m; ++i)
if (w[i].size() && w[i].back() == A[i]) {
seq = rw[i];
if (extend(0, seq, rE, rw)) {
path[seq.back()][B[i]][0][0].push_back(seq.size());
if (debug) {
printf("-1 -1 path :");
for (int i : seq) printf("%d ", i);
puts("");
}
}
}
for (int i = 1; i <= m; ++i)
if (w[i].size() && w[i][0] == B[i]) {
seq = w[i];
if (extend(0, seq, E, w)) {
path[A[i]][seq.back()][1][1].push_back(seq.size());
if (debug) {
printf("0 0 path :");
for (int i : seq) printf("%d ", i);
puts("");
}
}
}
bool found = 1;
for (int i = 1; i <= m; ++i)
if (w[i].size()) {
int p = -1;
for (int j = 1; j < w[i].size(); ++j)
if (w[i][j - 1] == A[i] && w[i][j] == B[i]) p = j;
if (p == -1) continue;
seq = rseq = {};
for (int j = p - 1; ~j; --j) rseq.push_back(w[i][j]);
for (int j = p; j < w[i].size(); ++j) seq.push_back(w[i][j]);
if (extend(0, seq, E, w) && extend(0, rseq, rE, rw)) {
path[rseq.back()][seq.back()][0][1].push_back(seq.size() + rseq.size() -
1);
std::reverse((rseq).begin(), (rseq).end());
if (!found) {
printf("%d\n", seq.size() + rseq.size());
for (int i : rseq) printf("%d ", i);
for (int i : seq) printf("%d ", i);
puts("");
found = 1;
}
if (debug) {
printf("-1 0 path :");
for (int i : rseq) printf("%d ", i);
for (int i : seq) printf("%d ", i);
puts("");
}
}
}
if (!found) puts("0\n");
for (int i = 1; i <= m; ++i)
if (w[i].empty()) {
path[A[i]][B[i]][1][0].push_back(1);
if (debug) printf("0 -1 path :%d %d\n", A[i], B[i]);
}
for (int i = 1; i <= n; ++i) f[0][i][0] = 1;
for (int le = 0; le <= n + n; ++le)
for (int i = 1; i <= n; ++i)
for (int o = 0; o < 2; ++o) {
if (!f[le][i][o]) continue;
if (debug) printf("%d %d %d %d\n", le, i, o, f[le][i][o]);
if (o) inc(ans[le], f[le][i][o]);
for (int j = 1; j <= n; ++j)
for (int to = 0; to < 2; ++to)
for (int nl : path[i][j][o][to])
if (nl + le <= n + n) inc(f[le + nl][j][to], f[le][i][o]);
}
for (int i = 1; i <= n + n; ++i) printf("%d\n", ans[i]);
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int msc = 90, mod = (int)1e9 + 7;
using namespace std;
typedef int arr32[110][110][110];
typedef int arrct[100010];
int path[5][110][110][110];
arr32 d, t, f;
arrct q;
int n, m;
void inc(int &x, const int &y) {
x += y;
if (x >= mod) x -= mod;
}
void work(int x, int y) {
int *a = d[x][y], *b = t[x][y];
if (b[0] == 0) return;
if (a[0] == 0) return;
if (!b[x] && !b[y]) return;
if (b[x] && b[x] != a[0] && a[b[x] + 1] != y) return;
if (b[y] && b[y] != 1 && a[b[y] - 1] != x) return;
int tA, He, nt, cnt, len = 1, st = 0, et = 0, stat = 0;
if (b[x]) {
tA = 0, He = 1, nt = x, cnt = 1;
for (int i = b[x] - 1; i; --i) q[++tA] = a[i];
while (He <= tA && cnt < msc) {
int z = q[He];
if (t[z][nt][0] == 0)
cnt = msc;
else
for (int i = d[z][nt][0]; i; --i) q[++tA] = d[z][nt][i];
++He, nt = z, ++len;
}
if (cnt == msc) return;
st = nt, stat += 1;
} else
st = x;
if (b[y]) {
tA = 0, He = 1, nt = y, cnt = 1;
for (int i = b[y] + 1; i <= a[0]; ++i) q[++tA] = a[i];
while (He <= tA && cnt < msc) {
int z = q[He];
if (t[nt][z][0] == 0)
cnt = msc;
else
for (int i = 1; i <= d[nt][z][0]; ++i) q[++tA] = d[nt][z][i];
++He, nt = z, ++len;
}
if (cnt == msc) return;
et = nt, stat += 2;
} else
et = y;
path[stat][len][st][et] += 1;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
for (int j = 1; j <= z; ++j) scanf("%d", q + j);
if (z <= 2 * n + 1) {
d[x][y][0] = z, t[x][y][0] = 1;
for (int j = 1; j <= z; ++j) t[x][y][q[j]] = j;
for (int j = 1; j <= z; ++j) d[x][y][j] = q[j];
}
if (z == 0) path[0][1][x][y] += 1;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (t[i][j][0] == 1) {
work(i, j);
}
int m = 2 * n;
for (int i = 1; i <= n; ++i) f[0][1][i] = 1;
for (int i = 0; i < m; ++i)
for (int stat_j = 0; stat_j < 4; ++stat_j) {
if (!(stat_j & 1)) continue;
for (int j = 1; j <= n; ++j) {
if (!f[i][stat_j][j]) continue;
for (int stat_k = 0; stat_k < 4; ++stat_k)
if ((stat_j >> 1) ^ (stat_k & 1))
for (int k = 1; k <= n; ++k)
for (int L = 1; L <= m; ++L) {
if (path[stat_k][L][j][k]) {
inc(f[i + L][(stat_j & 1) ^ (stat_k & 2)][k],
(long long)f[i][stat_j][j] * path[stat_k][L][j][k] % mod);
}
}
}
}
for (int i = 1; i <= m; ++i) {
int result = 0;
for (int j = 1; j <= n; ++j) inc(result, f[i][3][j]);
printf("%d\n", result);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int N = 50;
const int MOD = (int)1e9 + 7;
std::vector<int> *graph[N][N], *rgraph[N][N];
std::vector<int> find(std::vector<int> *graph[N][N], std::vector<int> seq,
int l) {
for (int i = 1; i < (int)seq.size() && (int)seq.size() <= l; ++i) {
std::vector<int> *g = graph[seq[i - 1]][seq[i]];
if (g == NULL) {
return std::vector<int>();
}
for (int v : *g) {
seq.push_back(v);
}
}
return seq;
}
std::vector<int> reverse(std::vector<int> seq) {
std::reverse((seq).begin(), (seq).end());
return seq;
}
std::vector<int> concat(std::vector<int> a, const std::vector<int> &b) {
a.insert(a.end(), b.begin(), b.end());
return a;
}
void update(int &x, int a) {
x += a;
if (x >= MOD) {
x -= MOD;
}
}
int ways[2 * N + 1][3][N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int _ = 0; _ < m; ++_) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
x--, y--;
std::vector<int> seq;
while (k--) {
int v;
scanf("%d", &v);
seq.push_back(--v);
}
graph[x][y] = new std::vector<int>(seq);
rgraph[y][x] = new std::vector<int>(reverse(seq));
}
std::vector<std::vector<int> > seqs[3];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (graph[i][j] != NULL) {
std::vector<int> seq = *graph[i][j];
if (!seq.empty() && seq.back() == i) {
const auto &path = reverse(find(rgraph, reverse(seq), 2 * n));
if (1 <= (int)path.size() && path.size() <= 2 * n) {
seqs[0].push_back(concat(path, std::vector<int>(1, j)));
}
}
for (int k = 1; k < (int)seq.size(); ++k) {
if (seq[k - 1] == i && seq[k] == j) {
const auto &bpath = reverse(find(
rgraph, reverse(std::vector<int>(seq.begin(), seq.begin() + k)),
2 * n));
const auto &fpath = find(
graph, std::vector<int>(seq.begin() + k, seq.end()), 2 * n);
if (!bpath.empty() && !fpath.empty() &&
bpath.size() + fpath.size() <= 2 * n) {
seqs[1].push_back(concat(bpath, fpath));
}
}
}
if (!seq.empty() && seq.front() == j) {
const auto &path = find(graph, seq, 2 * n);
if (1 <= (int)path.size() && path.size() <= 2 * n) {
seqs[2].push_back(concat(std::vector<int>(1, i), path));
}
}
}
}
}
for (int i = 0; i < 3; ++i) {
std::sort((seqs[i]).begin(), (seqs[i]).end());
seqs[i].erase(std::unique((seqs[i]).begin(), (seqs[i]).end()),
seqs[i].end());
}
memset(ways, 0, sizeof(ways));
for (int v = 0; v < n; ++v) {
ways[0][0][v] = ways[0][1][v] = 1;
}
for (int i = 0; i <= 2 * n; ++i) {
for (int s = 0; s < 3; ++s) {
for (const std::vector<int> &seq : seqs[s]) {
int u = seq.front();
int v = seq.back();
int j = i + seq.size() - 1;
if (j <= 2 * n) {
if (s != 1) {
update(ways[j][s][v], ways[i][s][u]);
}
if (s != 2) {
update(ways[j][s + 1][v], ways[i][0][u]);
}
}
}
}
if (i + 1 <= 2 * n) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
std::vector<int> *seq = graph[j][k];
if (seq != NULL && seq->empty()) {
update(ways[i + 1][0][k], ways[i][2][j]);
update(ways[i + 1][1][k], ways[i][2][j]);
}
}
}
}
if (i) {
int result = 0;
for (int v = 0; v < n; ++v) {
update(result, ways[i][2][v]);
}
printf("%d\n", result);
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int Sn = 55;
const int mod = (int)1e9 + 7;
int n, m;
int G[Sn][Sn];
vector<int> V[Sn][Sn];
int T[Sn * 4], tT;
int Ms[Sn][Sn], Mo[Sn][Sn];
int bf[Sn][Sn][Sn * 2];
int dp[Sn][Sn * 2];
int suf[Sn][Sn * 2];
vector<pair<int, int> > trP[Sn];
int trC[Sn][Sn * Sn * Sn * 2];
int trN[Sn];
bool contain(int u, int v, int& pu, int& pv) {
int sz = V[u][v].size();
for (int l = 0; l <= sz - 2; l++)
if (V[u][v][l] == u && V[u][v][l + 1] == v) return pu = l, pv = l + 1, 1;
return 0;
}
int find(int d, int q, int wk) {
if (q == tT) return d;
if (tT > 2 * n + 1) return -1;
int k = T[q + 1], sz = V[d][k].size();
if (G[d][k] == wk) {
for (int l = 0; l <= sz - 1; l++) T[++tT] = V[d][k][l];
return find(k, q + 1, wk);
} else
return -1;
}
void add(int& a, int b) { a = (a + b) % mod; }
void transform(int i, int j, vector<pair<int, int> >& P, int C[]) {
int N = P.size();
for (int l = 0; l <= N - 1; l++)
if (j >= P[l].second)
add(dp[i][j],
(long long)C[l + 1] * suf[P[l].first][j - P[l].second] % mod);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v, sz, x; i <= m; i++) {
scanf("%d%d%d", &u, &v, &sz);
G[u][v] = 1, G[v][u] = -1;
for (int l = 1; l <= sz; l++) scanf("%d", &x), V[u][v].push_back(x);
for (int l = 1; l <= sz; l++) V[v][u].push_back(V[u][v][sz - l]);
}
for (int u = 1; u <= n; u++)
for (int v = 1; v <= n; v++)
if (G[u][v] == 1 && V[u][v].size()) {
int sz = V[u][v].size();
if (V[u][v][0] != v) continue;
tT = 0;
for (int l = 0; l <= sz - 1; l++) T[++tT] = V[u][v][l];
int vt = find(v, 1, 1);
if (vt != -1) Ms[u][v] = tT, Mo[u][v] = vt;
}
for (int i = 1; i <= n; i++) bf[i][i][0] = 1;
for (int j = 1; j <= 2 * n; j++) {
for (int i = 1; i <= n; i++)
for (int k = 1; k <= n; k++)
if (G[i][k] == -1 && V[i][k].size()) {
int sz = V[i][k].size();
if (V[i][k][0] != k) continue;
tT = 0;
for (int l = 0; l <= sz - 1; l++) T[++tT] = V[i][k][l];
int vt = find(k, 1, -1);
if (vt != -1 && j >= tT)
for (int o = 1; o <= n; o++) add(bf[i][o][j], bf[vt][o][j - tT]);
}
}
int pu, pv, ld, lx, rd, rx, sz;
for (int u = 1; u <= n; u++)
for (int v = 1; v <= n; v++) {
sz = V[u][v].size();
if (G[u][v] == 1 && contain(u, v, pu, pv)) {
tT = 0;
for (int l = pu; l >= 0; l--) T[++tT] = V[u][v][l];
ld = find(u, 1, -1), lx = tT - 1;
tT = 0;
for (int l = pv; l <= sz - 1; l++) T[++tT] = V[u][v][l];
rd = find(v, 1, 1), rx = tT - 1;
int len = lx + rx + 1;
if (ld == -1 || rd == -1 || len > 2 * n) continue;
int cc;
for (int i = 1; i <= n; i++)
for (int j0 = 0; j0 <= 2 * n - len; j0++)
if (cc = bf[ld][i][j0], cc) {
trP[i].push_back(make_pair(rd, j0 + len));
trC[i][++trN[i]] = cc;
}
}
}
for (int i = 1; i <= n; i++) suf[i][0] = 1;
for (int j = 1; j <= 2 * n; j++) {
for (int i = 1; i <= n; i++)
for (int k = 1; k <= n; k++)
if (Ms[i][k] && j >= Ms[i][k])
add(suf[i][j], suf[Mo[i][k]][j - Ms[i][k]]);
int ansj = 0;
for (int i = 1; i <= n; i++) {
transform(i, j, trP[i], trC[i]);
add(ansj, dp[i][j]);
for (int k = 1; k <= n; k++)
if (G[k][i] == 1 && !V[k][i].size()) add(suf[k][j + 1], dp[i][j]);
}
printf("%d\n", ansj);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int szg1[100][100][100 << 1];
int szg2[100][100][100 << 1];
int szg3[100][100][100 << 1];
int szg4[100][100][100 << 1];
int dp[100 << 1][100][2];
int szm[100][100];
int numd;
int numb;
int head;
int tail;
struct nodel {
nodel* back;
nodel* next;
int d;
};
struct nodeb {
nodel* head;
nodel* tail;
int num;
int w1;
int w2;
void init() {
head = new nodel;
tail = new nodel;
head->next = tail;
tail->back = head;
return;
}
void addl(int x) {
nodel* p;
p = new nodel;
p->d = x;
p->back = tail->back;
tail->back->next = p;
p->next = tail;
tail->back = p;
return;
}
};
nodeb szb[1500];
struct nodeq {
nodel* p;
int x;
};
nodeq szq[100 << 2];
bool geth(nodeq x, int& to, int& len) {
nodeq now;
nodel* p;
for (len = 0, head = 1, tail = 1, szq[1] = x, to = szb[x.x].w1; head <= tail;)
for (now = szq[head++], p = now.p; p != szb[now.x].head; p = p->back) {
if ((szm[p->d][to] == 0) || (len > numd << 1)) return false;
szq[++tail] = (nodeq){szb[szm[p->d][to]].tail->back, szm[p->d][to]};
to = p->d;
len++;
}
return true;
}
bool gett(nodeq x, int& to, int& len) {
nodeq now;
nodel* p;
for (len = 0, head = 1, tail = 1, szq[1] = x, to = szb[x.x].w2; head <= tail;)
for (now = szq[head++], p = now.p; p != szb[now.x].tail; p = p->next) {
if ((szm[to][p->d] == 0) || (len > numd << 1)) return false;
szq[++tail] = (nodeq){szb[szm[to][p->d]].head->next, szm[to][p->d]};
to = p->d;
len++;
}
return true;
}
int main() {
nodel* p;
bool flag;
int len1;
int len2;
int len;
int ans;
int lin;
int to1;
int to2;
int to;
int f1;
int f2;
int f3;
int f4;
int f5;
int f6;
scanf("%d%d", &numd, &numb);
for (f1 = 1; f1 <= numb; f1++) {
scanf("%d%d%d", &szb[f1].w1, &szb[f1].w2, &szb[f1].num);
szm[szb[f1].w1][szb[f1].w2] = f1;
szb[f1].init();
for (f2 = 1; f2 <= szb[f1].num; f2++) {
scanf("%d", &lin);
szb[f1].addl(lin);
}
}
for (f1 = 1; f1 <= numd; f1++)
for (f2 = 1; f2 <= numd; f2++) {
lin = szm[f2][f1];
if ((lin == 0) || (szb[lin].num == 0) || (szb[lin].tail->back->d != f2))
continue;
if (geth((nodeq){szb[lin].tail->back->back, lin}, to, len))
szg1[to][f1][len + 1]++;
}
for (f1 = 1; f1 <= numd; f1++)
for (f2 = 1; f2 <= numd; f2++) {
lin = szm[f1][f2];
if ((lin == 0) || (szb[lin].num == 0) || (szb[lin].head->next->d != f2))
continue;
if (gett((nodeq){szb[lin].head->next->next, lin}, to, len))
szg2[f1][to][len + 1]++;
}
for (f1 = 1; f1 <= numb; f1++) {
flag = false;
for (p = szb[f1].head->next; p != szb[f1].tail; p = p->next) {
if (flag && (p->d == szb[f1].w2)) break;
if (p->d == szb[f1].w1)
flag = true;
else
flag = false;
}
if (p == szb[f1].tail) continue;
if (geth((nodeq){p->back->back, f1}, to1, len1) == false) continue;
if (gett((nodeq){p->next, f1}, to2, len2) == false) continue;
szg3[to1][to2][len1 + len2 + 1]++;
}
for (f1 = 1; f1 <= numd; f1++)
for (f2 = 1; f2 <= numd; f2++)
if ((szm[f1][f2] != 0) && (szb[szm[f1][f2]].num == 0))
szg4[f1][f2][1] = 1;
for (f1 = 1; f1 <= numd; f1++) dp[0][f1][0] = 1;
for (f1 = 1; f1 <= numd << 1; f1++)
for (f2 = 1; f2 <= numd; f2++)
for (f3 = 1; f3 <= f1; f3++)
for (f4 = 1; f4 <= numd; f4++) {
dp[f1][f2][0] +=
(long long int)dp[f1 - f3][f4][0] * szg1[f4][f2][f3] % 1000000007;
if (dp[f1][f2][0] >= 1000000007) dp[f1][f2][0] -= 1000000007;
dp[f1][f2][0] +=
(long long int)dp[f1 - f3][f4][1] * szg4[f4][f2][f3] % 1000000007;
if (dp[f1][f2][0] >= 1000000007) dp[f1][f2][0] -= 1000000007;
dp[f1][f2][1] +=
(long long int)dp[f1 - f3][f4][0] * szg3[f4][f2][f3] % 1000000007;
if (dp[f1][f2][1] >= 1000000007) dp[f1][f2][1] -= 1000000007;
dp[f1][f2][1] +=
(long long int)dp[f1 - f3][f4][1] * szg2[f4][f2][f3] % 1000000007;
if (dp[f1][f2][1] >= 1000000007) dp[f1][f2][1] -= 1000000007;
}
for (f1 = 1; f1 <= numd << 1; f1++) {
ans = 0;
for (f2 = 1; f2 <= numd; f2++) {
ans += dp[f1][f2][1];
if (ans >= 1000000007) ans -= 1000000007;
}
printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
int n, m, num[110][110], v[110];
int top, s[21000];
vector<int> vec[21000];
struct node {
int x, y, k;
} a[21000];
char Getchar() {
static char now[1 << 20], *S, *T;
if (T == S) {
T = (S = now) + fread(now, 1, 1 << 20, stdin);
if (T == S) return EOF;
}
return *S++;
}
int read() {
int x = 0, f = 1;
char ch = Getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = Getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = Getchar();
return x * f;
}
pair<int, int> get_path(int x, bool rev) {
int now = 0, y, e;
for (int i = 1; i <= top && top <= 2 * n; i++) {
y = s[i];
e = num[x][y];
if (!e || (rev && e <= m) || (!rev && e > m))
return pair<int, int>(2 * n + 1, 2 * n + 1);
for (int j = 0; j < (int)vec[e].size(); j++) s[++top] = vec[e][j];
x = y;
now++;
}
return pair<int, int>(top, x);
}
int dp1[2][2][55][55][110], dp2[110][55][2];
int f[55][55][110], g[55][55][110];
void work(bool rev) {
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
for (int i = 1; i <= m * 2; i++) {
if (rev && i <= m || !rev && i > m) continue;
for (int j = 0; j < (int)vec[i].size(); j++)
if (vec[i][j] == a[i].x) {
top = 0;
for (int k = j - 1; k >= 0; k--) s[++top] = vec[i][k];
pair<int, int> res = get_path(a[i].x, !rev);
if (res.first + 1 > 2 * n) continue;
if (j + 1 == (int)vec[i].size())
g[res.second][a[i].y][res.first + 1]++;
else {
if (vec[i][j + 1] != a[i].y) continue;
top = 0;
for (int k = j + 2; k < (int)vec[i].size(); k++) s[++top] = vec[i][k];
pair<int, int> res2 = get_path(a[i].y, rev);
if (res2.first + 1 + res.first <= 2 * n)
f[res.second][res2.second][res2.first + 1 + res.first]++;
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
int x, y, k;
for (int i = 1; i <= m; i++) {
x = read();
y = read();
k = read();
for (int j = 1; j <= k; j++) v[j] = read();
a[i].x = x;
a[i].y = y;
a[i].k = k;
num[x][y] = i;
for (int j = 1; j <= k; j++) vec[i].push_back(v[j]);
a[i + m].x = y;
a[i + m].y = x;
a[i + m].k = k;
num[y][x] = i + m;
for (int j = 1; j <= k; j++) vec[i + m].push_back(v[k - j + 1]);
if (!k) dp1[0][0][x][y][1]++;
}
work(false);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) {
dp1[1][1][i][j][k] = f[i][j][k];
dp1[1][0][i][j][k] = g[i][j][k];
}
work(true);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) dp1[0][1][i][j][k] = g[j][i][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) {
dp2[k][j][0] = (dp2[k][j][0] + dp1[1][0][i][j][k]) % Mod;
dp2[k][j][1] = (dp2[k][j][1] + dp1[1][1][i][j][k]) % Mod;
}
for (int p = 1; p <= n * 2; p++) {
int res = 0;
for (int i = 1; i <= n; i++) {
res = (res + dp2[p][i][1]) % Mod;
for (int m = 0; m <= 1; m++)
if (dp2[p][i][m]) {
for (int s = 0; s <= 1; s++)
for (int x = 1; x <= n; x++)
for (int q = 1; q <= n * 2 - p; q++)
dp2[p + q][x][s] =
(dp2[p + q][x][s] +
1ll * dp2[p][i][m] * dp1[m ^ 1][s][i][x][q]) %
Mod;
}
}
printf("%d\n", res);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
"no-stack-protector")
#pragma GCC target("popcnt,tune=native")
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class T>
inline void getc(T &x) {
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z'));
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
x = c;
}
template <class I>
inline void rd(I &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::getc;
using io ::print;
using io ::putc;
using io ::rd;
const int MAXN = 100 + 5;
const int MOD = 1e9 + 7;
int mo(int x, int y) { return (x + y) >= MOD ? (x + y - MOD) : (x + y); }
int sub(int x, int y) { return x < y ? (x - y + MOD) : (x - y); }
int ksm(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = 1ll * x * x % MOD)
if (y & 1) res = 1ll * res * x % MOD;
return res;
}
void fix(int &x, const int &v) { x = (x + v) >= MOD ? (x + v - MOD) : (x + v); }
int n, m;
bool vis[MAXN][MAXN];
vector<int> e[MAXN][MAXN];
void add(int x, int y, vector<int> t) {
vis[x][y] = 1;
e[x][y] = t;
}
struct Node {
vector<int> g[MAXN][MAXN];
vector<int> solvemid() {
vector<int> nxt, res, now;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
for (int i = 0; i + 1 < e[x][y].size(); i++)
if (e[x][y][i] == x && e[x][y][i + 1] == y) {
now.clear();
nxt = e[x][y];
bool flag = 1;
do {
now = nxt;
nxt.clear();
flag = (now.size() <= (2 * n + 1));
for (int i = 0; i + 1 < now.size() && flag; i++) {
if (!vis[now[i]][now[i + 1]]) {
flag = 0;
break;
}
nxt.insert(nxt.end(), e[now[i]][now[i + 1]].begin(),
e[now[i]][now[i + 1]].end());
}
} while (flag && now != nxt);
if (flag) {
if (!res.size()) res = nxt;
g[nxt[0]][nxt.back()].push_back(nxt.size() - 1);
}
break;
}
return res;
}
void solvefront() {
vector<int> nxt, res, now, Cnt;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
if (e[x][y].size() && e[x][y].back() == x) {
now.clear();
nxt.clear();
nxt.push_back(x);
bool flag = 1;
do {
now = nxt;
nxt.clear();
flag = (now.size() <= (2 * n + 1));
nxt = e[now[0]][y];
reverse(nxt.begin(), nxt.end());
for (int i = 0; i + 1 < now.size() && flag; i++) {
if (!vis[now[i + 1]][now[i]]) {
flag = 0;
break;
}
nxt.insert(nxt.end(), e[now[i + 1]][now[i]].rbegin(),
e[now[i + 1]][now[i]].rend());
}
} while (flag && now != nxt);
if (flag) g[nxt.back()][y].push_back(nxt.size());
}
}
void solveend() {
vector<int> nxt, res, now, Cnt;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
if (e[x][y].size() && e[x][y][0] == y) {
now.clear();
nxt.clear();
nxt.push_back(y);
bool flag = 1;
do {
now = nxt;
nxt.clear();
flag = (now.size() <= (2 * n + 1));
nxt = e[x][now[0]];
for (int i = 0; i + 1 < now.size() && flag; i++) {
if (!vis[now[i]][now[i + 1]]) {
flag = 0;
break;
}
nxt.insert(nxt.end(), e[now[i]][now[i + 1]].begin(),
e[now[i]][now[i + 1]].end());
}
} while (flag && now != nxt);
if (flag) g[x][nxt.back()].push_back(nxt.size());
}
}
int dp[MAXN][MAXN][MAXN];
void solveA() {
for (int i = 1; i <= n; i++) dp[i][i][0] = 1;
for (int i = 0; i <= n * 2; i++)
for (int s = 1; s <= n; s++)
for (int l = 1; l <= n; l++)
for (int r = 1; r <= n; r++)
for (auto &len : g[l][r])
if (i + len <= 2 * n + 1) fix(dp[s][r][i + len], dp[s][l][i]);
}
} A, B, C;
int dp[MAXN][MAXN][MAXN], dp0[MAXN][MAXN][MAXN], ans[MAXN][MAXN];
int main() {
rd(n);
rd(m);
for (int i = 1, a, b, K; i <= m; i++) {
rd(a);
rd(b);
rd(K);
vector<int> v;
v.resize(K);
for (int i = 0; i < K; i++) rd(v[i]);
add(a, b, v);
}
A.solvefront();
vector<int> res = B.solvemid();
C.solveend();
A.solveA();
for (int i = 0; i <= n * 2; i++)
for (int s = 1; s <= n; s++)
for (int l = 1; l <= n; l++)
for (int r = 1; r <= n; r++)
for (auto &len : B.g[l][r])
if (i + len <= 2 * n) fix(dp[s][r][i + len], A.dp[s][l][i]);
for (int i = 0; i <= n * 2; i++)
for (int s = 1; s <= n; s++)
for (int l = 1; l <= n; l++)
for (int r = 1; r <= n; r++)
for (auto &len : C.g[l][r])
if (i + len <= 2 * n) fix(dp[s][r][i + len], dp[s][l][i]);
for (int l = 1; l <= n; l++)
for (int mid = 1; mid <= n; mid++)
if (vis[l][mid] && e[l][mid].empty())
for (int r = 1; r <= n; r++)
for (int i = 0; i + 1 <= 2 * n; i++)
fix(dp0[l][r][i + 1], dp[mid][r][i]);
for (int l = 1; l <= n; l++)
for (int r = 1; r <= n; r++)
for (int len = 1; len <= 2 * n; len++) fix(ans[r][len], dp[l][r][len]);
for (int i = 1; i <= 2 * n; i++)
for (int l = 1; l <= n; l++)
for (int r = 1; r <= n; r++)
for (int len = 1; len + i <= 2 * n; len++)
fix(ans[r][len + i], 1ll * ans[l][i] * dp0[l][r][len] % MOD);
for (int i = 1; i <= 2 * n; i++) {
int aa = 0;
for (int s = 1; s <= n; s++) fix(aa, ans[s][i]);
print(aa);
putc('\n');
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50, mod = 1000000007;
int add(int a, int b, int p = mod) { return a + b >= p ? a + b - p : a + b; }
int sub(int a, int b, int p = mod) { return a - b < 0 ? a - b + p : a - b; }
int mul(int a, int b, int p = mod) { return 1LL * a * b % p; }
void sadd(int &a, int b, int p = mod) { a = add(a, b, p); }
void ssub(int &a, int b, int p = mod) { a = sub(a, b, p); }
void smul(int &a, int b, int p = mod) { a = mul(a, b, p); }
int n, m, e[N + 9][N + 9];
vector<int> str[N + 9][N + 9];
void into() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
e[x][y] = 1;
for (int j = 0; j < c; ++j) {
int k;
scanf("%d", &k);
str[x][y].push_back(k);
}
}
}
int cnt[N * 2 + 9][N + 9][N + 9][2][2];
int q[N * 2 + 9], hd, tl;
void Get_cnt0(int x, int y) {
hd = 1;
tl = 0;
for (int vs = str[x][y].size(), i = 0; i < vs; ++i) q[++tl] = str[x][y][i];
for (; hd < tl;) {
int u = q[hd], v = q[++hd];
if (x == 6 && y == 1) printf("%d %d\n", u, v);
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = 0; i < vs; ++i) q[++tl] = str[u][v][i];
}
++cnt[tl][x][q[tl]][0][1];
}
void Get_cnt1(int x, int y) {
hd = 1;
tl = 0;
for (int vs = str[x][y].size(), i = vs - 1; i >= 0; --i)
q[++tl] = str[x][y][i];
for (; hd < tl;) {
int v = q[hd], u = q[++hd];
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = vs - 1; i >= 0; --i)
q[++tl] = str[u][v][i];
}
++cnt[tl][q[tl]][y][1][0];
}
void Get_cnt(int x, int y, int p) {
hd = 1;
tl = 0;
for (int vs = str[x][y].size(), i = p - 1; i >= 0; --i)
q[++tl] = str[x][y][i];
for (; hd < tl;) {
int v = q[hd], u = q[++hd];
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = vs - 1; i >= 0; --i)
q[++tl] = str[u][v][i];
}
reverse(q + 1, q + tl + 1);
if (tl + str[x][y].size() - p > n * 2 + 1) return;
for (int vs = str[x][y].size(), i = p; i < vs; ++i) q[++tl] = str[x][y][i];
for (++hd; hd < tl;) {
int u = q[hd], v = q[++hd];
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = 0; i < vs; ++i) q[++tl] = str[u][v][i];
}
++cnt[tl - 1][q[1]][q[tl]][1][1];
}
void Get_cnt(int x, int y) {
if (!e[x][y]) return;
if (str[x][y].size() > n * 2 + 1) return;
if (str[x][y].empty()) {
cnt[1][x][y][0][0] = 1;
return;
}
if (str[x][y][0] == y) Get_cnt0(x, y);
if (str[x][y].back() == x) Get_cnt1(x, y);
for (int vs = str[x][y].size(), i = 1; i < vs; ++i)
if (str[x][y][i - 1] == x && str[x][y][i] == y) Get_cnt(x, y, i);
}
void Get_cnt() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
Get_cnt(i, j);
}
}
int dp[N * 2 + 9][N + 9][2], ans[N * 2 + 9];
void Get_dp() {
for (int i = 1; i <= n; ++i) dp[0][i][0] = 1;
for (int i = 0; i <= n << 1; ++i)
for (int x = 1; x <= n; ++x) {
sadd(ans[i], dp[i][x][1]);
for (int j = 1; i + j <= n << 1; ++j)
for (int y = 1; y <= n; ++y)
for (int u = 0; u < 2; ++u)
for (int v = 0; v < 2; ++v)
sadd(dp[i + j][y][v], mul(dp[i][x][u], cnt[j][x][y][u ^ 1][v]));
}
}
void work() {
Get_cnt();
Get_dp();
}
void outo() {
for (int i = 1; i <= n << 1; ++i) printf("%d\n", ans[i]);
}
int main() {
into();
work();
outo();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, x, y, k, a, q, h, l, r, j, p, ans, s[400], dp[51][51][110],
dp1[51][51][110], tail1[51][51][110], tail2[51][51][110], dp3[51][110],
sss[51][51][110], dpp[51][110], dpp1[51][110];
vector<int> ve[51][51];
bool ok1, ok2, Find, ok[51][51];
void get(int x, int y, int z) {
q = 105;
h = 104;
for (int i = 1; i < ve[x][y].size(); i++) {
s[++h] = ve[x][y][i];
if (i == z) l = h, r = h + 1;
}
while (q != l && h - q + 1 <= 2 * n + 1) {
if (ve[s[l - 1]][s[l]].size() == 0) return;
for (int i = ve[s[l - 1]][s[l]].size() - 1; i; i--)
s[--q] = ve[s[l - 1]][s[l]][i];
l--;
}
if (h - q + 1 > 2 * n + 1) return;
while (h != r && h - q + 1 <= 2 * n) {
if (ve[s[r]][s[r + 1]].size() == 0) return;
for (int i = 1; i < ve[s[r]][s[r + 1]].size(); i++)
s[++h] = ve[s[r]][s[r + 1]][i];
r++;
}
if (h - q + 1 > 2 * n + 1) return;
dp[s[q]][s[h]][h - q + 1]++;
}
void Findtail1(int x, int y) {
q = 105;
h = 104;
for (int i = 1; i < ve[x][y].size(); i++) s[++h] = ve[x][y][i];
l = r = h;
while (q != l && h - q + 1 <= 2 * n + 1) {
if (ve[s[l - 1]][s[l]].size() == 0) return;
for (int i = ve[s[l - 1]][s[l]].size() - 1; i; i--)
s[--q] = ve[s[l - 1]][s[l]][i];
l--;
}
if (h - q + 1 > 2 * n + 1) return;
tail1[s[q]][y][h - q + 1]++;
}
void Findtail2(int x, int y) {
q = 105;
h = 104;
for (int i = 1; i < ve[x][y].size(); i++) s[++h] = ve[x][y][i];
l = r = q;
while (h != r && h - q + 1 <= 2 * n + 1) {
if (ve[s[r]][s[r + 1]].size() == 0) return;
for (int i = 1; i < ve[s[r]][s[r + 1]].size(); i++)
s[++h] = ve[s[r]][s[r + 1]][i];
r++;
}
if (h - q + 1 > 2 * n + 1) return;
tail2[x][s[h]][h - q + 1]++;
}
inline void add(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &k);
ok1 = false;
ok2 = false;
ve[x][y].push_back(0);
a = 0;
while (k--) {
if (a != x)
ok1 = false;
else
ok1 = true;
scanf("%d", &a);
if (a == y && ok1) ok2 = true;
ve[x][y].push_back(a);
}
if (ok2) ok[x][y] = true;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
if (ok[i][j])
for (p = 1; p < ve[i][j].size() - 1; p++)
if (ve[i][j][p] == i && ve[i][j][p + 1] == j) get(i, j, p);
if (ve[i][j].size() > 1 && ve[i][j][ve[i][j].size() - 1] == i)
Findtail1(i, j);
if (ve[i][j].size() > 1 && ve[i][j][1] == j) Findtail2(i, j);
}
for (l = 1; l <= 2 * n + 1; l++) {
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (p = 1; p < l; p++)
if (tail1[i][j][p])
for (q = 1; q <= n; q++)
dp[i][q][l] =
(dp[i][q][l] + 1LL * dp[j][q][l - p] * tail1[i][j][p]) %
1000000007;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (p = 1; p < l; p++)
if (tail2[i][j][p])
for (q = 1; q <= n; q++) {
dp1[q][j][l] =
(dp1[q][j][l] + 1LL * dp[q][i][l - p] * tail2[i][j][p]) %
1000000007;
dp1[q][j][l] =
(dp1[q][j][l] + 1LL * dp1[q][i][l - p] * tail2[i][j][p]) %
1000000007;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (p = 1; p < l; p++)
if (sss[i][j][p]) {
int ss = 0;
add(ss, dpp[j][l - p]);
add(ss, dpp1[j][l - p]);
add(ss, dp3[j][l - p]);
add(dp3[i][l], 1LL * ss * sss[i][j][p] % 1000000007);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (p = 1; p <= n; p++)
if (ve[j][p].size() == 1) {
sss[i][p][l] = (sss[i][p][l] + dp[i][j][l]) % 1000000007;
sss[i][p][l] = (sss[i][p][l] + dp1[i][j][l]) % 1000000007;
}
for (ans = 0, i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
ans = (((ans + dp[i][j][l]) % 1000000007 + dp1[i][j][l]) % 1000000007) %
1000000007;
for (i = 1; i <= n; i++) add(ans, dp3[i][l]);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
add(dpp[i][l], dp[i][j][l]), add(dpp1[i][l], dp1[i][j][l]);
if (l > 1) printf("%d\n", ans);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int n, m, f[N][N][2];
bool G[N][N];
vector<int> E[N][N], trs[N][2][N][2];
void inc(int &a, int b) { a = a + b >= mod ? a + b - mod : a + b; }
bool ext(deque<int> &q, deque<int>::iterator it, bool dir) {
bool fl = 1;
if (!dir) {
while (it != q.begin() && fl && int(q.size()) <= n + n) {
auto pre = prev(it);
fl &= G[*pre][*it];
q.insert(q.begin(), E[*pre][*it].begin(), E[*pre][*it].end());
--it;
}
} else {
while (next(it) != q.end() && fl && int(q.size()) <= n + n) {
auto nxt = next(it);
fl &= G[*it][*nxt];
q.insert(q.end(), E[*it][*nxt].begin(), E[*it][*nxt].end());
++it;
}
}
return fl && int(q.size()) <= n + n + 1;
}
int main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
u = gi();
v = gi();
G[u][v] = 1;
int k = gi();
while (k--) E[u][v].push_back(gi());
}
bool fl = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (!E[i][j].empty() && E[i][j].back() == i) {
deque<int> seq(E[i][j].begin(), E[i][j].end());
if (ext(seq, --seq.end(), 0)) {
trs[seq[0]][0][j][0].push_back(int(seq.size()));
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
auto it = find(E[i][j].begin(), E[i][j].end(), i);
while (it != E[i][j].end() && next(it) != E[i][j].end() && *next(it) != j)
it = find(next(it), E[i][j].end(), i);
if (it == E[i][j].end() || next(it) == E[i][j].end()) continue;
deque<int> seq(E[i][j].begin(), E[i][j].end());
auto itt = seq.begin() + (it - E[i][j].begin());
if (ext(seq, itt, 0) && ext(seq, next(itt), 1)) {
if (!fl) {
fl = 1;
cout << int(seq.size()) << '\n';
for (auto x : seq) cout << x << ' ';
cout << '\n';
}
trs[seq[0]][0][seq.back()][1].push_back(int(seq.size()) - 1);
}
}
if (!fl) cout << 0 << '\n' << '\n';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (G[i][j] && E[i][j].empty()) trs[i][1][j][0].push_back(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (!E[i][j].empty() && E[i][j][0] == j) {
deque<int> seq(E[i][j].begin(), E[i][j].end());
if (ext(seq, seq.begin(), 1)) {
trs[i][1][seq.back()][1].push_back(int(seq.size()));
}
}
for (int i = 1; i <= n; i++) f[0][i][0] = 1;
for (int i = 0; i < n + n; i++)
for (int u = 1; u <= n; u++)
for (int p = 0; p < 2; p++)
if (f[i][u][p])
for (int v = 1; v <= n; v++)
for (int q = 0; q < 2; q++)
for (auto t : trs[u][p][v][q])
if (i + t <= n + n) inc(f[i + t][v][q], f[i][u][p]);
for (int i = 1; i <= n + n; i++) {
int ans = 0;
for (int u = 1; u <= n; u++) inc(ans, f[i][u][1]);
cout << ans << '\n';
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int Read() {
char c;
while (c = getchar(), (c != '-') && (c < '0' || c > '9'))
;
bool neg = (c == '-');
int ret = (neg ? 0 : c - 48);
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + c - 48;
return neg ? -ret : ret;
}
const int MAXN = 55, MOD = 7 + 1e9;
vector<pair<int, int> > h[MAXN], t[MAXN];
vector<int> g[MAXN][MAXN];
bool con[MAXN][MAXN];
int N, M, tail, q[MAXN * 4];
int b[MAXN * 2][MAXN][MAXN], f[MAXN * 2][MAXN], c[MAXN * 2][MAXN][MAXN];
void init() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++) {
int u = Read(), v = Read(), k = Read();
con[u][v] = 1;
for (int j = 1; j <= k; j++) {
int x = Read();
g[u][v].push_back(x);
}
}
}
bool Expand() {
for (int head = 1; head <= tail - 1; head++) {
int x = q[head], y = q[head + 1];
if (con[x][y]) {
for (int k = 0; k <= (int)g[x][y].size() - 1; k++) q[++tail] = g[x][y][k];
if (tail > 2 * N) return 0;
} else
return 0;
}
return 1;
}
bool RExpand() {
for (int head = 1; head <= tail - 1; head++) {
int x = q[head], y = q[head + 1];
if (con[y][x]) {
for (int k = (int)g[y][x].size() - 1; k >= 0; k--) q[++tail] = g[y][x][k];
if (tail > 2 * N) return 0;
} else
return 0;
}
return 1;
}
void Add(int &x, int y) { x += y, x -= (x >= MOD ? MOD : 0); }
void work() {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
if (con[i][j] && g[i][j].size()) {
if (g[i][j].back() == i) {
tail = 0;
for (int k = g[i][j].size() - 1; k >= 0; k--) q[++tail] = g[i][j][k];
if (RExpand()) h[j].push_back(make_pair(tail, q[tail]));
}
if (g[i][j][0] == j) {
tail = 0;
for (int k = 0; k <= g[i][j].size() - 1; k++) q[++tail] = g[i][j][k];
if (Expand()) t[i].push_back(make_pair(tail, q[tail]));
}
if (g[i][j].size() > 1) {
for (int k = 1; k <= g[i][j].size() - 1; k++)
if (g[i][j][k - 1] == i && g[i][j][k] == j) {
tail = 0;
for (int p = k - 1; p >= 0; p--) q[++tail] = g[i][j][p];
if (RExpand()) {
int tl = tail, tp = q[tail];
tail = 0;
for (int p = k; p <= g[i][j].size() - 1; p++)
q[++tail] = g[i][j][p];
if (Expand() && tl + tail - 1 <= 2 * N)
++b[tl + tail - 1][tp][q[tail]];
}
break;
}
}
}
for (int l = 1; l <= 2 * N - 1; l++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
if (b[l][i][j])
for (int k = 0; k <= (int)h[i].size() - 1; k++) {
int x = h[i][k].first, y = h[i][k].second;
if (l + x <= 2 * N) Add(b[l + x][y][j], b[l][i][j]);
}
for (int l = 1; l <= 2 * N - 1; l++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
if (b[l][i][j])
for (int k = 0; k <= (int)t[j].size() - 1; k++) {
int x = t[j][k].first, y = t[j][k].second;
if (l + x <= 2 * N) Add(b[l + x][i][y], b[l][i][j]);
}
for (int l = 1; l <= 2 * N; l++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) Add(f[l][j], b[l][i][j]);
for (int l = 1; l <= 2 * N; l++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
if (b[l][i][j])
for (int k = 1; k <= N; k++)
if (con[k][i] && !g[k][i].size()) Add(c[l + 1][k][j], b[l][i][j]);
for (int l1 = 1; l1 <= 2 * N; l1++)
for (int i = 1; i <= N; i++)
if (f[l1][i])
for (int l2 = 1; l2 <= 2 * N - l1; l2++)
for (int j = 1; j <= N; j++)
Add(f[l1 + l2][j], (long long)f[l1][i] * c[l2][i][j] % MOD);
for (int i = 1; i <= 2 * N; i++) {
int ans = 0;
for (int j = 1; j <= N; j++) Add(ans, f[i][j]);
printf("%d\n", ans);
}
}
int main() {
init();
work();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, x, y, z, nn, flag;
int id[60][60], f[60 * 2][60][60], o[60 * 2][60][60], re[60 * 2][60];
vector<int> a[3000], g, h;
vector<pair<int, int> > q[60], w[60];
bool dfs(int x, int y, int ty) {
if (!ty && x == g.size() || ty && x == h.size()) return 1;
int i;
int A = !ty ? g[x] : h[x], B = !ty ? id[y][A] : id[A][y];
if (!B) return 0;
if (!ty) {
for (i = 0; i < a[B].size(); i++) {
int C = a[B][i];
g.push_back(C);
if (g.size() > nn) return 0;
}
} else {
for (i = a[B].size() - 1; i >= 0; i--) {
int C = a[B][i];
h.push_back(C);
if (h.size() > nn) return 0;
}
}
return dfs(x + 1, A, ty);
}
inline void work1(int i, int j) {
int A = id[i][j], wei, len = a[A].size();
if (!A || len < 2) return;
for (k = 0; k + 1 < len; k++) {
int B = a[A][k], C = a[A][k + 1];
if (B == i && C == j) break;
}
if (k + 1 == len) return;
wei = k;
g.clear();
for (k = wei + 1; k < len; k++) {
int B = a[A][k];
g.push_back(B);
if (g.size() > nn) return;
}
h.clear();
for (k = wei; k >= 0; k--) {
int B = a[A][k];
h.push_back(B);
if (h.size() > nn) return;
}
if (dfs(1, j, 0) && dfs(1, i, 1)) {
int B = g.size() + h.size();
if (B <= nn) f[B - 1][h[h.size() - 1]][g[g.size() - 1]]++;
}
}
inline void work2(int i, int j) {
int A = id[i][j], len = a[A].size();
if (!len) return;
if (a[A][len - 1] != i) return;
h.clear();
for (k = len - 1; k >= 0; k--) {
int B = a[A][k];
h.push_back(B);
if (h.size() > nn) return;
}
if (dfs(1, i, 1)) {
int B = h.size();
q[j].push_back(make_pair(h[B - 1], B));
}
}
inline void work3(int i, int j) {
int A = id[i][j], len = a[A].size();
if (!len) return;
if (a[A][0] != j) return;
g.clear();
for (k = 0; k < len; k++) {
int B = a[A][k];
g.push_back(B);
if (g.size() > nn) return;
}
if (dfs(1, j, 0)) {
int B = g.size();
w[i].push_back(make_pair(g[B - 1], B));
}
}
inline void S(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
inline void print() {
int i, j, k;
for (i = 1; i <= 40; i++) {
int an = 0;
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++)
if (f[i][j][k]) printf("%d %d %d %d\n", i, j, k, f[i][j][k]);
}
printf("\n");
}
inline void work() {
int u, r, v, x, y, t;
for (i = 1; i <= nn; i++)
for (u = 1; u <= n; u++)
for (r = 1; r <= n; r++)
if (x = f[i][u][r]) {
for (j = 0; j < q[u].size(); j++) {
pair<int, int> A = q[u][j];
int B = A.second + i;
if (B <= nn) S(f[B][A.first][r], x);
}
}
for (i = 1; i <= nn; i++)
for (u = 1; u <= n; u++)
for (r = 1; r <= n; r++)
if (x = f[i][u][r]) {
for (j = 0; j < w[r].size(); j++) {
pair<int, int> A = w[r][j];
int B = A.second + i;
if (B <= nn) S(f[B][u][A.first], x);
}
}
for (i = 1; i <= nn; i++)
for (u = 1; u <= n; u++)
for (r = 1; r <= n; r++)
if (x = f[i][u][r]) {
for (v = 1; v <= n; v++) {
int A = id[r][v];
if (A && !a[A].size()) S(o[i + 1][u][v], x);
}
S(re[i][u], x);
}
for (i = 1; i <= nn; i++)
for (u = 1; u <= n; u++)
if (x = re[i][u]) {
for (j = 1; j <= nn - i; j++) {
for (v = 1; v <= n; v++)
if (y = o[j][v][u]) S(re[i + j][v], 1ll * x * y % 1000000007);
}
}
}
int main() {
scanf("%d%d", &n, &m);
nn = n * 2 + 1;
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &k);
id[x][y] = i;
for (j = 1; j <= k; j++) scanf("%d", &z), a[i].push_back(z);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
work1(i, j);
work2(i, j);
work3(i, j);
}
work();
for (i = 1; i <= nn - 1; i++) {
int an = 0;
for (j = 1; j <= n; j++) S(an, re[i][j]);
printf("%d\n", an);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, D = 100010;
const int mod = 1e9 + 7;
int n, m, e[N][N], rv, rl, id[2][N][N], dn, ans[N];
int sv[D], svt, de[D], dp[D];
vector<int> tp[D], dv[N][N];
void inc(int &a, int b) {
if (a += b, a >= mod) a -= mod;
}
void go(int u, int ty) {
rv = -1, rl = 0;
while (rl + 1 <= svt && rl <= 2 * n) {
int v = sv[++rl];
if (e[u][v] != ty) return;
for (int j = 0, jt = dv[u][v].size(); j < jt; ++j) sv[++svt] = dv[u][v][j];
u = v;
}
rv = u;
if (rl > 2 * n) rv = -1;
}
void link(int u, int v) { tp[u].push_back(v), ++de[v]; }
void trans(int *u, int *v, int l) {
for (int i = 0; i + l <= 2 * n; ++i) link(u[i], v[i + l]);
}
void build() {
for (int u = 1; u <= n; ++u)
for (int v = 1; v <= n; ++v) {
vector<int> ls = dv[u][v];
if (e[u][v] == 1) {
for (int j = 0, jt = ls.size(); j + 1 < jt; ++j)
if (ls[j] == u && ls[j + 1] == v) {
int len = 0, uu, vv;
svt = 0;
for (int jj = j - 1; jj >= 0; --jj) sv[++svt] = ls[jj];
go(u, -1), uu = rv, len += rl;
svt = 0;
for (int jj = j + 2; jj < jt; ++jj) sv[++svt] = ls[jj];
go(v, 1), vv = rv, len += rl;
if (uu > 0 && vv > 0 && len <= 2 * n)
trans(id[1][uu], id[0][vv], len + 1);
break;
}
if (!ls.size()) {
trans(id[0][u], id[1][v], 1);
} else if (ls[0] == v) {
svt = 0;
for (int j = 1, jt = ls.size(); j < jt; ++j) sv[++svt] = ls[j];
go(v, 1);
if (rv > 0) trans(id[0][u], id[0][rv], rl + 1);
}
}
if (e[u][v] == -1 && ls.size() && ls[0] == v) {
svt = 0;
for (int j = 1, jt = ls.size(); j < jt; ++j) sv[++svt] = ls[j];
go(v, -1);
if (rv > 0) trans(id[1][rv], id[1][u], rl + 1);
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v, k, x;
scanf("%d %d %d", &u, &v, &k);
e[u][v] = 1, e[v][u] = -1;
for (int j = 0; j < k; ++j) {
scanf("%d", &x);
dv[u][v].push_back(x);
}
for (int j = 0; j < k; ++j) dv[v][u].push_back(dv[u][v][k - 1 - j]);
}
for (int i = 1; i <= n; ++i)
for (int l = 0; l <= 2 * n; ++l) {
id[1][i][l] = ++dn;
if (!l) dp[dn] = 1;
id[0][i][l] = ++dn;
}
build();
svt = 0;
for (int i = 1; i <= dn; ++i)
if (!de[i]) sv[++svt] = i;
while (svt) {
int u = sv[svt--], v;
for (int j = 0, jt = tp[u].size(); j < jt; ++j) {
v = tp[u][j];
inc(dp[v], dp[u]);
if (--de[v] == 0) sv[++svt] = v;
}
}
for (int i = 1; i <= n; ++i)
for (int l = 1; l <= 2 * n; ++l) {
inc(ans[l], dp[id[0][i][l]]);
}
for (int i = 1; i <= 2 * n; ++i) printf("%d\n", ans[i]);
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int N = 55, M = N * N, p = 1e9 + 7;
int n, m, x[M], y[M], len[M], f[N << 1][N][2], q[N << 1], mp[N][N], mpr[N][N];
std::vector<int> a[M];
typedef struct {
int y, l, fx, fy;
} node;
std::vector<node> qs[N];
inline void add(int x, int y, int l, int fx, int fy) {
qs[x].push_back((node){y, l, fx, fy});
}
int main() {
int i, j, k, tmp, hd, tl, xx, yy, zz;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x[i], &y[i], &len[i]);
mp[x[i]][y[i]] = mpr[y[i]][x[i]] = i;
for (j = 0; j < len[i]; j++) scanf("%d", &tmp), a[i].push_back(tmp);
}
for (i = 1; i <= m; i++) {
for (j = 0; j + 1 < len[i]; j++)
if (a[i][j] == x[i] && a[i][j + 1] == y[i]) break;
if (j + 1 < len[i]) {
tmp = j;
for (j = tmp - 1, q[tl = 0] = x[i]; j >= 0; j--) q[++tl] = a[i][j];
for (hd = 1; hd <= tl && mpr[q[hd - 1]][q[hd]] && tl <= n * 2; hd++)
for (k = len[mpr[q[hd - 1]][q[hd]]] - 1; k >= 0; k--)
q[++tl] = a[mpr[q[hd - 1]][q[hd]]][k];
if (hd <= tl) continue;
xx = q[tl];
zz = tl;
for (j = tmp + 2, q[tl = 0] = y[i]; j < len[i]; j++) q[++tl] = a[i][j];
for (hd = 1; hd <= tl && mp[q[hd - 1]][q[hd]] && tl <= n * 2; hd++)
for (k = 0; k < len[mp[q[hd - 1]][q[hd]]]; k++)
q[++tl] = a[mp[q[hd - 1]][q[hd]]][k];
if (hd <= tl) continue;
yy = q[tl];
zz += tl;
add(xx, yy, zz + 1, 1, 1);
} else if (len[i] && a[i][len[i] - 1] == x[i]) {
for (j = len[i] - 2, q[tl = 0] = x[i]; j >= 0; j--) q[++tl] = a[i][j];
for (hd = 1; hd <= tl && mpr[q[hd - 1]][q[hd]] && tl <= n * 2; hd++)
for (k = len[mpr[q[hd - 1]][q[hd]]] - 1; k >= 0; k--)
q[++tl] = a[mpr[q[hd - 1]][q[hd]]][k];
if (hd <= tl) continue;
add(q[tl], y[i], tl + 1, 1, 0);
} else if (len[i] && a[i][0] == y[i]) {
for (j = 1, q[tl = 0] = y[i]; j < len[i]; j++) q[++tl] = a[i][j];
for (hd = 1; hd <= tl && mp[q[hd - 1]][q[hd]] && tl <= n * 2; hd++)
for (k = 0; k < len[mp[q[hd - 1]][q[hd]]]; k++)
q[++tl] = a[mp[q[hd - 1]][q[hd]]][k];
if (hd <= tl) continue;
add(x[i], q[tl], tl + 1, 0, 1);
} else if (!len[i])
add(x[i], y[i], 1, 0, 0);
}
for (i = 1; i <= n; i++) f[0][i][0] = 1;
for (i = 0; i <= n * 2; i++)
for (j = 1; j <= n; j++)
for (k = 0; k < qs[j].size(); k++)
f[i + qs[j][k].l][qs[j][k].y][qs[j][k].fy] =
(f[i + qs[j][k].l][qs[j][k].y][qs[j][k].fy] +
f[i][j][qs[j][k].fx ^ 1]) %
p;
for (i = 1; i <= n * 2; i++) {
for (tmp = 0, j = 1; j <= n; j++) tmp = (tmp + f[i][j][1]) % p;
printf("%d\n", tmp);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55, mod = 1e9 + 7;
void add(int &x, int y) {
x += y;
x = (x >= mod ? x - mod : x);
}
int cnt[N << 1][N][N][2][2], f[N << 1][N][2];
int n, q[N << 1], head, tail;
bool e[N][N];
vector<int> vec[N][N];
void solve0(int x, int y) {
head = 1;
tail = 0;
for (int nd : vec[x][y]) q[++tail] = nd;
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[u][v] || tail + vec[u][v].size() > n + n + 1) return;
for (int nd : vec[u][v]) q[++tail] = nd;
}
++cnt[tail][x][q[tail]][0][1];
}
void solve1(int x, int y) {
head = 1;
tail = 0;
for (int i = vec[x][y].size() - 1; i >= 0; --i) q[++tail] = vec[x][y][i];
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[v][u] || tail + vec[v][u].size() > n + n + 1) return;
for (int i = vec[v][u].size() - 1; i >= 0; --i) q[++tail] = vec[v][u][i];
}
++cnt[tail][q[tail]][y][1][0];
}
void solve(int x, int y, int pos) {
head = 1;
tail = 0;
for (int i = pos - 1; i >= 0; --i) q[++tail] = vec[x][y][i];
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[v][u] || tail + vec[v][u].size() > n + n + 1) return;
for (int i = vec[v][u].size() - 1; i >= 0; --i) q[++tail] = vec[v][u][i];
}
if (tail + vec[x][y].size() - pos > n + n + 1) return;
reverse(q + 1, q + tail + 1);
for (int i = pos; i < vec[x][y].size(); ++i) q[++tail] = vec[x][y][i];
++head;
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[u][v] || tail + vec[u][v].size() > n + n + 1) return;
for (int nd : vec[u][v]) q[++tail] = nd;
}
++cnt[tail - 1][q[1]][q[tail]][1][1];
}
void solve(int u, int v) {
if (!e[u][v]) return;
if (vec[u][v].size() > n + n + 1) return;
if (vec[u][v].size() == 0) return (void)(++cnt[1][u][v][0][0]);
if (vec[u][v].front() == v) solve0(u, v);
if (vec[u][v].back() == u) solve1(u, v);
for (int i = 1; i < vec[u][v].size(); ++i)
if (vec[u][v][i - 1] == u && vec[u][v][i] == v) solve(u, v, i);
}
int ans[N << 1];
signed main() {
int u, v, x, m, d;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> u >> v >> x;
e[u][v] = 1;
for (int j = 0; j < x; ++j) cin >> d, vec[u][v].push_back(d);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) solve(i, j);
for (int i = 1; i <= n; ++i) f[0][i][0] = 1;
for (int i = 0; i <= n + n; ++i)
for (int x = 1; x <= n; ++x) {
add(ans[i], f[i][x][1]);
for (int j = 0; i + j <= n + n; ++j)
for (int y = 1; y <= n; ++y)
for (int u = 0; u < 2; ++u)
for (int v = 0; v < 2; ++v)
add(f[i + j][y][v],
1ll * f[i][x][u] * cnt[j][x][y][u ^ 1][v] % mod);
}
for (int i = 1; i <= n + n; ++i) cout << ans[i] << endl;
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, x, y, tp;
int a[105][105][105], b[105][105], tk[105][105];
int A[105], B[105], C[105];
long long f[105][105][105][4], g[105][105][2], ans[105];
void Find(int X, int Y) {
int i, j, k = 0;
for (int t = 1; t < tk[X][Y]; t++)
if (a[X][Y][t] == X && a[X][Y][t + 1] == Y) k++;
if (k == 1)
for (int t = 1; t < tk[X][Y]; t++)
if (a[X][Y][t] == X && a[X][Y][t + 1] == Y) {
A[0] = 0;
for (i = t; i >= 1; i--) A[++A[0]] = a[X][Y][i];
int bz = 1;
for (i = 1; i < A[0]; i++) {
x = A[i + 1], y = A[i];
if (!b[x][y]) {
bz = 0;
break;
}
for (j = tk[x][y]; j >= 1; j--) {
A[++A[0]] = a[x][y][j];
if (A[0] > 2 * n + 1) {
bz = 0;
break;
}
}
if (!bz) break;
}
if (!bz) continue;
B[0] = 0;
for (i = t + 1; i <= tk[X][Y]; i++) B[++B[0]] = a[X][Y][i];
for (i = 1; i < B[0]; i++) {
x = B[i], y = B[i + 1];
if (!b[x][y]) {
bz = 0;
break;
}
for (j = 1; j <= tk[x][y]; j++) {
B[++B[0]] = a[x][y][j];
if (B[0] > 2 * n + 1) {
bz = 0;
break;
}
}
if (!bz) break;
}
if (!bz || A[0] + B[0] > 2 * n + 1) continue;
f[A[A[0]]][B[B[0]]][A[0] + B[0] - 1][0]++;
g[A[0] + B[0] - 1][B[B[0]]][1]++;
}
if (!tk[X][Y])
f[X][Y][1][3]++;
else {
if (a[X][Y][tk[X][Y]] == X) {
A[0] = 0;
for (i = tk[X][Y]; i >= 1; i--) A[++A[0]] = a[X][Y][i];
int bz = 1;
for (i = 1; i < A[0]; i++) {
x = A[i + 1], y = A[i];
if (!b[x][y]) {
bz = 0;
break;
}
for (j = tk[x][y]; j >= 1; j--) {
A[++A[0]] = a[x][y][j];
if (A[0] > 2 * n) {
bz = 0;
break;
}
}
if (!bz) break;
}
if (bz) f[A[A[0]]][Y][A[0]][1]++, g[A[0]][Y][0]++;
}
if (a[X][Y][1] == Y) {
A[0] = 0;
for (i = 1; i <= tk[X][Y]; i++) A[++A[0]] = a[X][Y][i];
int bz = 1;
for (i = 1; i < A[0]; i++) {
x = A[i], y = A[i + 1];
if (!b[x][y]) {
bz = 0;
break;
}
for (j = 1; j <= tk[x][y]; j++) {
A[++A[0]] = a[x][y][j];
if (A[0] > 2 * n) {
bz = 0;
break;
}
}
if (!bz) break;
}
if (bz) f[X][A[A[0]]][A[0]][2]++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y), b[x][y] = 1;
scanf("%d", &tk[x][y]);
for (j = 1; j <= tk[x][y]; j++) scanf("%d", &a[x][y][j]);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (b[i][j]) Find(i, j);
for (i = 1; i <= 2 * n; i++)
for (x = 1; x <= n; x++)
for (j = 0; j < 2; j++)
if (g[i][x][j]) {
for (k = 1; i + k <= 2 * n; k++)
for (y = 1; y <= n; y++) {
if (!j && f[x][y][k][0])
(g[i + k][y][1] += g[i][x][j] * f[x][y][k][0]) %= 1000000007;
if (!j && f[x][y][k][1])
(g[i + k][y][0] += g[i][x][j] * f[x][y][k][1]) %= 1000000007;
if (j && f[x][y][k][2])
(g[i + k][y][1] += g[i][x][j] * f[x][y][k][2]) %= 1000000007;
if (j && f[x][y][k][3])
(g[i + k][y][0] += g[i][x][j] * f[x][y][k][3]) %= 1000000007;
}
if (j) ans[i] += g[i][x][j];
}
for (i = 1; i <= 2 * n; i++) printf("%lld\n", ans[i] % 1000000007);
}
| 11 |
CPP
|
#include <bits/stdc++.h>
long long n, m, p = (long long)(1e9 + 7);
long long a[105][105], seq[105][105][105];
long long pl[1300], pr[1300], rd[1300];
long long flag[105][105];
long long f[105][105][105][4], dp[105][105][2];
long long ans[105];
void inc(long long i, long long j, long long k, long long o) {
f[i][j][k][o]++;
if (o == 0) dp[j][k][1]++;
if (o == 2) dp[j][k][0]++;
}
void pt_pt() {
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
if (flag[i][j]) {
long long pos, x, y, rf = 0;
for (long long k = 1; k <= seq[i][j][0] - 1; k++)
if (seq[i][j][k] == i && seq[i][j][k + 1] == j) {
pos = k;
break;
}
pl[pl[0] = 1] = i, pr[pr[0] = 1] = j;
rd[0] = 0;
for (long long k = pos + 1; k <= seq[i][j][0]; k++)
rd[++rd[0]] = seq[i][j][k];
while (pl[0] + pr[0] <= 2 * n + 1 && rd[0] > pr[0] &&
a[rd[pr[0]]][rd[pr[0] + 1]]) {
rf |= flag[x = rd[pr[0]]][y = rd[pr[0] + 1]];
pr[++pr[0]] = y;
for (long long k = 1; k <= seq[x][y][0]; k++)
rd[++rd[0]] = seq[x][y][k];
}
if (rd[0] > pr[0]) continue;
rd[0] = 0;
for (long long k = pos; k >= 1; k--) rd[++rd[0]] = seq[i][j][k];
while (pl[0] + pr[0] <= 2 * n + 1 && rd[0] > pl[0] &&
a[rd[pl[0] + 1]][rd[pl[0]]]) {
x = rd[pl[0] + 1], y = rd[pl[0]];
pl[++pl[0]] = x;
for (long long k = seq[x][y][0]; k >= 1; k--)
rd[++rd[0]] = seq[x][y][k];
}
if (rd[0] > pl[0]) continue;
if (!rf) inc(pl[pl[0]], pr[pr[0]], pl[0] + pr[0] - 1, 0);
}
}
void _pt() {
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
if (a[i][j] && seq[i][j][1] == j) {
long long x, y;
rd[0] = 0;
for (long long k = 1; k <= seq[i][j][0]; k++)
rd[++rd[0]] = seq[i][j][k];
pr[pr[0] = 1] = j;
while (pr[0] <= 2 * n && rd[0] > pr[0] && a[rd[pr[0]]][rd[pr[0] + 1]]) {
x = rd[pr[0]], y = rd[pr[0] + 1];
pr[++pr[0]] = y;
for (long long k = 1; k <= seq[x][y][0]; k++)
rd[++rd[0]] = seq[x][y][k];
}
if (rd[0] > pr[0]) continue;
inc(i, pr[pr[0]], pr[0], 1);
}
}
void pt_() {
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
if (a[i][j] && seq[i][j][seq[i][j][0]] == i) {
long long x, y;
rd[0] = 0;
for (long long k = seq[i][j][0]; k >= 1; k--)
rd[++rd[0]] = seq[i][j][k];
pl[pl[0] = 1] = i;
while (pl[0] <= 2 * n && rd[0] > pl[0] && a[rd[pl[0] + 1]][rd[pl[0]]]) {
x = rd[pl[0] + 1], y = rd[pl[0]];
pl[++pl[0]] = x;
for (long long k = seq[x][y][0]; k >= 1; k--)
rd[++rd[0]] = seq[x][y][k];
}
if (rd[0] > pl[0]) continue;
inc(pl[pl[0]], j, pl[0], 2);
}
}
long long add(long long& x, long long y) { (x += y) %= p; }
void calc() {
for (long long j = 1; j <= 2 * n; j++)
for (long long i = 1; i <= n; i++)
if (dp[i][j][0] || dp[i][j][1]) {
for (long long k = 1; k <= n; k++)
for (long long o = 1; o <= 2 * n - j; o++) {
if (dp[i][j][0] && f[i][k][o][2])
add(dp[k][j + o][0], dp[i][j][0] * f[i][k][o][2]);
if (dp[i][j][0] && f[i][k][o][0])
add(dp[k][j + o][1], dp[i][j][0] * f[i][k][o][0]);
if (dp[i][j][1] && f[i][k][o][1])
add(dp[k][j + o][1], dp[i][j][1] * f[i][k][o][1]);
if (dp[i][j][1] && f[i][k][o][3])
add(dp[k][j + o][0], dp[i][j][1] * f[i][k][o][3]);
}
add(ans[j], dp[i][j][1]);
}
}
int main() {
scanf("%lld", &n), scanf("%lld", &m);
for (long long i = 1; i <= m; i++) {
long long x, y;
scanf("%lld", &x), scanf("%lld", &y);
a[x][y] = i;
scanf("%lld", &seq[x][y][0]);
if (!seq[x][y][0]) inc(x, y, 1, 3);
for (long long j = 1; j <= seq[x][y][0]; j++)
scanf("%lld", &seq[x][y][j]),
flag[x][y] |= j > 1 && seq[x][y][j - 1] == x && seq[x][y][j] == y;
}
pt_pt(), _pt(), pt_();
calc();
for (long long i = 1; i <= 2 * n; i++) printf("%lld\n", ans[i]);
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int jsb = 1000000007;
const int N = 105;
int g[2][2][N][N][N];
int f[N][N][2];
int n, m;
int ans[N];
vector<int> xu[N * N];
int st[N * N], ed[N * N];
int go[N][N];
inline void add(int &x, int y) {
x += y;
if (x >= jsb) x -= jsb;
}
pair<int, int> GOGOGO(vector<int> &tp, int x, bool fan) {
int now = 0;
while (now + 1 <= tp.size()) {
int y = tp[now];
int bian = go[x][y];
if (!bian || tp.size() > 2 * n || (bian > m) != fan)
return pair<int, int>(10086, -1);
for (int j = (0); j <= (int)xu[bian].size() - 1; j++)
tp.push_back(xu[bian][j]);
x = y;
now++;
}
return pair<int, int>(tp.size(), x);
}
void Read() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (int)m; i++) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
go[x][y] = i;
st[i] = x;
ed[i] = y;
for (int j = (1); j <= (int)k; j++) {
int v;
scanf("%d", &v);
xu[i].push_back(v);
}
go[y][x] = i + m;
st[i + m] = y;
ed[i + m] = x;
for (int j = (k - 1); j >= (int)0; j--) xu[i + m].push_back(xu[i][j]);
if (k == 0) g[0][0][x][y][1]++;
}
}
int man[N][N][N];
int wei[N][N][N];
void work(bool fan) {
memset(man, 0, sizeof man);
memset(wei, 0, sizeof wei);
for (int i = (1); i <= (int)2 * m; i++)
if ((i <= m) ^ fan) {
for (int j = (0); j <= (int)xu[i].size() - 1; j++)
if (xu[i][j] == st[i]) {
vector<int> t1, t2;
for (int k = (j - 1); k >= (int)0; k--) t1.push_back(xu[i][k]);
pair<int, int> result = GOGOGO(t1, st[i], fan ^ 1);
if (result.first > 2 * n) continue;
if (j + 1 == xu[i].size())
wei[result.second][ed[i]][result.first + 1]++;
else {
if (xu[i][j + 1] != ed[i]) continue;
for (int k = (j + 2); k <= (int)xu[i].size() - 1; k++)
t2.push_back(xu[i][k]);
pair<int, int> res2 = GOGOGO(t2, ed[i], fan);
if (res2.first + 1 + result.first <= 2 * n)
man[result.second][res2.second][res2.first + 1 + result.first]++;
}
}
}
}
void GetG() {
work(0);
for (int i = (1); i <= (int)n; i++)
for (int j = (1); j <= (int)n; j++)
for (int k = (1); k <= (int)2 * n; k++) {
g[1][1][i][j][k] = man[i][j][k];
g[1][0][i][j][k] = wei[i][j][k];
}
work(1);
for (int i = (1); i <= (int)n; i++)
for (int j = (1); j <= (int)n; j++)
for (int k = (1); k <= (int)2 * n; k++) g[0][1][j][i][k] = wei[i][j][k];
}
void Solve() {
for (int i = (1); i <= (int)n; i++)
for (int j = (1); j <= (int)n; j++)
for (int k = (1); k <= (int)2 * n; k++)
for (int v = (0); v <= (int)1; v++) add(f[k][j][v], g[1][v][i][j][k]);
int rp;
for (int k = (1); k <= (int)n * 2; k++) {
rp = 0;
for (int i = (1); i <= (int)n; i++) {
add(rp, f[k][i][1]);
for (int mid = (0); mid <= (int)1; mid++)
if (f[k][i][mid]) {
for (int ed = (0); ed <= (int)1; ed++)
for (int zd = (1); zd <= (int)n; zd++)
for (int len = (1); len <= (int)2 * n - k; len++)
add(f[k + len][zd][ed],
f[k][i][mid] * 1ll * g[mid ^ 1][ed][i][zd][len] % jsb);
}
}
printf("%d\n", rp);
}
}
int main() {
Read();
GetG();
Solve();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 53, M = N * N, mod = 1e9 + 7;
template <typename T>
void rd(T &x) {
int ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
void qmo(int &x) { x += x >> 31 & mod; }
int n, m, id[N][N], x[M], y[M], l[M], q[N << 1], fr, re, dp[N << 1][N][2];
vector<int> a[M];
struct Node {
int to, l;
bool st, ed;
Node(int _a = 0, int _b = 0, bool _c = 0, bool _d = 0)
: to(_a), l(_b), st(_c), ed(_d) {}
};
vector<Node> pt[N];
int main() {
rd(n);
rd(m);
for (int i = 1; i <= m; ++i) {
rd(x[i]);
rd(y[i]);
rd(l[i]);
a[i].resize(l[i]);
id[x[i]][y[i]] = i;
for (int j = 0; j < l[i]; ++j) rd(a[i][j]);
}
for (int i = 1, p, e; i <= m; ++i) {
for (p = 0; p + 1 < l[i]; ++p)
if (a[i][p] == x[i] && a[i][p + 1] == y[i]) break;
if (!l[i])
pt[x[i]].emplace_back(y[i], 1, 0, 0);
else if (p + 1 < l[i]) {
q[re = 0] = x[i];
for (int j = p - 1; ~j; --j) q[++re] = a[i][j];
for (fr = 0; fr < re && (e = id[q[fr + 1]][q[fr]]) && re <= (n << 1);
++fr)
for (int j = l[e] - 1; ~j && re <= (n << 1); --j) q[++re] = a[e][j];
if (fr < re) continue;
int St = q[re], Le = re + 1;
q[re = 0] = y[i];
for (int j = p + 2; j < l[i]; ++j) q[++re] = a[i][j];
for (fr = 0; fr < re && (e = id[q[fr]][q[fr + 1]]) && re <= (n << 1);
++fr)
for (int j = 0; j < l[e] && re <= (n << 1); ++j) q[++re] = a[e][j];
if (fr == re) pt[St].emplace_back(q[re], Le + re, 1, 1);
} else if (a[i][0] == y[i]) {
q[re = 0] = y[i];
for (int j = 1; j < l[i]; ++j) q[++re] = a[i][j];
for (fr = 0; fr < re && (e = id[q[fr]][q[fr + 1]]) && re <= (n << 1);
++fr)
for (int j = 0; j < l[e] && re <= (n << 1); ++j) q[++re] = a[e][j];
if (fr == re) pt[x[i]].emplace_back(q[re], re + 1, 0, 1);
} else if (a[i][l[i] - 1] == x[i]) {
q[re = 0] = x[i];
for (int j = l[i] - 2; ~j; --j) q[++re] = a[i][j];
for (fr = 0; fr < re && (e = id[q[fr + 1]][q[fr]]) && re <= (n << 1);
++fr)
for (int j = l[e] - 1; ~j && re <= (n << 1); --j) q[++re] = a[e][j];
if (fr == re) pt[q[re]].emplace_back(y[i], re + 1, 1, 0);
}
}
for (int i = 1; i <= n; ++i) dp[0][i][0] = 1;
for (int i = 0; i < (n << 1); ++i)
for (int j = 1; j <= n; ++j)
for (Node _ : pt[j])
if (i + _.l <= (n << 1))
qmo(dp[i + _.l][_.to][_.ed] += dp[i][j][!_.st] - mod);
for (int i = 1; i <= (n << 1); ++i) {
int ans = 0;
for (int j = 1; j <= n; ++j) qmo(ans += dp[i][j][1] - mod);
printf("%d\n", ans);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55, mo = 1000000007;
int n, m;
int E[maxn][maxn];
int g[2][2][maxn][maxn][maxn << 1], f[maxn << 1][maxn][2],
A[maxn][maxn][maxn << 1], B[maxn][maxn][maxn << 1];
vector<int> ed[maxn * maxn];
int stk[maxn * 3], l, r;
void add(int &x, int y) {
x += y;
if (x >= mo) x -= mo;
}
pair<int, int> Go(int x, bool s) {
int i, len = 1, y, t;
while (l < r && r <= n + n) {
y = stk[l++];
if (t = E[x][y], !t || (t > m) != s) return pair<int, int>(111, 111);
x = y;
len++;
for (i = 0; i < (int)ed[t].size(); i++) stk[r++] = ed[t][i];
}
if (l == r) return pair<int, int>(len, x);
return pair<int, int>(111, 111);
}
void Work(bool s) {
memset(A, 0, sizeof A);
memset(B, 0, sizeof B);
int i, j, k, p, t;
pair<int, int> tmp1, tmp2;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (t = E[i][j], t && (t > m) == s)
for (k = 0; k < (int)ed[t].size(); k++)
if (ed[t][k] == i) {
l = r = 0;
for (p = k - 1; p >= 0; p--) stk[r++] = ed[t][p];
tmp1 = Go(i, s ^ 1);
if (tmp1.first > n + n) continue;
if (k == (int)ed[t].size() - 1)
A[tmp1.second][j][tmp1.first]++;
else if (ed[t][k + 1] == j) {
l = r = 0;
for (p = k + 2; p < (int)ed[t].size(); p++) stk[r++] = ed[t][p];
tmp2 = Go(j, s);
if (tmp2.first + tmp1.first - 1 <= n + n)
B[tmp1.second][tmp2.second][tmp1.first + tmp2.first - 1]++;
}
}
}
int main() {
int i, j, k, l, u, v, tmp, ans;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &k);
E[u][v] = i;
E[v][u] = i + m;
if (!k)
g[0][0][u][v][1] = 1;
else {
for (j = k; j; j--) {
scanf("%d", &k);
ed[i].push_back(k);
}
ed[i + m] = ed[i];
reverse(ed[i + m].begin(), ed[i + m].end());
}
}
Work(0);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n + n; k++)
g[1][0][i][j][k] = A[i][j][k], g[1][1][i][j][k] = B[i][j][k];
Work(1);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n + n; k++) g[0][1][i][j][k] = A[j][i][k];
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n + n; k++)
for (v = 0; v < 2; v++) add(f[k][j][v], g[1][v][i][j][k]);
for (i = 1; i <= n + n; i++) {
ans = 0;
for (j = 1; j <= n; j++) {
add(ans, f[i][j][1]);
for (v = 0; v < 2; v++)
for (l = 1; i + l <= n + n; l++)
for (k = 1; k <= n; k++)
for (u = 0; u < 2; u++)
if ((tmp = g[v ^ 1][u][j][k][l]))
add(f[i + l][k][u], 1LL * f[i][j][v] * tmp);
}
printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct path {
int u, u1, v, v1, l;
inline bool operator==(const path& x) const {
return u == x.u && u1 == x.u1 && v == x.v && v1 == x.v1 && l == x.l;
}
} p[3000 << 2];
struct edge {
bool is;
int s[55], st;
} is[55][55];
bool pd;
int head[500], sta[500], T[500], L, R, top, n, m, pt, dp[500][500][2];
inline bool extend(int);
int main() {
scanf("%d%d", &n, &m);
for (int i(1), j, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
scanf("%d", &is[u][v].st);
is[u][v].is = 1;
for (j = 1; j <= is[u][v].st; ++j) scanf("%d", &is[u][v].s[j]);
}
for (int i(1), j, k; i <= n; ++i)
for (j = 1; j <= n; ++j) {
if (!is[i][j].is) continue;
if (is[i][j].s[is[i][j].st] == i) {
top = 0, sta[++top] = j, sta[++top] = i;
L = 1, R = is[i][j].st - 1, memcpy(T + 1, is[i][j].s + 1, R << 2);
reverse(T + 1, T + R + 1);
if (extend(-1)) p[++pt] = {sta[top], 1, j, 1, top - 1};
}
for (k = 1; k <= is[i][j].st; ++k)
if (is[i][j].s[k] == i) break;
if (k < is[i][j].st && is[i][j].s[k + 1] == j) {
top = 0, sta[++top] = i, L = 1, R = k - 1;
memcpy(T + 1, is[i][j].s + 1, R << 2), reverse(T + 1, T + R + 1);
if (extend(-1)) {
reverse(sta + 1, sta + top + 1);
sta[++top] = j, L = 1, R = is[i][j].st - k - 1;
memcpy(T + 1, is[i][j].s + k + 2, R << 2);
if (extend(1))
if (top - 1 <= n << 1) {
p[++pt] = {sta[1], 1, sta[top], 0, top - 1};
}
}
}
if (!is[i][j].st) p[++pt] = {i, 0, j, 1, 1};
if (is[i][j].s[1] == j) {
top = 0, sta[++top] = i, sta[++top] = j;
L = 1, R = is[i][j].st - 1, memcpy(T + 1, is[i][j].s + 2, R << 2);
if (extend(1)) p[++pt] = {i, 0, sta[top], 0, top - 1};
}
}
for (int i(1); i <= n; ++i) dp[0][i][1] = 1;
for (int i(0), j; i < n << 1; ++i)
for (j = 1; j <= pt; ++j)
if (i + p[j].l <= n << 1)
(dp[i + p[j].l][p[j].v][p[j].v1] += dp[i][p[j].u][p[j].u1]) %=
1000000007;
for (int i(1), j; i <= n << 1; ++i) {
int ans(0);
for (j = 1; j <= n; ++j) (ans += dp[i][j][0]) %= 1000000007;
printf("%d\n", (ans + 1000000007) % 1000000007);
}
return 0;
}
inline bool extend(int d) {
while (L <= R) {
edge& i1(~d ? is[sta[top]][T[L]] : is[T[L]][sta[top]]);
if (!i1.is) return false;
sta[++top] = T[L++];
for (int j(~d ? 1 : i1.st); j && j <= i1.st; j += d) T[++R] = i1.s[j];
if (top - 1 > n << 1 || R - 1 > n << 1) return false;
}
return true;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50, mod = 1000000007;
int add(int a, int b, int p = mod) { return a + b >= p ? a + b - p : a + b; }
int sub(int a, int b, int p = mod) { return a - b < 0 ? a - b + p : a - b; }
int mul(int a, int b, int p = mod) { return 1LL * a * b % p; }
void sadd(int &a, int b, int p = mod) { a = add(a, b, p); }
void ssub(int &a, int b, int p = mod) { a = sub(a, b, p); }
void smul(int &a, int b, int p = mod) { a = mul(a, b, p); }
int n, m, e[N + 9][N + 9];
vector<int> str[N + 9][N + 9];
void into() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
e[x][y] = 1;
for (int j = 0; j < c; ++j) {
int k;
scanf("%d", &k);
str[x][y].push_back(k);
}
}
}
int cnt[N * 2 + 9][N + 9][N + 9][2][2];
int q[N * 2 + 9], hd, tl;
void Get_cnt0(int x, int y) {
hd = 1;
tl = 0;
for (int vs = str[x][y].size(), i = 0; i < vs; ++i) q[++tl] = str[x][y][i];
for (; hd < tl;) {
int u = q[hd], v = q[++hd];
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = 0; i < vs; ++i) q[++tl] = str[u][v][i];
}
++cnt[tl][x][q[tl]][0][1];
}
void Get_cnt1(int x, int y) {
hd = 1;
tl = 0;
for (int vs = str[x][y].size(), i = vs - 1; i >= 0; --i)
q[++tl] = str[x][y][i];
for (; hd < tl;) {
int v = q[hd], u = q[++hd];
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = vs - 1; i >= 0; --i)
q[++tl] = str[u][v][i];
}
++cnt[tl][q[tl]][y][1][0];
}
void Get_cnt(int x, int y, int p) {
hd = 1;
tl = 0;
for (int vs = str[x][y].size(), i = p - 1; i >= 0; --i)
q[++tl] = str[x][y][i];
for (; hd < tl;) {
int v = q[hd], u = q[++hd];
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = vs - 1; i >= 0; --i)
q[++tl] = str[u][v][i];
}
reverse(q + 1, q + tl + 1);
if (tl + str[x][y].size() - p > n * 2 + 1) return;
for (int vs = str[x][y].size(), i = p; i < vs; ++i) q[++tl] = str[x][y][i];
for (++hd; hd < tl;) {
int u = q[hd], v = q[++hd];
if (!e[u][v]) return;
if (tl + str[u][v].size() > n * 2 + 1) return;
for (int vs = str[u][v].size(), i = 0; i < vs; ++i) q[++tl] = str[u][v][i];
}
++cnt[tl - 1][q[1]][q[tl]][1][1];
}
void Get_cnt(int x, int y) {
if (!e[x][y]) return;
if (str[x][y].size() > n * 2 + 1) return;
if (str[x][y].empty()) {
cnt[1][x][y][0][0] = 1;
return;
}
if (str[x][y][0] == y) Get_cnt0(x, y);
if (str[x][y].back() == x) Get_cnt1(x, y);
for (int vs = str[x][y].size(), i = 1; i < vs; ++i)
if (str[x][y][i - 1] == x && str[x][y][i] == y) Get_cnt(x, y, i);
}
void Get_cnt() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
Get_cnt(i, j);
}
}
int dp[N * 2 + 9][N + 9][2], ans[N * 2 + 9];
void Get_dp() {
for (int i = 1; i <= n; ++i) dp[0][i][0] = 1;
for (int i = 0; i <= n << 1; ++i)
for (int x = 1; x <= n; ++x) {
sadd(ans[i], dp[i][x][1]);
for (int j = 1; i + j <= n << 1; ++j)
for (int y = 1; y <= n; ++y)
for (int u = 0; u < 2; ++u)
for (int v = 0; v < 2; ++v)
sadd(dp[i + j][y][v], mul(dp[i][x][u], cnt[j][x][y][u ^ 1][v]));
}
}
void work() {
Get_cnt();
Get_dp();
}
void outo() {
for (int i = 1; i <= n << 1; ++i) printf("%d\n", ans[i]);
}
int main() {
into();
work();
outo();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long ssum = 0, ff = 1;
char ch;
for (ch = getchar(); !isdigit(ch) && ch != '-'; ch = getchar())
;
if (ch == '-') ff = -1, ch = getchar();
for (; isdigit(ch); ch = getchar()) ssum = ssum * 10 + ch - '0';
return ssum * ff;
}
const long long M = 2505, N = 105, mod = 1e9 + 7;
long long n, m, cnt, x[M], y[M], c[M], l[M], ty[M], Head[M], G1[N][N], G2[N][N];
long long f[N][N][2];
vector<long long> Ve[M];
queue<long long> Qu1, Qu2;
long long etot, head[M], go[M], nex[M], w[M];
bool s[M], e[M];
inline void Addedge(long long u, long long v, long long len, bool ha,
bool haha) {
nex[++etot] = head[u];
head[u] = etot;
go[etot] = v;
w[etot] = len;
s[etot] = ha;
e[etot] = haha;
}
signed main() {
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
l[i] = -1;
x[i] = getint(), y[i] = getint(), c[i] = getint();
for (long long j = 1; j <= c[i]; j++) {
long long u = getint();
Ve[i].push_back(u);
}
G1[x[i]][y[i]] = i;
G2[y[i]][x[i]] = i;
for (long long j = 0; j < c[i] - 1; j++)
if (Ve[i][j] == x[i] && Ve[i][j + 1] == y[i]) l[i] = j;
if (l[i] != -1) {
ty[i] = 1;
goto END1;
}
for (long long j = 0; j < c[i]; j++)
if (Ve[i][j] == x[i]) l[i] = j;
if (l[i] != -1) ty[i] = 2;
l[i] = -1;
for (long long j = 0; j < c[i]; j++)
if (Ve[i][j] == y[i]) l[i] = j;
if (l[i] != -1) {
if (ty[i] == 2)
ty[i] == 4;
else
ty[i] = 3;
goto END1;
}
END1:;
}
for (long long i = 1; i <= m; i++) {
long long S, E;
if (ty[i] == 1) {
long long tmp_len = 1;
while (!Qu1.empty()) Qu1.pop();
while (!Qu2.empty()) Qu2.pop();
for (long long j = l[i] - 1; ~j; j--) Qu1.push(Ve[i][j]);
for (long long j = l[i] + 2; j < Ve[i].size(); j++) Qu2.push(Ve[i][j]);
S = x[i];
while (!Qu1.empty()) {
long long u = Qu1.front();
Qu1.pop();
tmp_len++;
if (tmp_len > 2 * n) goto END2;
if (!G2[S][u]) goto END2;
for (vector<long long>::reverse_iterator it = Ve[G2[S][u]].rbegin();
it != Ve[G2[S][u]].rend(); it++)
Qu1.push(*it);
S = u;
}
E = y[i];
while (!Qu2.empty()) {
long long u = Qu2.front();
Qu2.pop();
tmp_len++;
if (tmp_len > 2 * n) goto END2;
if (!G1[E][u]) goto END2;
for (vector<long long>::iterator it = Ve[G1[E][u]].begin();
it != Ve[G1[E][u]].end(); it++)
Qu2.push(*it);
E = u;
}
Addedge(S, E, tmp_len, 1, 1);
}
if ((ty[i] == 2 || ty[i] == 4) && *Ve[i].rbegin() == x[i]) {
long long tmp_len = 1;
while (!Qu1.empty()) Qu1.pop();
for (long long j = (long long)Ve[i].size() - 2; ~j; j--) {
Qu1.push(Ve[i][j]);
}
S = x[i], E = y[i];
while (!Qu1.empty()) {
long long u = Qu1.front();
Qu1.pop();
tmp_len++;
if (tmp_len > 2 * n) goto GG;
if (!G2[S][u]) goto GG;
for (vector<long long>::reverse_iterator it = Ve[G2[S][u]].rbegin();
it != Ve[G2[S][u]].rend(); it++)
Qu1.push(*it);
S = u;
}
Addedge(S, E, tmp_len, 1, 0);
}
GG:
if ((ty[i] == 3 || ty[i] == 4) && *Ve[i].begin() == y[i]) {
long long tmp_len = 1;
while (!Qu2.empty()) Qu2.pop();
for (long long j = 1; j < Ve[i].size(); j++) Qu2.push(Ve[i][j]);
S = x[i], E = y[i];
while (!Qu2.empty()) {
long long u = Qu2.front();
Qu2.pop();
tmp_len++;
if (tmp_len > 2 * n) goto END2;
if (!G1[E][u]) goto END2;
for (vector<long long>::iterator it = Ve[G1[E][u]].begin();
it != Ve[G1[E][u]].end(); it++)
Qu2.push(*it);
E = u;
}
Addedge(S, E, tmp_len, 0, 1);
}
if (!Ve[i].size()) Addedge(x[i], y[i], 1, 0, 0);
END2:;
}
for (long long i = 1; i <= n; i++) f[0][i][0] = 1;
for (long long l = 0; l <= 2 * n; l++) {
for (long long u = 1; u <= n; u++) {
for (long long i = head[u]; i; i = nex[i]) {
(f[l + w[i]][go[i]][e[i]] += f[l][u][s[i] ^ 1]) %= mod;
}
}
}
for (long long i = 1; i <= 2 * n; i++) {
long long ans = 0;
for (long long j = 1; j <= n; j++) (ans += f[i][j][1]) %= mod;
cout << ans << "\n";
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int b[51][51][51], c[51][51], d1[10001], d2[10001], n, m, i, j, k, l, x, h, t1,
t2;
long long f[2][101][51], g[3][101][51][51], ans[101];
bool a[51][51], Ans1;
void work1() {
int i, j, k, l, x, len;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++)
if (a[i][j] && c[i][j]) {
for (k = 1; k <= c[i][j] - 1; k++)
if (b[i][j][k] == i && b[i][j][k + 1] == j) {
x = i;
h = t1 = 1;
d1[1] = i;
len = 1;
for (l = k - 1; l >= 1; l--) d1[++t1] = b[i][j][l], ++len;
while (h < t1) {
++h;
if (len > n + n || !a[d1[h]][x]) {
h = -114514;
break;
}
for (l = c[d1[h]][x]; l >= 1; l--)
d1[++t1] = b[d1[h]][x][l], ++len;
x = d1[h];
}
if (h < t1) break;
x = j;
h = t2 = 1;
d2[1] = j;
for (l = k + 2; l <= c[i][j]; l++) d2[++t2] = b[i][j][l], ++len;
while (h < t2) {
++h;
if (len > n + n || !a[x][d2[h]]) {
h = -114514;
break;
}
for (l = 1; l <= c[x][d2[h]]; l++)
d2[++t2] = b[x][d2[h]][l], ++len;
x = d2[h];
}
if (h < t2) break;
if (!Ans1) {
Ans1 = 1;
}
++g[1][len][d1[t1]][d2[t2]];
break;
}
if (b[i][j][c[i][j]] == i) {
x = i;
h = t1 = 1;
d1[1] = i;
len = 1;
for (l = c[i][j] - 1; l >= 1; l--) d1[++t1] = b[i][j][l], ++len;
while (h < t1) {
++h;
if (len > n + n || !a[d1[h]][x]) {
h = -114514;
break;
}
for (l = c[d1[h]][x]; l >= 1; l--) d1[++t1] = b[d1[h]][x][l], ++len;
x = d1[h];
}
if (!(len > n + n || h < t1)) ++g[0][len][d1[t1]][j];
}
if (b[i][j][1] == j) {
x = j;
h = t2 = 1;
d2[1] = j;
len = 1;
for (l = 2; l <= c[i][j]; l++) d2[++t2] = b[i][j][l], ++len;
while (h < t2) {
++h;
if (len > n + n || !a[x][d2[h]]) {
h = -114514;
break;
}
for (l = 1; l <= c[x][d2[h]]; l++) d2[++t2] = b[x][d2[h]][l], ++len;
x = d2[h];
}
if (!(len > n + n || h < t2)) ++g[2][len][i][d2[t2]];
}
}
}
}
void work2() {
int i, s, j, k, l;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
for (k = 1; k <= n + n; k++)
f[0][k][j] = ((f[0][k][j]) + (g[0][k][i][j])) % 1000000007,
f[1][k][j] = ((f[1][k][j]) + (g[1][k][i][j])) % 1000000007;
}
}
for (i = 1; i <= n + n - 1; i++) {
for (s = 0; s <= 1; s++) {
for (j = 1; j <= n; j++)
if (f[s][i][j]) {
if (s == 1) {
for (l = 1; l <= n; l++)
if (a[j][l] && !c[j][l])
f[0][i + 1][l] = ((f[0][i + 1][l]) + (f[s][i][j])) % 1000000007;
}
for (k = 1; k <= n + n - i; k++) {
for (l = 1; l <= n; l++) switch (s) {
case 0: {
f[0][i + k][l] =
((f[0][i + k][l]) + (f[s][i][j] * g[0][k][j][l])) %
1000000007;
f[1][i + k][l] =
((f[1][i + k][l]) + (f[s][i][j] * g[1][k][j][l])) %
1000000007;
break;
}
case 1: {
f[1][i + k][l] =
((f[1][i + k][l]) + (f[s][i][j] * g[2][k][j][l])) %
1000000007;
break;
}
}
}
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &j, &k);
a[j][k] = 1;
scanf("%d", &c[j][k]);
for (l = 1; l <= c[j][k]; l++) scanf("%d", &b[j][k][l]);
}
work1();
if (!Ans1) {
for (i = 1; i <= n + n; i++) printf("0\n");
} else {
work2();
for (i = 1; i <= n + n; i++)
for (j = 1; j <= n; j++) ans[i] = ((ans[i]) + (f[1][i][j])) % 1000000007;
for (i = 1; i <= n + n; i++) printf("%lld\n", ans[i]);
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
const int MaxN = 50;
const int MaxM = 1225;
const int MaxL = MaxN * 2;
int n, m, lmax;
int a[MaxN + 1][MaxN + 1][MaxN + 1];
int a_n[MaxN + 1][MaxN + 1];
inline int &modaddto(int &a, const int &b) { return (a += b) %= Mod; }
int path_n;
int path[MaxL + MaxN];
bool extend_path(int sv, int su, int sp, int d) {
path_n = 0;
if (d == 1) {
for (int i = sp; i < a_n[sv][su]; i++) path[path_n++] = a[sv][su][i];
} else {
for (int i = sp; i >= 0; i--) path[path_n++] = a[sv][su][i];
}
for (int i = 0; i + 1 < path_n && path_n <= lmax; i++) {
int v = path[i], u = path[i + 1];
if (d == 1) {
if (a_n[v][u] == -1) return false;
for (int j = 0; j < a_n[v][u]; j++) path[path_n++] = a[v][u][j];
} else {
if (a_n[u][v] == -1) return false;
for (int j = a_n[u][v] - 1; j >= 0; j--) path[path_n++] = a[u][v][j];
}
}
return path_n <= lmax;
}
int main() {
cin >> n >> m;
lmax = n * 2;
for (int v = 1; v <= n; v++)
for (int u = 1; u <= n; u++) a_n[v][u] = -1;
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d %d", &v, &u);
scanf("%d", &a_n[v][u]);
for (int k = 0; k < a_n[v][u]; k++) scanf("%d", &a[v][u][k]);
}
static int g[MaxL + 1][MaxN + 1][MaxN + 1];
for (int ev = 1; ev <= n; ev++)
for (int eu = 1; eu <= n; eu++)
if (a_n[ev][eu] >= 2)
for (int p = 0; p + 1 < a_n[ev][eu]; p++)
if (a[ev][eu][p] == ev && a[ev][eu][p + 1] == eu) {
int st, ed;
int cur_n = 0;
if (!extend_path(ev, eu, p, -1)) continue;
st = path[path_n - 1];
cur_n += path_n;
if (!extend_path(ev, eu, p + 1, 1)) continue;
ed = path[path_n - 1];
cur_n += path_n;
cur_n--;
if (cur_n <= lmax) g[cur_n][st][ed]++;
}
int li_n;
static int li_v[MaxM], li_u[MaxM], li_l[MaxM];
li_n = 0;
for (int ev = 1; ev <= n; ev++)
for (int eu = 1; eu <= n; eu++)
if (a_n[ev][eu] >= 1 && a[ev][eu][a_n[ev][eu] - 1] == ev) {
if (!extend_path(ev, eu, a_n[ev][eu] - 1, -1)) continue;
li_v[li_n] = path[path_n - 1], li_u[li_n] = eu, li_l[li_n] = path_n,
li_n++;
}
for (int l = 1; l <= lmax; l++)
for (int u = 1; u <= n; u++)
for (int i = 0; i < li_n; i++)
if (l + li_l[i] <= lmax)
modaddto(g[l + li_l[i]][li_v[i]][u], g[l][li_u[i]][u]);
li_n = 0;
for (int ev = 1; ev <= n; ev++)
for (int eu = 1; eu <= n; eu++)
if (a_n[ev][eu] >= 1 && a[ev][eu][0] == eu) {
if (!extend_path(ev, eu, 0, 1)) continue;
li_v[li_n] = ev, li_u[li_n] = path[path_n - 1], li_l[li_n] = path_n,
li_n++;
}
for (int l = 1; l <= lmax; l++)
for (int v = 1; v <= n; v++)
for (int i = 0; i < li_n; i++)
if (l + li_l[i] <= lmax)
modaddto(g[l + li_l[i]][v][li_u[i]], g[l][v][li_v[i]]);
static int ga[MaxL + 1][MaxN + 1][MaxN + 1];
for (int l = 1; l <= lmax - 1; l++)
for (int v = 1; v <= n; v++)
for (int u = 1; u <= n; u++)
for (int k = 1; k <= n; k++)
if (a_n[k][v] == 0) modaddto(ga[l + 1][k][u], g[l][v][u]);
static int res[MaxL + 1][MaxN + 1];
for (int l = 1; l <= lmax; l++)
for (int v = 1; v <= n; v++)
for (int u = 1; u <= n; u++) modaddto(res[l][u], g[l][v][u]);
for (int l = 1; l <= lmax; l++)
for (int u = 1; u <= n; u++)
for (int k = 1; k <= n; k++)
for (int p = 1; l + p <= lmax; p++)
modaddto(res[l + p][k], (long long)res[l][u] * ga[p][u][k] % Mod);
for (int l = 1; l <= lmax; l++) {
int cur = 0;
for (int v = 1; v <= n; v++) (cur += res[l][v]) %= Mod;
printf("%d\n", cur);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline void _add(int &a, int b) {
if ((a += b) >= mod) a -= mod;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
int n, m;
bool f[52][52];
vector<int> E[52][52];
int typA_[52][52][102], typA_C[52][52][102], typA_CB_[52][52][102],
typZA_CB_[52][52][102], ans[52][102];
vector<int> typA[52][52], typB[52][52], typC[52][52];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, s, e, K; i <= m; i++) {
scanf("%d%d%d", &s, &e, &K);
f[s][e] = 1;
E[s][e].resize(K);
for (int j = 0; j < K; j++) scanf("%d", &E[s][e][j]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 0; k + 1 < E[i][j].size(); k++) {
if (E[i][j][k] == i && E[i][j][k + 1] == j) {
vector<int> cur = E[i][j], tmp;
while (1) {
if (cur.size() > 2 * n + 1) break;
bool flag = 0;
tmp.clear();
for (int t = 0; t + 1 < cur.size(); t++) {
if (!f[cur[t]][cur[t + 1]]) {
flag = 1;
break;
}
tmp.insert(tmp.end(), E[cur[t]][cur[t + 1]].begin(),
E[cur[t]][cur[t + 1]].end());
}
if (flag) break;
if (tmp == cur) {
typC[cur[0]][cur.back()].push_back(cur.size() - 1);
break;
}
if (tmp.size() > 2 * n + 1) break;
swap(tmp, cur);
}
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (E[i][j].size() && E[i][j].back() == i) {
vector<int> cur({i}), tmp;
while (1) {
if (cur.size() > 2 * n) break;
bool flag = 0;
tmp = E[cur[0]][j];
reverse(tmp.begin(), tmp.end());
for (int t = 0; t + 1 < cur.size(); t++) {
if (!f[cur[t + 1]][cur[t]]) {
flag = 1;
break;
}
reverse(E[cur[t + 1]][cur[t]].begin(), E[cur[t + 1]][cur[t]].end());
tmp.insert(tmp.end(), E[cur[t + 1]][cur[t]].begin(),
E[cur[t + 1]][cur[t]].end());
reverse(E[cur[t + 1]][cur[t]].begin(), E[cur[t + 1]][cur[t]].end());
}
if (flag) break;
if (tmp == cur) {
typA[cur.back()][j].push_back(cur.size());
break;
}
if (tmp.size() > 2 * n) break;
cur = tmp;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (E[i][j].size() && E[i][j][0] == j) {
vector<int> cur({j}), tmp;
while (1) {
if (cur.size() > 2 * n) break;
bool flag = 0;
tmp = E[i][cur[0]];
for (int t = 0; t + 1 < cur.size(); t++) {
if (!f[cur[t]][cur[t + 1]]) {
flag = 1;
break;
}
tmp.insert(tmp.end(), E[cur[t]][cur[t + 1]].begin(),
E[cur[t]][cur[t + 1]].end());
}
if (flag) break;
if (tmp == cur) {
typB[i][cur.back()].push_back(cur.size());
break;
}
if (tmp.size() > 2 * n) break;
cur = tmp;
}
}
}
}
for (int i = 1; i <= n; i++) typA_[i][i][0] = 1;
for (int len = 0; len <= 2 * n; len++) {
for (int s = 1; s <= n; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int &x : typA[i][j])
if (x + len <= 2 * n) _add(typA_[s][j][len + x], typA_[s][i][len]);
}
}
}
}
for (int s = 1; s <= n; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int len = 0; len <= 2 * n; len++) {
for (int &x : typC[i][j])
if (x + len <= 2 * n) _add(typA_C[s][j][len + x], typA_[s][i][len]);
}
}
}
}
memcpy(typA_CB_, typA_C, sizeof(typA_C));
for (int len = 0; len <= 2 * n; len++) {
for (int s = 1; s <= n; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int &x : typB[i][j])
if (x + len <= 2 * n)
_add(typA_CB_[s][j][len + x], typA_CB_[s][i][len]);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (f[i][j] && !E[i][j].size()) {
for (int k = 1; k <= n; k++) {
for (int l = 0; l + 1 <= 2 * n; l++) {
_add(typZA_CB_[i][k][l + 1], typA_CB_[j][k][l]);
}
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int l = 1; l <= 2 * n; l++) _add(ans[j][l], typA_CB_[i][j][l]);
}
}
for (int l = 1; l <= 2 * n; l++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int l1 = 1; l1 + l <= 2 * n; l1++) {
_add(ans[j][l + l1], mult(ans[i][l], typZA_CB_[i][j][l1]));
}
}
}
}
for (int i = 1; i <= n * 2; i++) {
int s = 0;
for (int j = 1; j <= n; j++) _add(s, ans[j][i]);
printf("%d\n", s);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55, mod = 1e9 + 7;
void add(int &x, int y) {
x += y;
x = (x >= mod ? x - mod : x);
}
int cnt[N << 1][N][N][2][2], f[N << 1][N][2];
int n, q[N << 1], head, tail;
bool e[N][N];
vector<int> vec[N][N];
void solve0(int x, int y) {
head = 1;
tail = 0;
for (int nd : vec[x][y]) q[++tail] = nd;
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[u][v] || tail + vec[u][v].size() > n + n + 1) return;
for (int nd : vec[u][v]) q[++tail] = nd;
}
++cnt[tail][x][q[tail]][0][1];
}
void solve1(int x, int y) {
head = 1;
tail = 0;
for (int i = vec[x][y].size() - 1; i >= 0; --i) q[++tail] = vec[x][y][i];
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[v][u] || tail + vec[v][u].size() > n + n + 1) return;
for (int i = vec[v][u].size() - 1; i >= 0; --i) q[++tail] = vec[v][u][i];
}
++cnt[tail][q[tail]][y][1][0];
}
void solve(int x, int y, int pos) {
head = 1;
tail = 0;
for (int i = pos - 1; i >= 0; --i) q[++tail] = vec[x][y][i];
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[v][u] || tail + vec[v][u].size() > n + n + 1) return;
for (int i = vec[v][u].size() - 1; i >= 0; --i) q[++tail] = vec[v][u][i];
}
if (tail + vec[x][y].size() - pos > n + n + 1) return;
reverse(q + 1, q + tail + 1);
for (int i = pos; i < vec[x][y].size(); ++i) q[++tail] = vec[x][y][i];
++head;
while (head < tail) {
int u = q[head], v = q[++head];
if (!e[u][v] || tail + vec[u][v].size() > n + n + 1) return;
for (int nd : vec[u][v]) q[++tail] = nd;
}
++cnt[tail - 1][q[1]][q[tail]][1][1];
}
void solve(int u, int v) {
if (!e[u][v]) return;
if (vec[u][v].size() > n + n + 1) return;
if (vec[u][v].size() == 0) return (void)(++cnt[1][u][v][0][0]);
if (vec[u][v].front() == v) solve0(u, v);
if (vec[u][v].back() == u) solve1(u, v);
for (int i = 1; i < vec[u][v].size(); ++i)
if (vec[u][v][i - 1] == u && vec[u][v][i] == v) solve(u, v, i);
}
int ans[N << 1];
signed main() {
int u, v, x, m, d;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> u >> v >> x;
e[u][v] = 1;
for (int j = 0; j < x; ++j) cin >> d, vec[u][v].push_back(d);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) solve(i, j);
for (int i = 1; i <= n; ++i) f[0][i][0] = 1;
for (int i = 0; i <= n + n; ++i)
for (int x = 1; x <= n; ++x) {
add(ans[i], f[i][x][1]);
for (int j = 0; i + j <= n + n; ++j)
for (int y = 1; y <= n; ++y)
for (int u = 0; u < 2; ++u)
for (int v = 0; v < 2; ++v)
add(f[i + j][y][v],
1ll * f[i][x][u] * cnt[j][x][y][u ^ 1][v] % mod);
}
for (int i = 1; i <= n + n; ++i) cout << ans[i] << endl;
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int e[50][50];
int re[50][50];
int efrom[1225];
int eto[1225];
int ecntv[1225];
int efirstv[1225];
int elastv[1225];
int eself[1225];
int nv;
int vval[100000];
int vnext[100000];
int vprev[100000];
int qh, qt;
int q[100];
int p[101];
int ntrans;
int firsttrans[100];
int nexttrans[122500];
int translen[122500];
int transto[122500];
const int MOD = 1000000007;
int cntways[102][100][100];
void run(int casenr) {
memset(e, -1, sizeof(e));
nv = 0;
ntrans = 0;
memset(firsttrans, -1, sizeof(firsttrans));
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); ++i) {
scanf("%d%d%d", &efrom[i], &eto[i], &ecntv[i]);
efrom[i]--;
eto[i]--;
e[efrom[i]][eto[i]] = i;
re[eto[i]][efrom[i]] = i;
efirstv[i] = elastv[i] = -1;
for (int j = (0); j < (ecntv[i]); ++j) {
scanf("%d", &vval[nv]);
--vval[nv];
if (j == 0) {
efirstv[i] = elastv[i] = nv;
vnext[nv] = vprev[nv] = -1;
} else {
vprev[nv] = elastv[i];
vnext[nv] = -1;
vnext[vprev[nv]] = nv;
elastv[i] = nv;
}
++nv;
}
}
for (int i = (0); i < (m); ++i) {
eself[i] = -1;
for (int j = efirstv[i]; j != -1; j = vnext[j])
if (vval[j] == efrom[i] && vnext[j] != -1 && vval[vnext[j]] == eto[i]) {
eself[i] = j;
break;
}
}
for (int i = (0); i < (m); ++i)
if (eself[i] != -1) {
bool ok = true;
int plen = 2;
int at;
qh = qt = 0;
for (int j = vprev[eself[i]]; j != -1; j = vprev[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = efrom[i];
while (qt < qh) {
int to = q[qt++];
if (e[to][at] == -1 || eself[e[to][at]] != -1) {
ok = false;
break;
}
for (int j = elastv[e[to][at]]; j != -1; j = vprev[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = to;
}
if (!ok) continue;
int pstart = at;
plen = 0;
for (int j = qh - 1; j >= 0; --j) p[plen++] = q[j];
p[plen++] = efrom[i];
p[plen++] = eto[i];
qh = qt = 0;
for (int j = vnext[vnext[eself[i]]]; j != -1; j = vnext[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = eto[i];
while (qt < qh) {
int to = q[qt++];
if (e[at][to] == -1) {
ok = false;
break;
}
for (int j = efirstv[e[at][to]]; j != -1; j = vnext[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = to;
}
int pend = at;
if (!ok) continue;
plen -= qh;
for (int j = 0; j < qh; ++j) p[plen++] = q[j];
nexttrans[ntrans] = firsttrans[n + pstart];
firsttrans[n + pstart] = ntrans;
translen[ntrans] = plen;
transto[ntrans] = pend;
++ntrans;
}
for (int i = (0); i < (m); ++i)
if (eself[i] == -1 && elastv[i] != -1 && vval[elastv[i]] == efrom[i]) {
bool ok = true;
int plen = 1;
int at;
qh = qt = 0;
for (int j = vprev[elastv[i]]; j != -1; j = vprev[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = efrom[i];
while (qt < qh) {
int to = q[qt++];
if (e[to][at] == -1 || eself[e[to][at]] != -1) {
ok = false;
break;
}
for (int j = elastv[e[to][at]]; j != -1; j = vprev[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = to;
}
if (!ok) continue;
int pstart = at, pend = eto[i];
nexttrans[ntrans] = firsttrans[n + pstart];
firsttrans[n + pstart] = ntrans;
translen[ntrans] = plen;
transto[ntrans] = n + pend;
++ntrans;
}
for (int i = (0); i < (m); ++i)
if (efirstv[i] != -1 && vval[efirstv[i]] == eto[i]) {
bool ok = true;
int plen = 1;
int at;
qh = qt = 0;
for (int j = vnext[efirstv[i]]; j != -1; j = vnext[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = eto[i];
while (qt < qh) {
int to = q[qt++];
if (e[at][to] == -1) {
ok = false;
break;
}
for (int j = efirstv[e[at][to]]; j != -1; j = vnext[j])
if (plen < 2 * n + 1) {
q[qh++] = vval[j];
++plen;
} else
ok = false;
at = to;
}
if (!ok) continue;
int pstart = efrom[i], pend = at;
nexttrans[ntrans] = firsttrans[pstart];
firsttrans[pstart] = ntrans;
translen[ntrans] = plen;
transto[ntrans] = pend;
++ntrans;
}
for (int i = (0); i < (m); ++i)
if (ecntv[i] == 0) {
int pstart = efrom[i], pend = eto[i], plen = 0;
nexttrans[ntrans] = firsttrans[pstart];
firsttrans[pstart] = ntrans;
translen[ntrans] = plen;
transto[ntrans] = n + pend;
++ntrans;
}
memset(cntways, 0, sizeof(cntways));
for (int j = (0); j < (n); ++j) cntways[0][n + j][n + j] = 1;
for (int i = (0); i < (2 * n + 1); ++i)
for (int j = (0); j < (2 * n); ++j)
for (int k = (0); k < (2 * n); ++k)
if (cntways[i][j][k] != 0)
for (int x = firsttrans[k]; x != -1; x = nexttrans[x])
if (i + translen[x] <= 2 * n + 1) {
cntways[i + translen[x]][j][transto[x]] += cntways[i][j][k];
if (cntways[i + translen[x]][j][transto[x]] >= MOD)
cntways[i + translen[x]][j][transto[x]] -= MOD;
}
for (int i = (2); i <= (2 * n + 1); ++i) {
int cur = 0;
for (int j = (0); j < (n); ++j)
for (int k = (0); k < (n); ++k) {
cur += cntways[i][n + j][k];
if (cur >= MOD) cur -= MOD;
}
printf("%d\n", cur);
}
}
int main() {
run(1);
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int MAXN = 55;
const int MAXS = 10105;
const int MOD = 1000000007;
int n;
bool g[MAXN][MAXN];
std::vector<int> e[MAXN][MAXN];
std::vector<int> tr[MAXS];
int f[MAXS];
void input() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int x, y, nv;
scanf("%d%d%d", &x, &y, &nv);
--x;
--y;
std::vector<int> ev(nv);
for (int j = 0; j < nv; ++j) {
int v;
scanf("%d", &v);
--v;
ev[j] = v;
}
g[x][y] = true;
e[x][y] = ev;
}
}
int check_edge(const std::vector<int> &a, int x, int y) {
if (a.empty()) return -1;
for (std::vector<int>::const_iterator i = a.begin(); i + 1 != a.end(); ++i)
if (*i == x && *(i + 1) == y) return i - a.begin();
return -1;
}
int walk(std::vector<int> &a, int now, bool reverse) {
for (int k = 0; (int)a.size() < 2 * n && k < (int)a.size(); ++k) {
if ((!reverse && !g[now][a[k]]) || (reverse && !g[a[k]][now])) return -1;
if (!reverse)
a.insert(a.end(), e[now][a[k]].begin(), e[now][a[k]].end());
else {
a.insert(a.end(), e[a[k]][now].rbegin(), e[a[k]][now].rend());
}
now = a[k];
}
if ((int)a.size() >= 2 * n) return -1;
return now;
}
void add_trans(int x, int y, int len) {
for (int i = 0; i + len <= 2 * n; ++i)
tr[i * (2 * n) + x].push_back((i + len) * (2 * n) + y);
}
void init() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (g[i][j]) {
int pos;
if ((pos = check_edge(e[i][j], i, j)) != -1) {
std::vector<int> tmpl(e[i][j].begin(), e[i][j].begin() + pos);
std::reverse(tmpl.begin(), tmpl.end());
int nowl = walk(tmpl, i, true);
std::vector<int> tmpr(e[i][j].begin() + (pos + 2), e[i][j].end());
int nowr = walk(tmpr, j, false);
if (nowl != -1 && nowr != -1)
add_trans(nowl, nowr + n, tmpl.size() + tmpr.size() + 1);
}
if (e[i][j].empty()) {
add_trans(i + n, j, 1);
}
if (!e[i][j].empty() && e[i][j].front() == j) {
std::vector<int> tmp(e[i][j].begin() + 1, e[i][j].end());
int now = walk(tmp, j, false);
if (now != -1) add_trans(i + n, now + n, tmp.size() + 1);
}
if (!e[i][j].empty() && e[i][j].back() == i) {
std::vector<int> tmp(e[i][j].begin(), e[i][j].end() - 1);
std::reverse(tmp.begin(), tmp.end());
int now = walk(tmp, i, true);
if (now != -1) add_trans(now, j, tmp.size() + 1);
}
}
}
void solve() {
int totstate = (2 * n + 1) * (2 * n);
for (int i = 0; i < n; ++i) f[i] = 1;
for (int i = 0; i < totstate; ++i)
for (std::vector<int>::const_iterator j = tr[i].begin(); j != tr[i].end();
++j)
(f[*j] += f[i]) %= MOD;
for (int i = 1; i <= 2 * n; ++i) {
int sum = 0;
for (int j = 0; j < n; ++j) (sum += f[i * (2 * n) + j + n]) %= MOD;
printf("%d\n", sum);
}
}
int main() {
input();
init();
solve();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
namespace FGF {
int n, m;
const int N = 55, M = N * N, mo = 1e9 + 7;
vector<int> s[M];
vector<int>::iterator it;
vector<int>::reverse_iterator rit;
int g[N][N], is[M], u[M], v[M], w[M], f[N << 1][N][2], cnt, head[N];
queue<int> q;
struct edg {
int to, nxt, w;
bool e, s;
} e[M << 1];
void add(int u, int v, bool s, bool ed, int w) {
e[++cnt].to = v;
e[cnt].nxt = head[u];
e[cnt].e = ed, e[cnt].s = s, e[cnt].w = w;
head[u] = cnt;
}
void work() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
is[i] = -1;
scanf("%d%d%d", &u[i], &v[i], &w[i]);
for (int j = 1, x; j <= w[i]; j++) scanf("%d", &x), s[i].push_back(x);
g[u[i]][v[i]] = i;
for (int j = 0; j < w[i] - 1; j++)
if (s[i][j] == u[i] && s[i][j + 1] == v[i]) is[i] = j;
}
for (int i = 1; i <= m; i++) {
if (~is[i]) {
int len = 1, S, E;
while (q.size()) q.pop();
for (int j = is[i] - 1; j >= 0; j--) q.push(s[i][j]);
S = u[i];
while (q.size()) {
int x = q.front();
q.pop();
len++;
if (len > 2 * n) goto END;
if (!g[x][S]) goto END;
if (s[g[x][S]].size())
for (rit = s[g[x][S]].rbegin(); rit != s[g[x][S]].rend(); rit++)
q.push(*rit);
S = x;
}
while (q.size()) q.pop();
for (int j = is[i] + 2; j < w[i]; j++) q.push(s[i][j]);
E = v[i];
while (q.size()) {
int x = q.front();
q.pop();
len++;
if (len > 2 * n) goto END;
if (!g[E][x]) goto END;
if (s[g[E][x]].size())
for (it = s[g[E][x]].begin(); it != s[g[E][x]].end(); it++)
q.push(*it);
E = x;
}
add(S, E, 1, 1, len);
} else if (s[i].size() && *s[i].rbegin() == u[i]) {
int len = 1, S = u[i], E = v[i];
while (q.size()) q.pop();
for (int j = w[i] - 2; j >= 0; j--) q.push(s[i][j]);
while (q.size()) {
int x = q.front();
q.pop();
len++;
if (len > 2 * n) goto END;
if (!g[x][S]) goto END;
if (s[g[x][S]].size())
for (rit = s[g[x][S]].rbegin(); rit != s[g[x][S]].rend(); rit++)
q.push(*rit);
S = x;
}
add(S, E, 1, 0, len);
} else if (s[i].size() && *s[i].begin() == v[i]) {
int len = 1, S = u[i], E = v[i];
while (q.size()) q.pop();
for (int j = 1; j < w[i]; j++) q.push(s[i][j]);
while (q.size()) {
int x = q.front();
q.pop();
len++;
if (len > 2 * n) goto END;
if (!g[E][x]) goto END;
if (s[g[E][x]].size())
for (it = s[g[E][x]].begin(); it != s[g[E][x]].end(); it++)
q.push(*it);
E = x;
}
add(S, E, 0, 1, len);
}
if (w[i] == 0) add(u[i], v[i], 0, 0, 1);
END:;
}
for (int i = 1; i <= n; i++) f[0][i][0] = 1;
for (int l = 0; l <= 2 * n; l++)
for (int x = 1; x <= n; x++)
for (int i = head[x]; i; i = e[i].nxt)
(f[l + e[i].w][e[i].to][e[i].e] += f[l][x][e[i].s ^ 1]) %= mo;
for (int l = 1; l <= 2 * n; l++) {
int ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + f[l][i][1]) % mo;
printf("%d\n", ans);
}
}
} // namespace FGF
int main() {
FGF::work();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int MAXN = 55;
const int MAXS = 10105;
const int MOD = 1000000007;
int n;
bool g[MAXN][MAXN];
std::vector<int> e[MAXN][MAXN];
std::vector<int> tr[MAXS];
int f[MAXS];
void input() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int x, y, nv;
scanf("%d%d%d", &x, &y, &nv);
--x;
--y;
std::vector<int> ev(nv);
for (int j = 0; j < nv; ++j) {
int v;
scanf("%d", &v);
--v;
ev[j] = v;
}
g[x][y] = true;
e[x][y] = ev;
}
}
int check_edge(const std::vector<int> &a, int x, int y) {
if (a.empty()) return -1;
for (std::vector<int>::const_iterator i = a.begin(); i + 1 != a.end(); ++i)
if (*i == x && *(i + 1) == y) return i - a.begin();
return -1;
}
int walk(std::vector<int> &a, int now, bool reverse) {
for (int k = 0; (int)a.size() < 2 * n && k < (int)a.size(); ++k) {
if ((!reverse && !g[now][a[k]]) || (reverse && !g[a[k]][now])) return -1;
if (!reverse)
a.insert(a.end(), e[now][a[k]].begin(), e[now][a[k]].end());
else {
a.insert(a.end(), e[a[k]][now].rbegin(), e[a[k]][now].rend());
}
now = a[k];
}
if ((int)a.size() >= 2 * n) return -1;
return now;
}
void add_trans(int x, int y, int len) {
for (int i = 0; i + len <= 2 * n; ++i)
tr[i * (2 * n) + x].push_back((i + len) * (2 * n) + y);
}
void init() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (g[i][j]) {
int pos;
if ((pos = check_edge(e[i][j], i, j)) != -1) {
std::vector<int> tmpl(e[i][j].begin(), e[i][j].begin() + pos);
std::reverse(tmpl.begin(), tmpl.end());
int nowl = walk(tmpl, i, true);
std::vector<int> tmpr(e[i][j].begin() + (pos + 2), e[i][j].end());
int nowr = walk(tmpr, j, false);
if (nowl != -1 && nowr != -1)
add_trans(nowl, nowr + n, tmpl.size() + tmpr.size() + 1);
}
if (e[i][j].empty()) {
add_trans(i + n, j, 1);
}
if (!e[i][j].empty() && e[i][j].front() == j) {
std::vector<int> tmp(e[i][j].begin() + 1, e[i][j].end());
int now = walk(tmp, j, false);
if (now != -1) add_trans(i + n, now + n, tmp.size() + 1);
}
if (!e[i][j].empty() && e[i][j].back() == i) {
std::vector<int> tmp(e[i][j].begin(), e[i][j].end() - 1);
std::reverse(tmp.begin(), tmp.end());
int now = walk(tmp, i, true);
if (now != -1) add_trans(now, j, tmp.size() + 1);
}
}
}
void solve() {
int totstate = (2 * n + 1) * (2 * n);
for (int i = 0; i < n; ++i) f[i] = 1;
for (int i = 0; i < totstate; ++i)
for (std::vector<int>::const_iterator j = tr[i].begin(); j != tr[i].end();
++j)
(f[*j] += f[i]) %= MOD;
for (int i = 1; i <= 2 * n; ++i) {
int sum = 0;
for (int j = 0; j < n; ++j) (sum += f[i * (2 * n) + j + n]) %= MOD;
printf("%d\n", sum);
}
}
int main() {
input();
init();
solve();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int prime = 1000000007;
int n, m;
int d[60][60], l[60][60], r[60][60], vis[100000];
bool con[60][60];
void init() {
scanf("%d%d", &n, &m);
memset(d, 0, sizeof(d));
memset(con, false, sizeof(con));
memset(vis, 0, sizeof(vis));
int top = 0;
int i, j;
for (i = 1; i <= (m); ++i) {
int x, y, z, t;
scanf("%d%d%d", &x, &y, &z);
d[x][y] = z;
con[x][y] = true;
l[x][y] = top + 1;
r[x][y] = top + z;
for (j = 1; j <= (z); ++j) {
scanf("%d", &t);
vis[top + j] = t;
}
top += z;
}
}
int ql, qr;
int q[1000];
void goback() {
while (ql <= qr && qr <= 2 * n + 2) {
int y = q[ql - 1];
int x = q[ql++];
if (!con[x][y]) {
qr = ql + 1;
return;
}
for (int p = r[x][y]; p >= l[x][y]; --p) q[++qr] = vis[p];
}
}
void gofront() {
while (ql <= qr && qr <= 2 * n + 2) {
int x = q[ql - 1];
int y = q[ql++];
if (!con[x][y]) {
qr = ql + 1;
return;
}
for (int p = l[x][y]; p <= r[x][y]; ++p) q[++qr] = vis[p];
}
}
int fullpath[60][60][120], prefix[60][60][120], suffix[60][60][120];
int ans[60];
vector<pair<int, int> > g1[60][60], g2[60][60], g3[60][60];
int f0[120][60], f1[120][60], s[60];
inline void update(int &x, int &y, int z) {
x = (x + (long long)y * z) % prime;
}
void work() {
int i, j, k, len;
memset(fullpath, 0, sizeof(fullpath));
memset(prefix, 0, sizeof(prefix));
memset(suffix, 0, sizeof(suffix));
for (i = 1; i <= (n); ++i)
for (j = 1; j <= (n); ++j)
for (k = l[i][j]; k <= (r[i][j] - 1); ++k)
if (vis[k] == i && vis[k + 1] == j) {
int len = 0;
ql = 2;
qr = 0;
for (int p = k; p >= l[i][j]; --p) q[++qr] = vis[p];
goback();
int x = q[qr];
len += qr;
if (ql <= qr) continue;
ql = 2;
qr = 0;
for (int p = k + 1; p <= r[i][j]; ++p) q[++qr] = vis[p];
gofront();
int y = q[qr];
len += qr;
if (ql <= qr) continue;
fullpath[x][y][len]++;
}
for (i = 1; i <= (n); ++i)
for (j = 1; j <= (n); ++j)
if (vis[r[i][j]] == i && l[i][j] <= r[i][j]) {
int len = 0;
ql = 2;
qr = 0;
for (int p = r[i][j]; p >= l[i][j]; --p) q[++qr] = vis[p];
goback();
int x = q[qr];
len += qr;
if (ql <= qr) continue;
prefix[x][j][len]++;
}
for (i = 1; i <= (n); ++i)
for (j = 1; j <= (n); ++j)
if (vis[l[i][j]] == j && l[i][j] <= r[i][j]) {
int len = 0;
ql = 2;
qr = 0;
for (int p = l[i][j]; p <= r[i][j]; ++p) q[++qr] = vis[p];
gofront();
int y = q[qr];
len += qr;
if (ql <= qr) continue;
suffix[i][y][len]++;
}
for (i = 1; i <= (n); ++i)
for (j = 1; j <= (n); ++j)
for (k = 1; k <= (n * 2 + 1); ++k) {
if (prefix[i][j][k] != 0)
g1[i][j].push_back(make_pair(prefix[i][j][k], k));
if (fullpath[i][j][k] != 0)
g2[i][j].push_back(make_pair(fullpath[i][j][k], k));
if (suffix[i][j][k] != 0)
g3[i][j].push_back(make_pair(suffix[i][j][k], k));
}
memset(f0, 0, sizeof(f0));
memset(f1, 0, sizeof(f1));
for (i = 1; i <= (n); ++i) f0[0][i] = 1;
vector<pair<int, int> >::iterator p;
for (len = 0; len <= (n * 2); ++len) {
memset(s, 0, sizeof(s));
for (i = 1; i <= (n); ++i)
for (j = 1; j <= (n); ++j) {
for (p = g1[i][j].begin();
p != g1[i][j].end() && p->second + len <= n * 2 + 1; ++p)
update(f0[len + p->second][j], f0[len][i], p->first);
for (p = g2[i][j].begin();
p != g2[i][j].end() && p->second + len <= n * 2 + 1; ++p)
update(f1[len + p->second][j], f0[len][i], p->first);
for (p = g3[i][j].begin();
p != g3[i][j].end() && p->second + len <= n * 2 + 1; ++p)
update(f1[len + p->second][j], f1[len][i], p->first);
}
if (len == 0) continue;
for (i = 1; i <= (n); ++i)
for (j = 1; j <= (n); ++j)
if (d[i][j] == 0 && con[i][j]) update(s[j], f1[len][i], 1);
for (j = 1; j <= (n); ++j)
for (k = 1; k <= (n); ++k) {
for (p = g1[j][k].begin();
p != g1[j][k].end() && p->second + len <= n * 2 + 1; ++p)
update(f0[len + p->second][k], s[j], p->first);
for (p = g2[j][k].begin();
p != g2[j][k].end() && p->second + len <= n * 2 + 1; ++p)
update(f1[len + p->second][k], s[j], p->first);
}
}
memset(ans, 0, sizeof(ans));
for (len = 2; len <= (n * 2 + 1); ++len)
for (i = 1; i <= (n); ++i) update(ans[len - 1], f1[len][i], 1);
for (i = 1; i <= (n * 2); ++i) printf("%d\n", ans[i]);
}
int main() {
init();
work();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int mod = 1e9 + 7, N = 55;
int n, m, lim, f[N << 1][2][N];
bool ex[N][N];
vector<int> a[N][N], trans[2][2][N][N];
bool extend_front(deque<int> &q, deque<int>::iterator it) {
while (it != q.begin() && q.size() <= lim) {
auto nit = it - 1;
if (!ex[*nit][*it] || q.size() + a[*nit][*it].size() > lim) return 0;
q.insert(q.begin(), a[*nit][*it].begin(), a[*nit][*it].end());
it = nit;
}
return q.size() <= lim;
}
bool extend_back(deque<int> &q, deque<int>::iterator it) {
while (it + 1 != q.end() && q.size() <= lim) {
auto nit = it + 1;
if (!ex[*it][*nit] || q.size() + a[*it][*nit].size() > lim) return 0;
q.insert(q.end(), a[*it][*nit].begin(), a[*it][*nit].end());
it = nit;
}
return q.size() <= lim;
}
void inc(int &x, int y) { x + y >= mod ? x += y - mod : x += y; }
signed main() {
read(n);
read(m);
lim = n << 1 | 1;
for (int i = 1, x, y, z; i <= m; i++) {
read(x);
read(y);
read(z);
ex[x][y] = 1;
a[x][y].resize(z);
for (int &o : a[x][y]) read(o);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (ex[i][j] && !a[i][j].empty() && a[i][j].back() == i) {
deque<int> q(a[i][j].begin(), a[i][j].end());
if (extend_front(q, --q.end()))
trans[0][0][q.front()][j].push_back(q.size());
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (ex[i][j] && !a[i][j].empty() && a[i][j].front() == j) {
deque<int> q(a[i][j].begin(), a[i][j].end());
if (extend_back(q, q.begin()))
trans[1][1][i][q.back()].push_back(q.size());
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (ex[i][j] && !a[i][j].empty()) {
deque<int> q(a[i][j].begin(), a[i][j].end());
auto p = find(q.begin(), q.end(), i);
if (p != q.end() && p + 1 != q.end() && *(p + 1) == j &&
extend_front(q, p) && extend_back(q, p + 1))
trans[0][1][q.front()][q.back()].push_back(q.size() - 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (ex[i][j] && a[i][j].empty()) trans[1][0][i][j].push_back(1);
for (int i = 1; i <= n; i++) f[0][0][i] = 1;
for (int len = 0; len < n << 1; len++)
for (int p : {0, 1})
for (int i = 1; i <= n; i++)
if (f[len][p][i])
for (int q : {0, 1})
for (int j = 1; j <= n; j++)
for (int x : trans[p][q][i][j])
if (len + x <= n << 1) inc(f[len + x][q][j], f[len][p][i]);
for (int len = 1; len <= n << 1; len++) {
int ans = 0;
for (int i = 1; i <= n; i++) inc(ans, f[len][1][i]);
write(ans);
puts("");
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
namespace zzc {
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
const int maxn = 55;
const int mod = 1e9 + 7;
int n, m;
int e[maxn][maxn], f[2][maxn][maxn << 1];
vector<int> str[maxn][maxn], trans[2][2][maxn][maxn];
bool extend(deque<int> &q, deque<int>::iterator it, int kind) {
bool flag = true;
if (!kind) {
for (auto pre = prev(it); it != q.begin() && (int)q.size() <= 2 * n;
it = pre, pre = prev(it)) {
flag &= e[*pre][*it];
q.insert(q.begin(), str[*pre][*it].begin(), str[*pre][*it].end());
}
} else {
for (auto nxt = next(it); nxt != q.end() && (int)q.size() <= 2 * n;
it = nxt, nxt = next(it)) {
flag &= e[*it][*nxt];
q.insert(q.end(), str[*it][*nxt].begin(), str[*it][*nxt].end());
}
}
return flag & ((int)q.size() <= 2 * n);
}
void init() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (str[i][j].size() && str[i][j].back() == i) {
deque<int> q(str[i][j].begin(), str[i][j].end());
if (extend(q, prev(q.end()), false))
trans[0][0][q.front()][j].push_back((int)q.size());
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
auto p = find(str[i][j].begin(), str[i][j].end(), i);
if (p == str[i][j].end() || (++p) == str[i][j].end() || (*p) != j)
continue;
deque<int> q(str[i][j].begin(), str[i][j].end());
deque<int>::iterator it = q.begin() + (p - str[i][j].begin()) - 1;
if (extend(q, it, false) && extend(q, it + 1, true))
trans[0][1][q.front()][q.back()].push_back((int)q.size() - 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (e[i][j] && str[i][j].empty()) trans[1][0][i][j].push_back(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (str[i][j].size() && str[i][j].front() == j) {
deque<int> q(str[i][j].begin(), str[i][j].end());
if (extend(q, q.begin(), true))
trans[1][1][i][q.back()].push_back((int)q.size());
}
}
}
void work() {
int a, b, c;
n = read();
m = read();
for (int i = 1; i <= n; i++) f[0][i][0] = 1;
for (int i = 1; i <= m; i++) {
a = read();
b = read();
e[a][b] = 1;
c = read();
while (c--) str[a][b].push_back(read());
}
init();
for (int l = 0; l < 2 * n; l++)
for (int i = 0; i <= 1; i++)
for (int j = 1; j <= n; j++) {
if (f[i][j][l]) {
for (int x = 0; x <= 1; x++)
for (int y = 1; y <= n; y++)
for (auto v : trans[i][x][j][y])
if (v + l <= 2 * n)
f[x][y][v + l] = (f[x][y][v + l] + f[i][j][l]) % mod;
}
}
for (int l = 1; l <= 2 * n; l++) {
int sum = 0;
for (int i = 1; i <= n; i++) sum = (sum + f[1][i][l]) % mod;
printf("%d\n", sum);
}
}
} // namespace zzc
int main() {
zzc::work();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int N = 100005, E = 262144;
int n, m, i, u, v, p, t, vis[55][55], j, k;
vector<int> g[55][55];
int q[N], l, r;
vector<int> ansr, ansl, w[55][55];
long long g1[55][55][105], g2[55][55][105], g3[55][55][105];
long long dp[105][55][2], f[55][55][105], ans[55][105], fe[55][55][105];
bool flag1 = true;
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d %d", &u, &v);
vis[u][v] = 1;
scanf("%d", &t);
if (t == 0) flag1 = false;
while (t--) {
scanf("%d", &p);
g[u][v].push_back(p);
}
}
bool flag = true;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if (i != j) {
for (k = 0; k + 1 < g[i][j].size(); ++k)
if (g[i][j][k] == i && g[i][j][k + 1] == j) break;
if (k + 1 < g[i][j].size()) {
l = 1, r = 0;
for (p = k + 2; p < g[i][j].size(); ++p) q[++r] = g[i][j][p];
p = j;
ansl.clear(), ansr.clear();
ansr.push_back(j);
while (l <= r && r <= 2 * n) {
if (!vis[p][q[l]]) break;
for (auto it : g[p][q[l]]) q[++r] = it;
p = q[l];
ansr.push_back(q[l]);
++l;
}
if (l <= r) continue;
l = 1, r = 0;
for (p = k - 1; p >= 0; --p) q[++r] = g[i][j][p];
p = i;
ansl.push_back(i);
while (l <= r && r <= 2 * n) {
if (!vis[q[l]][p]) break;
for (int i = g[q[l]][p].size() - 1; i >= 0; --i)
q[++r] = g[q[l]][p][i];
p = q[l];
ansl.push_back(q[l]);
++l;
}
if (l <= r) continue;
if (ansl.size() + ansr.size() <= 2 * n) {
++g1[ansl[ansl.size() - 1]][ansr[ansr.size() - 1]]
[ansl.size() + ansr.size() - 1];
}
}
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if (g[i][j].size() && g[i][j][0] == j) {
l = 1, r = 0;
for (p = 1; p < g[i][j].size(); ++p) q[++r] = g[i][j][p];
p = j;
ansr.clear();
ansr.push_back(j);
while (l <= r && r <= 2 * n) {
if (!vis[p][q[l]]) break;
for (auto it : g[p][q[l]]) q[++r] = it;
p = q[l];
ansr.push_back(q[l]);
++l;
}
if (l <= r) continue;
++g3[i][ansr[ansr.size() - 1]][ansr.size()];
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if (g[i][j].size() && g[i][j][g[i][j].size() - 1] == i) {
l = 1, r = 0;
for (p = g[i][j].size() - 2; p >= 0; --p) q[++r] = g[i][j][p];
p = i;
ansl.clear();
ansl.push_back(i);
while (l <= r && r <= 2 * n) {
if (!vis[q[l]][p]) break;
for (int i = g[q[l]][p].size() - 1; i >= 0; --i)
q[++r] = g[q[l]][p][i];
p = q[l];
ansl.push_back(q[l]);
++l;
}
if (l <= r) continue;
++g2[ansl[ansl.size() - 1]][j][ansl.size()];
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
for (k = 1; k <= 2 * n; ++k)
if (g1[i][j][k] || g2[i][j][k] || g3[i][j][k]) w[i][j].push_back(k);
for (i = 1; i <= n; ++i) {
memset(dp, 0, sizeof(dp));
dp[0][i][0] = 1;
for (j = 1; j <= n * 2; ++j)
for (k = 1; k <= n; ++k)
for (l = 1; l <= n; ++l)
for (auto m : w[l][k]) {
dp[j][k][0] = (dp[j][k][0] + dp[j - m][l][0] * g2[l][k][m]) % M;
dp[j][k][1] = (dp[j][k][1] + dp[j - m][l][0] * g1[l][k][m] +
dp[j - m][l][1] * g3[l][k][m]) %
M;
}
for (j = 1; j <= n; ++j)
for (k = 1; k <= 2 * n; ++k) f[i][j][k] = dp[k][j][1];
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
for (k = 1; k <= 2 * n; ++k) ans[j][k] = (ans[j][k] + f[i][j][k]) % M;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
for (l = 1; l <= n; ++l)
if (g[l][i].size() == 0 && vis[l][i])
for (k = 1; k < 2 * n; ++k)
fe[l][j][k + 1] = (fe[l][j][k + 1] + f[i][j][k]) % M;
for (k = 1; k <= 2 * n; ++k)
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
for (l = 1; l <= k; ++l)
ans[i][k] = (ans[i][k] + ans[j][k - l] * fe[j][i][l]) % M;
for (k = 1; k <= 2 * n; ++k) {
long long s = 0;
for (i = 1; i <= n; ++i) s = (s + ans[i][k]) % M;
cout << s << endl;
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 52;
int g[2][2][N][N][N * 2];
int f[N * 2][N][2];
int n, m, st[N * N], ed[N * N];
vector<int> seq[N * N];
int e[N][N];
pair<int, int> walk(vector<int> &tp, int x, bool fl) {
int now = 0;
for (; now + 1 <= tp.size();) {
int y = tp[now], ed = e[x][y];
if (!ed || tp.size() > 2 * n || (ed > m) != fl)
return pair<int, int>(23333, -1);
for (int j = 0; j < seq[ed].size(); j++) tp.push_back(seq[ed][j]);
x = y;
now++;
}
return pair<int, int>(tp.size(), x);
}
int man[N][N][N * 2];
int wei[N][N][N * 2];
void work(bool fl) {
memset(man, 0, sizeof(man));
memset(wei, 0, sizeof(wei));
for (int i = 1; i <= 2 * m; i++)
if ((i <= m) ^ fl)
for (int j = 0; j < seq[i].size(); j++)
if (seq[i][j] == st[i]) {
vector<int> t1, t2;
for (int k = j - 1; k >= 0; k--) t1.push_back(seq[i][k]);
pair<int, int> res = walk(t1, st[i], fl ^ 1);
if (res.first > 2 * n) continue;
if (j + 1 == seq[i].size())
wei[res.second][ed[i]][res.first + 1]++;
else if (seq[i][j + 1] == ed[i]) {
for (int k = j + 2; k < seq[i].size(); k++) t2.push_back(seq[i][k]);
pair<int, int> res2 = walk(t2, ed[i], fl);
if (res2.first + 1 + res.first <= 2 * n)
man[res.second][res2.second][res2.first + 1 + res.first]++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
e[x][y] = i;
e[y][x] = i + m;
st[i] = ed[i + m] = x;
st[i + m] = ed[i] = y;
for (int j = 1; j <= k; j++) {
int v;
scanf("%d", &v);
seq[i].push_back(v);
}
seq[i + m] = seq[i];
reverse(seq[i + m].begin(), seq[i + m].end());
if (!k) g[0][0][x][y][1]++;
}
work(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
g[1][1][i][j][k] = man[i][j][k], g[1][0][i][j][k] = wei[i][j][k];
work(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) g[0][1][j][i][k] = wei[i][j][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
for (int v = 0; v <= 1; v++)
(((f[k][j][v]) += (g[1][v][i][j][k])) >= mo ? f[k][j][v] -= mo : 233);
;
for (int k = 1; k <= n * 2; k++) {
int ans = 0;
for (int i = 1; i <= n; i++) {
(((ans) += (f[k][i][1])) >= mo ? ans -= mo : 233);
;
for (int mid = 0; mid <= 1; mid++)
if (f[k][i][mid])
for (int ed = 0; ed <= 1; ed++)
for (int zd = 1; zd <= n; zd++)
for (int l = 1; l <= 2 * n - k; l++)
(((f[k + l][zd][ed]) +=
(1ll * f[k][i][mid] * g[mid ^ 1][ed][i][zd][l] % mo)) >= mo
? f[k + l][zd][ed] -= mo
: 233);
;
}
printf("%d\n", ans);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool d = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') d = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return d ? x : -x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar('0' + x % 10);
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void writep(long long x) {
write(x);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 105, mo = 1e9 + 7;
int n, f[N][N][2];
vector<long long> v[N][N], zy[2][2][N][N];
bool b[N][N];
bool check(deque<int> &q, deque<int>::iterator it, bool op) {
if (!op) {
for (auto pre = prev(it); it != q.begin() && (int)q.size() <= 2 * n;
it = pre, pre = prev(it)) {
if (!b[*pre][*it]) return 0;
q.insert(q.begin(), v[*pre][*it].begin(), v[*pre][*it].end());
}
} else {
for (auto nxt = next(it); nxt != q.end() && (int)q.size() <= 2 * n;
it = nxt, nxt = next(it)) {
if (!b[*it][*nxt]) return 0;
q.insert(q.end(), v[*it][*nxt].begin(), v[*it][*nxt].end());
}
}
return (int)q.size() <= 2 * n;
}
void init() {
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(n); j++)
if (b[i][j]) {
int sz = (int)v[i][j].size();
if (sz == 0 || v[i][j][sz - 1] != i) continue;
deque<int> q(v[i][j].begin(), v[i][j].end());
if (check(q, prev(q.end()), 0))
zy[0][0][q.front()][j].push_back(q.size());
}
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(n); j++)
if (b[i][j]) {
int sz = (int)v[i][j].size();
if (sz == 0 || v[i][j][0] != j) continue;
deque<int> q(v[i][j].begin(), v[i][j].end());
if (check(q, q.begin(), 1)) zy[1][1][i][q.back()].push_back(q.size());
}
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(n); j++)
if (b[i][j]) {
int sz = (int)v[i][j].size();
if (sz) continue;
zy[1][0][i][j].push_back(1);
}
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(n); j++)
if (b[i][j]) {
int sz = (int)v[i][j].size();
if (sz <= 1) continue;
auto pos = find(v[i][j].begin(), v[i][j].end(), i);
if (pos == v[i][j].end() || ++pos == v[i][j].end() || *pos != j)
continue;
deque<int> q(v[i][j].begin(), v[i][j].end());
auto it = q.begin() + (pos - v[i][j].begin()) - 1;
if (check(q, it, 0) && check(q, it + 1, 1))
zy[0][1][q.front()][q.back()].push_back(q.size() - 1);
}
}
void upd(int &x, int y) {
x += y;
if (x >= mo) x -= mo;
}
int main() {
n = read();
int m = read();
for (int i = (int)(1); i <= (int)(m); i++) {
int x = read(), y = read(), k = read();
for (int j = (int)(1); j <= (int)(k); j++) v[x][y].push_back(read());
b[x][y] = 1;
}
init();
for (int i = (int)(1); i <= (int)(n); i++) f[i][0][0] = 1;
for (int j = (int)(0); j <= (int)(2 * n - 1); j++)
for (int i = (int)(1); i <= (int)(n); i++) {
for (int k = (int)(0); k <= (int)(1); k++)
if (f[i][j][k]) {
for (int t = (int)(0); t <= (int)(1); t++)
for (int l = (int)(1); l <= (int)(n); l++) {
for (auto ssw : zy[k][t][i][l]) {
if (j + ssw <= 2 * n) upd(f[l][j + ssw][t], f[i][j][k]);
}
}
}
}
for (int o = (int)(1); o <= (int)(2 * n); o++) {
int ans = 0;
for (int i = (int)(1); i <= (int)(n); i++) upd(ans, f[i][o][1]);
printf("%d\n", ans);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 52;
int g[2][2][N][N][N * 2];
int f[N * 2][N][2];
int n, m, st[N * N], ed[N * N];
vector<int> seq[N * N];
int e[N][N];
pair<int, int> walk(vector<int> &tp, int x, bool fl) {
int now = 0;
for (; now + 1 <= tp.size();) {
int y = tp[now], ed = e[x][y];
if (!ed || tp.size() > 2 * n || (ed > m) != fl)
return pair<int, int>(23333, -1);
for (int j = 0; j < seq[ed].size(); j++) tp.push_back(seq[ed][j]);
x = y;
now++;
}
return pair<int, int>(tp.size(), x);
}
int man[N][N][N * 2];
int wei[N][N][N * 2];
void work(bool fl) {
memset(man, 0, sizeof(man));
memset(wei, 0, sizeof(wei));
for (int i = 1; i <= 2 * m; i++)
if ((i <= m) ^ fl)
for (int j = 0; j < seq[i].size(); j++)
if (seq[i][j] == st[i]) {
vector<int> t1, t2;
for (int k = j - 1; k >= 0; k--) t1.push_back(seq[i][k]);
pair<int, int> res = walk(t1, st[i], fl ^ 1);
if (res.first > 2 * n) continue;
if (j + 1 == seq[i].size())
wei[res.second][ed[i]][res.first + 1]++;
else if (seq[i][j + 1] == ed[i]) {
for (int k = j + 2; k < seq[i].size(); k++) t2.push_back(seq[i][k]);
pair<int, int> res2 = walk(t2, ed[i], fl);
if (res2.first + 1 + res.first <= 2 * n)
man[res.second][res2.second][res2.first + 1 + res.first]++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
e[x][y] = i;
e[y][x] = i + m;
st[i] = ed[i + m] = x;
st[i + m] = ed[i] = y;
for (int j = 1; j <= k; j++) {
int v;
scanf("%d", &v);
seq[i].push_back(v);
}
seq[i + m] = seq[i];
reverse(seq[i + m].begin(), seq[i + m].end());
if (!k) g[0][0][x][y][1]++;
}
work(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
g[1][1][i][j][k] = man[i][j][k], g[1][0][i][j][k] = wei[i][j][k];
work(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) g[0][1][j][i][k] = wei[i][j][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
for (int v = 0; v <= 1; v++)
(((f[k][j][v]) += (g[1][v][i][j][k])) >= mo ? f[k][j][v] -= mo : 233);
;
for (int k = 1; k <= n * 2; k++) {
int ans = 0;
for (int i = 1; i <= n; i++) {
(((ans) += (f[k][i][1])) >= mo ? ans -= mo : 233);
;
for (int mid = 0; mid <= 1; mid++)
if (f[k][i][mid])
for (int ed = 0; ed <= 1; ed++)
for (int zd = 1; zd <= n; zd++)
for (int l = 1; l <= 2 * n - k; l++)
(((f[k + l][zd][ed]) +=
(1ll * f[k][i][mid] * g[mid ^ 1][ed][i][zd][l] % mo)) >= mo
? f[k + l][zd][ed] -= mo
: 233);
;
}
printf("%d\n", ans);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const double pi = acos(-1);
int n, m;
int trans[2][2][105][105][2 * 105], f[2 * 105][105][2];
int E[105][105], A[105][105][2 * 105], B[105][105][2 * 105], X[105 * 105],
Y[105 * 105];
vector<int> V[105 * 105];
void Plus(int &x, int y) {
x += y;
if (x >= mo) x -= mo;
}
pair<int, int> Get_chain(vector<int> &t, int x, bool flag) {
int i = 0;
while (i + 1 <= t.size()) {
int y = t[i], p = E[x][y];
if (!p || t.size() > 2 * n || (p > m) != flag)
return make_pair(1 << 20, -1);
for (int j = 0; j < V[p].size(); ++j) t.push_back(V[p][j]);
x = y;
i++;
}
return make_pair(t.size(), x);
}
void work(bool flag) {
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int i = 1; i <= 2 * m; ++i)
if ((i > m) == flag) {
for (int j = 0; j < V[i].size(); ++j)
if (V[i][j] == X[i]) {
vector<int> t1, t2;
for (int k = j - 1; k >= 0; --k) t1.push_back(V[i][k]);
pair<int, int> tmp1 = Get_chain(t1, X[i], flag ^ 1);
if (tmp1.first > 2 * n) continue;
if (j + 1 == V[i].size()) {
B[tmp1.second][Y[i]][tmp1.first + 1]++;
} else {
if (V[i][j + 1] != Y[i]) continue;
for (int k = j + 2; k < V[i].size(); ++k) t2.push_back(V[i][k]);
pair<int, int> tmp2 = Get_chain(t2, Y[i], flag);
if (tmp1.first + tmp2.first + 1 <= 2 * n)
A[tmp1.second][tmp2.second][tmp1.first + tmp2.first + 1]++;
}
}
}
}
void solve() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= 2 * n; ++k) {
Plus(f[k][j][0], trans[1][0][i][j][k]);
Plus(f[k][j][1], trans[1][1][i][j][k]);
}
for (int k = 1; k <= 2 * n; ++k) {
int ans = 0;
for (int i = 1; i <= n; ++i) {
Plus(ans, f[k][i][1]);
for (int j = 0; j <= 1; ++j)
if (f[k][i][j]) {
for (int v = 0; v <= 1; ++v) {
for (int x = 1; x <= n; ++x)
for (int len = 1; len <= 2 * n - k; ++len)
if (trans[j ^ 1][v][i][x][len])
Plus(f[k + len][x][v],
1ll * f[k][i][j] * trans[j ^ 1][v][i][x][len] % mo);
}
}
}
printf("%d\n", ans);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &X[i], &Y[i]);
E[X[i]][Y[i]] = i;
int x, k;
scanf("%d", &k);
for (int j = 1; j <= k; ++j) {
scanf("%d", &x);
V[i].push_back(x);
}
if (!k) trans[0][0][X[i]][Y[i]][1]++;
X[i + m] = Y[i];
Y[i + m] = X[i];
E[Y[i]][X[i]] = i + m;
V[i + m] = V[i];
reverse(V[i + m].begin(), V[i + m].end());
}
work(0);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= 2 * n; ++k) {
trans[1][1][i][j][k] = A[i][j][k];
trans[1][0][i][j][k] = B[i][j][k];
}
work(1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= 2 * n; ++k) {
assert(trans[1][1][j][i][k] == A[i][j][k]);
trans[0][1][j][i][k] = B[i][j][k];
}
solve();
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100 + 10;
const int Mod = (int)1e9 + 7;
int n, m;
int g[MAX][MAX], can[MAX][MAX];
vector<int> p[MAX][MAX];
int get(vector<int> &before, int kind, int could, int have) {
int j;
int now = 0, cc = have;
for (; now < (int)before.size(); now++) {
if (now + 1 == (int)before.size()) break;
int a = before[now];
int b = before[now + 1];
if (g[a][b] != kind || (!could && can[a][b])) return 0;
vector<int> &nL = p[a][b];
for ((j) = (0); (j) != ((int)nL.size()); ++(j)) {
if (cc < (int)before.size()) {
if (nL[j] == before[cc])
cc++;
else
return 0;
} else {
while (j < (int)nL.size()) {
before.push_back(nL[j++]);
if ((int)before.size() > 2 * n + 1) return 0;
}
cc = before.size();
break;
}
}
}
return cc == (int)before.size();
}
int isCan(int a, int b) {
int i;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) return 1;
return 0;
}
int f_Before[MAX][MAX][MAX], f_After[MAX][MAX][MAX], tmp[MAX][MAX][MAX];
int Before[MAX][MAX], After[MAX][MAX];
int ans[MAX];
void work(int u, int kind, int f[MAX][MAX][MAX]) {
int v;
for ((v) = (1); (v) <= (n); ++(v))
if (g[u][v] == kind && !can[v][u]) {
vector<int> after;
after.push_back(u);
after.push_back(v);
if (!get(after, kind, kind != 2, 1)) continue;
int Len = after.size();
f[u][after[Len - 1]][Len - 1]++;
}
}
void add(int &a, int b) {
a += b;
if (a >= Mod) a -= Mod;
}
void work2(int a, int b) {
int i, j;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) {
vector<int> before, after;
for (j = i; j >= 0; --j) before.push_back(L[j]);
for (j = i + 1; j < len; ++j) after.push_back(L[j]);
if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
reverse(before.begin(), before.end());
int A = before[0];
int B = after[after.size() - 1];
int Len = before.size() + after.size() - 1;
int k, l, o;
for ((l) = (1); (l) <= (n); ++(l))
for ((o) = (0); (o) <= (2 * n); ++(o))
if (tmp[A][l][o])
for ((k) = (1); (k) <= (n); ++(k))
if (g[k][l] == 1 && p[k][l].size() == 0 && Len + 1 + o <= 2 * n)
add(f_After[k][B][Len + 1 + o], tmp[A][l][o]);
} else
return;
}
return;
}
int tot = 0, First;
void Dp1(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
int i, j, k, l, o;
memset(tmp, 0, sizeof tmp);
for ((i) = (1); (i) <= (n); ++(i)) tmp[i][i][0] = 1;
int up = 2 * n;
for ((l) = (1); (l) <= (up); ++(l))
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((o) = (0); (o) <= (l); ++(o))
if (f[i][j][o])
for ((k) = (1); (k) <= (n); ++(k))
if (tmp[j][k][l - o])
add(tmp[i][k][l],
(long long)f[i][j][o] * tmp[j][k][l - o] % Mod);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((l) = (0); (l) <= (2 * n); ++(l)) add(after[i][l], tmp[i][j][l]);
}
void Dp2(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
int i, j, k, l;
for ((i) = (1); (i) <= (n); ++(i)) after[i][0] = 1;
int up = 2 * n;
for ((l) = (1); (l) <= (up); ++(l))
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((k) = (0); (k) != (l); ++(k))
add(After[i][l], (long long)f[i][j][l - k] * After[j][k] % Mod);
}
void check(int a, int b) {
int i, j;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) {
vector<int> before, after;
for (j = i; j >= 0; --j) before.push_back(L[j]);
for (j = i + 1; j < len; ++j) after.push_back(L[j]);
if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
reverse(before.begin(), before.end());
int A = before[0];
int B = after[after.size() - 1];
int Len = before.size() + after.size() - 1;
int l1, l2;
for ((l1) = (0); (l1) <= (2 * n); ++(l1))
for ((l2) = (0); (l2) <= (2 * n); ++(l2))
if (l1 + l2 + Len <= 2 * n)
add(ans[l1 + l2 + Len],
(long long)Before[A][l1] * After[B][l2] % Mod);
} else
return;
}
return;
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for ((i) = (1); (i) <= (m); ++(i)) {
int a, b;
scanf("%d%d", &a, &b);
if (!First) First = a;
g[a][b] = 1;
g[b][a] = 2;
int k, first;
scanf("%d", &k);
while (k--) {
scanf("%d", &first);
p[a][b].push_back(first);
}
p[b][a] = p[a][b];
reverse(p[b][a].begin(), p[b][a].end());
}
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && isCan(i, j)) can[j][i] = can[i][j] = 1;
for ((i) = (1); (i) <= (n); ++(i)) work(i, 1, f_After);
for ((i) = (1); (i) <= (n); ++(i)) work(i, 2, f_Before);
Dp1(f_Before, Before);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && can[i][j] == 1) work2(i, j);
Dp2(f_After, After);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && can[i][j] == 1) check(i, j);
for ((i) = (1); (i) <= (2 * n); ++(i)) cout << ans[i] << endl;
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
set<long long> kharab = {1, 2, 3, 5, 6, 9, 10, 13, 17, 31, 34,
37, 38, 41, 43, 45, 46, 49, 50, 53, 57, 71,
83, 111, 123, 391, 403, 437, 457, 471, 483, 511, 523};
long long a[6];
vector<long long> D[43];
void f(long long n) {
if (kharab.find(n) != kharab.end()) {
fill(a, a + 6, -1);
return;
}
if (n < 8) {
a[0] = n;
return;
}
for (long long i = 0; i <= 42; i++) {
if ((!D[i].size() || ~D[i].back()) && i % 10 == n % 10 &&
kharab.find((n - i) / 10) == kharab.end()) {
f((n - i) / 10);
for (long long j = 0; j < 6; j++) a[j] *= 10;
for (long long j = 0; j < D[i].size(); j++) a[j] += D[i][j];
return;
}
}
}
int32_t main() {
long long t;
cin >> t;
D[4].push_back(4);
D[7].push_back(7);
for (long long i = 1; i <= 42; i++) {
if (i == 4 || i == 7) continue;
if (kharab.find(i) != kharab.end() || i == 40) {
D[i].push_back(-1);
continue;
}
if (D[i - 4].size() < 6 && (!D[i - 4].size() || ~D[i - 4].back())) {
D[i] = D[i - 4];
D[i].push_back(4);
} else {
D[i] = D[i - 7];
D[i].push_back(7);
}
}
while (t--) {
long long n;
cin >> n;
fill(a, a + 6, 0);
f(n);
if (~a[0])
for (long long i = 0; i < 6; i++) cout << a[i] << ' ';
else
cout << -1;
cout << '\n';
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int D[3] = {0, 4, 7};
string S;
vector<int> way[50];
int dp[20][10];
int nxt[20][10];
int getdp(int x, int y) {
int &ref = dp[x][y];
if (ref != -1) {
return ref;
}
if (x == S.size()) {
return ref = (y == 0);
}
int mod10 = ((S[x] - '0') - y + 20) % 10;
for (int i = mod10; i < 50; i += 10) {
if (way[i].empty()) {
continue;
}
if (getdp(x + 1, (i + y) / 10)) {
nxt[x][y] = i;
return ref = 1;
}
}
return ref = 0;
}
void go() {
cin >> S;
reverse((S).begin(), (S).end());
memset((dp), (-1), sizeof(dp));
if (getdp(0, 0)) {
string ans[6] = {"", "", "", "", "", ""};
int s = 0;
for (int i = 0; i < S.size(); i++) {
int nx = nxt[i][s];
for (int j = 0; j < 6; j++) {
ans[j] += char('0' + way[nx][j]);
}
s = (s + nx) / 10;
}
for (string s : ans) {
reverse((s).begin(), (s).end());
stringstream ss(s);
long long x;
ss >> x;
cout << x << ' ';
}
cout << '\n';
} else {
cout << "-1\n";
}
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
ios::sync_with_stdio(false);
for (int i1 : D) {
for (int i2 : D) {
for (int i3 : D) {
for (int i4 : D) {
for (int i5 : D) {
for (int i6 : D) {
way[i1 + i2 + i3 + i4 + i5 + i6] = {i1, i2, i3, i4, i5, i6};
}
}
}
}
}
}
int nq;
for (cin >> nq; nq--;) {
go();
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& out, const pair<T, U>& val) {
return out << "(" << val.first << ", " << val.second << ")";
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& val) {
out << "{";
for (int i = 0; i < (int)((int)((val).size())); ++i)
out << (i ? ", " : "") << val[i];
return out << "}";
}
double dot(complex<double> a, complex<double> b) { return real(conj(a) * b); }
double crs(complex<double> a, complex<double> b) { return imag(conj(a) * b); }
complex<double> ortho(complex<double> a) {
return complex<double>(imag(a), -real(a));
}
complex<double> ortho(pair<complex<double>, complex<double> > a) {
return ortho(a.second - a.first);
}
complex<double> crspt(complex<double> a, complex<double> b, complex<double> c,
complex<double> d) {
b -= a, d -= c;
return a + b * crs(d, c - a) / crs(d, b);
}
complex<double> crspt(pair<complex<double>, complex<double> > a,
pair<complex<double>, complex<double> > b) {
return crspt(a.first, a.second, b.first, b.second);
}
bool onl(complex<double> a1, complex<double> a2, complex<double> b) {
return abs(b - a1) + abs(b - a2) < abs(a1 - a2) + (1e-6);
}
bool onl(pair<complex<double>, complex<double> > a, complex<double> b) {
return onl(a.first, a.second, b);
}
bool iscrs(pair<complex<double>, complex<double> > a,
pair<complex<double>, complex<double> > b) {
complex<double> c = crspt(a, b);
return onl(a, c) && onl(b, c);
}
void pkuassert(bool t) { t = 1 / t; };
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, -1, 1, 1, -1};
enum { TOP, BTM, LFT, RGT, FRT, BCK };
int dxdy2ce[] = {RGT, FRT, LFT, BCK};
int s2i(string& a) {
stringstream ss(a);
int r;
ss >> r;
return r;
}
template <class T>
T shift(T a, int b, int c, int d, int e) {
__typeof(a[0]) t = a[b];
a[b] = a[c];
a[c] = a[d];
a[d] = a[e];
a[e] = t;
return a;
}
template <class T>
T rgt(T a) {
return shift(a, TOP, LFT, BTM, RGT);
}
template <class T>
T lft(T a) {
return shift(a, TOP, RGT, BTM, LFT);
}
template <class T>
T frt(T a) {
return shift(a, TOP, BCK, BTM, FRT);
}
template <class T>
T bck(T a) {
return shift(a, TOP, FRT, BTM, BCK);
}
pair<complex<double>, complex<double> > mkl(complex<double> a,
complex<double> v) {
return pair<complex<double>, complex<double> >(a, a + v);
}
double lpdist(pair<complex<double>, complex<double> > a, complex<double> b) {
return abs(b - crspt(a, mkl(b, ortho(a))));
}
double spdist(pair<complex<double>, complex<double> > a, complex<double> b) {
complex<double> c(crspt(a, mkl(b, ortho(a))));
return onl(a, c) ? abs(b - c) : min(abs(a.first - b), abs(a.second - b));
}
double ssdist(pair<complex<double>, complex<double> > a,
pair<complex<double>, complex<double> > b) {
return iscrs(a, b)
? 0.
: min((spdist(a, b.first)),
min(((spdist(a, b.second))),
min(((spdist(b, a.first))), ((spdist(b, a.second))))));
}
string in;
int memo[20][19];
int keta4[20];
int keta7[20];
int rec(int ne, int ca) {
if (ne == (int)((in).size())) return ca == 0;
if (memo[ne][ca] != -1) return memo[ne][ca];
int& ret = memo[ne][ca] = 0;
for (int i4 = 0; i4 <= 6; ++i4)
for (int i7 = 0; i4 + i7 <= 6; ++i7) {
int p = i4 * 4 + i7 * 7 + ca;
if (in[ne] == p % 10 + '0' && rec(ne + 1, p / 10)) {
keta4[ne] = i4;
keta7[ne] = i7;
return ret = 1;
}
}
return ret;
}
void solve() {
cin >> in;
reverse(in.begin(), in.end());
memset(memo, -1, sizeof(memo));
memset(keta4, 0, sizeof(keta4));
memset(keta7, 0, sizeof(keta7));
int t = rec(0, 0);
if (!t) {
cout << -1 << endl;
return;
}
for (int i = 0; i < (int)(6); ++i) {
if (i) cout << ' ';
int ma = 0;
for (int j = 0; j < (int)(20); ++j) {
ma = max(ma, keta4[19 - j] + keta7[19 - j]);
if (i < keta4[19 - j])
cout << 4;
else if (i < keta4[19 - j] + keta7[19 - j])
cout << 7;
else if (ma > i)
cout << 0;
}
if (ma <= i) cout << 0;
}
cout << endl;
}
int main(int argc, char* argv[]) {
int t;
cin >> t;
for (int i = 0; i < (int)(t); ++i) solve();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int T, cnt4[20], cnt7[20];
long long n, ans[20];
bool flag;
void dfs(long long n, int k) {
if (n < 0 || flag) return;
if (!n) {
memset(ans, 0, sizeof ans);
long long tmp = 1;
flag = 1;
for (int i = 0; i < k; i++) {
for (int j = 1; j <= cnt4[i]; j++) ans[j] += 4 * tmp;
for (int j = 1; j <= cnt7[i]; j++) ans[cnt4[i] + j] += 7 * tmp;
tmp *= 10;
}
for (int i = 1; i <= 6; i++) printf("%I64d ", ans[i]);
puts("");
return;
}
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++)
if ((4 * i + 7 * j) % 10 == n % 10) {
cnt4[k] = i;
cnt7[k] = j;
dfs(n / 10 - (4 * i + 7 * j) / 10, k + 1);
}
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%I64d", &n);
flag = 0;
dfs(n, 0);
if (!flag) puts("-1");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 10000, inf = 1e9 + 100;
set<int> bad = {1, 2, 3, 5, 6, 9, 10, 13, 17, 31, 34,
37, 38, 41, 43, 45, 46, 49, 50, 53, 57, 71,
83, 111, 123, 391, 403, 437, 457, 471, 483, 511, 523};
bool is_happy(long long a) {
while (a) {
int d = a % 10;
if (d != 4 && d != 0 && d != 7) {
return false;
}
a /= 10;
}
return true;
}
vector<int> happy;
bool was2[max_n * 6];
bool was3[max_n * 6];
bool was4[max_n * 6];
bool was5[max_n * 6];
vector<long long> was6[max_n * 6];
int c4[10];
int c7[10];
void init() {
for (int n4 = 0; n4 <= 6; ++n4) {
for (int n7 = 0; n7 + n4 <= 6; ++n7) {
int res = (n4 * 4 + n7 * 7) % 10;
c4[res] = n4;
c7[res] = n7;
}
}
for (int i = 0; i < max_n; ++i) {
if (is_happy(i)) {
happy.push_back(i);
}
}
reverse(happy.begin(), happy.end());
int cur = 0;
for (int a1 : happy) {
cur += a1;
for (int a2 : happy) {
cur += a2;
if (cur > max_n || was2[cur]) {
cur -= a2;
continue;
}
was2[cur] = true;
for (int a3 : happy) {
cur += a3;
if (cur > max_n || was3[cur]) {
cur -= a3;
continue;
}
was3[cur] = true;
for (int a4 : happy) {
cur += a4;
if (cur > max_n || was4[cur]) {
cur -= a4;
continue;
}
was4[cur] = true;
for (int a5 : happy) {
cur += a5;
if (cur > max_n || was5[cur]) {
cur -= a5;
continue;
}
was5[cur] = true;
for (int a6 : happy) {
cur += a6;
if (cur > max_n) {
cur -= a6;
continue;
}
was6[cur] = vector<long long>({a1, a2, a3, a4, a5, a6});
cur -= a6;
}
cur -= a5;
}
cur -= a4;
}
cur -= a3;
}
cur -= a2;
}
cur -= a1;
}
}
vector<long long> solve(long long a) {
vector<int> ans4;
vector<int> ans7;
int per = 0;
while (a >= max_n) {
int d = a % 10 - per;
if (d < 0) d += 10;
int n4 = c4[d];
int n7 = c7[d];
int val = n4 * 4 + n7 * 7 + per;
ans4.push_back(n4);
ans7.push_back(n7);
per = val / 10;
a /= 10;
}
a -= per;
vector<long long> res = was6[a];
long long pw = 1;
for (int i = 0; i < ans4.size(); ++i) {
pw *= 10;
}
for (long long& val : res) {
val *= pw;
}
pw = 1;
for (int i = 0; i < ans4.size(); ++i) {
for (int j = 0; j < ans4[i]; ++j) {
res[j] += 4 * pw;
}
for (int j = 0; j < ans7[i]; ++j) {
res[ans4[i] + j] += 7 * pw;
}
pw *= 10;
}
return res;
}
int main() {
init();
int q;
cin >> q;
while (q--) {
long long a;
cin >> a;
if (bad.count(a)) {
cout << -1 << "\n";
continue;
}
if (a < max_n) {
for (long long val : was6[a]) {
cout << val << ' ';
}
cout << "\n";
continue;
}
vector<long long> res = solve(a);
for (long long val : res) {
cout << val << ' ';
}
long long sum = 0;
for (long long val : res) {
sum += val;
}
if (sum != a) {
cout << "AAA " << a << endl;
exit(228);
}
cout << "\n";
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long a[10];
bool calc[20][10], f[100][100];
int num, c[100];
int attemp(int pos, int cary) {
if (calc[pos][cary]) return f[pos][cary];
calc[pos][cary] = true;
if (pos > num) {
f[pos][cary] = (cary == 0);
return f[pos][cary];
}
f[pos][cary] = false;
for (int i = (0), _b = (6); i <= _b; i++)
for (int j = (0), _b = (6 - i); j <= _b; j++)
if ((i * 4 + j * 7 + cary) % 10 == c[pos]) {
f[pos][cary] |= attemp(pos + 1, (i * 4 + j * 7 + cary) / 10);
}
return f[pos][cary];
}
void add(long long &a, int pos, int digit) {
long long t = digit;
for (int i = (2), _b = (pos); i <= _b; i++) t *= 10;
a += t;
}
void trace(int pos, int cary) {
if (pos > num) return;
for (int i = (0), _b = (6); i <= _b; i++)
for (int j = (0), _b = (6 - i); j <= _b; j++)
if ((i * 4 + j * 7 + cary) % 10 == c[pos])
if (attemp(pos + 1, (i * 4 + j * 7 + cary) / 10)) {
for (int k = (1), _b = (i); k <= _b; k++) add(a[k], pos, 4);
for (int k = (i + 1), _b = (i + j); k <= _b; k++) add(a[k], pos, 7);
trace(pos + 1, (i * 4 + j * 7 + cary) / 10);
return;
}
}
int main() {
int ntest;
cin >> ntest;
while (ntest--) {
long long n;
cin >> n;
num = 0;
do {
c[++num] = n % 10;
n /= 10;
} while (n);
memset(calc, false, sizeof(calc));
int res = attemp(1, 0);
if (!res)
cout << -1 << endl;
else {
memset(a, 0, sizeof(a));
trace(1, 0);
for (int i = (1), _b = (6); i <= _b; i++) cout << a[i] << " ";
cout << endl;
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
reverse(s.begin(), s.end());
while (s.size() < 20) {
s += "0";
}
bool dp[21][1000] = {0};
int lastx[21][1000] = {0};
int last0[21][1000] = {0};
int last4[21][1000] = {0};
int last7[21][1000] = {0};
dp[0][0] = 1;
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 1000; j++) {
if (!dp[i][j]) {
continue;
}
for (int a = 0; a <= 6; a++) {
for (int b = 0; a + b <= 6; b++) {
int c = 6 - a - b;
int x = j + b * 4 + c * 7;
if (x / 10 < 1000 && x % 10 == s[i] - '0') {
dp[i + 1][x / 10] = 1;
lastx[i + 1][x / 10] = j;
last0[i + 1][x / 10] = a;
last4[i + 1][x / 10] = b;
last7[i + 1][x / 10] = c;
}
}
}
}
}
if (dp[20][0]) {
vector<string> ans(6);
int n = 20, x = 0;
while (n) {
int j = 0;
for (int i = j; i < j + last0[n][x]; i++) {
ans[i] += '0';
}
j += last0[n][x];
for (int i = j; i < j + last4[n][x]; i++) {
ans[i] += '4';
}
j += last4[n][x];
for (int i = j; i < j + last7[n][x]; i++) {
ans[i] += '7';
}
x = lastx[n][x];
n--;
}
for (string i : ans) {
long long y = 0;
for (char c : i) {
y *= 10;
y += c - '0';
}
cout << y << " ";
}
cout << "\n";
} else {
cout << -1 << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int v[7000], dp[20][10], m;
int l[] = {0, 4, 7};
char s[20];
void PrintMsk(int msk) {
int i;
for (i = 0; i < 6; i++, msk /= 3) {
if (i) printf(" ");
printf("%d", l[msk % 3]);
}
printf("\n");
}
void initvar() {
int i, tmp;
for (i = 0, m = 1; i < 6; i++) m *= 3;
for (i = 0; i < m; i++) {
tmp = i;
while (tmp) {
v[i] += l[tmp % 3];
tmp /= 3;
}
}
}
bool check(int msk) {
if (msk == 243 || msk == 3 || msk == 1)
return 1;
else
return 0;
}
int dfs(int pos, int lst) {
int i, t;
if (dp[pos][lst] != -1) return dp[pos][lst];
if (!s[pos]) {
if (lst)
return dp[pos][lst] = 0;
else
return dp[pos][lst] = 1;
}
t = s[pos] - '0' + lst * 10;
for (i = 0; i < m; i++)
if (v[i] <= t && t - v[i] <= 4) {
if (check(i)) {
}
int tmp = dfs(pos + 1, t - v[i]);
if (tmp) return dp[pos][lst] = 1;
}
return dp[pos][lst] = 0;
}
long long ans[7];
void getans(int pos, int lst) {
int i, j, t;
if (!s[pos]) return;
t = s[pos] - '0' + lst * 10;
for (i = 0; i < m; i++)
if (v[i] <= t && t - v[i] <= 4 && dp[pos + 1][t - v[i]]) {
int tmp = i;
for (j = 0; j < 6; j++, tmp /= 3) ans[j] = ans[j] * 10 + l[tmp % 3];
getans(pos + 1, t - v[i]);
break;
}
}
void PrintAns() {
memset(ans, 0, sizeof(ans));
getans(0, 0);
for (int i = 0; i < 6; i++) {
if (i) printf(" ");
printf("%I64d", ans[i]);
}
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
initvar();
while (t--) {
long long n = 0;
scanf("%s", s);
for (int i = 0; s[i]; i++) n = n * 10 + s[i] - '0';
memset(dp, -1, sizeof(dp));
if (!dfs(0, 0))
printf("-1\n");
else
PrintAns();
long long sum = 0;
for (int i = 0; i < 6; i++) sum += ans[i];
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int D[3] = {0, 4, 7};
int trail[7];
int val[80], pn;
int des[80][7];
bool dp[20][50];
int trav[20][50], from[20][50];
long long ans[7];
void dfs(int cur, int sum, int bound) {
if (cur == 6) {
for (int i = 0; i < 6; i++) des[pn][i] = trail[i];
val[pn++] = sum;
return;
}
for (; bound < 3; bound++) {
trail[cur] = D[bound];
dfs(cur + 1, sum + D[bound], bound);
}
}
int main() {
pn = 0;
dfs(0, 0, 0);
int t;
cin >> t;
while (t--) {
long long d;
cin >> d;
int pos = 0;
memset(dp, 0, sizeof(dp));
dp[0][0] = true;
while (d) {
int toGet = (int)(d % 10);
for (int i = 0; i < 50; i++) {
if (!dp[pos][i]) continue;
for (int j = 0; j < pn; j++) {
int nxt = val[j] + i;
if (nxt % 10 != toGet) continue;
dp[pos + 1][nxt / 10] = true;
trav[pos + 1][nxt / 10] = j;
from[pos + 1][nxt / 10] = i;
}
}
pos++;
d /= 10;
}
if (!dp[pos][0])
cout << "-1" << endl;
else {
memset(ans, 0, sizeof(ans));
int cur = 0;
for (int i = pos; i; i--) {
int kk = trav[i][cur];
for (int j = 0; j < 6; j++) ans[j] = ans[j] * 10 + des[kk][j];
cur = from[i][cur];
}
cout << ans[0];
for (int i = 1; i < 6; i++) cout << " " << ans[i];
cout << endl;
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int a[30];
bool dp[30][10];
int c4[30][10], c7[30][10];
long long ten[20];
long long ans[10];
void func(void) {
int i, j, k, p, q;
for ((i) = 0; (i) < (int)(30); (i)++)
for ((j) = 0; (j) < (int)(10); (j)++) dp[i][j] = false;
dp[20][0] = true;
for (i = 19; i >= 0; i--)
for ((j) = 0; (j) < (int)(5); (j)++) {
for ((p) = 0; (p) < (int)(7); (p)++)
for ((q) = 0; (q) < (int)(7 - p); (q)++) {
if ((4 * p + 7 * q + j) % 10 == a[i]) {
int carry = (4 * p + 7 * q + j) / 10;
if (dp[i + 1][carry]) {
c4[i][j] = p;
c7[i][j] = q;
dp[i][j] = true;
}
}
}
}
if (!dp[0][0]) {
printf("-1\n");
return;
}
for ((i) = 0; (i) < (int)(6); (i)++) ans[i] = 0;
i = 0;
j = 0;
while (i <= 18) {
p = c4[i][j];
q = c7[i][j];
for ((k) = 0; (k) < (int)(p); (k)++) ans[k] += ten[i] * 4;
for ((k) = 0; (k) < (int)(q); (k)++) ans[p + k] += ten[i] * 7;
j = (4 * p + 7 * q + j) / 10;
i++;
}
for ((i) = 0; (i) < (int)(6); (i)++) {
printf("%I64d", ans[i]);
if (i == 5)
printf("\n");
else
printf(" ");
}
}
int main(void) {
int Q, i, j;
long long N;
ten[0] = 1;
for (i = 1; i <= 18; i++) ten[i] = ten[i - 1] * 10;
cin >> Q;
for ((i) = 0; (i) < (int)(Q); (i)++) {
cin >> N;
for ((j) = 0; (j) < (int)(20); (j)++) {
a[j] = (int)(N % 10);
N /= 10;
}
func();
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int t, n, lucky[] = {0, 4, 7};
char a[20];
bool dp[20][6], done;
long long tenPower[20], ans[7];
void solve(int i, int c) {
if (done) return;
if (i == -1) {
done = !c;
return;
}
if (dp[i][c]) return;
dp[i][c] = true;
for (int q = 0; q <= 2; ++q)
for (int w = 0; w <= 2; ++w)
for (int e = 0; e <= 2; ++e)
for (int r = 0; r <= 2; ++r)
for (int t = 0; t <= 2; ++t)
for (int y = 0; y <= 2; ++y) {
int x = lucky[q] + lucky[w] + lucky[e] + lucky[r] + lucky[t] +
lucky[y] + c;
if (x % 10 == a[i] - '0') {
ans[1] += lucky[q] * tenPower[n - i - 1];
ans[2] += lucky[w] * tenPower[n - i - 1];
ans[3] += lucky[e] * tenPower[n - i - 1];
ans[4] += lucky[r] * tenPower[n - i - 1];
ans[5] += lucky[t] * tenPower[n - i - 1];
ans[6] += lucky[y] * tenPower[n - i - 1];
solve(i - 1, x / 10);
if (done) return;
ans[1] -= lucky[q] * tenPower[n - i - 1];
ans[2] -= lucky[w] * tenPower[n - i - 1];
ans[3] -= lucky[e] * tenPower[n - i - 1];
ans[4] -= lucky[r] * tenPower[n - i - 1];
ans[5] -= lucky[t] * tenPower[n - i - 1];
ans[6] -= lucky[y] * tenPower[n - i - 1];
}
}
}
int main() {
tenPower[0] = 1;
for (int i = 1; i <= 18; ++i) tenPower[i] = tenPower[i - 1] * 10;
scanf("%d", &t);
while (t--) {
scanf("%s", a);
n = strlen(a);
memset(dp, 0, sizeof dp);
memset(ans, 0, sizeof ans);
done = false;
solve(n - 1, 0);
if (done)
for (int i = 1; i <= 6; ++i) printf("%I64d ", ans[i]);
else
printf("-1");
puts("");
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
vector<int> var[50];
int ppp[3] = {0, 4, 7};
void dfs(int sum, vector<int> v) {
if (int((v).size()) == 6)
var[sum] = v;
else {
for (int d = 0; d < 3; ++d) {
int cc = ppp[d];
vector<int> tmp = v;
tmp.push_back(cc);
dfs(sum + cc, tmp);
}
}
}
void solve() {
long long x;
cin >> x;
string s;
do {
s += (char)('0' + (x % 10));
x /= 10;
} while (x);
int n = int((s).size());
const int maxrem = 7;
vector<vector<bool> > dp(n + 1, vector<bool>(maxrem));
vector<vector<int> > predj(n + 1, vector<int>(maxrem));
vector<vector<int> > predp(n + 1, vector<int>(maxrem));
dp[0][0] = true;
for (int i = 0; i < n; ++i)
for (int j = 0; j < maxrem; ++j) {
if (dp[i][j] == 0) continue;
for (int t = 0; t < 43; ++t)
if ((j + t) % 10 == s[i] - '0' && int((var[t]).size())) {
int torem = (j + t) / 10;
dp[i + 1][torem] = 1;
predj[i + 1][torem] = j;
predp[i + 1][torem] = t;
}
}
if (dp[n][0] == 0)
printf("-1\n");
else {
vector<vector<int> > vv;
int curj = 0;
for (int i = n; i > 0; --i) {
vv.push_back(var[predp[i][curj]]);
curj = predj[i][curj];
}
for (int i = 0; i < 6; ++i) {
long long num = 0;
for (int j = 0; j < int((vv).size()); ++j) num = num * 10 + vv[j][i];
printf("%I64d ", num);
}
printf("\n");
}
}
int main() {
int t;
scanf("%d", &t);
dfs(0, vector<int>());
while (t--) {
solve();
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
bool chk[64] = {false};
int comb[64][8];
char s[128];
int dp[16][128];
char ans[8][32];
int main() {
for (int p = 0; p <= 6; p++)
for (int q = 0; p + q <= 6; q++) {
int r = 6 - p - q;
int v = q * 4 + r * 7;
chk[v] = true;
for (int i = 0; i < p; i++) comb[v][i] = 0;
for (int i = p; i < p + q; i++) comb[v][i] = 4;
for (int i = p + q; i < p + q + r; i++) comb[v][i] = 7;
}
int T;
scanf("%d", &T);
while (T--) {
s[0] = '0';
scanf("%s", s + 1);
int l = strlen(s);
memset(dp, -1, sizeof(dp));
dp[0][0] = -2;
for (int i = 1; i < l; i++)
for (int j = 0; j < 10; j++)
if (dp[j][i - 1] != -1) {
int v = 10 * j + (s[i] - '0');
for (int k = 0; k < 64; k++)
if (chk[k] && v >= k && v - k < 10) dp[v - k][i] = k;
}
if (dp[0][l - 1] == -1)
printf("-1\n");
else {
int cv = 0;
for (int j = 0; j < 6; j++) {
ans[j][0] = '0';
ans[j][l] = '\0';
}
for (int i = l - 1; i > 0; i--) {
int w = dp[cv][i];
for (int j = 0; j < 6; j++) ans[j][i] = '0' + comb[w][j];
cv += w;
cv /= 10;
}
for (int j = 0; j < 6; j++) {
long long pans;
sscanf(ans[j], "%lld", &pans);
printf(" %lld" + !j, pans);
}
printf("\n");
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
bool succ;
int dig[25];
long long sol[6];
stack<int> a, b, c;
void dfs(int x, int r) {
if (x < 0) {
if (r == 0)
succ = 1;
else
return;
memset(sol, 0, sizeof(sol));
while (!a.empty()) {
int i = 0, u;
u = a.top();
a.pop();
while (u--) {
sol[i] = sol[i] * 10 + 4;
i++;
}
u = b.top();
b.pop();
while (u--) {
sol[i] = sol[i] * 10 + 7;
i++;
}
u = c.top();
c.pop();
while (u--) {
sol[i] = sol[i] * 10;
i++;
}
}
for (int i = 0; i < 6; i++)
printf("%I64d%c", sol[i], (i == 5) ? '\n' : ' ');
return;
}
for (int i = 0; i <= 6 && !succ; i++) {
for (int j = 0; j <= 6 - i && !succ; j++) {
int tmp = r + 4 * i + 7 * j;
if (tmp % 10 == dig[x]) {
a.push(i);
b.push(j);
c.push(6 - i - j);
dfs(x - 1, tmp / 10);
if (succ) break;
a.pop();
b.pop();
c.pop();
}
}
}
}
void gao(long long x) {
int cnt = 0;
do {
dig[cnt++] = x % 10;
x /= 10;
} while (x);
reverse(dig, dig + cnt);
dfs(cnt - 1, 0);
}
int main() {
int T;
long long x;
scanf("%d", &T);
while (T--) {
scanf("%I64d", &x);
while (!a.empty()) a.pop();
while (!b.empty()) b.pop();
while (!c.empty()) c.pop();
succ = 0;
gao(x);
if (!succ) printf("-1\n");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int Z;
string N;
vector<pair<int, int> > vf;
bool f[20][5];
pair<int, int> p[20][5];
string sres[6];
void prep();
void solve();
void back_track(int, int);
int main() {
prep();
cin >> Z;
for (int zi = 1; zi <= Z; ++zi) cin >> N, solve();
return 0;
}
void prep() {
for (int i = 0; i <= 6; ++i)
for (int j = 0; i + j <= 6; ++j) vf.push_back(make_pair(i, j));
}
void solve() {
fill(&f[0][0], &f[20][0], false);
f[0][0] = true;
reverse((N).begin(), (N).end());
for (int i = 0; i < int((N).size()); ++i)
for (int j = 0; j < 5; ++j)
if (f[i][j]) {
int t = int(N[i] - '0');
for (int k = 0; k < int((vf).size()); ++k) {
int r = j + 4 * vf[k].first + 7 * vf[k].second;
if (r % 10 == t) {
f[i + 1][r / 10] = true;
p[i + 1][r / 10] = make_pair(j, k);
}
}
}
if (!f[int((N).size())][0])
cout << "-1\n";
else {
for (int i = 0; i < 6; ++i) sres[i] = "";
back_track(int((N).size()), 0);
for (int i = 0; i < 6; ++i) {
istringstream iss(sres[i]);
long long res;
iss >> res;
cout << res << (i + 1 == 6 ? "\n" : " ");
}
}
}
void back_track(int i, int j) {
if (i > 0) {
int k = 0, s = vf[p[i][j].second].first, t = vf[p[i][j].second].second;
for (int c = 0; c < s; ++c, ++k) sres[k].push_back('4');
for (int c = 0; c < t; ++c, ++k) sres[k].push_back('7');
while (k < 6) sres[k].push_back('0'), ++k;
back_track(i - 1, p[i][j].first);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, L[3] = {0, 4, 7}, ok[1000];
string second;
vector<int> caras[1000];
vector<int> somas;
int dp[20][100], prox[20][100];
int solve(int i, int sobra) {
if (i < 0) return (sobra == 0);
if (dp[i][sobra] != -1) return dp[i][sobra];
int ans = 0;
for (int j = 0; j < somas.size(); j++) {
int S = somas[j] + sobra;
int sobra2 = S / 10;
S = S - 10 * sobra2;
if (S == (second[i] - '0')) {
ans |= solve(i - 1, sobra2);
if (ans) {
prox[i][sobra] = j;
return dp[i][sobra] = 1;
}
}
}
return dp[i][sobra] = ans;
}
string ans[10];
void get(int i, int sobra) {
if (i < 0) return;
int j = prox[i][sobra];
int S = somas[j] + sobra;
int sobra2 = S / 10;
for (int z = 0; z < caras[somas[j]].size(); z++)
ans[z].push_back((char)(L[caras[somas[j]][z]] + '0'));
get(i - 1, sobra2);
}
void build() {
for (int a = 0; a < 3; a++)
for (int b = 0; b < 3; b++)
for (int c = 0; c < 3; c++)
for (int d = 0; d < 3; d++)
for (int e = 0; e < 3; e++)
for (int first = 0; first < 3; first++) {
int sum = L[a] + L[b] + L[c] + L[d] + L[e] + L[first];
if (ok[sum]) continue;
ok[sum] = 1;
caras[sum].push_back(a);
caras[sum].push_back(b);
caras[sum].push_back(c);
caras[sum].push_back(d);
caras[sum].push_back(e);
caras[sum].push_back(first);
somas.push_back(sum);
}
}
int T;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
build();
cin >> T;
while (T--) {
cin >> second;
memset(dp, -1, sizeof dp);
for (int i = 0; i < 6; i++) ans[i].clear();
if (solve((int)second.size() - 1, 0)) {
get((int)second.size() - 1, 0);
for (int j = 0; j < 6; j++) {
reverse(ans[j].begin(), ans[j].end());
int z = 0;
while (z < ans[j].size() and ans[j][z] == '0') z++;
if (z >= ans[j].size()) z--;
for (int u = z; u < ans[j].size(); u++) cout << ans[j][u];
cout << " ";
}
cout << "\n";
} else
cout << "-1\n";
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int table[32][10];
char buf[32];
int len;
long long int ans[6];
bool go(int loc, int carry) {
if (loc == len)
return !carry;
else if (table[loc][carry])
return table[loc][carry] - 1;
else {
int& v = table[loc][carry];
for (int i = 0; !v && i <= 6; i++)
for (int j = 0; i + j <= 6; j++) {
int d = carry + i * 4 + j * 7;
if (d % 10 == buf[loc] && go(loc + 1, d / 10)) {
v = 1;
break;
}
}
return v++;
}
}
void go2(int loc, int carry, long long int radix) {
if (loc < len) {
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++) {
int d = carry + i * 4 + j * 7;
if (d % 10 == buf[loc] && go(loc + 1, d / 10)) {
for (int a = 0; a < i; a++) ans[a] += 4 * radix;
for (int b = i; b < i + j; b++) ans[b] += 7 * radix;
go2(loc + 1, d / 10, radix * 10);
return;
}
}
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long int N;
scanf("%I64d", &N);
len = 0;
do buf[len++] = N % 10;
while (N /= 10);
memset(table, 0, sizeof(table));
memset(ans, 0, sizeof(ans));
if (!go(0, 0))
puts("-1");
else {
go2(0, 0, 1);
for (int i = 0; i < 6; i++) {
if (i) printf(" ");
printf("%I64d", ans[i]);
}
printf("\n");
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, vector<int>>> pos[10];
vector<int> curr_vec(6);
const int lucky[3] = {0, 4, 7};
void gen(int ind, int curr_sum) {
if (ind == 6) {
pos[curr_sum % 10].push_back({curr_sum, curr_vec});
return;
}
for (int i = 0; i < 3; ++i) {
curr_vec[ind] = lucky[i];
gen(ind + 1, curr_sum + lucky[i]);
}
}
long long n;
int vis[19][5], vis_id;
int col_n[19];
inline void decompose() {
int curr_col = 0;
memset(col_n, 0, sizeof col_n);
while (n) {
col_n[curr_col++] = n % 10;
n /= 10;
}
}
vector<int> ans[19];
bool solve(int curr_col, int carry) {
if (curr_col == 19) return !carry;
if (vis[curr_col][carry] == vis_id) return 0;
vis[curr_col][carry] = vis_id;
auto& wanted = pos[(10 + col_n[curr_col] - carry) % 10];
for (auto& p : wanted)
if (solve(curr_col + 1, (p.first + carry) / 10)) {
ans[curr_col] = p.second;
return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
gen(0, 0);
int t;
cin >> t;
while (t--) {
++vis_id;
cin >> n;
decompose();
if (solve(0, 0)) {
long long res[6];
for (int i = 0; i < 6; ++i) {
res[i] = 0;
for (int j = 18; j >= 0; --j) {
res[i] = 10 * res[i] + ans[j][i];
}
cout << res[i] << ' ';
}
cout << '\n';
} else {
cout << "-1\n";
}
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long int P[20], out[6], ans[20];
vector<int> vec[10];
vector<pair<int, pair<int, int> > > num;
void print(int sz) {
memset(out, 0, sizeof out);
for (int i = 0; i < sz; i++) {
for (int j = 0; j < num[ans[i]].second.first; j++) out[j] += 7 * P[i];
for (int j = 0; j < num[ans[i]].second.second; j++)
out[j + num[ans[i]].second.first] += 4 * P[i];
}
for (int i = 0; i < 6; i++) cout << out[i] << ' ';
cout << '\n';
return;
}
bool build(long long int rem, int pos = 0) {
if (rem == 0) {
print(pos);
return true;
}
int id = rem % 10;
for (auto valid : vec[id]) {
int val = num[valid].first;
if (val > rem) continue;
ans[pos] = valid;
if (build((rem - val) / 10, pos + 1)) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
P[0] = 1;
for (int i = 1; i <= 18; i++) P[i] = P[i - 1] * 10;
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++) {
vec[(7 * i + 4 * j) % 10].push_back(((int)(num).size()));
num.push_back(make_pair(7 * i + 4 * j, make_pair(i, j)));
}
int q;
cin >> q;
while (q--) {
long long int val;
cin >> val;
if (!build(val)) cout << "-1\n";
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20, CNT = 30;
int par[N][10], a[CNT], cnt;
bool dp[N][10];
long long ans[6];
string b[CNT], inp;
void cons(int c, int d) {
if (!c) return;
cons(c - 1, (a[par[c][d]] + d - inp[c - 1]) / 10);
for (int i = 0; i < 6; i++) ans[i] = ans[i] * 10 + b[par[c][d]][i] - '0';
}
bool pos() {
fill(ans, ans + 6, 0);
dp[0][0] = true;
for (int i = 1; i <= inp.size(); i++) {
inp[i - 1] -= '0';
for (int d = 0; d < 5; d++) {
dp[i][d] = false;
for (int j = 0; j < cnt; j++)
if ((d + a[j]) % 10 == inp[i - 1])
if (dp[i][d] |= dp[i - 1][(a[j] + d - inp[i - 1]) / 10]) {
par[i][d] = j;
break;
}
}
}
if (!dp[inp.size()][0]) return false;
cons(inp.size(), 0);
return true;
}
int main() {
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++)
for (int k = 0; i + j + k <= 6; k++)
if (i + j + k == 6) {
for (int x = 0; x < i; x++) b[cnt].push_back('0');
for (int x = 0; x < j; x++) b[cnt].push_back('4');
for (int x = 0; x < k; x++) b[cnt].push_back('7');
a[cnt++] = j * 4 + k * 7;
}
ios_base::sync_with_stdio(false);
int test;
cin >> test;
while (test--) {
cin >> inp;
if (pos())
for (int i = 0; i < 6; i++) cout << ans[i] << ' ';
else
cout << -1;
cout << '\n';
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int ok[28] = {0, 4, 7, 8, 11, 12, 14, 15, 16, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 35, 36, 39, 42};
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long n, tmp;
cin >> n;
tmp = n;
vector<int> use[5], use_n[5];
int dig[19] = {};
int dign = log10(n);
for (int j = 0; j < 19; j++) {
dig[j] = tmp % 10;
tmp /= 10;
}
set<int> st, st_n;
set<int>::iterator it;
st.insert(dig[dign]);
for (int j = dign - 1; j >= 0; j--) {
for (it = st.begin(); it != st.end(); it++) {
for (int k = 0; k < 28; k++) {
int hoge = (*it) - ok[k];
if (hoge > 4) continue;
if (hoge < 0) break;
st_n.insert(hoge * 10 + dig[j]);
use_n[hoge] = use[(*it) / 10];
use_n[hoge].push_back(k);
}
}
st = st_n;
st_n.clear();
for (int k = 0; k < 5; k++) use[k] = use_n[k];
}
bool flag = false;
int mem = -1;
for (it = st.begin(); it != st.end(); it++) {
for (int k = 0; k < 28; k++) {
if ((*it) == ok[k]) {
flag = true;
use[(*it) / 10].push_back(k);
mem = (*it) / 10;
break;
}
}
if (flag) break;
}
if (!flag) {
cout << -1 << endl;
continue;
}
long long ans[6] = {};
long long jo = 1;
for (int j = 0; j < dign; j++) jo *= 10;
for (int j = 0; j <= dign; j++) {
int fuga = ok[use[mem][j]];
int num4 = 0, num7 = 0;
if (fuga % 7 == 0) num4 = 0;
if (fuga % 7 == 1) num4 = 2;
if (fuga % 7 == 2) num4 = 4;
if (fuga % 7 == 3) num4 = 6;
if (fuga % 7 == 4) num4 = 1;
if (fuga % 7 == 5) num4 = 3;
if (fuga % 7 == 6) num4 = 5;
num7 = (fuga - num4 * 4) / 7;
for (int k = 0; k < num4; k++) {
ans[k] += 4 * jo;
}
for (int k = num4; k < num4 + num7; k++) {
ans[k] += 7 * jo;
}
jo /= 10;
}
for (int j = 0; j < 6; j++) {
cout << ans[j] << " ";
}
cout << endl;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
struct C {
int a[6];
};
int parent[20][5];
int p[20][5];
int digits[20], m;
C ways[1000];
int sum[1000];
int cntW;
bool dp[20][5];
int u[100], v[100];
void rec(int k, C current) {
if (k == 6) {
sum[cntW] = 0;
for (int i = 0; i < 6; ++i) {
sum[cntW] += current.a[i];
}
ways[cntW++] = current;
return;
}
current.a[k] = 0;
rec(k + 1, current);
current.a[k] = 4;
rec(k + 1, current);
current.a[k] = 7;
rec(k + 1, current);
}
void solve() {
long long n;
cin >> n;
m = 0;
while (n) {
digits[m++] = n % 10;
n /= 10;
}
for (int i = 0; i < 20; ++i) {
for (int j = 0; j < 5; ++j) {
dp[i][j] = false;
}
}
dp[0][0] = true;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 5; ++j) {
if (!dp[i][j]) {
continue;
}
for (int k = 0; k < cntW; ++k) {
if (u[j + sum[k]] == digits[i]) {
dp[i + 1][v[j + sum[k]]] = true;
parent[i + 1][v[j + sum[k]]] = k;
p[i + 1][v[j + sum[k]]] = j;
}
}
}
}
if (!dp[m][0]) {
printf("-1\n");
return;
}
vector<long long> r(6);
int u = m, v = 0;
while (u != 0) {
int index = parent[u][v];
for (int i = 0; i < 6; ++i) {
r[i] = r[i] * 10LL + ways[index].a[i];
}
v = p[u][v];
--u;
}
for (int i = 0; i < 6; ++i) {
printf("%I64d", r[i]);
if (i == 5) {
printf("\n");
} else {
printf(" ");
}
}
}
int main() {
rec(0, C());
for (int i = 0; i < 100; ++i) {
u[i] = i % 10;
v[i] = i / 10;
}
int t;
scanf("%d", &t);
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int oo = 1e9;
const int N = 1e5 + 10;
int t, dp[20][11];
char tmp[21];
string s, p[6];
int calc(int idx, int carry) {
if (idx == 19) return (carry == 0);
int &ret = dp[idx][carry];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i <= 6; ++i)
for (int j = 0; j + i <= 6; ++j) {
int cs = i * 7 + j * 4 + carry;
if (calc(idx + 1, cs / 10) && s[idx] - '0' == cs % 10) ret = 1;
}
return ret;
}
void build(int idx, int carry) {
if (idx == 19) return;
for (int i = 0; i <= 6; ++i)
for (int j = 0; j + i <= 6; ++j) {
int cs = i * 7 + j * 4 + carry;
if (calc(idx + 1, cs / 10) && s[idx] - '0' == cs % 10) {
int f = 0;
for (int k = 0; k < i; ++k) p[f++] += '7';
for (int k = 0; k < j; ++k) p[f++] += '4';
for (int k = 0; k < 6 - (i + j); ++k) p[f++] += '0';
build(idx + 1, cs / 10);
return;
}
}
}
int main() {
cin >> t;
while (t--) {
scanf("%s", tmp);
s = tmp;
memset(dp, -1, sizeof dp);
reverse(s.begin(), s.end());
while (s.size() <= 18) s += '0';
for (int i = 0; i < 6; ++i) p[i] = "";
if (calc(0, 0)) {
build(0, 0);
for (int i = 0; i < 6; ++i) reverse(p[i].begin(), p[i].end());
for (int i = 0; i < 6; ++i) {
if (i) printf(" ");
int idx = 0;
while (idx < p[i].size() && p[i][idx] == '0') idx++;
if (idx == p[i].size()) {
printf("0");
} else {
for (int j = idx; j < p[i].size(); ++j) printf("%c", p[i][j]);
}
}
puts("");
} else {
puts("-1");
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long FASTBUFFER;
vector<int> can[20];
vector<int>::iterator it;
long long i, j, k, t, temp, sel[7], ok[1005], a[1005], Ans[105][105], tot;
long long f[105][20], succ[105][20];
long long Now, ans[7];
void dfs(long long i, long long s);
int main() {
dfs(1, 0);
for (i = 0; i <= 42; i++)
if (ok[i] == 1) can[i % 10].push_back(i);
scanf("%I64d", &t);
while (t > 0) {
t--;
scanf("%I64d", &Now);
tot = 0;
while (Now > 0) {
a[++tot] = Now % 10;
Now /= 10;
}
memset(f, 0, sizeof(f));
f[1][0] = 1;
for (i = 1; i <= tot; i++) {
for (j = 0; j <= 9; j++) {
if (f[i][j] == 0) continue;
k = a[i] - j;
if (k < 0) k += 10;
for (it = can[k].begin(); it != can[k].end(); ++it)
f[i + 1][(j + (*it)) / 10] = 1, succ[i + 1][(j + (*it)) / 10] = (*it);
}
}
if (f[tot + 1][0] == 1) {
for (i = 1; i <= 6; i++) ans[i] = 0;
i = tot + 1, j = 0;
while (i > 1) {
temp = succ[i][j];
for (k = 1; k <= 6; k++) {
ans[k] *= 10;
ans[k] += Ans[temp][k];
}
j = a[i - 1] - (temp % 10);
if (j < 0) j += 10;
i--;
}
for (i = 1; i <= 5; i++) printf("%I64d ", ans[i]);
printf("%I64d\n", ans[i]);
} else
printf("-1\n");
}
return 0;
}
void dfs(long long i, long long s) {
long long x;
if (i > 6) {
ok[s] = 1;
for (x = 1; x <= 6; x++) Ans[s][x] = sel[x];
return;
}
sel[i] = 0, dfs(i + 1, s + 0);
sel[i] = 4, dfs(i + 1, s + 4);
sel[i] = 7, dfs(i + 1, s + 7);
return;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int can[10][5], ls[10][5][7];
void init() {
for (int i = 0; i <= 6; i++)
for (int j = 0; j + i <= 6; j++) {
int k = 6 - i - j;
int s = i * 7 + j * 4;
int jw = s / 10;
int re = s % 10;
can[re][jw] = 1;
for (int l = 0; l < 6; l++)
if (l < i)
ls[re][jw][l] = 7;
else if (l < i + j)
ls[re][jw][l] = 4;
else
ls[re][jw][l] = 0;
}
}
int dp[30][11], pr[30][11];
long long n;
int num[30], t;
int ret[30][30];
int main() {
init();
int T;
cin >> T;
while (T--) {
cin >> n;
t = 0;
while (n) {
num[t++] = n % 10;
n /= 10;
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < t; i++)
for (int j = 0; j < 6; j++)
if (dp[i][j]) {
int d = (num[i] - j + 10) % 10;
for (int k = 0; k < 5; k++)
if (can[d][k]) {
int s = k * 10 + d + j;
int jw = s / 10;
dp[i + 1][jw] = 1;
pr[i + 1][jw] = j;
}
}
if (dp[t][0] == 0)
puts("-1");
else {
int nj = 0;
for (int i = t; i > 0; i--) {
int j = pr[i][nj];
int d = (num[i - 1] - j + 10) % 10;
for (int k = 0; k < 5; k++)
if (can[d][k]) {
int s = k * 10 + d + j;
int jw = s / 10;
if (jw == nj) {
for (int l = 0; l < 6; l++) ret[l][i] = ls[d][k][l];
break;
}
}
nj = j;
}
for (int i = 0; i < 6; i++) {
if (i) printf(" ");
bool nz = false;
for (int j = t; j > 0; j--) {
if (ret[i][j] == 0) {
if (j == 1 || nz) printf("0");
} else {
nz = true;
printf("%d", ret[i][j]);
}
}
}
puts("");
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int mem[20][5];
int sz;
int ara[3];
int cc[20];
int okay[44];
int dp(int len, int c) {
if (len == sz) return !c;
int ret = mem[len][c];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i < 43; i++) {
if (!okay[i]) continue;
if ((c + i) % 10 == cc[len]) ret |= dp(len + 1, (c + i) / 10);
if (ret) break;
}
return mem[len][c] = (bool)ret;
}
vector<int> vec;
void path(int len, int c) {
if (len == sz) return;
for (int i = 0; i < 43; i++) {
if (!okay[i]) continue;
if ((c + i) % 10 == cc[len] && mem[len][c] == dp(len + 1, (c + i) / 10)) {
vec.push_back(i);
path(len + 1, (c + i) / 10);
return;
}
}
return;
}
vector<int> v[44];
bool ok(int cnt, int sum, int x) {
if (!cnt) return (sum == 0);
for (int i = 0; i < 3; i++) {
if (ok(cnt - 1, sum - ara[i], x)) {
v[x].push_back(ara[i]);
return 1;
}
}
return 0;
}
int main() {
ara[0] = 0;
ara[1] = 4;
ara[2] = 7;
for (int i = 0; i < 43; i++) {
okay[i] = ok(6, i, i);
}
long long n;
int ts;
cin >> ts;
while (ts--) {
cin >> n;
int k = 0;
while (n > 0ll) {
cc[k++] = (n % 10ll);
n /= 10ll;
}
sz = k;
memset(mem, -1, sizeof mem);
if (dp(0, 0)) {
vec.clear();
path(0, 0);
long long ans[6];
memset(ans, 0ll, sizeof ans);
for (int i = vec.size() - 1; i >= 0; i--) {
int x = vec[i];
for (int j = 0; j < 6; j++) ans[j] = (ans[j] * 10ll) + v[x][j];
}
for (int i = 0; i < 6; i++) cout << ans[i] << " ";
cout << endl;
} else
cout << -1 << endl;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int arr[29] = {0, 4, 7, 8, 11, 12, 14, 15, 16, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 32, 33, 35, 36, 39, 42, 100000000};
int decision[111];
int res[111];
bool dfs(long long x, long long dec, int d) {
if (d < 0) {
if (x == 0) memcpy(res, decision, sizeof res);
return x == 0;
}
long long c = upper_bound(arr, arr + 28, x / dec) - arr - 1;
for (int i = c; i >= 0; --i) {
if (x - dec * arr[i] > 5ll * dec) break;
decision[d] = arr[i];
if (dfs(x - dec * arr[i], dec / 10ll, d - 1)) return true;
}
return false;
}
bool check(int x) {
while (x) {
int c = x % 10;
if (c != 4 && c != 7 && c != 0) return false;
x /= 10;
}
return true;
}
long long ans[11];
int dp[11][3111], pre[11][3111];
int main() {
int T;
cin >> T;
dp[0][0] = 1;
for (int i = 0; i <= 5; ++i)
for (int j = 0; j <= 1111; ++j)
if (dp[i][j]) {
for (int k = 0; k <= 1111; ++k)
if (check(k)) {
dp[i + 1][j + k] = true;
pre[i + 1][j + k] = k;
}
}
for (int TK = 1; TK <= T; ++TK) {
long long x;
cin >> x;
long long cur = 1, d = 0;
while (cur * 10 < x) {
cur *= 10;
++d;
}
if (!dfs(x, cur, d)) {
puts("-1");
assert(x < 1000);
continue;
}
cur = 1;
memset(ans, 0, sizeof ans);
for (int i = 0; i <= d; ++i) {
int c = res[i];
int c4 = 0, c7 = 0;
for (int x = 0; x <= 6; ++x)
for (int y = 0; y <= 6 - x; ++y)
if (x * 4 + y * 7 == c) {
c4 = x;
c7 = y;
}
for (int i = 1; i <= c4; ++i) ans[i] += cur * 4;
for (int i = c4 + 1; i <= c4 + c7; ++i) ans[i] += cur * 7;
cur *= 10;
}
for (int i = 1; i <= 6; ++i) printf("%I64d%c", ans[i], " \n"[i == 6]);
assert(ans[1] + ans[2] + ans[3] + ans[4] + ans[5] + ans[6] == x);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
bool mark[20][20], dp[20][20];
int t, n;
int a[20];
long long val[20];
inline bool go(int pos, int carry) {
if (pos == n) {
if (carry == 0) return true;
return false;
}
if (mark[pos][carry]) return dp[pos][carry];
mark[pos][carry] = true;
for (int i = 0; i <= 6; i++)
for (int j = 0; j + i <= 6; j++)
if ((carry + i * 4 + j * 7) % 10 == a[pos]) {
if (go(pos + 1, (carry + i * 4 + j * 7) / 10))
return dp[pos][carry] = true;
}
return dp[pos][carry] = false;
}
inline void print(int pos, int carry, long long p) {
if (pos == n) {
for (int i = 0; i < 6; i++) cout << val[i] << ' ';
cout << endl;
return;
}
for (int i = 0; i <= 6; i++)
for (int j = 0; j + i <= 6; j++)
if ((carry + i * 4 + j * 7) % 10 == a[pos]) {
if (go(pos + 1, (carry + i * 4 + j * 7) / 10)) {
for (int k = 0; k < 6; k++) {
if (k < i)
val[k] = val[k] + p * 4;
else if (k < i + j)
val[k] = val[k] + p * 7;
}
print(pos + 1, (carry + i * 4 + j * 7) / 10, p * 10LL);
return;
}
}
}
int main() {
cin >> t;
for (int o = 0; o < t; o++) {
string s;
cin >> s;
n = (int)s.size();
for (int i = 0; i < (int)s.size(); i++) a[n - i - 1] = s[i] - '0';
memset(mark, false, sizeof mark);
if (go(0, 0)) {
memset(val, 0, sizeof val);
print(0, 0, 1);
} else
cout << -1 << endl;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int pat[100][6];
int pat2[5000][6];
int T;
signed long long N;
int val[7];
bool dfs(signed long long V, int d) {
int i;
if (d >= 7) return false;
if (V == 0) {
while (d < 7) val[d++] = 0;
return true;
}
for (i = 0; i < 5; i++) {
int v = V % 1000 + i * 1000;
if (pat2[v][0] == -1 || V < v) continue;
val[d] = v;
if (dfs((V - v) / 1000, d + 1)) return true;
val[d] = -1;
}
return false;
}
void solve() {
int i, j, k, l, r, x, y;
string s;
memset(pat, 0xff, sizeof(pat));
memset(pat2, 0xff, sizeof(pat2));
for (j = 0; j < 7; j++)
for (k = 0; k < 7; k++)
if (j + k <= 6)
for (l = 0; l < 6; l++) {
if (l < k)
pat[j * 4 + k * 7][l] = 7;
else if (l < k + j)
pat[j * 4 + k * 7][l] = 4;
else
pat[j * 4 + k * 7][l] = 0;
}
for (i = 0; i < 50; i++)
for (j = 0; j < 50; j++)
for (k = 0; k < 50; k++)
if (pat[i][0] >= 0 && pat[j][0] >= 0 && pat[k][0] >= 0) {
if (pat2[i * 100 + j * 10 + k][0] >= 0) continue;
for (l = 0; l < 6; l++)
pat2[i * 100 + j * 10 + k][l] =
pat[i][l] * 100 + pat[j][l] * 10 + pat[k][l];
}
cin >> T;
while (T--) {
cin >> N;
memset(val, 0xff, sizeof(val));
if (!dfs(N, 0))
(void)printf("-1\n");
else {
for (l = 0; l < 6; l++) {
signed long long v = pat2[val[6]][l] * 1000000000000000000LL;
v += pat2[val[5]][l] * 1000000000000000LL;
v += pat2[val[4]][l] * 1000000000000LL;
v += pat2[val[3]][l] * 1000000000LL;
v += pat2[val[2]][l] * 1000000LL;
v += pat2[val[1]][l] * 1000LL;
v += pat2[val[0]][l];
(void)printf("%lld ", v);
}
(void)printf("\n");
}
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < argc - 1; i++) s += argv[i + 1], s += '\n';
for (i = 0; i < s.size(); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MOD = 1000000007;
int s[11];
vector<int> g;
vector<int> ans[11];
vector<string> solve(long long n) {
vector<string> res(6, "0");
if (n < 0) {
res[0] = "-";
return res;
}
if (n == 0) return res;
for (int i1 = 0; i1 <= 2; ++i1)
for (int i2 = i1; i2 <= 2; ++i2)
for (int i3 = i2; i3 <= 2; ++i3)
for (int i4 = i3; i4 <= 2; ++i4)
for (int i5 = i4; i5 <= 2; ++i5)
for (int i6 = i5; i6 <= 2; ++i6) {
int cur = g[i1] + g[i2] + g[i3] + g[i4] + g[i5] + g[i6];
if (cur % 10 != n % 10) continue;
vector<string> got = solve((n - cur) / 10);
if (got[0] == "-") continue;
got[0] += char(g[i1] + 48);
got[1] += char(g[i2] + 48);
got[2] += char(g[i3] + 48);
got[3] += char(g[i4] + 48);
got[4] += char(g[i5] + 48);
got[5] += char(g[i6] + 48);
return got;
}
res[0] = "-";
return res;
}
int main() {
g.push_back(0);
g.push_back(4);
g.push_back(7);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<string> a = solve(n);
if (a[0] == "-")
cout << "-1";
else
for (int i = 0; i <= 5; ++i) {
int pos = 0;
while (pos < (int)((a[i]).size()) - 1 && a[i][pos] == '0') ++pos;
for (int j = pos; j <= (int)((a[i]).size()) - 1; ++j) cout << a[i][j];
cout << " ";
}
cout << endl;
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
map<long long, vector<long long> > mp;
vector<long long> ans(long long x) {
if (mp.count(x)) {
return mp[x];
}
if (x == 0) {
return mp[x] = {0, 0, 0, 0, 0, 0};
}
mp[x] = {-1, 0, 0, 0, 0, 0};
if (x < 0) {
return mp[x];
}
for (int i = 0; i <= 6; i++) {
for (int j = 0; j + i <= 6; j++) {
if ((x - i * 4 - j * 7) % 10 == 0) {
auto v = ans((x - i * 4 - j * 7) / 10);
if (v[0] != -1) {
for (int k = 0; k < 6; k++) {
v[k] *= 10;
if (k < i) {
v[k] += 4;
} else if (k < i + j) {
v[k] += 7;
}
}
return mp[x] = v;
}
}
}
}
return mp[x];
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
auto v = ans(x);
if (v[0] != -1) {
for (auto j : v) {
cout << j << " ";
}
} else {
cout << -1;
}
cout << endl;
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
bool dp[20][10];
int dp4[20][10], dp7[20][10], dpj[20][10];
long long n;
int bit = 1;
long long ten[20];
long long r[6];
int w[20];
int main() {
int tcase;
scanf("%d", &tcase);
ten[0] = 1;
for (int i = 1; i <= 18; i++) ten[i] = ten[i - 1] * 10;
while (tcase--) {
memset(dp, 0, sizeof(dp));
bit = 1;
scanf("%lld", &n);
while (n) {
w[bit++] = n % 10;
n /= 10;
}
bit--;
dp[1][0] = true;
for (int i = 1; i <= bit; i++) {
for (int j = 0; j < 9; j++)
if (dp[i][j]) {
for (int x = 0; x <= 6; x++)
for (int y = 0; x + y <= 6; y++) {
if ((x * 4 + y * 7 + j - w[i]) % 10 != 0) continue;
dp[i + 1][(x * 4 + y * 7 + j - w[i]) / 10] = 1;
dp4[i + 1][(x * 4 + y * 7 + j - w[i]) / 10] = x;
dp7[i + 1][(x * 4 + y * 7 + j - w[i]) / 10] = y;
dpj[i + 1][(x * 4 + y * 7 + j - w[i]) / 10] = j;
}
}
}
if (!dp[bit + 1][0]) {
puts("-1");
continue;
}
int j = 0;
memset(r, 0, sizeof(r));
for (int i = bit + 1; i >= 2; i--) {
int x = dp4[i][j], y = dp7[i][j], jj = dpj[i][j];
for (int k = 0; k < 6; k++) {
if (k < x)
r[k] += 4 * ten[i - 2];
else if (k < x + y)
r[k] += 7 * ten[i - 2];
}
j = jj;
}
for (int i = 0; i < 6; i++) printf("%lld ", r[i]);
puts("");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const long double pi = 3.14159265358979323846;
const long long int inf = (long long int)1ll << 50;
const int ss = (int)1e6 + 3;
const long long int base = inf;
bool pred(const pair<int, int>& i, const pair<int, int>& j) {
if (i.first == j.first) {
return i.second > j.second;
} else {
return i.first > j.first;
}
}
bool pred1(const string& i, const string& j) { return i.size() > j.size(); }
vector<pair<int, int> > check(int number, int plus) {
vector<pair<int, int> > res;
for (int i = 0; i <= 6; ++i) {
for (int j = 0; j <= 6 - i; ++j) {
int z = i * 4 + j * 7;
z += plus;
if (z % 10 == number) {
res.push_back(make_pair(i, j));
}
}
}
return res;
}
int main() {
int t;
cin >> t;
for (int tt = 0; tt < t; ++tt) {
string s;
cin >> s;
vector<vector<bool> > dp(25, vector<bool>(5));
vector<vector<int> > p(25, vector<int>(5, -1));
vector<vector<pair<int, int> > > ans(25, vector<pair<int, int> >(5));
dp[0][0] = true;
for (int i = s.size() - 1, k = 1; i >= 0; --i, ++k) {
int now = s[i] - '0';
for (int j = 0; j < 5; ++j) {
if (dp[k - 1][j]) {
vector<pair<int, int> > res = check(now, j);
for (int j1 = 0; j1 < res.size(); ++j1) {
int z = res[j1].first * 4 + res[j1].second * 7 + j;
dp[k][z / 10] = true;
p[k][z / 10] = j;
ans[k][z / 10] = res[j1];
}
}
}
}
if (dp[s.size()][0] == false) {
cout << "-1\n";
continue;
}
vector<string> out(6);
for (int i = 0, k = s.size(); p[k][i] != -1; i = p[k][i], --k) {
int x = ans[k][i].first;
int y = ans[k][i].second;
for (int j = 0; j < x; ++j) {
out[j] += "4";
}
for (int j = x; j < x + y; ++j) {
out[j] += "7";
}
for (int j = x + y; j < 6; ++j) {
out[j] += "0";
}
}
for (int i = 0; i < 6; ++i) {
long long int now = 0;
long long int st = 1;
for (int j = out[i].size() - 1; j >= 0; --j) {
now += st * (out[i][j] - '0');
st *= 10;
}
cout << now << " ";
}
cout << "\n";
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
const double EPS = 1e-8;
const double PI = acos(-1.0);
int popcount(int n) { return __builtin_popcount(n); }
int popcount(long long n) { return __builtin_popcountll(n); }
template <class T>
int SIZE(T a) {
return a.size();
}
template <class T>
string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T>
T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++) res = (res * 10 + str[i] - '0');
return res;
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
long long getTen(int a) { return (a <= 0) ? 1 : (getTen(a - 1) * 10); }
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0) res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
int T;
bool isMade[101];
vector<int> M[101];
void dfs(int num, int depth, int ary[], int sz) {
if (depth == 6) {
if (!isMade[num]) {
isMade[num] = true;
for (int i = 0; i < 6; i++) M[num].push_back(ary[i]);
}
} else {
ary[sz] = 4;
dfs(num + 4, depth + 1, ary, sz + 1);
ary[sz] = 7;
dfs(num + 7, depth + 1, ary, sz + 1);
ary[sz] = 0;
dfs(num + 0, depth + 1, ary, sz + 1);
}
}
int dp[20][10];
vector<long long> rec(string &s) {
vector<long long> res(6);
int i = 0;
int j = 0;
long long p = 1;
while (i != (int)s.size()) {
for (int k = 0; k < 50; k++) {
if (isMade[k]) {
int c = (k + j) / 10;
int m = (k + j) % 10;
if (m == s[i] - '0' && dp[i + 1][c]) {
i = i + 1;
j = c;
for (int l = 0; l < 6; l++) {
res[l] += (M[k][l]) * p;
}
p *= 10;
break;
}
}
}
}
return res;
}
int main() {
int ary[10];
dfs(0, 0, ary, 0);
cin >> T;
while (T--) {
long long N;
cin >> N;
string s = IntToString<long long>(N);
reverse(s.begin(), s.end());
for (int i = (int)s.size(); i >= 0; i--) {
for (int j = 0; j < 10; j++) {
int res = 0;
if (i == (int)s.size()) {
if (j == 0) res = true;
} else {
for (int k = 0; k < 50; k++) {
if (isMade[k]) {
int c = (k + j) / 10;
int m = (k + j) % 10;
if (m == s[i] - '0') res |= dp[i + 1][c];
}
}
}
dp[i][j] = res;
}
}
if (!dp[0][0])
cout << -1 << endl;
else {
vector<long long> res = rec(s);
for (int i = 0; i < 6; i++) {
cout << res[i] << " ";
}
cout << endl;
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
struct node {
int val, a, b;
node(int i = 0, int j = 0, int k = 0) : a(i), b(j), val(k) {}
};
std::vector<node> the[10];
long long ten[19];
long long ans[6];
bool dfs(long long now, int bit) {
if (!now) return true;
if (now < 0ll) return false;
int v = now % 10;
for (int i(0); i < the[v].size(); ++i) {
int a(the[v][i].a), b(a + the[v][i].b), j(0);
for (; j < a; ++j) ans[j] = ans[j] % ten[bit] + 4ll * ten[bit];
for (; j < b; ++j) ans[j] = ans[j] % ten[bit] + 7ll * ten[bit];
for (; j < 6; ++j) ans[j] %= ten[bit];
if (dfs((now - the[v][i].val) / 10, bit + 1)) return true;
}
return false;
}
int T;
int i, j, k;
long long n;
int main() {
for (i = 0; i <= 6; ++i)
for (j = 0; i + j <= 6; ++j) {
k = i * 4 + j * 7;
the[k % 10].push_back(node(i, j, k));
}
ten[0] = 1ll;
for (i = 1; i < 19; ++i) ten[i] = ten[i - 1] * 10ll;
scanf("%d", &T);
while (T--) {
scanf("%I64d", &n);
if (dfs(n, 0))
for (i = 0; i < 6; ++i) printf("%I64d%c", ans[i], " \n"[i == 5]);
else
puts("-1");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int PRIME = 999983;
const int MOD = 10007;
const int MULTI = 1000000007;
const double EPS = 1e-9;
long long n;
int bit[20], m;
bool tag;
vector<pair<int, int> > d[10], ans;
void dfs(int p, int x) {
if (p == m) {
if (!x) {
tag = false;
long long res[6] = {0}, base = 1;
for (int i = 0; i < ans.size(); i++, base *= 10) {
int a = ans[i].first, b = ans[i].second;
for (int j = 0; j < 6; j++) {
if (a)
res[j] += 4 * base, a--;
else if (b)
res[j] += 7 * base, b--;
}
}
for (int i = 0; i < 6; i++) printf("%I64d ", res[i]);
puts("");
}
return;
}
int y = (bit[p] - x + 10) % 10;
for (int i = 0; tag && i < d[y].size(); i++) {
ans.push_back(d[y][i]);
int a = d[y][i].first, b = d[y][i].second;
dfs(p + 1, (x + a * 4 + b * 7) / 10);
ans.pop_back();
}
}
int main() {
int re;
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++)
d[(i * 4 + j * 7) % 10].push_back((pair<int, int>){i, j});
scanf("%d", &re);
while (re--) {
scanf("%I64d", &n);
m = 0;
while (n) bit[m++] = n % 10, n /= 10;
tag = true;
dfs(0, 0);
if (tag) puts("-1");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int ND = 19;
const int M = 6;
const int MaxAdd = 4;
int a[ND + 1];
bool f[ND + 1][MaxAdd + 1];
inline void solve(long long n) {
for (int d = 1; d <= ND; d++) a[d] = n % 10, n /= 10;
for (int d = 0; d <= ND; d++)
for (int add = 0; add <= MaxAdd; add++) f[d][add] = false;
f[0][0] = true;
for (int d = 1; d <= ND; d++)
for (int n4 = 0; n4 <= M; n4++)
for (int n7 = 0; n4 + n7 <= M; n7++) {
int t = n4 * 4 + n7 * 7;
int add = (a[d] - t % 10 + 10) % 10;
t += add;
if (add > MaxAdd) continue;
f[d][t / 10] |= f[d - 1][add];
}
if (!f[ND][0]) {
cout << "-1" << endl;
return;
}
int curRest = 0;
static long long res[M];
for (int i = 0; i < M; i++) res[i] = 0;
for (int d = ND; d >= 1; d--) {
curRest = curRest * 10 + a[d];
bool ok = false;
for (int n4 = 0; n4 <= M && !ok; n4++)
for (int n7 = 0; n4 + n7 <= M && !ok; n7++) {
int t = n4 * 4 + n7 * 7;
int add = curRest - t;
if (0 > add || add > MaxAdd) continue;
if (!f[d - 1][add]) continue;
curRest -= t;
ok = true;
for (int i = 0; i < n4; i++) res[i] = res[i] * 10 + 4;
for (int i = n4; i < n4 + n7; i++) res[i] = res[i] * 10 + 7;
for (int i = n4 + n7; i < M; i++) res[i] = res[i] * 10;
}
}
for (int i = 0; i < M; i++) cout << res[i] << " ";
cout << endl;
}
int main() {
int nCases;
cin >> nCases;
while (nCases--) {
long long n;
cin >> n;
solve(n);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int N = 20, M = 6, K = 5;
int n, a[N];
int f[N][K], g[N][K];
struct Tuple {
int a, b;
Tuple() {}
Tuple(int _a, int _b) : a(_a), b(_b) {}
inline int sum() { return 7 * a + 4 * b; }
};
std::vector<Tuple> tuple;
void init() {
for (int a = 0; a <= M; ++a)
for (int b = 0; a + b <= M; ++b) tuple.push_back(Tuple(a, b));
}
char s[M][N];
void print(int n, int k) {
if (!n) return;
const Tuple &t = tuple[g[n][k]];
for (int i = 0; i < t.a; ++i) s[i][n - 1] = '7';
for (int i = 0; i < t.b; ++i) s[t.a + i][n - 1] = '4';
for (int i = t.a + t.b; i < M; ++i) s[i][n - 1] = '0';
print(n - 1, f[n][k]);
}
void write(char *num) {
int t = strlen(num);
while (t && num[t - 1] == '0') --t;
for (int i = t - 1; i >= 0; --i) putchar(num[i]);
if (!t) putchar('0');
putchar(' ');
}
void solve() {
memset(f, -1, sizeof f);
f[0][0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < K; ++j) {
int cur = f[i][j];
if (cur == -1) continue;
for (int k = 0; k < tuple.size(); ++k) {
int t = tuple[k].sum() + j;
if (t % 10 != a[i]) continue;
f[i + 1][t / 10] = j;
g[i + 1][t / 10] = k;
}
}
}
if (f[n][0] != -1) {
memset(s, 0, sizeof s);
print(n, 0);
for (int j = 0; j < M; ++j) write(s[j]);
putchar('\n');
} else {
puts("-1");
}
}
int main() {
init();
int tcase;
for (scanf("%d", &tcase); tcase--;) {
long long x;
scanf("%lld", &x);
n = 0;
for (; x; x /= 10) a[n++] = x % 10;
solve();
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int D[3] = {0, 4, 7};
int dt[20][5][6];
char dat[32];
int precalc[729][6], tt;
int presum[729];
int main() {
for (int a = 0; a < 3; a++)
for (int b = a; b < 3; b++)
for (int c = b; c < 3; c++)
for (int d = c; d < 3; d++)
for (int e = d; e < 3; e++)
for (int f = e; f < 3; f++)
precalc[tt][0] = D[a], precalc[tt][1] = D[b],
precalc[tt][2] = D[c], precalc[tt][3] = D[d],
precalc[tt][4] = D[e], precalc[tt][5] = D[f], tt++;
for (int i = 0; i < tt; i++)
presum[i] = accumulate(precalc[i], precalc[i] + 6, 0);
int t;
scanf("%d", &t);
while (t-- > 0) {
scanf("%s", dat);
int n = strlen(dat);
memset(dt, -1, sizeof(dt));
for (int i = 0; i < 6; i++) dt[0][0][i] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 4; j++) {
if (dt[i][j][0] == -1) continue;
int newval = j * 10 + dat[i] - '0';
for (int state = 0; state < tt; state++) {
int curval = newval - presum[state];
if (curval >= 0 && curval <= 4) {
memcpy(dt[i + 1][curval], precalc[state], sizeof(*precalc));
}
}
}
}
if (dt[n][0][0] == -1) {
printf("-1\n");
continue;
}
int rem = 0;
vector<char> ans[6];
for (int i = n; i > 0; i--) {
int *curdt = dt[i][rem];
for (int k = 0; k < 6; k++) {
ans[k].push_back(curdt[k] + '0');
rem += curdt[k];
}
rem -= dat[i - 1] - '0';
rem /= 10;
}
for (int i = 0; i < 6; i++) {
bool notzero = false;
for (int j = 0; j < ans[i].size(); j++) {
char curc = ans[i].rbegin()[j];
if (curc != '0') notzero = true;
if (notzero) printf("%c", curc);
}
if (!notzero) printf("0");
printf(i == 5 ? "\n" : " ");
}
}
return 0;
}
| 11 |
CPP
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.