text
stringlengths 49
983k
|
|---|
#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);
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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]);
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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]);
}
|
#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;
}
|
#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);
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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("");
}
}
|
#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;
}
|
#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;
}
}
|
#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);
}
}
|
#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);
}
}
|
#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);
}
}
|
#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();
}
|
#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;
}
|
#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';
}
}
|
#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();
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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();
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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("");
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
}
|
#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";
}
}
|
#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;
}
|
#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";
}
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
}
|
#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;
}
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
int luck_number[105], tot;
int dp[10005][7];
bool is_luck(int x) {
while (x) {
int y = x % 10;
x = x / 10;
if (y > 0 && y < 4) return false;
if (y > 4 && y < 7) return false;
if (y > 7) return false;
}
return true;
}
void init() {
tot = 0;
for (int i = 0; i <= 10000; i++) {
if (is_luck(i)) luck_number[tot++] = i;
}
}
void pre10000() {
for (int i = 0; i <= 10000; i++)
for (int j = 0; j <= 6; j++) dp[i][j] = -1;
for (int i = 0; i <= 6; i++) {
dp[0][i] = 0;
}
for (int i = 1; i <= 6; i++) {
for (int j = 0; j < tot; j++) {
int x = luck_number[j];
for (int k = x; k <= 10000; k++) {
if (dp[k - x][i - 1] != -1) {
dp[k][i] = x;
}
}
}
}
}
int main() {
init();
pre10000();
int cas;
scanf("%d", &cas);
while (cas--) {
long long N;
cin >> N;
if (N < 10000LL) {
int n = (int)(N);
if (dp[n][6] != -1) {
for (int i = 6; i > 0; i--) {
printf("%d ", dp[n][i]);
n -= dp[n][i];
}
puts("");
} else
printf("-1\n");
} else {
int n1 = (int)(N % 4000LL);
if (dp[n1][6] == -1) n1 += 4000, N -= 4000;
long long res[7];
for (int i = 6; i > 0; i--) {
res[i] = (long long)(dp[n1][i]);
n1 -= dp[n1][i];
}
long long n2 = N - n1;
long long p = n2 / 4000LL, base = 1000LL;
while (p) {
int d = (int)(p % 10LL);
if (d <= 6) {
for (int i = 1; i <= d; i++) {
res[i] += base * 4;
}
} else {
for (int i = 1; i <= d - 7; i++) {
res[i] += base * 4;
}
for (int i = 6; i >= 3; i--) {
res[i] += base * 7;
}
}
base *= 10LL;
p /= 10LL;
}
for (int i = 1; i <= 6; i++) cout << res[i] << " ";
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
char memo[10][20];
int len;
std::string num;
std::vector<std::string> ans;
int go(const int& co, const int& cur) {
if (cur < 0) return co == 0;
char& ret = memo[co][cur];
if (ret != -1) return ret;
ret = 0;
for (int fr = 0; fr <= 6; ++fr)
for (int sv = 0; sv + fr <= 6; ++sv) {
int sum = fr * 4 + sv * 7 + co;
ret = ret || (sum % 10 == num[cur] - '0' && go(sum / 10, cur - 1));
}
return ret;
}
void bb(const int& co, const int& cur) {
if (cur < 0) return;
for (int fr = 0; fr <= 6; ++fr)
for (int sv = 0; sv + fr <= 6; ++sv) {
int sum = fr * 4 + sv * 7 + co;
if (sum % 10 == num[cur] - '0' && go(sum / 10, cur - 1)) {
int idx = 0;
for (int diff = 6 - fr - sv; diff--;) ans[idx++].push_back('0');
while (fr--) ans[idx++].push_back('4');
while (sv--) ans[idx++].push_back('7');
bb(sum / 10, cur - 1);
return;
}
}
}
void one_case(void) {
std::cin >> num;
len = num.length();
memset(memo, 0xff, sizeof(memo));
if (!go(0, len - 1)) {
std::cout << "-1\n";
return;
}
ans = std::vector<std::string>(6);
bb(0, len - 1);
for (auto& e : ans) {
while (static_cast<int>(e.size()) > 1 && e.back() == '0') e.pop_back();
std::reverse(e.begin(), e.end());
std::cout << e << " ";
}
std::cout << "\n";
}
int main(void) {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int t;
std::cin >> t;
while (t--) one_case();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const double eps = 1e-10;
const int MOD = 100000007;
const int MAXN = 1000000;
vector<pair<int, int> > v[10];
void init() {
for (int i = (0); i <= (6); ++i)
for (int j = (0); j <= (6 - i); ++j) {
v[(i * 4 + j * 7) % 10].push_back(make_pair(i, j));
}
}
long long pw[] = {
1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000,
100000000000,
1000000000000,
10000000000000,
100000000000000,
1000000000000000,
10000000000000000,
100000000000000000,
1000000000000000000,
};
bool ok;
pair<int, int> p[30];
vector<long long> ans;
void fun(long long n, int index) {
if (ok || n < 0) return;
if (n == 0) {
int n4 = 0, n7 = 0;
ans.clear();
for (int i = (index - 1); i >= (0); --i) {
n4 = p[i].first, n7 = p[i].second;
int size = ans.size();
for (int j = 0; j < (size); ++j) {
if (n4 > 0)
ans[j] = ans[j] * 10 + 4, n4--;
else if (n7 > 0)
ans[j] = ans[j] * 10 + 7, n7--;
else
ans[j] *= 10;
}
while (n4--) ans.push_back(4);
while (n7--) ans.push_back(7);
if (ans.size() > 6) return;
}
ok = true;
return;
}
int low = n % 10;
for (int i = 0; i < (v[low].size()); ++i) {
pair<int, int> t = v[low][i];
p[index] = t;
fun(n / 10 - (t.first * 4 + t.second * 7) / 10, index + 1);
}
}
int main() {
init();
int n;
scanf("%d", &n);
while (n--) {
ok = false;
long long input;
cin >> input;
fun(input, 0);
if (ok) {
while (ans.size() < 6) ans.push_back(0);
cout << ans[0];
for (int i = (1); i < (6); ++i) cout << " " << ans[i];
cout << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long p10[20];
bool vis[20][10];
vector<long long> dp[20][10];
vector<long long> dig[100];
vector<long long> go(int k, int p) {
if (vis[k][p]) return dp[k][p];
vis[k][p] = true;
int cur = n / p10[k - 1] % 10 + p * 10;
if (k == 1) return dig[cur];
for (int i = 0, _n = (int)(10); i < _n; i++) {
if (i > cur) break;
if ((int((dig[cur - i]).size())) == 0) continue;
vector<long long> tmp = go(k - 1, i);
if ((int((tmp).size())) == 0) continue;
for (int j = 0, _n = (int)(6); j < _n; j++)
tmp[j] += dig[cur - i][j] * p10[k - 1];
return dp[k][p] = tmp;
}
return dp[k][p] = vector<long long>();
}
int main() {
ios_base::sync_with_stdio(false);
p10[0] = 1;
for (int i = (int)(1), _n = (int)(20); i < _n; i++) p10[i] = p10[i - 1] * 10;
for (int i = 0, _n = (int)(3 * 3 * 3 * 3 * 3 * 3); i < _n; i++) {
vector<long long> tmp;
int x = i;
for (int j = 0, _n = (int)(6); j < _n; j++)
tmp.push_back(x % 3 == 0 ? 0 : x % 3 == 1 ? 4 : 7), x /= 3;
long long sum = accumulate((tmp).begin(), (tmp).end(), 0);
dig[sum] = tmp;
}
int TTT;
for (cin >> TTT; TTT--;) {
cin >> n;
memset(vis, false, sizeof vis);
vector<long long> ans = go(19, 0);
if ((int((ans).size())) == 0)
cout << -1 << endl;
else {
for (int i = 0, _n = (int)(6); i < _n; i++) cout << ans[i] << ' ';
cout << endl;
}
}
{
int _;
cin >> _;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int TC;
long long N;
bool used[100];
int P[100][7];
char D[100];
int L;
bool Chk[20][20];
long long Res[20][20][7];
void init() {
memset(Chk, 0, sizeof Chk);
memset(Res, 0, sizeof Chk);
}
void solve() {
int i, j, k;
int f, s;
init();
for (i = 0; i <= D[1]; i++)
if (used[i]) {
Chk[1][D[1] - i] = 1;
for (j = 0; j < 6; j++) Res[1][D[1] - i][j] = P[i][j];
}
for (i = 2; i <= L; i++)
for (j = 0; j < 50; j++)
if (used[j]) {
for (k = 0; k < 10; k++)
if (Chk[i - 1][k]) {
int val = 10 * k + D[i] - j;
if (0 <= val && val < 10) {
Chk[i][val] = 1;
for (int x = 0; x < 6; x++)
Res[i][val][x] = Res[i - 1][k][x] * 10 + P[j][x];
}
}
}
if (!Chk[L][0]) {
puts("-1");
} else {
for (i = 0; i < 6; i++)
printf("%I64d%c", Res[L][0][i], (i == 5) ? '\n' : ' ');
long long sum = 0;
for (i = 0; i < 6; i++) sum += Res[L][0][i];
assert(sum == N);
}
}
int main() {
int i, j, k;
int f, z;
for (z = 0; z <= 6; z++)
for (f = 0; f <= 6 - z; f++) {
int s = 6 - (z + f);
int a = 4 * f + 7 * s;
used[a] = 1;
for (i = 0; i < z; i++) P[a][i] = 0;
for (i = z; i < z + f; i++) P[a][i] = 4;
for (i = z + f; i < 6; i++) P[a][i] = 7;
}
scanf("%d", &TC);
while (TC--) {
scanf("%s", D + 1);
sscanf(D + 1, "%I64d", &N);
L = strlen(D + 1);
for (i = 1; i <= L; i++) D[i] -= '0';
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct l6 {
l6(long long a, long long b, long long c, long long d, long long e,
long long first, int p = 0) {
vals[0] = a;
vals[1] = b;
vals[2] = c;
vals[3] = d;
vals[4] = e;
vals[5] = first;
pow10_val = p;
}
l6 cop() {
return l6(vals[0], vals[1], vals[2], vals[3], vals[4], vals[5],
pow10_val + 1);
}
long long vals[6];
int pow10_val;
};
vector<int> XtoA[10];
vector<int> XtoB[10];
int main() {
std::ios_base::sync_with_stdio(false);
for (int X = 0; X < 10; X++) {
XtoA[X] = vector<int>();
XtoB[X] = vector<int>();
for (int A = 0; A <= 6; A++) {
for (int B = 0; B + A <= 6; B++) {
if ((7 * A + 4 * B) % 10 == X) {
XtoA[X].push_back(A);
XtoB[X].push_back(B);
}
}
}
}
int T;
cin >> T;
long long N;
long long nums[6];
bool w;
long long X, A, B, C, R;
while (T--) {
cin >> N;
w = false;
long long pow10 = 1;
int prev10 = 0;
for (int i = 0; i < 6; i++) {
nums[i] = 0;
}
queue<l6> Q;
set<long long> seenNums = {N};
Q.push(l6(0, 0, 0, 0, 0, 0));
while (Q.size()) {
l6 a = Q.front();
Q.pop();
if (a.pow10_val != prev10) {
prev10 = a.pow10_val;
pow10 *= 10;
}
long long sub = 0;
for (int i = 0; i < 6; i++) {
sub += a.vals[i];
}
R = N - sub;
if (R == 0) {
w = true;
for (long long i : a.vals) cout << i << " ";
cout << "\n";
break;
}
R /= pow10;
X = R % 10;
if (R < 4) continue;
for (int i = 0; i < XtoA[X].size(); i++) {
A = XtoA[X][i];
B = XtoB[X][i];
C = 6 - A - B;
if (A * 7 + 4 * B > R) continue;
l6 b = a.cop();
long long added = 0;
for (int ii = 0; ii < 6; ii++) {
if (ii < A) {
b.vals[ii] += 7 * pow10;
added += 7 * pow10;
} else if (ii < A + B) {
b.vals[ii] += 4 * pow10;
added += 4 * pow10;
}
}
if (C == 6 || seenNums.find(N - sub - added) == seenNums.end()) {
seenNums.insert(N - sub - added);
Q.push(b);
}
}
}
if (!w) cout << "-1\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int t, used[21][5], cur, len, a[N];
long long n, res[N], ten[N];
bool dp[21][5];
bool solve(int pos, int d) {
if (used[pos][d] == cur) return dp[pos][d];
used[pos][d] = cur;
if (pos >= len) {
if (d == 0)
dp[pos][d] = true;
else
dp[pos][d] = false;
return dp[pos][d];
}
dp[pos][d] = false;
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++)
if ((4 * i + 7 * j + d) % 10 == a[pos]) {
dp[pos][d] |= solve(pos + 1, (4 * i + 7 * j + d) / 10);
if (dp[pos][d]) return true;
}
return false;
}
void solve1(int pos, int d) {
if (pos >= len) return;
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++)
if ((4 * i + 7 * j + d) % 10 == a[pos] &&
dp[pos + 1][(4 * i + 7 * j + d) / 10]) {
int r = 0;
for (int k = 0; k < i; k++) res[r++] += 4ll * ten[pos];
for (int k = 0; k < j; k++) res[r++] += 7ll * ten[pos];
solve1(pos + 1, (4 * i + 7 * j + d) / 10);
return;
}
}
int main() {
cin >> t;
cur = 0;
ten[0] = 1;
for (int i = 1; i <= 19; i++) ten[i] = ten[i - 1] * 10;
while (t--) {
cur++;
cin >> n;
len = 0;
long long t = n;
while (t > 0) {
a[len++] = t % 10;
t /= 10;
}
for (int i = 0; i < 6; i++) res[i] = 0;
if (!solve(0, 0))
printf("%d\n", -1);
else {
solve1(0, 0);
for (int i = 0; i < 6; i++) printf("%I64d ", res[i]);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long BASE[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 TBL[28][2];
const long long DAME1[33] = {
+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};
const long long DAME2[14] = {-71, -62, -59, -55, -41, -32, -29,
-25, -11, -8, -5, -4, -2, -1};
long long ONEMAX[1 + 18];
long long SIXMAX[1 + 18];
bool YES1[1 + 42];
bool YES2[1 + 462];
bool YES(int N, long long X) {
if (X < 0 || X > SIXMAX[N]) return false;
if (N == 0) return true;
if (N == 1) return YES1[X];
if (N == 2) return YES2[X];
const long long *it;
it = lower_bound(DAME1, DAME1 + 33, X);
if (it != DAME1 + 33 && *it == X) return false;
it = lower_bound(DAME2, DAME2 + 14, X - SIXMAX[N]);
if (it != DAME2 + 14 && *it == X - SIXMAX[N]) return false;
return true;
}
bool solve(long long X) {
int A[18];
long long Z[6];
if (!YES(18, X)) return false;
for (int i = 0; i < 18; i++) {
for (int j = 0; j < 28; j++) {
long long Y = X - BASE[j];
if (Y < 0 || Y % 10 != 0) continue;
Y /= 10;
if (!YES(17 - i, Y)) continue;
X = Y;
A[i] = j;
break;
}
}
memset(Z, 0x00, sizeof(Z));
for (int i = 17; i >= 0; i--) {
int n4 = TBL[A[i]][0];
int n7 = TBL[A[i]][1];
for (int j = 0; j < 6; j++) {
Z[j] *= 10;
if (n4 != 0) {
Z[j] += 4;
n4--;
} else if (n7 != 0) {
Z[j] += 7;
n7--;
}
}
}
cout << Z[0] << ' ' << Z[1] << ' ' << Z[2] << ' ' << Z[3] << ' ' << Z[4]
<< ' ' << Z[5] << endl;
return true;
}
void build() {
for (int i = 0; i < 28; i++) {
for (int j = 0; j <= 6; j++) {
for (int k = 0; j + k <= 6; k++) {
if (j * 4 + k * 7 == BASE[i]) {
TBL[i][0] = j;
TBL[i][1] = k;
goto out;
}
}
}
out:;
}
for (int i = 1; i <= 18; i++) {
ONEMAX[i] = ONEMAX[i - 1] * 10 + 7;
SIXMAX[i] = 6 * ONEMAX[i];
}
for (int i = 0; i < 28; i++) {
YES1[BASE[i]] = true;
for (int j = 0; j < 28; j++) YES2[BASE[i] * 10 + BASE[j]] = true;
}
}
int main() {
ios_base::sync_with_stdio(false);
build();
int T;
cin >> T;
while (--T >= 0) {
long long X;
cin >> X;
if (!solve(X)) cout << "-1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ex[30], dp[31][7], ans[7], pre1[30][7], pre2[30][7], pre3[30][7];
int v[30];
void lemon() {
ex[0] = 1;
for (int i = (1); i <= (19); i++) ex[i] = ex[i - 1] * 10;
long long s;
scanf("%I64d", &s);
for (int i = (1); i <= (19); i++) v[i] = s % 10, s /= 10;
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (int i = (0); i <= (19); i++)
for (int k = (0); k <= (5); k++)
if (dp[i][k])
for (int s4 = (0); s4 <= (6); s4++)
for (int s7 = (0); s7 <= (6 - s4); s7++) {
int t = s4 * 4 + s7 * 7 + k;
if (t % 10 != v[i + 1]) continue;
t /= 10;
dp[i + 1][t] = 1;
pre1[i + 1][t] = s4;
pre2[i + 1][t] = s7;
pre3[i + 1][t] = k;
}
if (!dp[20][0]) {
printf("-1\n");
return;
}
int cur = 0;
memset(ans, 0, sizeof ans);
for (int i = (20); i >= (1); i--) {
int t = 1;
for (int k = (1); k <= (pre1[i][cur]); k++) ans[t] += ex[i - 1] * 4, t++;
for (int k = (1); k <= (pre2[i][cur]); k++) ans[t] += ex[i - 1] * 7, t++;
cur = pre3[i][cur];
}
for (int i = (1); i <= (6); i++) printf("%I64d ", ans[i]);
printf("\n");
}
int main() {
ios::sync_with_stdio(true);
int tcase;
scanf("%d", &tcase);
while (tcase--) lemon();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
string Number;
int test;
int check[200], Digit4[200], Digit7[200], f[20][20], Digit[20][20],
Value[20][20];
long long ans[10];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++) {
check[i * 4 + j * 7] = 1;
Digit4[i * 4 + j * 7] = i;
Digit7[i * 4 + j * 7] = j;
}
cin >> test;
while (test) {
test--;
cin >> Number;
int len_Number = Number.length();
Number = ' ' + Number;
for (int i = 19; i >= 0; i--)
for (int j = 19; j >= 0; j--) f[i][j] = 0;
f[len_Number][0] = 1;
for (int i = len_Number; i >= 1; i--) {
int digit = Number[i] - '0';
for (int j = 0; j <= 9; j++)
if (f[i][j] == 1) {
for (int k = digit - j; k <= 42; k += 10)
if (check[k] == 1 and k >= 0) {
f[i - 1][(k + j) / 10] = 1;
Digit[i - 1][(k + j) / 10] = j;
Value[i - 1][(k + j) / 10] = k;
}
}
}
if (f[0][0] == 0) {
cout << "-1\n";
} else {
for (int i = 1; i <= 6; i++) ans[i] = 0;
int j = 0;
for (int i = 0; i < len_Number; i++) {
int Num = Value[i][j];
for (int k = 1; k <= Digit4[Num]; k++) ans[k] = ans[k] * 10 + 4;
for (int k = 1; k <= Digit7[Num]; k++)
ans[k + Digit4[Num]] = ans[k + Digit4[Num]] * 10 + 7;
for (int k = Digit4[Num] + Digit7[Num] + 1; k <= 6; k++) ans[k] *= 10;
j = Digit[i][j];
}
for (int i = 1; i <= 6; i++) cout << ans[i] << ' ';
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25];
int dp[25][15];
int nxt[25][15];
int mat[15][25];
void load() { scanf("%s", s); }
int express(int x) {
for (int i = 0; i < 7 && x >= 0; i++) {
if (!(x % 7)) return i + x / 7 > 6 ? -1 : i;
x -= 4;
}
return -1;
}
int rec(int pos, int carry) {
int &ref = dp[pos][carry];
if (ref != -1) return ref;
int digit = s[pos] - '0' - carry;
if (digit < 0) digit += 10;
ref = 0;
for (int i = 0; i < 5; i++)
if (express(10 * i + digit) != -1 &&
rec(pos + 1, i + (digit + carry) / 10)) {
ref = 1;
nxt[pos][carry] = i;
}
return ref;
}
void solve() {
int N = strlen(s);
reverse(s, s + N);
memset(dp, -1, sizeof dp);
memset(mat, 0, sizeof mat);
dp[N][0] = 1;
for (int i = 1; i < 10; i++) dp[N][i] = 0;
int res = rec(0, 0);
if (!res) {
puts("-1");
return;
}
int curr = 0;
for (int i = 0; i < N; i++) {
int digit = s[i] - '0' - curr;
if (digit < 0) digit += 10;
int num = 10 * nxt[i][curr] + digit;
int tmp = express(num);
for (int j = 0; j < tmp; j++) mat[j][N - i - 1] = 4;
for (int j = 0; j < (num - tmp * 4) / 7; j++) mat[tmp + j][N - i - 1] = 7;
curr = nxt[i][curr] + (digit + curr) / 10;
}
for (int i = 0; i < 6; i++) {
long long sol = 0;
for (int j = 0; j < N; j++) sol = 10 * sol + (long long)mat[i][j];
printf("%I64d ", sol);
}
puts("");
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
load();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100005;
int n;
int a[max_n];
int ln[3] = {0, 4, 7};
vector<int> M[55];
map<long long, int> ML, visited;
bool func(long long N) {
if (N == 0) return 1;
if (!visited[N]) {
visited[N] = 1;
int d = N % 10;
for (int i = 0; i <= 4; i++)
if (M[10 * i + d].size() == 6)
if (func((N / 10) - i)) {
ML[N] = i + 1;
return 1;
}
return 0;
}
return ML[N];
}
void cal(vector<int> x) {
if (x.size() == 6) {
int sum = 0;
for (int i = 0; i < 6; i++) sum += x[i];
M[sum] = x;
return;
}
for (int i = 0; i < 3; i++) {
vector<int> y = x;
y.push_back(ln[i]);
cal(y);
}
}
void construct(long long N, vector<int> res[]) {
if (N == 0) {
for (int i = 0; i < 6; i++) {
reverse(res[i].begin(), res[i].end());
int nr = res[i].size();
int j = 0;
while (j < nr - 1 and res[i][j] == 0) j++;
for (; j < nr; j++) printf("%d", res[i][j]);
printf(" ");
}
return;
}
int v = ML[N] - 1;
for (int i = 0; i < 6; i++) res[i].push_back(M[10 * v + N % 10][i]);
construct((N / 10) - v, res);
}
int main() {
vector<int> x;
cal(x);
long long N;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> N;
if (func(N)) {
vector<int> res[6];
construct(N, res);
printf("\n");
} else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[7];
int n;
long long a[5001];
vector<pair<int, pair<int, int>>> mask[20];
pair<int, pair<int, int>> last[100];
vector<int> carry[20];
bool calc(long long x) {
if (x <= 42) {
int a = last[x].first, b = last[x].second.first, c = last[x].second.second;
if (a + b + c) {
for (int i = 1; i <= a; ++i) s[i] += '7';
for (int i = a + 1; i <= a + b; ++i) s[i] += '4';
for (int i = a + b + 1; i <= 6; ++i) s[i] += '0';
return 1;
};
}
long long cur = x;
int mod = cur % 10;
if (!carry[mod].size()) return 0;
for (int i = 0; i < carry[mod].size(); ++i) {
cur = x / 10;
cur -= carry[mod][i];
if (cur <= 0) continue;
if (calc(cur)) {
int a = mask[mod][i].first, b = mask[mod][i].second.first,
c = mask[mod][i].second.second;
for (int i = 1; i <= a; ++i) s[i] += '7';
for (int i = a + 1; i <= a + b; ++i) s[i] += '4';
for (int i = a + b + 1; i <= 6; ++i) s[i] += '0';
return 1;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int a = 0; a <= 6; ++a) {
for (int b = 0; b + a <= 6; ++b) {
int x = 6 - a - b;
int second = a * 7 + b * 4;
carry[second % 10].push_back(second / 10);
mask[second % 10].push_back(make_pair(a, make_pair(b, x)));
last[second] = make_pair(a, make_pair(b, x));
}
}
for (int i = 1; i <= n; ++i) {
cin >> a[i];
for (int j = 1; j <= 6; ++j) s[j] = "";
if (calc(a[i])) {
for (int i = 1; i <= 6; ++i) {
while (s[i].length() > 1 && s[i][0] == '0') s[i].erase(0, 1);
cout << s[i] << ' ';
;
}
} else
cout << -1;
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
char n[30];
int D[30][10], T[30][10], sol[10][33];
int c[] = {0, 4, 7};
int main() {
int tests;
scanf("%d\n", &tests);
while (tests--) {
memset(n, 0, sizeof(n));
scanf("%s", n + 1);
int l = strlen(n + 1);
memset(D, 0, sizeof(D));
memset(T, 0, sizeof(T));
memset(sol, 0, sizeof(sol));
D[l + 1][0] = 1;
for (int i = l + 1; i >= 2; --i) {
for (int j = 0; j < 10; ++j) {
if (!D[i][j]) continue;
int p = 0;
for (int a1 = 0; a1 < 3; ++a1) {
for (int a2 = a1; a2 < 3; ++a2) {
for (int a3 = a2; a3 < 3; ++a3) {
for (int a4 = a3; a4 < 3; ++a4) {
for (int a5 = a4; a5 < 3; ++a5) {
for (int a6 = a5; a6 < 3; ++a6) {
++p;
int s = c[a1] + c[a2] + c[a3] + c[a4] + c[a5] + c[a6];
s += j;
int cat = s / 10;
int rest = s - cat * 10;
if (rest == n[i - 1] - '0') {
D[i - 1][cat] = p;
T[i - 1][cat] = j;
}
}
}
}
}
}
}
}
}
if (!D[1][0]) {
printf("%d\n", -1);
continue;
}
int cat = 0;
for (int i = 1; i <= l; ++i) {
int p = D[i][cat];
for (int a1 = 0; a1 < 3 && p; ++a1) {
for (int a2 = a1; a2 < 3 && p; ++a2) {
for (int a3 = a2; a3 < 3 && p; ++a3) {
for (int a4 = a3; a4 < 3 && p; ++a4) {
for (int a5 = a4; a5 < 3 && p; ++a5) {
for (int a6 = a5; a6 < 3 && p; ++a6) {
--p;
if (!p) {
sol[1][i] = c[a1], sol[2][i] = c[a2], sol[3][i] = c[a3];
sol[4][i] = c[a4], sol[5][i] = c[a5], sol[6][i] = c[a6];
}
}
}
}
}
}
}
cat = T[i][cat];
}
for (int i = 1; i <= 6; ++i) {
int x = 1;
while (x < l && sol[i][x] == 0) ++x;
for (int j = x; j <= l; ++j) {
printf("%d", sol[i][j]);
}
printf(" ");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void debug(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(T1 e1, T2 e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(T1 e1, T2 e2, T3 e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << "\t"
<< e6 << endl;
}
template <class T>
void debug(vector<vector<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[110][110], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool isVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
int dp[25][8];
bool col[25][8];
char str[25];
int now;
long long ans[10];
int dprec(int in, int carry) {
if (in < 0) return (!carry);
int &ret = dp[in][carry];
if (col[in][carry] == now) return ret;
col[in][carry] = now;
int i, j;
ret = 0;
for (i = 0; i <= 6 && !ret; i++)
for (j = 0; i + j <= 6 && !ret; j++) {
int tot = i * 4 + j * 7 + carry;
if ((tot % 10) != (str[in] - '0')) continue;
tot /= 10;
ret = dprec(in - 1, tot);
if (!ret) continue;
int k;
for (k = 1; k <= i; k++) ans[k] = 10 * ans[k] + 4;
for (; k <= i + j; k++) ans[k] = 10 * ans[k] + 7;
for (; k <= 6; k++) ans[k] = 10 * ans[k];
}
return ret;
}
int main() {
int t;
cin >> t;
now = 0;
while (t--) {
now++;
int i;
memset(ans, 0, sizeof(ans));
scanf("%s", str);
int n = strlen(str);
if (!dprec(n - 1, 0))
cout << "-1" << endl;
else {
cout << ans[1];
for (i = 2; i <= 6; i++) cout << " " << ans[i];
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[50];
int dp[20][10];
vector<int> w[10][10];
int ans[20][6];
bool cal(int pos, int mod) {
if (pos == -1 && mod == 0)
return true;
else if (pos == -1)
return false;
if (dp[pos][mod] != -1) return dp[pos][mod];
int tp = s[pos] - '0';
for (int i = 0; i <= 9; i++) {
int p, q;
if (i > tp) {
if (mod == 0) continue;
p = mod - 1;
q = tp + 10 - i;
} else {
p = mod;
q = tp - i;
}
if (w[p][q].size())
if (cal(pos - 1, i)) {
for (int j = 0; j < w[p][q].size(); j++) ans[pos][j] = w[p][q][j];
dp[pos][mod] = true;
return true;
}
}
return dp[pos][mod] = false;
}
void init() {
int n = pow(3, 7);
for (int i = 0; i < n; i++) {
vector<int> q;
int k = i;
for (int j = 0; j < 6; j++) {
int p = k % 3;
if (p == 0)
q.push_back(0);
else if (p == 1)
q.push_back(4);
else
q.push_back(7);
k /= 3;
}
int ans = 0;
for (int i = 0; i < q.size(); i++) ans += q[i];
w[ans / 10][ans % 10] = q;
}
}
int main() {
init();
int t;
scanf("%d", &t);
while (t--) {
scanf("%s", s);
int len = strlen(s);
memset(dp, -1, sizeof dp);
reverse(s, s + len);
if (cal(len - 1, 0)) {
for (int i = 0; i < 6; i++) {
int j;
for (j = len - 1; j >= 0; j--)
if (ans[j][i]) break;
if (j == -1) printf("0");
while (j >= 0) {
printf("%d", ans[j][i]);
j--;
}
printf(" ");
}
printf("\n");
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long CARRY = 10;
const long long VALUE = 10;
const long long LOC = 10;
const long long FOURS = 0;
const long long SEVENS = 1;
long long value[50][2] = {0};
bool valid[50] = {0};
long long weight[50] = {0};
long long digis[50] = {0};
bool bad[CARRY][LOC] = {0};
long long digits;
long long number[20] = {0};
long long dig_cnt;
long long answers[6];
long long dfs(long long current_carry, long long loc) {
if (bad[current_carry][loc]) {
return 0;
}
if (loc >= dig_cnt) {
return current_carry == 0;
}
long long next_carry, digi;
next_carry = 0;
digi = -current_carry;
digi += number[loc];
while (digi < 0) {
digi += 10;
next_carry++;
}
while (digi <= 46) {
if (!valid[digi]) {
digi += 10;
next_carry++;
continue;
}
if (dfs(next_carry, loc + 1)) {
digis[loc] = digi;
return 1;
}
digi += 10;
next_carry++;
}
bad[current_carry][loc] = 1;
return 0;
}
void pre_process() {
for (long long i = 0; i < 7; i++) {
for (long long j = 0; j < 7; j++) {
if (i + j > 6) continue;
value[i * 4 + j * 7][FOURS] = i;
value[i * 4 + j * 7][SEVENS] = j;
valid[i * 4 + j * 7] = 1;
}
}
weight[0] = 1;
for (long long i = 1; i < 19; i++) {
weight[i] = weight[i - 1] * 10;
}
}
int main() {
pre_process();
long long t_case;
char buf[100000];
long long len;
long long has_sln;
cin >> t_case;
for (long long i = 0; i < t_case; i++) {
memset(bad, 0, sizeof(bad));
memset(digis, 0, sizeof(digis));
scanf("%s", buf);
len = strlen(buf);
reverse(buf, buf + len);
for (long long i = 0; i < len; i++) {
number[i] = buf[i] - '0';
}
dig_cnt = len;
has_sln = dfs(0, 0);
if (has_sln == 0) {
puts("-1");
continue;
}
for (long long i = 0; i < 6; i++) {
answers[i] = 0;
}
long long cnt_t[2];
for (long long i = 0; i < dig_cnt; i++) {
cnt_t[SEVENS] = value[digis[i]][SEVENS];
cnt_t[FOURS] = value[digis[i]][FOURS];
for (long long j = 0; j < 6; j++) {
if (cnt_t[SEVENS]) {
cnt_t[SEVENS]--;
answers[j] += weight[i] * 7LL;
} else if (cnt_t[FOURS]) {
cnt_t[FOURS]--;
answers[j] += weight[i] * 4LL;
}
}
}
for (long long i = 0; i < 6; i++) {
cout << answers[i] << " ";
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int memo[19][5][6];
vector<vector<vector<int>>> sums;
void dp(int pos, int res) {
if (pos == s.size() && res) {
memo[pos][res][0] = -2;
return;
}
if (pos == s.size() && !res) {
return;
}
if (memo[pos][res][0] != -1) return;
int flag = 0;
int r = (s[pos] - '0') - res;
if (pos == s.size() - 1 && r < 0) {
memo[pos][res][0] = -2;
return;
}
if (r < 0) {
r += 10;
flag = 1;
}
int j;
for (j = 0; j < sums[r].size(); ++j) {
dp(pos + 1, flag + (sums[r][j][6]) / 10);
if (memo[pos + 1][flag + (sums[r][j][6]) / 10][0] != -2) {
break;
}
}
if (j == sums[r].size())
for (int i = 0; i < 6; ++i) memo[pos][res][i] = -2;
else {
for (int i = 0; i < 6; ++i) memo[pos][res][i] = sums[r][j][i];
}
}
void print() {
string ans[6] = {"", "", "", "", "", ""};
int pos = 0, res = 0;
while (1) {
if (pos >= s.size() || memo[pos][res][0] == -1 || memo[pos][res][0] == -2)
break;
for (int i = 0; i < 6; ++i) {
ans[i] += (char)(memo[pos][res][i] + '0');
}
int flag = 0;
int r = (s[pos] - '0') - res;
if (r < 0) {
r += 10;
flag = 1;
}
int j;
for (j = 0; j < sums[r].size(); ++j) {
if (memo[pos + 1][flag + (sums[r][j][6]) / 10][0] != -2) {
pos++;
res = flag + (sums[r][j][6]) / 10;
break;
}
}
if (j == sums[r].size()) break;
}
for (int k = 0; k < 6; ++k) {
reverse(ans[k].begin(), ans[k].end());
int z = 0;
for (int i = 0; i < ans[k].size(); ++i) {
if (ans[k][i] == '0' && !z) continue;
z = 1;
cout << ans[k][i];
}
if (!z) cout << "0";
cout << " ";
}
cout << "\n";
}
int main() {
int T;
cin >> T;
sums.resize(10);
int lucky[3] = {0, 4, 7};
int a, b, c, d, e, f;
for (int i = 0; i < 3; ++i) {
for (int j = i; j < 3; ++j) {
for (int k = j; k < 3; ++k) {
for (int l = k; l < 3; ++l) {
for (int m = l; m < 3; ++m) {
for (int n = m; n < 3; ++n) {
int sum = lucky[i] + lucky[j] + lucky[k] + lucky[l] + lucky[m] +
lucky[n];
vector<int> vec = {lucky[i], lucky[j], lucky[k], lucky[l],
lucky[m], lucky[n], sum};
sums[sum % 10].push_back(vec);
}
}
}
}
}
}
while (T--) {
memset(memo, -1, sizeof(memo));
cin >> s;
reverse(s.begin(), s.end());
dp(0, 0);
if (memo[0][0][0] == -2)
cout << "-1\n";
else
print();
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > options[10];
vector<int> res[6];
bool go(long long target) {
if (target <= 0) return (target == 0);
int digit = target % 10;
for (int i = 0; i < options[digit].size(); i++) {
pair<int, int> option = options[digit][i];
int remains = (option.first * 4 + option.second * 7) / 10;
if (!go(target / 10 - remains)) continue;
for (int j = 0; j < option.first; j++) res[j].push_back(4);
for (int j = option.first; j < option.first + option.second; j++)
res[j].push_back(7);
for (int j = option.first + option.second; j < 6; j++) res[j].push_back(0);
return 1;
}
return 0;
}
void print(vector<int>& t) {
int start = 0;
while ((start < t.size() - 1) and (t[start] == 0)) start++;
for (int i = start; i < t.size(); i++) printf("%d", t[i]);
printf(" ");
}
int main() {
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6 - i; j++)
options[(i * 4 + j * 7) % 10].push_back(make_pair(i, j));
}
int t;
scanf("%d", &t);
while (t--) {
long long n;
scanf("%I64d", &n);
if (!go(n)) {
printf("-1\n");
continue;
}
for (int i = 0; i < 6; i++) {
print(res[i]);
res[i].clear();
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[200][500];
char num[200];
struct comb {
int v[60];
int s;
comb() { s = 0; }
} v[500];
int qnt = 1;
int get(int p, int c) {
if (p == -1 && c == 0) return 1;
if (p == -1) return 0;
if (dp[p][c] + 1) return dp[p][c];
dp[p][c] = 0;
for (int i = 1; i <= qnt; i++) {
if ((v[i].s + c) % 10 != num[p]) continue;
if (get(p - 1, (v[i].s + c) / 10)) dp[p][c] = i;
}
return dp[p][c];
};
void gera(int p, int d, comb C) {
if (p == 6) {
v[++qnt] = C;
return;
}
C.v[p] = 7;
C.s += 7;
gera(p + 1, 7, C);
C.s -= 7;
if (d != 7) {
C.v[p] = 4;
C.s += 4;
gera(p + 1, 4, C);
C.s -= 4;
}
if (d == 0) {
C.v[p] = 0;
gera(p + 1, 0, C);
}
}
void print(int *p) {
int foi = 0;
for (int i = 0; i <= 17; i++) {
if (*(p + i) == 0 && !foi) continue;
foi = 1;
printf("%d", *(p + i));
}
if (!foi) printf("0");
}
int resp[80][200];
int main() {
gera(0, 0, comb());
int t;
scanf("%d", &t);
while (t--) {
char ch;
scanf(" %s", num);
int n = strlen(num);
for (int i = 0; i < n; i++) num[i] -= '0';
memset(dp, -1, sizeof(dp));
if (get(n - 1, 0) == 0)
printf("-1\n");
else {
memset(resp, 0, sizeof(resp));
int c = 0;
for (int i = n - 1; i >= 0; i--) {
int k = get(i, c);
c = (v[k].s + c) / 10;
;
for (int j = 0; j < 6; j++)
;
;
for (int j = 0; j < 6; j++) {
resp[j][i + 18 - n] = v[k].v[j];
if (v[k].v[j])
;
}
}
for (int i = 0; i < 6; i++) {
if (i) printf(" ");
print(resp[i]);
}
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t, b[25];
long long n;
bool dp[25][15][15][10];
int main() {
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i <= 20; ++i) {
for (int j = 0; j <= 6; ++j) {
for (int k = 0; k <= 6; ++k) {
for (int v = 0; v <= 4; ++v) dp[i][j][k][v] = 0;
}
}
}
dp[0][0][0][0] = 1;
int x = 1;
vector<long long> d;
for (int i = 1; i <= 6; ++i) d.push_back(0);
int a = n % 10;
while (n) {
for (int i = 0; i <= 6; ++i) {
for (int j = 0; j <= 6 - i; ++j) {
for (int k = 0; k <= 4; ++k) {
if (dp[x - 1][i][j][k]) {
for (int m = 0; m <= 6; ++m) {
for (int t = 0; t <= 6 - m; ++t) {
if ((m * 4 + t * 7 + k) % 10 == a) {
dp[x][m][t][(m * 4 + t * 7 + k) / 10] = 1;
}
}
}
}
}
}
}
b[x] = a;
++x;
n /= 10;
a = n % 10;
}
int k = 0;
bool u = 0;
while (x > 1) {
--x;
u = 0;
for (int i = 0; i <= 6; ++i) {
for (int j = 0; j <= 6 - i; ++j) {
if (dp[x][i][j][k]) {
for (int l = 0; l < 6; ++l) d[l] *= 10;
for (int p = 0; p < i; ++p) d[p] += 4;
for (int q = i; q < i + j; ++q) d[q] += 7;
u = 1;
k = (b[x] + 10 - (i * 4 + j * 7) % 10) % 10;
break;
}
}
if (u) break;
}
if (!u) {
cout << -1;
break;
}
}
if (u) {
for (int i = 0; i < 6; ++i) cout << d[i] << ' ';
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
string a;
bool b[21][10] = {1};
pair<pair<int, int>, pair<int, int> > c[21][10] = {};
cin >> a;
reverse(a.begin(), a.end());
a += "000000000000000000000000";
for (int i = 0; i <= 19; i++) {
for (int j = 0; j <= 9; j++)
if (b[i][j]) {
for (int k = 0; k <= 6; k++) {
for (int l = 0; l <= 6 - k; l++) {
if ((j + k * 4 + l * 7) % 10 == a[i] - '0') {
b[i + 1][(j + k * 4 + l * 7) / 10] = 1;
c[i + 1][(j + k * 4 + l * 7) / 10] = {{i, j}, {k, l}};
}
}
}
}
}
if (b[19][0]) {
int d[20] = {}, e[20] = {}, x = 19, y = 0;
long long p[20] = {1}, z[6] = {};
for (int i = 1; i <= 18; i++) p[i] = p[i - 1] * 10;
while (x) {
pair<pair<int, int>, pair<int, int> > f = c[x][y];
x = f.first.first;
y = f.first.second;
d[x] = f.second.first;
e[x] = f.second.second;
}
for (int i = 0; i <= 18; i++) {
for (int j = 0; j < d[i]; j++) z[j] += p[i] * 4;
for (int j = d[i]; j < d[i] + e[i]; j++) z[j] += p[i] * 7;
}
cout << z[0] << ' ' << z[1] << ' ' << z[2] << ' ' << z[3] << ' ' << z[4]
<< ' ' << z[5] << '\n';
} else
cout << -1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, mod = 1e9 + 7, inf = 1e9 + 7;
const long long linf = (long long)1e18 + 7;
const long double eps = 1e-15, pi = 3.141592;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1},
dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
long long n;
long long res[7], p[20];
pair<int, int> first[50];
vector<int> d, ans;
inline bool Calc(long long x) {
if (!x) return 1;
for (auto i : d)
if (i <= x && ((x - i) % 10) == 0) {
ans.push_back(i);
if (Calc((x - i) / 10)) return 1;
ans.pop_back();
}
return 0;
}
inline void Solve() {
long long x;
scanf("%I64d", &x);
ans.clear();
if (!Calc(x))
printf("-1\n");
else {
memset(res, 0, sizeof(res));
for (int i = 0; i <= ans.size() - 1; i++) {
for (int j = 1; j <= first[ans[i]].first; j++) res[j] += 4 * p[i];
for (int j = 6 - first[ans[i]].second + 1; j <= 6; j++)
res[j] += 7 * p[i];
}
for (int i = 1; i <= 6; i++) printf("%I64d ", res[i]);
printf("\n");
}
}
int main() {
for (int i = 0; i <= 6; i++)
for (int j = 0; j <= 6; j++)
if (i + j <= 6) d.push_back(4 * i + 7 * j), first[d.back()] = {i, j};
p[0] = 1;
for (int i = 1; i <= 18; i++) p[i] = p[i - 1] * 10;
scanf("%d", &n);
for (int i = 1; i <= n; i++) Solve();
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[6][20];
int a[20];
long long num;
int pos;
int luck[3] = {0, 4, 7};
int cnt = 0;
int use_num[3][400];
void prev() {
cnt = 0;
for (int i = 0; i <= 6; i++) {
for (int j = 0; j + i <= 6; j++) {
use_num[0][cnt] = i;
use_num[1][cnt] = j;
use_num[2][cnt] = 6 - i - j;
cnt++;
}
}
}
void init() {
pos = 0;
while (num > 0) {
a[pos++] = num % 10;
num = num / 10;
}
memset(ans, 0, sizeof(ans));
}
bool dfs(int deep, int nu, int sum) {
if (nu >= cnt) return false;
if (deep == pos && sum == 0) return true;
if (deep == pos) return false;
int tot = sum;
for (int i = 0; i < 3; i++) tot += use_num[i][nu] * luck[i];
int t = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < use_num[i][nu]; j++) ans[t++][deep] = luck[i];
}
if (tot % 10 == a[deep])
if (dfs(deep + 1, 0, tot / 10)) return true;
return dfs(deep, nu + 1, sum);
}
int main() {
prev();
int n;
scanf("%d", &n);
for (int T = 0; T < n; T++) {
scanf("%I64d", &num);
init();
if (dfs(0, 0, 0)) {
for (int i = 0; i < 6; i++) {
string S = "";
for (int j = 0; j < 20; j++) {
S += (char)('0' + ans[i][j]);
}
reverse(S.begin(), S.end());
int pp = 0;
while (pp < S.length() - 1 && S[pp] == '0') pp++;
string res = S.substr(pp);
cout << res << " ";
}
cout << endl;
} else
printf("-1\n");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.