text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int MAXN = 1e5 + 5;
const int MOD = 1e9 + 7;
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
long long pw(long long a, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int cnt4[20], cnt7[20];
long long ans[20];
bool dfs(long long n, int k) {
if (n < 0) return false;
if (!n) {
memset(ans, 0, sizeof(ans));
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j <= cnt4[i]; j++) ans[j] = ans[j] * 10 + 4;
for (int j = cnt4[i] + 1; j <= cnt4[i] + cnt7[i]; j++)
ans[j] = ans[j] * 10 + 7;
for (int j = cnt4[i] + cnt7[i] + 1; j <= 6; j++) ans[j] *= 10;
}
for (int i = 1; i <= 6; i++) printf("%I64d ", ans[i]);
printf("\n");
return true;
}
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;
if (dfs(n / 10 - (4 * i + 7 * j) / 10, k + 1)) return true;
}
return false;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long n;
scanf("%I64d", &n);
if (!dfs(n, 0)) puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 5100;
struct pii {
int x, y;
};
pii mp(int x, int y) {
pii ret;
ret.x = x;
ret.y = y;
return ret;
}
int N, D[20], nn;
pii last[20][15];
int dp[20][15], cnt4[20][15], cnt7[20][15];
long long num[10];
int main() {
scanf("%d", &N);
while (N--) {
long long x;
scanf("%I64d", &x);
nn = 0;
memset(D, 0, sizeof(D));
long long tmp = x;
while (tmp) {
D[nn++] = tmp % 10;
tmp /= 10;
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i <= 18; i++) {
for (int j = 0; j <= 9; j++)
if (dp[i][j]) {
for (int k = 0; k <= 6; k++) {
for (int l = 0; l <= 6 - k; l++) {
int x = k * 4 + l * 7 + j;
if (x % 10 != D[i]) continue;
x /= 10;
dp[i + 1][x] = 1;
cnt4[i + 1][x] = k;
cnt7[i + 1][x] = l;
last[i + 1][x] = mp(i, j);
}
}
}
}
if (!dp[19][0]) {
puts("-1");
continue;
}
pii p = mp(19, 0);
for (int i = 1; i <= 6; i++) num[i] = 0;
while (p.x != 0) {
for (int i = 1; i <= 6; i++) num[i] *= 10;
for (int i = 1; i <= cnt4[p.x][p.y]; i++) num[i] = num[i] + 4;
for (int i = 1; i <= cnt7[p.x][p.y]; i++)
num[cnt4[p.x][p.y] + i] = num[cnt4[p.x][p.y] + i] + 7;
p = last[p.x][p.y];
}
for (int i = 1; i <= 6; i++) printf("%I64d ", num[i]);
puts("");
}
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool can[100];
int use[20][10];
void get(int x, int d) {
if (d > 6) return;
can[x] = 1;
get(x + 4, d + 1);
get(x + 7, d + 1);
}
int s[20], dp[20][10], rec[20][10], pre[20][10];
void undo(int p, int x) {
for (int i = 0; i <= 6 && x >= i * 4; i++) {
if ((x - i * 4) % 7 == 0) {
use[p][4] = i;
use[p][7] = (x - i * 4) / 7;
break;
}
}
}
void prt(int i, int j) {
if (i < 0) return;
undo(i, rec[i][j]);
prt(i - 1, pre[i][j]);
}
long long ans[10];
int main() {
get(0, 0);
long long n;
int cas, tmp, t;
scanf("%d", &cas);
while (cas--) {
scanf("%I64d", &n);
int len = 0;
while (n) {
s[len++] = n % 10;
n /= 10;
}
memset(dp, 0, sizeof(dp));
memset(use, 0, sizeof(use));
dp[0][0] = 1;
for (int i = 0; i < len; i++) {
for (int j = 0; j < 10; j++) {
if (!dp[i][j]) continue;
tmp = s[i] - j;
if (tmp < 0) {
t = 1;
tmp += 10;
} else
t = 0;
for (int x = 0; x < 100; x++) {
if (x % 10 != tmp || !can[x]) continue;
dp[i + 1][x / 10 + t] = 1;
rec[i + 1][x / 10 + t] = x;
pre[i + 1][x / 10 + t] = j;
}
}
}
if (!dp[len][0])
printf("-1\n");
else {
prt(len, 0);
for (int i = 0; i < 10; i++) ans[i] = 0;
for (int i = 19; i >= 1; i--) {
for (int j = 0; j < use[i][4]; j++) {
ans[j] = ans[j] * 10 + 4;
}
for (int j = use[i][4]; j < use[i][4] + use[i][7]; j++) {
ans[j] = ans[j] * 10 + 7;
}
for (int j = use[i][4] + use[i][7]; j < 6; j++) {
ans[j] = ans[j] * 10;
}
}
for (int i = 0; i < 6; i++) printf("%I64d ", ans[i]);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bad[9] = {1, 2, 3, 5, 6, 9, 10, 13, 17};
long long a[20];
int d[20][10];
long long ans[20];
long long ten[20];
int solve(int x, int rem) {
int i, j, k, tmp, tmp1;
if (x == -1) {
if (rem == 0)
return 1;
else
return 0;
}
if (d[x][rem] != -1) return d[x][rem];
tmp = rem * 10 + a[x];
for (i = 0; i <= 6; i++)
for (j = 0; j <= 6; j++)
if (i + j <= 6) {
if ((tmp - i * 4 - j * 7 >= 0) && (tmp - i * 4 - j * 7 < 10)) {
tmp1 = solve(x - 1, tmp - i * 4 - j * 7);
if (tmp1 == 1) {
for (k = 0; k < 6; k++)
if (k < i)
ans[k] += ten[x] * 4;
else if (k < i + j)
ans[k] += ten[x] * 7;
return 1;
}
}
}
d[x][rem] = 0;
return 0;
}
int main() {
int i, l, t, m, tmp;
long long n;
ten[0] = 1;
for (i = 1; i <= 18; i++) ten[i] = ten[i - 1] * 10;
cin >> t;
for (l = 0; l < t; l++) {
cin >> n;
for (i = 0; i < 9; i++)
if (n == bad[i]) {
cout << "-1" << endl;
break;
}
if (i < 9) continue;
m = 0;
while (n > 0) {
a[m] = n % 10;
m++;
n /= 10;
}
memset(d, -1, sizeof(d));
memset(ans, 0, sizeof(ans));
tmp = solve(m - 1, 0);
if (tmp == 0)
cout << "-1" << endl;
else {
for (i = 0; i < 6; i++) {
if (i != 0) cout << " ";
cout << ans[i];
}
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int bs[20];
int cvp[8][20];
int tl;
bool dur = false;
vector<int> b1[10];
vector<int> b2[10];
vector<int> b3[10];
vector<int> b4[10];
vector<int> b5[10];
vector<int> b6[10];
pair<pair<int, int>, pair<int, int> > nereden[20][10];
inline void rec(int sira, int elde) {
if (dur) return;
if (sira == tl && elde == 0) {
int s = sira, e = elde;
while (true) {
int ee = e;
int es = s;
s = nereden[es][ee].first.first;
e = nereden[es][ee].first.second;
int g = nereden[es][ee].second.first;
int i = nereden[es][ee].second.second;
cvp[1][s] = b1[g][i];
cvp[2][s] = b2[g][i];
cvp[3][s] = b3[g][i];
cvp[4][s] = b4[g][i];
cvp[5][s] = b5[g][i];
cvp[6][s] = b6[g][i];
if (s == 0) break;
}
dur = true;
return;
}
if (sira == tl) return;
int g = (bs[sira] - elde + 10) % 10;
for (int i = 0; i < b1[g].size(); i++) {
int t = b1[g][i] + b2[g][i] + b3[g][i] + b4[g][i] + b5[g][i] + b6[g][i];
nereden[sira + 1][(elde + t) / 10] =
make_pair(make_pair(sira, elde), make_pair(g, i));
rec(sira + 1, (elde + t) / 10);
}
}
inline void solve(long long int t) {
dur = false;
tl = 0;
memset(bs, 0, sizeof(bs));
memset(cvp, 0, sizeof(cvp));
while (t) {
bs[tl++] = t % 10;
t /= 10;
}
rec(0, 0);
tl++;
if (!dur) {
printf("%d", -1);
} else {
for (int i = 1; i <= 6; i++) {
bool sifir = true;
for (int j = tl - 1; j >= 0; j--) {
if (cvp[i][j] == 0 && j >= 1 && sifir) {
} else {
printf("%d", cvp[i][j]);
sifir = false;
}
}
printf(" ");
}
}
printf("\n");
}
int main() {
for (int i = 0; i < 8; i += 4) {
for (int j = i; j < 8; j += 4) {
for (int k = j; k < 8; k += 4) {
for (int x = k; x < 8; x += 4) {
for (int y = x; y < 8; y += 4) {
for (int z = y; z < 8; z += 4) {
int toplam = x + y + z + i + j + k;
b1[toplam % 10].push_back(i);
b2[toplam % 10].push_back(j);
b3[toplam % 10].push_back(k);
b4[toplam % 10].push_back(x);
b5[toplam % 10].push_back(y);
b6[toplam % 10].push_back(z);
if (z == 4) z--;
}
if (y == 4) y--;
}
if (x == 4) x--;
}
if (k == 4) k--;
}
if (j == 4) j--;
}
if (i == 4) i--;
}
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long int t;
scanf("%I64d", &t);
solve(t);
}
getchar();
getchar();
getchar();
getchar();
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T;
char tar[20];
long long num[7];
int f, l;
long long n;
struct Node {
int a, b, c;
};
vector<Node> t[10];
inline long long calc(int t) {
long long re = 1;
while (t--) re *= 10;
return re;
}
void dfs(int v, int r) {
if (f || v > l) return;
if (v == l && !r && !f) {
for (int i = 1; i <= 6; i++) cout << num[i] << ' ';
cout << endl;
f = 1;
return;
}
int ind = (tar[v] - '0' - r + 10) % 10;
int len = t[ind].size();
for (int i = 0; i < len; i++) {
for (int j = 1; j <= t[ind][i].a; j++) num[j] += 4 * calc(v);
for (int j = t[ind][i].a + 1; j <= t[ind][i].a + t[ind][i].b; j++)
num[j] += 7 * calc(v);
dfs(v + 1, (4 * t[ind][i].a + 7 * t[ind][i].b + r) / 10);
for (int j = 1; j <= t[ind][i].a; j++) num[j] -= 4 * calc(v);
for (int j = t[ind][i].a + 1; j <= t[ind][i].a + t[ind][i].b; j++)
num[j] -= 7 * calc(v);
}
return;
}
int main() {
scanf("%d", &T);
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6 - i; j++) {
Node temp;
temp.a = i, temp.b = j;
t[(4 * i + 7 * j) % 10].push_back(temp);
}
}
while (T--) {
f = 0;
memset(num, 0, sizeof(num));
scanf("%s", tar);
l = strlen(tar);
reverse(tar, tar + l);
dfs(0, 0);
if (!f) puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct num {
int nd;
int d[23];
num() {
nd = 0;
memset(d, 0, sizeof d);
}
num(long long first) {
nd = 0;
memset(d, 0, sizeof d);
if (first == 0LL) {
nd = 1;
d[nd - 1] = 0;
}
while (first > 0LL) {
nd++;
d[nd - 1] = first % 10;
first = first / 10;
}
}
int operator[](const int &i) const {
if (i > nd) return (0);
return (d[i - 1]);
}
void add(const int &i) {
nd++;
d[nd - 1] = i;
}
void print(void) {
int i;
long long val = 0LL;
for (i = 0; i < nd; i = i + 1) val = val * 10LL + d[i];
printf("%I64d", val);
}
};
const int digit[] = {0, 4, 7};
int ndg;
long long n;
num tmp;
num ans[7];
bool vst[23][9];
pair<vector<int>, pair<int, int> > t[23][9];
void init(void) {
scanf("%I64d", &n);
tmp = num(n);
ndg = tmp.nd;
memset(vst, false, sizeof vst);
int i;
for (i = 0; i < 6; i = i + 1) ans[i].nd = 0;
}
void BFS(void) {
queue<pair<int, int> > q;
while (!q.empty()) q.pop();
pair<int, int> p;
int i1, i2, i3, i4, i5, i6;
int pd, pr;
vst[0][0] = true;
q.push(pair<int, int>(0, 0));
while (!q.empty()) {
p = q.front();
q.pop();
pd = p.first;
pr = p.second;
if (pd == ndg && pr == 0) return;
if (pd == ndg) continue;
for (i1 = 0; i1 < 3; i1++)
for (i2 = i1; i2 < 3; i2++)
for (i3 = i2; i3 < 3; i3++)
for (i4 = i3; i4 < 3; i4++)
for (i5 = i4; i5 < 3; i5++)
for (i6 = i5; i6 < 3; i6++)
if ((digit[i1] + digit[i2] + digit[i3] + digit[i4] + digit[i5] +
digit[i6] + pr) %
10 ==
tmp[pd + 1])
if (!vst[pd + 1][(digit[i1] + digit[i2] + digit[i3] +
digit[i4] + digit[i5] + digit[i6] + pr) /
10]) {
vst[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10] = true;
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.first.clear();
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.first.push_back(i1);
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.first.push_back(i2);
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.first.push_back(i3);
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.first.push_back(i4);
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.first.push_back(i5);
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.first.push_back(i6);
t[pd + 1][(digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10]
.second = p;
q.push(pair<int, int>(
pd + 1, (digit[i1] + digit[i2] + digit[i3] + digit[i4] +
digit[i5] + digit[i6] + pr) /
10));
}
}
}
void trace(void) {
if (!vst[ndg][0]) {
printf("-1\n");
return;
}
pair<int, int> cur = pair<int, int>(ndg, 0);
int cd, cr, i;
while (cur != pair<int, int>(0, 0)) {
cd = cur.first;
cr = cur.second;
for (i = 0; i < 6; i = i + 1) ans[i].add(digit[t[cd][cr].first[i]]);
cur = t[cd][cr].second;
}
for (i = 0; i < 6; i = i + 1) {
ans[i].print();
if (i < 5)
printf(" ");
else
printf("\n");
}
}
int main(void) {
int t, ct;
scanf("%d", &t);
for (ct = 0; ct < t; ct++) {
init();
BFS();
trace();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[12];
int dyn[20][10], wher[20][10], wher2[20][10], wher3[20][10], t;
long long cur, on[20];
int dig(int pos) { return (cur / on[pos - 1]) % 10; }
bool fun(int pos, int elde) {
if (pos == 20 && elde == 0) return 1;
if (pos == 20 && elde != 0) return 0;
if (dyn[pos][elde] != -1) return dyn[pos][elde];
int need = dig(pos);
if (need >= elde) {
for (int i = 0; i < (int)v[need - elde].size(); i++)
if (fun(pos + 1, (v[need - elde][i].first * 4 +
v[need - elde][i].second * 7 + elde) /
10)) {
dyn[pos][elde] = 1;
wher[pos][elde] = pos + 1;
wher2[pos][elde] = (v[need - elde][i].first * 4 +
v[need - elde][i].second * 7 + elde) /
10;
wher3[pos][elde] = i;
return 1;
}
dyn[pos][elde] = 0;
return 0;
} else {
int rneed = (need + 10) - elde;
for (int i = 0; i < (int)v[rneed].size(); i++)
if (fun(pos + 1,
(v[rneed][i].first * 4 + v[rneed][i].second * 7 + elde) / 10)) {
dyn[pos][elde] = 1;
wher[pos][elde] = pos + 1;
wher2[pos][elde] =
(v[rneed][i].first * 4 + v[rneed][i].second * 7 + elde) / 10;
wher3[pos][elde] = i;
return 1;
}
dyn[pos][elde] = 0;
return 0;
}
}
int main() {
for (int i = 0; i <= 6; i++)
for (int j = 0; j <= 6; j++)
if (i + j <= 6) v[(i * 4 + j * 7) % 10].push_back(make_pair(i, j));
on[0] = 1;
for (int i = 1; i <= 20; i++) on[i] = on[i - 1] * 10;
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
memset(dyn, -1, sizeof(dyn));
memset(wher, -1, sizeof(wher));
memset(wher2, -1, sizeof(wher2));
memset(wher3, -1, sizeof(wher3));
cin >> cur;
int lelel = fun(1, 0);
if (lelel == 0) {
printf("-1\n");
continue;
}
int pos = 1, elde = 0;
long long d[7] = {0, 0, 0, 0, 0, 0, 0};
while (pos < 20) {
int kek = wher[pos][elde], kek2 = wher2[pos][elde],
kek3 = wher3[pos][elde];
int need = dig(pos) - elde;
if (need < 0) need += 10;
for (int i = 1; i <= v[need][kek3].first; i++)
d[i] += on[pos - 1] * 1ll * 4;
for (int i = v[need][kek3].first + 1;
i <= v[need][kek3].first + v[need][kek3].second; i++)
d[i] += on[pos - 1] * 1ll * 7;
pos = kek;
elde = kek2;
}
for (int i = 1; i <= 6; i++) cout << d[i] << ' ';
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int len, a[3] = {0, 4, 7}, c[100][6], d[6], e[20], an[6][20];
bool b[100];
char n[20];
void precalc(int i, int sum) {
if (i == 6) {
if (!b[sum]) {
b[sum] = 1;
for (int j = 0; j < 6; j++) {
c[sum][j] = d[j];
}
}
return;
}
for (int j = 0; j < 3; j++) {
d[i] = a[j];
sum += a[j];
precalc(i + 1, sum);
sum = sum - a[j];
}
}
bool ans(int i, int carry) {
int f;
if (i < 0) {
if (carry == 0)
return 1;
else
return 0;
} else {
int k = n[i] - '0';
for (int j = 0; j < 100; j++) {
f = j + carry;
if (f % 10 == k && b[j]) {
e[i] = j;
if (ans(i - 1, f / 10)) return 1;
}
}
return 0;
}
}
int main() {
precalc(0, 0);
int tot;
scanf("%d", &tot);
long long int an;
while (tot--) {
scanf("%s", n);
len = strlen(n);
int res = ans(len - 1, 0);
if (!res)
printf("-1\n");
else {
for (int i = 0; i < 6; i++) {
an = 0;
for (int j = 0; j < len; j++) {
an = 10 * an + (long long int)(c[e[j]][i]);
}
cout << an << " ";
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
int constexpr a[] = {0, 4, 7};
std::vector<std::map<int, std::vector<int>>> v(10);
int constexpr maxn = 20;
int constexpr maxm = 6;
bool f[maxn][maxm];
int from[maxn][maxm];
std::vector<int> bit[maxn][maxm];
int num[maxn];
long long n;
int len = 0;
void print(int l) {
std::vector<long long> a(6);
for (int i = l, t = 0; i; t = from[i--][t])
for (int j = 0; j < 6; j++) a[j] = a[j] * 10 + bit[i][t][j];
for (auto i : a) std::cout << i << ' ';
std::cout << '\n';
}
int main() {
std::map<int, std::vector<int>> all;
for (int i1 = 0; i1 < 3; i1++)
for (int i2 = 0; i2 < 3; i2++)
for (int i3 = 0; i3 < 3; i3++)
for (int i4 = 0; i4 < 3; i4++)
for (int i5 = 0; i5 < 3; i5++)
for (int i6 = 0; i6 < 3; i6++) {
int tmp = a[i1] + a[i2] + a[i3] + a[i4] + a[i5] + a[i6];
std::vector<int> tv{a[i1], a[i2], a[i3], a[i4], a[i5], a[i6]};
all[tmp] = tv;
}
for (auto i : all) v[i.first % 10][i.first / 10] = i.second;
int T;
std::cin >> T;
while (T--) {
std::memset(f, 0, sizeof(f));
std::cin >> n;
auto tn = n;
len = 0;
for (; tn; tn /= 10) num[len++] = tn % 10;
f[0][0] = true;
for (int i = 0; i < len; i++)
for (int j = 0; j < maxm; j++) {
for (int t = 0; t < maxm; t++) {
if (!f[i][t]) continue;
int tj = j - (num[i] < t);
int tmp = (num[i] - t + 10) % 10;
for (auto k : v[tmp])
if (k.first == tj) {
f[i + 1][j] = true;
from[i + 1][j] = t;
bit[i + 1][j] = k.second;
}
}
}
if (f[len][0])
print(len);
else
std::cout << "-1\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int num4[10][10], num7[10][10];
long long int p[10];
long long int ok, n4[20], n7[20];
long long int n;
void pre() {
memset(p, 0, sizeof(p));
for (int i = 0; i <= 6; i++) {
for (int k = 0; k + i <= 6; k++) {
int mod = (i * 4 + k * 7) % 10;
num4[mod][++p[mod]] = i;
num7[mod][p[mod]] = k;
}
}
}
void output() {
long long int x[10];
memset(x, 0, sizeof(x));
long long int w = 1;
for (int i = 1; i <= 18; i++) {
int no = 1;
for (int k = 1; k <= n4[i]; k++) x[k] += 4 * w;
for (int k = n4[i] + 1; k <= n4[i] + n7[i]; k++) x[k] += 7 * w;
w *= 10;
}
printf("%I64d %I64d %I64d %I64d %I64d %I64d\n", x[1], x[2], x[3], x[4], x[5],
x[6]);
}
void dp(long long int w) {
if (n == 0) {
ok = 1;
output();
return;
} else if (n > 0) {
long long int tmp = n;
if (!ok) {
long long int x = (n % 10);
for (int i = 1; i <= p[x]; i++) {
if (n - (4 * num4[x][i] + 7 * num7[x][i]) >= 0 && !ok) {
n = (n - (4 * num4[x][i] + 7 * num7[x][i])) / 10;
n4[w] = num4[x][i];
n7[w] = num7[x][i];
dp(w + 1);
n = tmp;
n4[w] = 0;
n7[w] = 0;
}
}
}
}
}
int main() {
pre();
int time;
scanf("%d", &time);
while (time--) {
scanf("%I64d", &n);
memset(n4, 0, sizeof(n4));
memset(n7, 0, sizeof(n7));
ok = 0;
dp(1);
if (!ok) cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int T, i, j, k, l, p, w;
char a[20];
long long ans[10], ten[20];
bool v[20][20];
bool dfs(int i, int j) {
if (j >= 5) return 0;
if (i == w + 1) return j == 0;
if (v[i][j]) return 0;
v[i][j] = 1;
int t, s0, s1, last = j * 10 + a[i] - '0';
for (s0 = 0; s0 <= 6; s0++)
for (s1 = 0; s1 <= 6 - s0; s1++)
if (s0 * 4 + s1 * 7 <= last)
if (dfs(i + 1, last - (s0 * 4 + s1 * 7))) {
for (t = 1; t <= s0; t++) ans[t] += ten[w - i] * 4;
for (t = 1; t <= s1; t++) ans[t + s0] += ten[w - i] * 7;
return 1;
}
return 0;
}
int main() {
for (read(T); T; T--) {
scanf("%s", a + 1);
w = strlen(a + 1);
memset(ans, 0, sizeof(ans));
memset(v, 0, sizeof(v));
ten[0] = 1;
for (i = 1; i <= w; i++) ten[i] = ten[i - 1] * 10;
if (dfs(1, 0)) {
for (i = 1; i <= 6; i++) printf("%I64d%s", ans[i], i == 6 ? "\n" : " ");
} else
printf("-1\n");
}
scanf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, A[20], m, B[7], s, ant[20][7];
long long first, res[7];
bool marc[43], valid[20][7];
vector<int> sol[43];
void back(int k) {
if (k == 7) {
if (!marc[s]) {
marc[s] = true;
for (int i = 1; i <= 6; i++) sol[s].push_back(B[i]);
}
return;
}
B[k] = 0;
back(k + 1);
B[k] = 4;
s += 4;
back(k + 1);
s -= 4;
B[k] = 7;
s += 7;
back(k + 1);
s -= 7;
}
void precompute() { back(1); }
void recons(int digit, int trans) {
if (digit == 0) return;
int i, val = ant[digit][trans];
for (i = 0; i < 6; i++) res[i + 1] = res[i + 1] * 10 + sol[val][i];
recons(digit - 1, 10 * trans + A[digit] - val);
}
int main() {
precompute();
cin >> n;
int i, j, k, t, val;
for (i = 1; i <= n; i++) {
cin >> first;
while (first) {
A[++m] = first % 10;
first /= 10;
}
for (k = 0; k <= 4; k++) {
val = k * 10 + A[1];
if (val <= 42 && marc[val]) {
valid[1][val / 10] = true;
ant[1][val / 10] = val;
}
}
for (j = 2; j <= m; j++)
for (k = 0; k <= 4; k++) {
val = k * 10 + A[j];
if (val <= 46) {
for (t = 0; t <= 4; t++)
if (valid[j - 1][t] && val - t <= 42 && marc[val - t]) {
valid[j][k] = true;
ant[j][k] = val - t;
}
}
}
if (!valid[m][0])
printf("-1\n");
else {
recons(m, 0);
for (j = 1; j < 6; j++) cout << res[j] << " ";
cout << res[6] << "\n";
}
m = 0;
memset(valid, false, sizeof(valid));
memset(ant, 0, sizeof(ant));
memset(res, 0, sizeof(res));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int CNT_STEP = 28;
const int CNT_NUMBERS = 6;
const int MAX_LEN = 20;
const int step[CNT_STEP][CNT_NUMBERS] = {
{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 4}, {0, 0, 0, 0, 0, 7},
{0, 0, 0, 0, 4, 4}, {0, 0, 0, 0, 4, 7}, {0, 0, 0, 0, 7, 7},
{0, 0, 0, 4, 4, 4}, {0, 0, 0, 4, 4, 7}, {0, 0, 0, 4, 7, 7},
{0, 0, 0, 7, 7, 7}, {0, 0, 4, 4, 4, 4}, {0, 0, 4, 4, 4, 7},
{0, 0, 4, 4, 7, 7}, {0, 0, 4, 7, 7, 7}, {0, 0, 7, 7, 7, 7},
{0, 4, 4, 4, 4, 4}, {0, 4, 4, 4, 4, 7}, {0, 4, 4, 4, 7, 7},
{0, 4, 4, 7, 7, 7}, {0, 4, 7, 7, 7, 7}, {0, 7, 7, 7, 7, 7},
{4, 4, 4, 4, 4, 4}, {4, 4, 4, 4, 4, 7}, {4, 4, 4, 4, 7, 7},
{4, 4, 4, 7, 7, 7}, {4, 4, 7, 7, 7, 7}, {4, 7, 7, 7, 7, 7},
{7, 7, 7, 7, 7, 7}};
int res[CNT_NUMBERS][MAX_LEN];
bool dp[MAX_LEN][CNT_NUMBERS];
int p[MAX_LEN][CNT_NUMBERS];
int a[MAX_LEN];
int sum[CNT_STEP];
int main() {
long long n, ans, N;
int pos, k, t;
scanf("%d", &t);
for (int i = 0; i < CNT_STEP; i++)
for (int j = 0; j < CNT_NUMBERS; j++) sum[i] += step[i][j];
for (int tt = 0; tt < t; tt++) {
cin >> n;
N = n;
for (int i = 0; i < MAX_LEN; i++, n /= 10) a[i] = n % 10;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < MAX_LEN - 1; i++) {
for (int j = 0; j < CNT_NUMBERS; j++) {
if (dp[i][j])
for (int k = 0; k < CNT_STEP; k++)
if ((sum[k] + j) % 10 == a[i]) {
dp[i + 1][(sum[k] + j) / 10] = 1;
p[i + 1][(sum[k] + j) / 10] = k;
}
}
}
memset(res, 0, sizeof(res));
if (dp[MAX_LEN - 1][0]) {
pos = 0;
for (int i = MAX_LEN - 1; i > 0; i--) {
k = p[i][pos];
for (int j = 0; j < CNT_NUMBERS; j++) res[j][i - 1] = step[k][j];
pos = pos * 10 + a[i - 1] - sum[k];
assert(0 <= pos && pos < 5);
}
long long answer = 0;
for (int i = 0; i < CNT_NUMBERS; i++) {
ans = 0;
for (int j = MAX_LEN - 2; j >= 0; j--) ans = ans * 10 + res[i][j];
cout << ans << " ";
answer += ans;
}
cout << endl;
assert(answer == N);
} else
cout << -1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int inf = (1 << 30) - 1;
const ll INF = (1LL << 60) - 1;
template <typename T>
bool chmax(T &x, const T &y) {
return (x < y) ? (x = y, true) : false;
};
template <typename T>
bool chmin(T &x, const T &y) {
return (x > y) ? (x = y, true) : false;
};
struct io_setup {
io_setup() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
}
} io_setup;
int main() {
int T;
cin >> T;
vector<vector<int>> ok;
vector<int> s;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < i; j++) {
vector<int> tmp;
int now = 4;
for (int k = 0; k < 8; k++) {
if (k == i || k == j)
now += 3, now %= 10;
else
tmp.emplace_back(now);
}
ok.emplace_back(tmp),
s.emplace_back(accumulate(tmp.begin(), tmp.end(), 0));
}
}
while (T--) {
ll N;
cin >> N;
string S = to_string(N);
reverse(S.begin(), S.end());
int n = (int)S.size();
vector<vector<bool>> dp(n + 1, vector<bool>(10, false));
vector<vector<pii>> pre(n + 1, vector<pii>(10));
dp[0][0] = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 10; j++) {
if (dp[i][j] == false) continue;
int x = S[i] - '0';
for (int k = 0; k < (int)s.size(); k++) {
int p = j + s[k];
if (p % 10 == x) {
dp[i + 1][p / 10] = true;
pre[i + 1][p / 10] = pii(j, k);
}
}
}
}
if (!dp[n][0]) {
cout << "-1\n";
continue;
}
int j = 0;
vector<string> ans(6);
for (int i = n; i >= 1; i--) {
auto [nj, nk] = pre[i][j];
for (int k = 0; k < 6; k++) {
ans[k] += char('0' + ok[nk][k]);
}
j = nj;
}
for (int i = 0; i < 6; i++) {
int j = 0;
while (j < (int)ans[i].size() - 1 && ans[i][j] == '0') j++;
cout << ans[i].substr(j) << (i == 5 ? '\n' : ' ');
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[6];
vector<pair<int, int> > to[10];
bool go(long long n) {
if (n < 0) {
return false;
} else if (n == 0) {
memset(a, 0, sizeof(a));
return true;
}
int d = n % 10;
for (int i = 0; i < (int)to[d].size(); ++i) {
if (go((n - to[d][i].first * 4 - to[d][i].second * 7) / 10)) {
int cnt4 = to[d][i].first;
int cnt7 = to[d][i].second;
for (int j = 0; j < 6; ++j) {
a[j] = a[j] * 10LL;
if (cnt4-- > 0) {
a[j] += 4LL;
} else if (cnt7-- > 0) {
a[j] += 7LL;
}
}
return true;
}
}
return false;
}
int main() {
for (int i = 0; i < 10; i++) {
for (int j = 0; j <= 6; ++j) {
for (int k = 0; k <= 6 - j; ++k) {
if ((j * 4 + k * 7) % 10 == i) {
to[i].push_back(make_pair(j, k));
}
}
};
for (int j = 0; j < (int)to[i].size(); ++j) {
;
}
}
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (go(n)) {
for (int i = 0; i < 6; ++i) {
cout << a[i] << " ";
}
cout << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int four[128], seven[128];
int memoi[160000];
int memoj[160000];
int memok[160000];
int memol[160000];
vector<int> f(long long n) {
if (n < 40000) {
vector<int> v = {memol[n], memok[n], memoj[n], memoi[n]};
return v;
}
int num = 0;
vector<int> w;
if (n % 10 == 0) num = 30;
if (n % 10 == 1) num = 21;
if (n % 10 == 2) num = 42;
if (n % 10 == 3) num = 33;
if (n % 10 == 4) num = 24;
if (n % 10 == 5) num = 35;
if (n % 10 == 6) num = 36;
if (n % 10 == 7) num = 27;
if (n % 10 == 8) num = 28;
if (n % 10 == 9) num = 39;
w = f((n - num) / 10);
w.push_back(num);
return w;
}
long long int res[8];
int main(void) {
for (int i = (0); i < (int)(128); ++i) four[i] = seven[i] = -1;
for (int i = (0); i < (int)(16000); ++i)
memoi[i] = memoj[i] = memok[i] = memol[i] = -1;
for (int i = (0); i < (int)(7); ++i)
for (int j = (0); j < (int)(7 - i); ++j) {
int num = 4 * i + 7 * j;
four[num] = i;
seven[num] = j;
}
for (int i = (0); i < (int)(50); ++i)
for (int j = (0); j < (int)(50); ++j)
for (int k = (0); k < (int)(50); ++k)
for (int l = (0); l < (int)(50); ++l) {
if (four[i] == -1) continue;
if (four[j] == -1) continue;
if (four[k] == -1) continue;
if (four[l] == -1) continue;
int num = i + j * 10 + k * 100 + l * 1000;
memoi[num] = i;
memoj[num] = j;
memok[num] = k;
memol[num] = l;
}
int q;
cin >> q;
for (int i = (0); i < (int)(q); ++i) {
long long n;
cin >> n;
vector<int> v = f(n);
memset(res, 0, sizeof(res));
bool flag = true;
for (int i = (0); i < (int)(v.size()); ++i) {
if (v[i] == -1) flag = false;
if (!flag) break;
int fo = four[v[i]];
int se = seven[v[i]];
for (int j = (0); j < (int)(6); ++j) res[j] *= 10;
for (int j = (0); j < (int)(fo); ++j) res[j] += 4;
for (int j = (0); j < (int)(se); ++j) res[5 - j] += 7;
}
if (flag) {
for (int i = (0); i < (int)(6); ++i) {
if (i > 0) cout << " ";
cout << res[i];
}
cout << endl;
} else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 mrand(43);
const double PI = acos((double)-1);
const double eps = 1e-5;
const long long inf0 = 1023 * 1024 * 1024;
const long long inf = inf0 * inf0;
const long long mod = 998244353;
void solve();
void scan();
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed;
cout.precision(15);
solve();
return 0;
}
int dp[21][5];
void solve() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
for (int i = 0; i < 21; i++)
for (int j = 0; j < 5; j++) dp[i][j] = -1;
dp[0][0] = 2e9;
vector<vector<int>> ans(6, vector<int>(19));
for (int i = 1; i <= 19; i++) {
for (int j = 0; j < 5; j++) {
if (dp[i - 1][j] == -1) continue;
for (int k = 0; k <= 6; k++) {
for (int h = 0; h <= 6 - k; h++) {
int t = 6 - k - h;
int x = 7 * k + 4 * h + j;
long long c = (n / (long long)pow(10ll, i - 1)) % 10ll;
if (x % 10 == c) dp[i][x / 10] = j;
}
}
}
}
if (dp[19][0] == -1)
cout << -1 << '\n';
else {
int x = 0;
for (int i = 19; i > 0; i--) {
;
int y = dp[i][x];
bool fl = false;
for (int k = 0; k <= 6; k++) {
for (int h = 0; h <= 6 - k; h++) {
int t = 6 - k - h;
int mem = 7 * k + 4 * h + y;
long long c = (n / (long long)pow(10ll, i - 1)) % 10ll;
if (mem % 10 == c && mem / 10 == x) {
for (int m = 0; m < k; m++) ans[m][i - 1] = 7;
for (int m = 5; m >= 6 - h; m--) ans[m][i - 1] = 4;
fl = true;
break;
}
}
if (fl) break;
}
x = y;
}
for (int i = 0; i < 6; i++) {
while (!ans[i].empty() && ans[i].back() == 0) ans[i].pop_back();
if (ans[i].empty()) ans[i].push_back(0);
reverse((ans[i]).begin(), (ans[i]).end());
for (int j : ans[i]) cout << j;
cout << " ";
}
cout << '\n';
}
}
return;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<long long, int> > computed;
map<pair<long long, int>, vector<long long> > soln;
long long N;
void input() { cin >> N; }
vector<long long> f(long long cur, int carry) {
if (computed.find(make_pair(cur, carry)) != computed.end())
return soln[make_pair(cur, carry)];
computed.insert(make_pair(cur, carry));
vector<long long> ret;
if (cur < carry) {
soln[make_pair(cur, carry)] = ret;
return ret;
}
if (cur == carry) {
vector<long long> base;
for (int i = 0; i < 6; i++) base.push_back(0);
return soln[make_pair(cur, carry)] = base;
}
for (int num7 = 0; num7 <= 6; num7++) {
for (int num4 = 0; num4 + num7 <= 6; num4++) {
int addval = num7 * 7 + num4 * 4 + carry;
if (addval % 10 == cur % 10) {
vector<long long> rec = f(cur / 10, addval / 10);
if (rec.size() > 0) {
for (int i = 0; i < num7; i++) ret.push_back(rec[i] * 10 + 7);
for (int i = num7; i < num7 + num4; i++)
ret.push_back(rec[i] * 10 + 4);
for (int i = num7 + num4; i < 6; i++) ret.push_back(rec[i] * 10);
return soln[make_pair(cur, carry)] = ret;
}
}
}
}
return soln[make_pair(cur, carry)] = ret;
}
void solve() {
vector<long long> ans = f(N, 0);
if (ans.size() == 0)
cout << "-1";
else
for (int i = 0; i < 6; i++) cout << ans[i] << " ";
cout << endl;
}
int main() {
int T;
cin >> T;
for (int i = 0; i < T; i++) {
input();
solve();
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
string s;
vector<long long> r;
set<pair<int, int> > u;
bool good(int pos, int add) {
if (u.count(pair<int, int>(pos, add))) return 0;
u.insert(pair<int, int>(pos, add));
if (pos == s.size()) {
if (add) return 0;
r.clear();
for (int i = (0); i < (6); i++) r.push_back(0);
return 1;
}
for (int z = (0); z < (7); z++)
for (int f = (0); f < (7 - z); f++) {
int ss = 6 - z - f;
int xx = f * 4 + ss * 7 + add;
if (xx % 10 == s[pos] - '0') {
if (good(pos + 1, xx / 10)) {
for (int i = (0); i < (z); i++) r[i] *= 10;
for (int i = (z); i < (z + f); i++) r[i] = r[i] * 10 + 4;
for (int i = (z + f); i < (6); i++) r[i] = r[i] * 10 + 7;
return true;
}
}
}
return 0;
}
int main() {
int tc;
cin >> tc;
for (int TC = (0); TC < (tc); TC++) {
cin >> s;
u.clear();
reverse(s.begin(), s.end());
if (good(0, 0)) {
sort((r).begin(), (r).end());
for (int i = (0); i < (r.size()); i++) {
if (i) printf(" ");
cout << r[i];
}
puts("");
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[22];
int a[4][22];
int flag, n;
int jin, t;
void search(int i) {
int jin2;
if (flag) return;
t = s[i] - '0' - jin;
jin2 = 0;
while (t < 0) {
jin2++;
t += 10;
}
if (i == 0) {
if (jin2 > 0) return;
if (t == 0) {
a[0][0] = 6;
a[1][0] = 0;
a[2][0] = 0;
flag = 1;
} else if (t == 4) {
a[0][0] = 5;
a[1][0] = 1;
a[2][0] = 0;
flag = 1;
} else if (t == 7) {
a[0][0] = 5;
a[1][0] = 0;
a[2][0] = 1;
flag = 1;
} else if (t == 8) {
a[0][0] = 4;
a[1][0] = 2;
a[2][0] = 0;
flag = 1;
}
return;
}
if (t == 0) {
jin = 0 + jin2;
a[0][i] = 6;
a[1][i] = 0;
a[2][i] = 0;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 1;
a[1][i] = 5;
a[2][i] = 0;
search(i - 1);
if (flag) return;
jin = 3 + jin2;
a[0][i] = 0;
a[1][i] = 4;
a[2][i] = 2;
search(i - 1);
if (flag) return;
} else if (t == 1) {
jin = 1 + jin2;
a[0][i] = 4;
a[1][i] = 1;
a[2][i] = 1;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 3;
a[1][i] = 0;
a[2][i] = 3;
search(i - 1);
if (flag) return;
} else if (t == 2) {
jin = 1 + jin2;
a[0][i] = 3;
a[1][i] = 3;
a[2][i] = 0;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 2;
a[1][i] = 2;
a[2][i] = 2;
search(i - 1);
if (flag) return;
jin = 3 + jin2;
a[0][i] = 1;
a[1][i] = 1;
a[2][i] = 4;
search(i - 1);
if (flag) return;
jin = 4 + jin2;
a[0][i] = 0;
a[1][i] = 0;
a[2][i] = 6;
search(i - 1);
if (flag) return;
} else if (t == 3) {
jin = 2 + jin2;
a[0][i] = 1;
a[1][i] = 4;
a[2][i] = 1;
search(i - 1);
if (flag) return;
jin = 3 + jin2;
a[0][i] = 0;
a[1][i] = 3;
a[2][i] = 3;
search(i - 1);
if (flag) return;
} else if (t == 4) {
jin = 0 + jin2;
a[0][i] = 5;
a[1][i] = 1;
a[2][i] = 0;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 0;
a[1][i] = 6;
a[2][i] = 0;
search(i - 1);
if (flag) return;
jin = 1 + jin2;
a[0][i] = 4;
a[1][i] = 0;
a[2][i] = 2;
search(i - 1);
if (flag) return;
} else if (t == 5) {
jin = 1 + jin2;
a[0][i] = 3;
a[1][i] = 2;
a[2][i] = 1;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 2;
a[1][i] = 1;
a[2][i] = 3;
search(i - 1);
if (flag) return;
jin = 3 + jin2;
a[0][i] = 1;
a[1][i] = 0;
a[2][i] = 5;
search(i - 1);
if (flag) return;
} else if (t == 6) {
jin = 1 + jin2;
a[0][i] = 2;
a[1][i] = 4;
a[2][i] = 0;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 1;
a[1][i] = 3;
a[2][i] = 2;
search(i - 1);
if (flag) return;
jin = 3 + jin2;
a[0][i] = 0;
a[1][i] = 2;
a[2][i] = 4;
search(i - 1);
if (flag) return;
} else if (t == 7) {
jin = 0 + jin2;
a[0][i] = 5;
a[1][i] = 0;
a[2][i] = 1;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 0;
a[1][i] = 5;
a[2][i] = 1;
search(i - 1);
if (flag) return;
} else if (t == 8) {
jin = 0 + jin2;
a[0][i] = 4;
a[1][i] = 2;
a[2][i] = 0;
search(i - 1);
if (flag) return;
jin = 1 + jin2;
a[0][i] = 3;
a[1][i] = 1;
a[2][i] = 2;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 2;
a[1][i] = 0;
a[2][i] = 4;
search(i - 1);
if (flag) return;
} else if (t == 9) {
jin = 1 + jin2;
a[0][i] = 2;
a[1][i] = 3;
a[2][i] = 1;
search(i - 1);
if (flag) return;
jin = 2 + jin2;
a[0][i] = 1;
a[1][i] = 2;
a[2][i] = 3;
search(i - 1);
if (flag) return;
jin = 3 + jin2;
a[0][i] = 0;
a[1][i] = 1;
a[2][i] = 5;
search(i - 1);
if (flag) return;
}
}
int main() {
int T;
int i, j;
unsigned long long re;
unsigned long long sum;
scanf("%d", &T);
while (T--) {
scanf("%s", s);
sum = 0;
n = strlen(s);
flag = 0;
jin = 0;
search(n - 1);
if (flag == 0)
cout << -1 << endl;
else {
re = 0;
for (i = 0; i < n; i++) {
if (a[0][i] > 0) {
re = re * 10 + 0;
a[0][i]--;
} else if (a[1][i] > 0) {
re = re * 10 + 4;
a[1][i]--;
} else if (a[2][i] > 0) {
re = re * 10 + 7;
a[2][i]--;
}
}
cout << re;
sum += re;
for (j = 1; j < 6; j++) {
re = 0;
for (i = 0; i < n; i++) {
if (a[0][i] > 0) {
re = re * 10 + 0;
a[0][i]--;
} else if (a[1][i] > 0) {
re = re * 10 + 4;
a[1][i]--;
} else if (a[2][i] > 0) {
re = re * 10 + 7;
a[2][i]--;
}
}
cout << ' ' << re;
sum += re;
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool dp[21][6][7][7][7];
int main() {
srand((unsigned int)time(NULL));
int t;
scanf("%d", &t);
while (t--) {
memset(dp, 0, sizeof(dp));
string second;
cin >> second;
reverse(second.begin(), second.end());
while (second.size() < 20) second.push_back('0');
int v[21];
for (int i = 1; i <= 20; i++) v[i] = second[i - 1] - '0';
dp[0][0][6][0][0] = true;
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 6; j++) {
for (int k = 0; k <= 6; k++) {
for (int l = 0; l <= 6; l++) {
for (int m = 0; m <= 6; m++) {
if (!dp[i][j][k][l][m]) continue;
if (k + l + m != 6) continue;
int x = j;
for (int a = 0; a <= 6; a++) {
for (int b = 0; b <= 6 - a; b++) {
int c = 6 - a - b;
if (c < 0) continue;
int sum = b * 4 + c * 7 + x;
if (sum % 10 != v[i + 1]) continue;
if (i == 19 && sum / 10 > 0) continue;
dp[i + 1][sum / 10][a][b][c] = true;
}
}
}
}
}
}
}
int zero, four, seven, sum;
{
for (int j = 0; j < 6; j++) {
for (int k = 0; k <= 6; k++) {
for (int l = 0; l <= 6; l++) {
for (int m = 0; m <= 6; m++) {
if (dp[20][j][k][l][m]) {
zero = k;
four = l;
seven = m;
sum = j;
goto next;
}
}
}
}
}
}
puts("-1");
continue;
next:;
int cur = 20;
string ans[6];
for (int i = 0; i < 6; i++) ans[i].clear();
while (cur > 0) {
int prev = 10 * sum + v[cur] - 4 * four - 7 * seven;
for (int i = 0; i < zero; i++) ans[i].push_back('0');
for (int i = zero; i < zero + four; i++) ans[i].push_back('4');
for (int i = zero + four; i < zero + four + seven; i++)
ans[i].push_back('7');
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6; j++) {
for (int k = 0; k <= 6; k++) {
if (dp[cur - 1][prev][i][j][k]) {
sum = prev;
zero = i;
four = j;
seven = k;
goto nxt;
}
}
}
}
nxt:;
cur--;
}
for (int i = 0; i < 6; i++) reverse(ans[i].begin(), ans[i].end());
for (int i = 0; i < 6; i++) {
while (!ans[i].empty() && ans[i][ans[i].size() - 1] == '0')
ans[i].resize(ans[i].size() - 1);
if (ans[i].empty()) ans[i] = "0";
}
for (int i = 0; i < 6; i++) reverse(ans[i].begin(), ans[i].end());
for (int i = 0; i < 6; i++) cout << ans[i] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 44;
const int L[] = {0, 4, 7};
vector<int> digits[10];
vector<int> numbers[MAX];
void generate(int a[], int d, int k) {
if (d == 6) {
int sum = 0;
for (int i = 0; i < 6; i++) {
sum += a[i];
}
if (numbers[sum].empty()) {
numbers[sum] = vector<int>(a, a + 6);
}
digits[sum % 10].push_back(sum);
} else {
for (int i = k; i < 3; i++) {
a[d] = L[i];
generate(a, d + 1, i);
}
}
}
long long result[6];
bool find(long long n) {
if (n < 0) {
return false;
} else if (n == 0) {
return true;
} else {
for (int i = 0; i < digits[n % 10].size(); i++) {
int nr = digits[n % 10][i];
if (find((n - nr) / 10)) {
for (int j = 0; j < 6; j++) {
result[j] = result[j] * 10 + numbers[nr][j];
}
return true;
}
}
return false;
}
}
int main() {
ios::sync_with_stdio(false);
int a[6];
generate(a, 0, 0);
int k;
cin >> k;
for (int i = 0; i < k; i++) {
memset(result, 0, 6 * sizeof(long long));
long long n;
cin >> n;
if (find(n)) {
for (int j = 0; j < 6; j++) {
cout << result[j] << ' ';
}
cout << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool possible[100000];
int ans[100000][8];
int res[18];
long long out[6];
int main() {
for (int i = 0; i <= 6; ++i)
for (int j = 0; i + j <= 6; ++j)
for (int k = 0; k <= 6; ++k)
for (int m = 0; k + m <= 6; ++m)
for (int n = 0; n <= 6; ++n)
for (int o = 0; o + n <= 6; ++o)
for (int p = 0; p <= 6; ++p)
for (int q = 0; q + p <= 6; ++q) {
possible[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q] = 1;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][0] = i;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][1] = j;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][2] = k;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][3] = m;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][4] = n;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][5] = o;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][6] = p;
ans[4 * i + 7 * j + 40 * k + 70 * m + 400 * n + 700 * o +
4000 * p + 7000 * q][7] = q;
}
int t;
scanf("%d", &t);
while (t--) {
long long n;
scanf("%I64d", &n);
if (n < 600 && !possible[n]) {
printf("-1\n");
continue;
}
for (int i = 0; i < 6; ++i) out[i] = 0;
long long ten = 1;
for (int i = 0; i < 17; ++i) ten *= 10;
for (int i = 17; i >= 4; --i) {
long long m = n - 600;
m /= ten;
int times;
for (times = m; !possible[times]; --times)
;
for (int j = 0; j < ans[times][0]; ++j) out[j] += 4 * ten;
for (int j = 0; j < ans[times][1]; ++j) out[j + ans[times][0]] += 7 * ten;
n -= times * (ten);
ten /= 10;
}
for (int j = 0; j < ans[n][0]; ++j) out[j] += 4;
for (int j = 0; j < ans[n][1]; ++j) out[j + ans[n][0]] += 7;
for (int j = 0; j < ans[n][2]; ++j) out[j] += 40;
for (int j = 0; j < ans[n][3]; ++j) out[j + ans[n][2]] += 70;
for (int j = 0; j < ans[n][4]; ++j) out[j] += 400;
for (int j = 0; j < ans[n][5]; ++j) out[j + ans[n][4]] += 700;
for (int j = 0; j < ans[n][6]; ++j) out[j] += 4000;
for (int j = 0; j < ans[n][7]; ++j) out[j + ans[n][6]] += 7000;
for (int j = 0; j < 6; ++j) printf("%I64d ", out[j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
namespace Xrocks {}
using namespace Xrocks;
namespace Xrocks {
class in {
} user_input;
class out {
} output;
in& operator>>(in& X, int& Y) {
scanf("%d", &Y);
return X;
}
in& operator>>(in& X, char* Y) {
scanf("%s", Y);
return X;
}
in& operator>>(in& X, float& Y) {
scanf("%f", &Y);
return X;
}
in& operator>>(in& X, double& Y) {
scanf("%lf", &Y);
return X;
}
in& operator>>(in& X, char& C) {
scanf("%c", &C);
return X;
}
in& operator>>(in& X, string& Y) {
cin >> Y;
return X;
}
in& operator>>(in& X, long long& Y) {
scanf("%lld", &Y);
return X;
}
template <typename T>
in& operator>>(in& X, vector<T>& Y) {
for (auto& x : Y) user_input >> x;
return X;
}
template <typename T>
out& operator<<(out& X, const T& Y) {
cout << Y;
return X;
}
template <typename T>
out& operator<<(out& X, vector<T>& Y) {
for (auto& x : Y) output << x << " ";
return X;
}
out& operator<<(out& X, const int& Y) {
printf("%d", Y);
return X;
}
out& operator<<(out& X, const char& C) {
printf("%c", C);
return X;
}
out& operator<<(out& X, const string& Y) {
printf("%s", Y.c_str());
return X;
}
out& operator<<(out& X, const long long& Y) {
printf("%lld", Y);
return X;
}
out& operator<<(out& X, const float& Y) {
printf("%f", Y);
return X;
}
out& operator<<(out& X, const double& Y) {
printf("%lf", Y);
return X;
}
out& operator<<(out& X, const char Y[]) {
printf("%s", Y);
return X;
}
template <typename T>
T max(T A) {
return A;
}
template <typename T, typename... args>
T max(T A, T B, args... S) {
return max(A > B ? A : B, S...);
}
template <typename T>
T min(T A) {
return A;
}
template <typename T, typename... args>
T min(T A, T B, args... S) {
return min(A < B ? A : B, S...);
}
template <typename T>
void vectorize(int y, vector<T>& A) {
A.resize(y);
}
template <typename T, typename... args>
void vectorize(int y, vector<T>& A, args&&... S) {
A.resize(y);
vectorize(y, S...);
}
long long fast(long long a, long long b, long long pr) {
if (b == 0) return 1 % pr;
long long ans = 1 % pr;
while (b) {
if (b & 1) ans = (ans * a) % pr;
b >>= 1;
a = (a * a) % pr;
}
return ans;
}
int readInt() {
int n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long readLong() {
long long n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long readBin() {
long long n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '1') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '1')
n = (n << 1) + (ch - '0'), ch = getchar_unlocked();
return n;
}
long long inv_(long long val,
long long pr = static_cast<long long>(1000000007)) {
return fast(val, pr - 2, pr);
}
} // namespace Xrocks
class solve {
vector<pair<pair<int, int>, int>> mask_for[10];
public:
solve() {
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= i; j++) {
int num = j * 7 + (i - j) * 4;
mask_for[num % 10].push_back({{i - j, j}, num / 10});
}
}
int t;
user_input >> t;
string S;
vector<pair<int, int>> ans;
for (int i = 0; i < t; i++) {
user_input >> S;
reverse(S.begin(), S.end());
S.push_back('0');
if (solver(S, 0, 0, ans)) {
vector<long long> A(6);
for (auto& x : ans) {
for (int j = 0; j < x.first; j++) A[j] = A[j] * 10 + 4;
for (int j = x.first; j < x.first + x.second; j++)
A[j] = A[j] * 10 + 7;
for (int j = x.first + x.second; j < 6; j++) A[j] *= 10;
}
ans.clear();
for (int i = 0; i < 6; i++) {
output << A[i] << " ";
}
output << "\n";
} else
output << "-1\n";
}
}
bool solver(string& S, int Pos, int c, vector<pair<int, int>>& ans) {
if (Pos == S.length()) {
return c == 0;
}
int dig = S[Pos] - '0';
dig -= c;
int add_carry = 0;
if (dig < 0) dig += 10, ++add_carry;
for (auto& x : mask_for[dig]) {
if (solver(S, Pos + 1, add_carry + x.second, ans)) {
ans.push_back(x.first);
return true;
}
}
return false;
}
};
int32_t main() {
int t = 1, i = 1;
if (0 || 0) scanf("%d", &t);
while (t--) {
if (0) printf("Case #%d: ", i++);
new solve;
}
output << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int qi[20], si[20];
long long x;
int ok, mx;
void dfs(long long x, int k) {
if (x == 0) {
ok = 1;
mx = k - 1;
return;
}
int u = x % 10;
for (int i = 0; i <= 6; i++)
for (int j = 0; j <= 6 - i; j++) {
int tmp = i * 4 + j * 7;
if (tmp % 10 == u && x >= tmp) {
si[k] = i;
qi[k] = j;
dfs((x - tmp) / 10, k + 1);
if (ok) return;
}
}
}
int main() {
int T;
cin >> T;
while (T--) {
memset(qi, 0, sizeof(qi));
memset(si, 0, sizeof(si));
ok = 0;
cin >> x;
dfs(x, 0);
if (!ok) {
printf("-1\n");
} else {
for (int num = 1; num <= 6; num++) {
while (mx && si[mx] == 0 && qi[mx] == 0) mx--;
for (int i = mx; i >= 0; i--) {
if (si[i]) {
printf("4");
si[i]--;
} else if (qi[i]) {
printf("7");
qi[i]--;
} else
printf("0");
}
if (num < 6)
printf(" ");
else
printf("\n");
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char beau[3] = {'0', '4', '7'};
string s;
string s1, s2, s3, s4, s5, s6;
bool chk[20][20];
void fix(string r) {
while (r[0] == '0' && r.size() > 1) r.erase(0, 1);
for (int i = 0; i < r.size(); i++) cout << r[i];
cout << ' ';
}
bool f(int n, int carry) {
if (n == s.size()) {
if (carry == 0)
return true;
else
return false;
}
if (chk[n][carry]) return false;
chk[n][carry] = 1;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
for (int q = 0; q < 3; q++)
for (int w = 0; w < 3; w++)
for (int e = 0; e < 3; e++) {
int z = beau[i] - '0' + beau[j] - '0' + beau[k] - '0' + beau[q] -
'0' + beau[w] - '0' + beau[e] - '0' + carry;
if (s[n] - '0' == z % 10 && f(n + 1, z / 10)) {
s1 += beau[i];
s2 += beau[j];
s3 += beau[k];
s4 += beau[q];
s5 += beau[w];
s6 += beau[e];
return true;
}
}
return false;
}
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
memset(chk, 0, sizeof(chk));
cin >> s;
reverse(s.begin(), s.end());
s1 = s2 = s3 = s4 = s5 = s6 = "";
if (!f(0, 0)) {
cout << -1 << endl;
continue;
} else {
fix(s1);
fix(s2);
fix(s3);
fix(s4);
fix(s5);
fix(s6);
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 10005;
int T;
long long N;
pair<int, int> DP[6][25];
int dig[] = {0, 4, 7};
vector<int> V[NMax];
int x[20];
int Sum[NMax];
int cnt;
char Str[20];
long long Res[20];
void Fill(int poz) {
for (int i = 1; i <= 6; i++) {
V[poz].push_back(x[i]);
Sum[poz] += x[i];
}
}
void back(int k) {
for (int i = 0; i < 3; i++) {
x[k] = dig[i];
if (k == 6) {
Fill(++cnt);
}
if (k < 6) back(k + 1);
}
}
void Print(int N) {
if (DP[0][N] == make_pair(-1, -1)) {
cout << "-1\n";
return;
}
for (int i = 1; i <= 6; i++) Res[i] = 0;
int j = N, f = 0;
while (j > 0) {
for (int i = 0; i < 6; i++)
Res[i + 1] = Res[i + 1] * 10 + V[DP[f][j].second][i];
int auxF = f;
f = DP[auxF][j].first;
j--;
}
for (int i = 1; i <= 6; i++) cout << Res[i] << " ";
cout << "\n";
}
void Solve() {
int N = strlen(Str + 1);
for (int i = 0; i <= 4; i++)
for (int j = 0; j <= 18; j++) DP[i][j] = make_pair(-1, -1);
DP[0][0] = make_pair(0, 0);
for (int j = 0; j < N; j++)
for (int i = 0; i <= 4; i++) {
if (DP[i][j] == make_pair(-1, -1)) continue;
for (int k = 1; k <= cnt; k++) {
if ((Sum[k] + i) % 10 == Str[j + 1] - '0') {
DP[(Sum[k] + i) / 10][j + 1] = make_pair(i, k);
}
}
}
Print(N);
}
int main() {
int T;
cin >> T;
cin.get();
back(1);
while (T--) {
cin.getline(Str + 1, 25);
int N = strlen(Str + 1);
reverse(Str + 1, Str + N + 1);
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bs[20];
int cvp[8][20];
int tl;
bool dur = false;
vector<int> b1[10];
vector<int> b2[10];
vector<int> b3[10];
vector<int> b4[10];
vector<int> b5[10];
vector<int> b6[10];
pair<pair<int, int>, pair<int, int> > nereden[20][10];
void rec(int sira, int elde) {
if (dur) return;
if (sira == tl && elde == 0) {
int s = sira, e = elde;
while (true) {
int ee = e;
int es = s;
s = nereden[es][ee].first.first;
e = nereden[es][ee].first.second;
int g = nereden[es][ee].second.first;
int i = nereden[es][ee].second.second;
cvp[1][s] = b1[g][i];
cvp[2][s] = b2[g][i];
cvp[3][s] = b3[g][i];
cvp[4][s] = b4[g][i];
cvp[5][s] = b5[g][i];
cvp[6][s] = b6[g][i];
if (s == 0) break;
}
dur = true;
return;
}
if (sira == tl) return;
int g = (bs[sira] - elde + 10) % 10;
for (int i = 0; i < b1[g].size(); i++) {
int t = b1[g][i] + b2[g][i] + b3[g][i] + b4[g][i] + b5[g][i] + b6[g][i];
nereden[sira + 1][(elde + t) / 10] =
make_pair(make_pair(sira, elde), make_pair(g, i));
rec(sira + 1, (elde + t) / 10);
}
}
void solve(long long int t) {
dur = false;
tl = 0;
memset(bs, 0, sizeof(bs));
memset(cvp, 0, sizeof(cvp));
while (t) {
bs[tl++] = t % 10;
t /= 10;
}
rec(0, 0);
tl++;
if (!dur) {
printf("%d", -1);
} else {
for (int i = 1; i <= 6; i++) {
bool sifir = true;
for (int j = tl - 1; j >= 0; j--) {
if (cvp[i][j] == 0 && j >= 1 && sifir) {
} else {
printf("%d", cvp[i][j]);
sifir = false;
}
}
printf(" ");
}
}
printf("\n");
}
int main() {
for (int i = 0; i < 8; i += 4) {
for (int j = i; j < 8; j += 4) {
for (int k = j; k < 8; k += 4) {
for (int x = k; x < 8; x += 4) {
for (int y = x; y < 8; y += 4) {
for (int z = y; z < 8; z += 4) {
int toplam = x + y + z + i + j + k;
b1[toplam % 10].push_back(i);
b2[toplam % 10].push_back(j);
b3[toplam % 10].push_back(k);
b4[toplam % 10].push_back(x);
b5[toplam % 10].push_back(y);
b6[toplam % 10].push_back(z);
if (z == 4) z--;
}
if (y == 4) y--;
}
if (x == 4) x--;
}
if (k == 4) k--;
}
if (j == 4) j--;
}
if (i == 4) i--;
}
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long int t;
scanf("%I64d", &t);
solve(t);
}
getchar();
getchar();
getchar();
getchar();
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, ind, i, j, k;
long long n, tmp, ans[10];
int vis[20][105];
int f4[20], f7[20];
bool success;
void dfs(long long n, int x, int y) {
int i, j;
if (success) return;
if (n == 0) {
if (y == 0) {
for (i = 1; i <= 6; ++i) ans[i] = 0;
tmp = 1;
for (i = 0; i < x; ++i) {
k = 0;
for (j = f4[i]; j; --j) ans[++k] += tmp * 4;
for (j = f7[i]; j; --j) ans[++k] += tmp * 7;
tmp *= 10;
}
printf("%I64d %I64d %I64d %I64d %I64d %I64d\n", ans[1], ans[2], ans[3],
ans[4], ans[5], ans[6]);
success = true;
}
return;
}
if (vis[x][y] == ind) return;
vis[x][y] = ind;
for (i = 0; i <= 6; ++i)
for (j = 6 - i; j >= 0; --j)
if ((4 * i + 7 * j + y) % 10 == n % 10) {
f4[x] = i;
f7[x] = j;
dfs(n / 10, x + 1, (4 * i + 7 * j + y) / 10);
}
}
int main() {
scanf("%d", &T);
for (; T; --T) {
scanf("%I64d", &n);
++ind;
success = false;
dfs(n, 0, 0);
if (!success) printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
string to[110];
void build(int dep, string now, int val) {
if (dep == 6) {
to[val] = now;
return;
}
char f0 = '0' + 0;
char f4 = '0' + 4;
char f7 = '0' + 7;
build(dep + 1, now + f0, val + 0);
build(dep + 1, now + f4, val + 4);
build(dep + 1, now + f7, val + 7);
}
void init() {
for (int i = 0; i <= 100; i++) to[i] = ".";
build(0, "", 0);
}
int dp[20][10];
int pre[20][10];
int val[20][10];
int pp[110];
int qq;
int dfs(int pos, int need) {
if (pos == -1) return need == 0;
if (dp[pos][need] != -1) return dp[pos][need];
int digit = need * 10 + pp[pos];
for (int add = 0; add <= 5; add++) {
int now = digit - add;
if (now < 0) continue;
if (dfs(pos - 1, add) == 1 && to[now] != ".") {
dp[pos][need] = 1;
val[pos][need] = now;
pre[pos][need] = add;
return 1;
}
}
dp[pos][need] = 0;
return 0;
}
string out[110];
int main() {
init();
int cas;
scanf("%d", &cas);
for (int cc = 1; cc <= cas; cc++) {
long long s;
scanf("%I64d", &s);
qq = 0;
while (s) {
pp[qq++] = s % 10;
s /= 10;
}
memset(dp, -1, sizeof(dp));
if (dfs(qq - 1, 0) == 0)
printf("-1\n");
else {
for (int i = 0; i < 6; i++)
out[i] = "0000000000000000000000000000000000000000";
int x = qq - 1;
int y = 0;
while (x != -1) {
int s = val[x][y];
for (int i = 0; i < 6; i++) out[i][x] = to[s][i];
y = pre[x][y];
x--;
}
for (int i = 0; i < 6; i++) {
int end = 0;
for (int j = 0; j < 30; j++)
if (out[i][j] != '0') end = j;
for (int j = end; j >= 0; j--) printf("%c", out[i][j]);
if (i == 5)
printf("\n");
else
printf(" ");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[8];
int n, f[22][22], pos[22][22], key[22][22], i, j, k, x, bo[120], zu[120][2], T;
char c[120];
void pret() {
for (i = 0; i <= 6; ++i)
for (j = 0; i + j <= 6; ++j) {
bo[i * 4 + j * 7] = 1;
zu[i * 4 + j * 7][0] = i;
zu[i * 4 + j * 7][1] = j;
}
}
int main() {
pret();
scanf("%d", &T);
for (; T--;) {
scanf("%s", c + 1);
n = strlen(c + 1);
memset(f, 0, sizeof(f));
f[n][0] = 1;
for (i = n; i >= 1; --i) {
x = c[i] - 48;
for (j = 0; j <= 9; ++j)
if (f[i][j]) {
for (k = x - j; k <= 42; k += 10)
if (k >= 0 && bo[k]) {
f[i - 1][(k + j) / 10] = 1;
pos[i - 1][(k + j) / 10] = j;
key[i - 1][(k + j) / 10] = k;
}
}
}
if (!f[0][0]) {
printf("-1\n");
} else {
memset(a, 0, sizeof(a));
j = 0;
for (i = 0; i < n; ++i) {
x = key[i][j];
for (k = 1; k <= zu[x][0]; ++k) a[k] = a[k] * 10 + 4;
for (k = 1; k <= zu[x][1]; ++k)
a[k + zu[x][0]] = a[k + zu[x][0]] * 10 + 7;
for (k = zu[x][0] + zu[x][1] + 1; k <= 6; ++k) a[k] *= 10;
j = pos[i][j];
}
for (i = 1; i <= 6; ++i) printf("%I64d ", a[i]);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INF64 = (long long)1e18;
const long double eps = 1e-9;
const long double pi = 3.14159265358979323846;
int dp[20][50];
int frmP[20][50], frmQ[20][50], frmE[20][50];
long long ten[20];
char str[60];
vector<long long> arr;
pair<long long, long long> rev[60];
long long num[20];
void update(int p1, int q1, int p2, int q2, int val) {
if (dp[p1][q1] == 0) {
dp[p1][q1] = 1;
frmP[p1][q1] = p2;
frmQ[p1][q1] = q2;
frmE[p1][q1] = val;
}
}
void re(int p1, int q1, int dep) {
if (p1) {
re(frmP[p1][q1], frmQ[p1][q1], dep + 1);
int xx, yy;
int i;
long long val;
val = arr[frmE[p1][q1]];
xx = rev[val].first;
yy = rev[val].second;
for (i = 0; i < xx; i++) num[i] += (4LL * ten[dep]);
for (i = 0; i < yy; i++) num[i + xx] += (7LL * ten[dep]);
}
}
int main() {
long long i, j, k;
for (i = 0; i <= 6; i++) {
for (j = 0; j + i <= 6; j++) {
arr.push_back(i * 4 + 7 * j);
rev[i * 4 + 7 * j] = (make_pair(i, j));
}
}
sort((arr).begin(), (arr).end());
int tn;
int len;
long long t;
t = 1;
for (i = 0; i <= 18; i++) {
ten[i] = t;
t *= 10LL;
}
cin >> tn;
while (tn--) {
cin >> str;
len = strlen(str);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (i = 1; i <= len; i++) {
for (j = 0; j < 50; j++) {
if (dp[i - 1][j]) {
t = j * 10LL + (str[i - 1] - '0');
for (k = 0; k < (int((arr).size())) && arr[k] <= t; k++) {
if (t - arr[k] < 50LL) {
update(i, t - arr[k], i - 1, j, k);
}
}
}
}
}
if (!dp[len][0])
printf("-1\n");
else {
memset(num, 0, sizeof(num));
re(len, 0, 0);
for (i = 0; i < 6; i++) {
if (i) printf(" ");
cout << num[i];
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> cache;
vector<long long> catalog[1000000];
int len = 0;
vector<long long> way[50];
int t;
void precomp() {
int pos = 3 * 3 * 3 * 3 * 3 * 3;
for (int i = 0; i < pos; i++) {
int c = i;
vector<int> moo;
int s = 0;
for (int j = 0; j < 6; j++) {
moo.push_back(3 * (c % 3) + (c % 3 != 0));
c /= 3;
s += moo[j];
}
if (way[s].empty()) {
for (int j = 0; j < 6; j++) {
way[s].push_back(moo[j]);
}
}
}
len++;
for (int i = 0; i < 6; i++) {
catalog[len].push_back(0);
}
cache[0] = len;
}
bool solve(long long n) {
if (cache.count(n) == 1) {
if (cache[n] == -1) return false;
return true;
}
for (int d = n % 10; d <= 42; d += 10) {
if (way[d].empty()) continue;
if (d > n) continue;
if (solve((n - d) / 10)) {
int moo = cache[(n - d) / 10];
len++;
for (int j = 0; j < 6; j++) {
catalog[len].push_back(catalog[moo][j] * 10 + way[d][j]);
}
cache[n] = len;
return true;
}
}
cache[n] = -1;
return false;
}
int main() {
precomp();
cin >> t;
for (int i = 0; i < t; i++) {
long long n;
cin >> n;
if (!solve(n)) {
printf("%d\n", -1);
} else {
int sol = cache[n];
cout << catalog[sol][0] << " " << catalog[sol][1] << " "
<< catalog[sol][2] << " " << catalog[sol][3] << " "
<< catalog[sol][4] << " " << catalog[sol][5] << "\n";
}
}
}
|
#include <bits/stdc++.h>
const long long INF = 4e18L + 1;
const int IINF = 2e9 + 1;
const int limit = 1048576;
using namespace std;
bool get_sol(
long long carry, long long ans, long long ten_pow,
const vector<pair<long long, long long> >& pos,
map<pair<pair<long long, long long>, long long>, vector<long long> >& acc) {
if (acc.count({{carry, ans}, ten_pow})) return true;
long long target = 10 * carry + ans / ten_pow;
if (ten_pow == 1) {
if (pos[target] != make_pair(-1ll, -1ll)) {
vector<long long> sol(6);
for (int j = (int)0; j < (int)pos[target].first; j++) sol[j] = 4;
for (int j = (int)pos[target].first;
j < (int)pos[target].first + pos[target].second; j++)
sol[j] = 7;
acc[{{carry, ans}, ten_pow}] = sol;
return true;
}
} else
for (int i = (int)0; i < (int)5; i++)
if (get_sol(i, ans % ten_pow, ten_pow / 10, pos, acc))
if (target >= i and pos[target - i] != make_pair(-1ll, -1ll)) {
vector<long long> sol = acc[{{i, ans % ten_pow}, ten_pow / 10}];
for (int j = (int)0; j < (int)pos[target - i].first; j++)
sol[j] += ten_pow * 4;
for (int j = (int)pos[target - i].first;
j < (int)pos[target - i].first + pos[target - i].second; j++)
sol[j] += ten_pow * 7;
acc[{{carry, ans}, ten_pow}] = sol;
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
vector<pair<long long, long long> > pos(102, {-1, -1});
for (int i = (int)0; i < (int)7; i++)
for (int j = (int)0; j < (int)7 - i; j++) pos[4 * i + 7 * j] = {i, j};
long long t;
cin >> t;
map<pair<pair<long long, long long>, long long>, vector<long long> > acc;
for (int j = (int)1; j < (int)t + 1; j++) {
long long n;
cin >> n;
long long ten_pow = 1;
while (10 <= n / ten_pow) ten_pow *= 10;
vector<long long> sol(6);
if (get_sol(0, n, ten_pow, pos, acc)) {
for (auto i : acc[{{0, n}, ten_pow}]) cout << i << " ";
cout << "\n";
} else
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int inf = 1e9;
int mod = 1e9 + 7;
vector<int> pos[43];
void pre() {
int p = 1;
for (int i = 0; i < 6; i++) {
p *= 3;
}
int bit[3] = {0, 4, 7};
for (int i = 0; i < p; i++) {
int temp = i, sum = 0;
vector<int> A;
for (int j = 0; j < 6; j++) {
sum += bit[temp % 3];
A.push_back(bit[temp % 3]);
temp /= 3;
}
if (pos[sum].empty()) {
pos[sum] = A;
}
}
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<int> digits;
while (n) {
digits.push_back(n % 10);
n /= 10;
}
bool check[19][10];
memset(check, false, sizeof(check));
int len = (int)digits.size();
vector<int> stk;
bool key = false;
function<bool(int, int)> dfs = [&](int l, int carry) {
if (l == len) {
return !carry;
}
if (check[l][carry]) {
return false;
}
check[l][carry] = true;
for (int i = 0; i < 43; i++) {
if (!pos[i].empty()) {
int temp = carry + i;
if (digits[l] == (temp % 10)) {
stk.push_back(i);
if (dfs(l + 1, temp / 10)) {
return true;
}
stk.pop_back();
}
}
}
return false;
};
if (dfs(0, 0)) {
vector<long long int> ans(6, 0LL);
for (int i = (int)stk.size() - 1; i >= 0; i--) {
for (int j = 0; j < 6; j++) {
ans[j] *= 10;
ans[j] += pos[stk[i]][j];
}
}
for (int i = 0; i < 6; i++) {
cout << ans[i] << " ";
}
cout << "\n";
continue;
}
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, n, m, an, K, tot;
const long long N = 22;
long long d[N], ans[N][N];
bool ff[N][6];
bool dfs(long long k, long long ss) {
if (ss > 5) return false;
if (ff[k][ss]) return false;
ff[k][ss] = true;
if (!k) {
if (!ss) return true;
return false;
}
ss = ss * 10 + d[k];
for (long long i = 0; i <= 6; i++)
for (long long now = 0; now < 1 << i; now++) {
long long s = 0;
for (long long j = 0; j < i; j++)
if (now & (1 << j))
s += 4;
else
s += 7;
if (s > ss) continue;
if (dfs(k - 1, ss - s)) {
for (long long j = 0; j < i; j++)
if (now & (1 << j))
ans[j][k] = 4;
else
ans[j][k] = 7;
return true;
}
}
return false;
}
int main() {
long long T;
scanf("%I64d", &T);
while (T) {
T--;
memset(ans, 0, sizeof(ans));
memset(ff, 0, sizeof(ff));
scanf("%I64d", &n);
tot = 0;
while (n) {
d[++tot] = n % 10;
n /= 10;
}
if (!dfs(tot, 0))
printf("-1");
else
for (long long i = 0; i < 6; i++) {
long long k = 0;
for (long long j = tot; j; j--)
if (ans[i][j] != 0) {
k = j;
break;
}
if (!k)
printf("0");
else
for (long long j = k; j; j--) printf("%I64d", ans[i][j]);
printf(" ");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
T Angle(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T euclide(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
void ia(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void pa(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T, class first>
inline T togglebit(T a, first i) {
T t = 1;
return (a ^ (t << i));
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int cdigittoint(char ch) { return ch - '0'; }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
double DEG(double x) { return (180.0 * x) / (2.0 * acos(0.0)); }
double RAD(double x) { return (x * (double)2.0 * acos(0.0)) / (180.0); }
int DP[23][7];
int a[23];
int PT[23][7][2];
int dp(int p, int c) {
if (p == 0) return c == 0;
if (DP[p][c] != -1) return DP[p][c];
int &res = DP[p][c];
res = 0;
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6; j++) {
int four = i, seven = j;
if (i + j > 6) continue;
int dg = (four * 4 + seven * 7 + c) % 10;
int cr = (four * 4 + seven * 7 + c) / 10;
if (dg == a[p]) {
int tmp = dp(p - 1, cr);
if (tmp) {
PT[p][c][0] = four;
PT[p][c][1] = seven;
}
res |= tmp;
}
}
}
return res;
}
long long int ans[8][23];
void Print(int l) {
int p = l, c = 0;
memset(ans, 0, sizeof ans);
while (p) {
int four = PT[p][c][0], seven = PT[p][c][1];
for (int i = 1; i <= four; i++) ans[i][p] = 4;
for (int i = 1; i <= seven; i++) ans[i + four][p] = 7;
p = p - 1;
c = (four * 4 + seven * 7 + c) / 10;
}
for (int i = 1; i <= 6; i++) {
int j = 1;
while (ans[i][j] == 0 && j <= l) j++;
if (j == l + 1) printf("0");
while (j <= l) printf("%d", ans[i][j]), j++;
printf(" ");
}
printf("\n");
;
}
int main() {
int(t);
scanf("%d", &t);
while (t--) {
long long int x;
scanf("%lld", &x);
int l = 0;
while (x) {
a[++l] = x % 10;
x /= 10;
}
reverse(a + 1, a + 1 + l);
memset(DP, -1, sizeof DP);
int ans = dp(l, 0);
if (ans)
Print(l);
else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const unsigned int &first) { printf("%u", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T elem, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(elem);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace escape__from__random__aetuhoetnuhshe {
using namespace std::chrono;
mt19937 rng(duration_cast<milliseconds>(system_clock::now().time_since_epoch())
.count());
}; // namespace escape__from__random__aetuhoetnuhshe
namespace typedefs {}
namespace numbers_operation {
template <class T>
T floor_mod(T a, T b) {
if (a % b == 0) return 0;
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
using namespace escape__from__random__aetuhoetnuhshe;
string base;
int get(int i) {
if (i >= ((int)base.size())) return 0;
return base[i] - '0';
}
const int N = 50;
vector<vector<int>> comp(N);
string strip(string s) {
while (((int)s.size()) > 1 && s[0] == '0') {
s.erase(s.begin());
}
return s;
}
void solve() {
cin, base;
reverse(base.begin(), base.end());
base += '0';
vector<vector<int>> dp(((int)base.size()), vector<int>(N));
vector<vector<pair<int, int>>> pref(((int)base.size()),
vector<pair<int, int>>(N));
for (int s = 0; s < ((int)comp.size()); s++) {
if (comp[s].empty()) continue;
if (s % 10 == get(0)) {
dp[0][s / 10] = 1;
pref[0][s / 10] = make_pair(s, 0);
}
}
for (int i = 1; i < ((int)base.size()); i++) {
for (int s = 0; s < N; s++) {
if (comp[s].empty()) continue;
for (int j = 0; j < N; j++) {
if ((s + j) % 10 == get(i)) {
if (dp[i - 1][j]) {
dp[i][(s + j) / 10] = 1;
pref[i][(s + j) / 10] = make_pair(s, j);
}
}
}
}
}
if (!dp[((int)base.size()) - 1][0]) {
smart_io::precall_print();
cout, -1;
return;
}
assert(dp[((int)base.size()) - 1][0]);
vector<string> result(6);
int cur = ((int)base.size()) - 1;
int j = 0;
while (cur >= 0) {
for (int k = 0; k < 6; k++) {
int id = pref[cur][j].first;
result[k] += to_string(comp[pref[cur][j].first][k]);
}
j = pref[cur][j].second;
cur--;
}
for (int k = 0; k < (6); k++) {
result[k] = strip(result[k]);
}
smart_io::precall_print();
cout, result;
}
signed main(signed argc, char *argv[]) {
for (int a : {0, 4, 7})
for (int b : {0, 4, 7})
for (int c : {0, 4, 7})
for (int d : {0, 4, 7})
for (int e : {0, 4, 7})
for (int z : {0, 4, 7})
comp[a + b + c + d + e + z] = {a, b, c, d, e, z};
int cnt_tests;
cin, cnt_tests;
for (int test = 0; test < (cnt_tests); test++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll llinf = (1ll << 61) - 1;
const double eps = 1e-6, ldeps = 1e-9;
struct Dbg {
static constexpr auto &os = cout;
template <class C>
static auto dud(C *x) -> decltype(os << *x, 0);
template <class C>
static char dud(...);
template <class C>
typename enable_if<sizeof dud<C>(0) != 1, Dbg &>::type operator<<(
const C &x) {
os << x;
return *this;
}
template <class C>
Dbg &dump(C b, C e) {
*this << "\n[";
int cur = 0;
for (C i = b; i != e and cur < 26; i++, cur++)
*this << ", " + 2 * (i == b) << *i;
return *this << ']';
}
template <class C>
typename enable_if<sizeof dud<C>(0) == 1, Dbg &>::type operator<<(
const C &x) {
return dump(begin(x), end(x));
}
template <class C, size_t X>
typename enable_if<sizeof(C) != 1, Dbg &>::type operator<<(C (&x)[X]) {
return dump(begin(x), end(x));
}
template <class B, class C>
Dbg &operator<<(const pair<B, C> &x) {
return *this << '{' << x.first << ", " << x.second << '}';
}
template <class C, size_t Y>
struct TP {
void operator()(Dbg &os, const C &t) {
TP<C, Y - 1>()(os, t);
os << ", " << get<Y - 1>(t);
}
};
template <class C>
struct TP<C, 1> {
void operator()(Dbg &os, const C &t) { os << get<0>(t); }
};
template <class... C>
Dbg &operator<<(const tuple<C...> &t) {
os << '{', TP<decltype(t), sizeof...(C)>()(*this, t);
return *this << '}';
}
Dbg &operator<<(ostream &(*x)(std::ostream &)) {
os << x;
return *this;
}
} dbg;
void err(istringstream *iss) { delete iss; }
template <class C, class... Args>
void err(istringstream *iss, const C &val, const Args &...args) {
string name;
*iss >> name;
if (name.back() == ',') name.pop_back();
dbg << name << " = " << val << "; ", err(iss, args...);
}
int m, K, T, Q, cn;
const int inf = 1000000007, mxn = 21;
vector<int> borrow[mxn];
vector<pair<int, int> > os[mxn];
deque<int> a;
ll n, ans[7];
pair<int, int> o[7][mxn];
int nxt[7][mxn];
bitset<mxn> vstd[7];
bool memo[7][mxn];
bool dp(int b, int at) {
if (!at) return !b;
bool &ret = memo[b][at];
if (vstd[b][at]) return ret;
vstd[b][at] = 1;
int x = a[at] - b + 10 * (a[at] < b);
ret = 0;
auto it = os[x].begin();
for (auto &i : borrow[x]) {
if (dp((a[at] < b) + i, at - 1)) {
ret = 1, o[b][at] = *it, nxt[b][at] = (a[at] < b) + i;
break;
}
it++;
}
return ret;
}
void resetAll() { memset(vstd, 0, sizeof(vstd)), a.clear(); }
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.precision(11);
for (int i = 0; i <= 6; i++) {
for (int j = 0; i + j <= 6; j++) {
int x = i * 4 + j * 7;
borrow[x % 10].push_back(x / 10), os[x % 10].push_back({i, j});
}
}
cin >> T;
while (cn++ != T) {
resetAll();
cin >> n;
while (n) {
a.push_front(int(n % 10)), n /= 10;
}
a.push_front(0);
auto x = dp(0, int(a.size()) - 1);
if (!x) {
cout << "-1\n";
continue;
}
memset(ans, 0, sizeof(ans));
int b = 0;
ll p10 = 1;
for (int i = int(a.size()) - 1; i >= 1; i--) {
for (int j = 0; j < o[b][i].first; j++) {
ans[j] += p10 * 4;
}
for (int j = 0; j < o[b][i].second; j++) {
ans[j + o[b][i].first] += p10 * 7;
}
b = nxt[b][i], p10 *= 10;
}
for (int i = 0; i < 6; i++) {
cout << ans[i] << " \n"[i == 5];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[8];
int n, f[22][22], pos[22][22], key[22][22], x, bo[120], zu[120][2], T;
char c[120];
void pret() {
for (int i = 0; i <= 6; ++i)
for (int j = 0; i + j <= 6; ++j) {
bo[i * 4 + j * 7] = 1;
zu[i * 4 + j * 7][0] = i;
zu[i * 4 + j * 7][1] = j;
}
}
int main() {
pret();
scanf("%d", &T);
while (T-- > 0) {
scanf("%s", c + 1);
n = strlen(c + 1);
memset(f, 0, sizeof(f));
f[n][0] = 1;
for (int i = n; i >= 1; --i) {
x = c[i] - 48;
for (int j = 0; j <= 9; ++j)
if (f[i][j]) {
for (int k = x - j; k <= 42; k += 10)
if (k >= 0 && bo[k]) {
f[i - 1][(k + j) / 10] = 1;
pos[i - 1][(k + j) / 10] = j;
key[i - 1][(k + j) / 10] = k;
}
}
}
if (!f[0][0]) {
printf("-1\n");
} else {
memset(a, 0, sizeof(a));
int j = 0;
for (int i = 0; i < n; ++i) {
x = key[i][j];
for (int k = 1; k <= zu[x][0]; ++k) a[k] = a[k] * 10 + 4;
for (int k = 1; k <= zu[x][1]; ++k)
a[k + zu[x][0]] = a[k + zu[x][0]] * 10 + 7;
for (int k = zu[x][0] + zu[x][1] + 1; k <= 6; ++k) a[k] *= 10;
j = pos[i][j];
}
for (int i = 1; i <= 6; ++i) printf("%I64d ", a[i]);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool possible[20][10];
pair<int, pair<int, int>> back[20][10];
int t;
int main() {
for (int j = 0; j < 10; j++) {
possible[0][j] = false;
}
possible[0][0] = true;
back[0][0] = make_pair(0, make_pair(0, 0));
cin >> t;
for (int c = 0; c < t; c++) {
int64_t n;
cin >> n;
for (int i = 1; i < 20; i++) {
int target_digit = n % 10;
n = n / 10;
for (int j = 0; j < 10; j++) {
possible[i][j] = false;
for (int n4 = 0; n4 <= 6; n4++) {
for (int n7 = 0; n4 + n7 <= 6; n7++) {
int x = n4 * 4 + n7 * 7;
int digit = x % 10;
int carry = (x - digit) / 10;
if (carry == j && digit <= target_digit &&
possible[i - 1][target_digit - digit]) {
possible[i][j] = true;
back[i][j] = make_pair(target_digit - digit, make_pair(n4, n7));
goto end;
} else if (carry == j - 1 && digit > target_digit &&
possible[i - 1][10 + target_digit - digit]) {
possible[i][j] = true;
back[i][j] =
make_pair(10 + target_digit - digit, make_pair(n4, n7));
goto end;
}
}
}
end:;
}
}
if (possible[19][0]) {
int digits[6][20];
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 20; j++) {
digits[i][j] = 0;
}
}
int j = 0;
for (int i = 19; i >= 0; i--) {
int j2 = get<0>(back[i][j]);
int n4 = get<0>(get<1>(back[i][j]));
int n7 = get<1>(get<1>(back[i][j]));
int k = 0;
for (int l = 0; l < n4; l++) {
digits[k][i] = 4;
k += 1;
}
for (int l = 0; l < n7; l++) {
digits[k][i] = 7;
k += 1;
}
j = j2;
}
int64_t numbers[6];
for (int i = 0; i < 6; i++) {
numbers[i] = 0;
for (int j = 19; j >= 0; j--) {
numbers[i] += digits[i][j];
if (j > 1) {
numbers[i] *= 10;
}
}
}
for (int i = 0; i < 6; i++) {
cout << numbers[i] << " ";
}
printf("\n");
} else {
printf("-1\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
#pragma comment(linker, "/STACK:102400000,102400000")
const int inf = 0x3f3f3f3f;
int mod = 1e9 + 7;
const int N = 3e5 + 111;
int a[22];
long long ten[22];
long long ans[6];
bool dp[22][7];
pair<int, int> st[22][7];
void work() {
long long x;
cin >> x;
int i, j, r, t;
memset(a, 0, sizeof(a));
memset(dp, 0, sizeof(dp));
int end = 0;
for (i = 1; i <= 20; i++) {
a[i] = x % 10;
x /= 10;
if (x == 0) {
end = i;
break;
}
}
ten[0] = 1;
for (i = 1; i <= 20; i++) ten[i] = ten[i - 1] * 10;
dp[0][0] = 1;
for (i = 1; i <= end; i++) {
for (j = 0; j < 7; j++) {
if (dp[i - 1][j]) {
for (t = 0; t < 7; t++) {
for (r = 0; r < 7 - t; r++) {
int tmp = t * 7 + r * 4 + j;
if (tmp % 10 == a[i]) {
dp[i][tmp / 10] = 1;
st[i][tmp / 10] = make_pair(t, r);
}
}
}
}
}
}
if (!dp[end][0]) {
puts("-1");
return;
}
memset(ans, 0, sizeof(ans));
int fk = 0;
for (i = end; i >= 1; i--) {
pair<int, int> tp = st[i][fk];
int tmp = tp.first * 7 + tp.second * 4 - fk * 10;
fk = a[i] - tmp;
for (j = 0; j < tp.first; j++) {
ans[j] += ten[i - 1] * 7;
}
for (j = tp.first; j < tp.first + tp.second; j++) {
ans[j] += ten[i - 1] * 4;
}
}
for (i = 0; i < 6; i++) printf("%I64d%c", ans[i], i == 5 ? '\n' : ' ');
}
int main() {
int t;
cin >> t;
while (t--) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[22][22];
int cnt[22][22][2];
int ans[22][2];
char s[22][22];
int num[22];
int n;
char str[22];
void getans(int i, int j) {
if (i == 0) return;
int a = j * 10 + num[i] - 4 * cnt[i][j][0] - 7 * cnt[i][j][1];
ans[i][0] = cnt[i][j][0];
ans[i][1] = cnt[i][j][1];
getans(i - 1, a);
}
void deal() {
memset(s, 0, sizeof(s));
for (int i = 0; i <= 18; i++) {
int z = ans[i + 1][0];
for (int j = 0; j < ans[i + 1][0]; j++) s[j][i] = '4';
for (int j = ans[i + 1][0]; j < ans[i + 1][0] + ans[i + 1][1]; j++)
s[j][i] = '7';
for (int j = ans[i + 1][0] + ans[i + 1][1]; j < 6; j++) s[j][i] = '0';
}
}
int main() {
scanf("%d", &n);
while (n--) {
scanf("%s", str);
int len = strlen(str);
memset(num, 0, sizeof(num));
for (int i = 1; i <= len; i++) num[i] = str[len - i] - '0';
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i <= 18; i++)
for (int j = 0; j < 10; j++) {
if (dp[i][j] == 0) continue;
for (int p = 0; p <= 6; p++)
for (int q = 0; q + p <= 6; q++) {
int t = p * 4 + q * 7;
int b = (t + j) % 10;
int a = (t + j) / 10;
if (b == num[i + 1]) {
dp[i + 1][a] = 1;
cnt[i + 1][a][0] = p;
cnt[i + 1][a][1] = q;
}
}
}
if (dp[19][0] == 0)
printf("-1\n");
else {
getans(19, 0);
deal();
for (int j = 0; j < 6; j++)
for (int i = 18; i >= 1; i--)
if (s[j][i] == '0')
s[j][i] = 0;
else
break;
for (int i = 0; i < 6; i++) {
int length = strlen(s[i]);
for (int j = 0; j + j < length; j++)
swap(s[i][j], s[i][length - 1 - j]);
}
for (int i = 0; i < 6; i++) {
printf("%s", s[i]);
if (i == 5)
printf("\n");
else
printf(" ");
}
}
}
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>
#pragma comment(linker, "/stack:256000000")
using namespace std;
const int N = 729;
string s;
int dp[22][10], prid[22][10], prmod[22][10], num[800][6];
long long ans[6];
int sum[50];
int go(int pos, int mod) {
if (dp[pos][mod] != -1) {
return dp[pos][mod];
}
if (pos == 20) {
if (mod == 0)
return dp[pos][mod] = 1;
else
return dp[pos][mod] = 0;
}
for (int i = 0; i < (50); i++) {
if (sum[i] == -1) continue;
if ((mod + i) % 10 == s[pos] - '0') {
if (go(pos + 1, (mod + i) / 10) == 1) {
prid[pos + 1][(mod + i) / 10] = i;
prmod[pos + 1][(mod + i) / 10] = mod;
return dp[pos][mod] = 1;
}
}
}
return dp[pos][mod] = 0;
}
int main() {
memset(sum, -1, sizeof(sum));
for (int i = 0; i < (N); i++) {
int x = i, t = 243;
for (int j = 0; j < (6); j++) {
num[i][j] = x / t;
x %= t;
t /= 3;
}
int tmp = 0;
for (int j = 0; j < (6); j++) {
if (num[i][j] == 1)
num[i][j] = 4;
else if (num[i][j] == 2)
num[i][j] = 7;
tmp += num[i][j];
}
if (sum[tmp] == -1) sum[tmp] = i;
}
int tst;
scanf("%d", &tst);
for (int _ = 0; _ < (tst); _++) {
cin >> s;
while ((int)(s).size() < 20) s = "0" + s;
reverse((s).begin(), (s).end());
memset(dp, -1, sizeof(dp));
memset(prid, -1, sizeof(prid));
memset(prmod, -1, sizeof(prmod));
if (go(0, 0)) {
memset(ans, 0, sizeof(ans));
int pos = 20, mod = 0;
while (pos > 0) {
int id = sum[prid[pos][mod]];
for (int i = 0; i < (6); i++) {
ans[i] *= 10;
ans[i] += num[id][i];
}
mod = prmod[pos][mod];
--pos;
}
for (int i = 0; i < (6); i++) {
cout << ans[i] << " ";
}
cout << "\n";
} else {
cout << -1 << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool flag, v[21][501];
long long n, a[9], tmp, pw[21];
int i, j, k, tests, b[21];
void work(int x, int d) {
int i, j, k, t;
if (v[x][d]) return;
v[x][d] = 1;
if (b[0] < x) {
if (d) return;
flag = 1;
for (i = 1; i <= 6; i++) cout << a[i] << " ";
cout << endl;
return;
}
for (i = 0; i <= 6; i++)
for (j = 0; j <= 6 - i; j++) {
t = d + i * 4 + j * 7;
if (t % 10 != b[x]) continue;
for (k = 1; k <= i; k++) a[k] += 4LL * pw[x - 1];
for (k = i + 1; k <= i + j; k++) a[k] += 7LL * pw[x - 1];
work(x + 1, t / 10);
if (flag) return;
for (k = 1; k <= i; k++) a[k] -= 4LL * pw[x - 1];
for (k = i + 1; k <= i + j; k++) a[k] -= 7LL * pw[x - 1];
}
}
int main() {
cin >> tests;
for (i = 1, pw[0] = 1; i <= 18; i++) pw[i] = pw[i - 1] * 10LL;
while (tests--) {
cin >> n;
memset(v, 0, sizeof(v));
memset(b, 0, sizeof(b));
memset(a, 0, sizeof(a));
for (tmp = n, b[0] = 0; tmp; tmp /= 10) b[++b[0]] = tmp % 10;
flag = 0;
work(1, 0);
if (!flag) cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
long long N, b[6];
int a[25], g[25][25][3], L;
bool f[25][25];
void doit() {
scanf("%I64d", &N), L = 0;
for (; N; N /= 10) a[++L] = N % 10;
memset(f, 0, sizeof(f)), memset(b, 0, sizeof(b)), f[0][0] = 1;
for (int i = 1; i <= L; i++)
for (int j = 0; j < 25; j++)
if (f[i - 1][j])
for (int k = 0; k <= 6; k++)
for (int l = 0, x, y; k + l <= 6; l++)
if ((x = j + k * 4 + l * 7) % 10 == a[i])
f[i][y = x / 10] = 1, g[i][y][0] = j, g[i][y][1] = k,
g[i][y][2] = l;
if (!f[L][0]) {
puts("-1");
return;
}
for (int i = L, j = 0, k, x, y; i; i--, j = k) {
k = g[i][j][0], x = g[i][j][1], y = g[i][j][2];
for (int l = 1; l <= x; l++) (b[l - 1] *= 10) += 4;
for (int l = 1; l <= y; l++) (b[x + l - 1] *= 10) += 7;
for (int l = x + y; l < 6; l++) b[l] *= 10;
}
for (int i = 0; i < 6; i++) printf("%I64d%c", b[i], i == 5 ? '\n' : ' ');
}
int main() {
int T;
for (scanf("%d", &T); T; T--) doit();
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
int dp[20][10][4];
string toString(long long n) {
stringstream ss;
ss << n;
return ss.str();
}
long long toNum(string str) {
stringstream ss(str);
long long ans;
ss >> ans;
return ans;
}
void solve(int i, int j, int previ, int prevj, int count4, int count7) {
if (dp[i][j][0] != -1) return;
dp[i][j][0] = previ;
dp[i][j][1] = prevj;
dp[i][j][2] = count4;
dp[i][j][3] = count7;
if (i >= str.size()) return;
int digit = (str[i] - '0');
for (int k = 0; k <= 6; k++) {
for (int l = 0; l <= 6; l++) {
if (l + k > 6) continue;
int last = (4 * k + 7 * l + j) % 10;
int rem = (4 * k + 7 * l + j) / 10;
if (last == digit) solve(i + 1, rem, i, j, count4 + k, count7 + l);
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
memset(dp, -1, sizeof dp);
long long num;
cin >> num;
str = toString(num);
reverse(str.begin(), str.end());
solve(0, 0, -1, -1, 0, 0);
vector<string> ans(6);
int i = str.size(), j = 0;
if (dp[i][j][0] == -1) {
cout << -1 << endl;
} else {
while (i != 0) {
int previ = dp[i][j][0], prevj = dp[i][j][1];
int count4 = dp[i][j][2] - dp[previ][prevj][2];
int count7 = dp[i][j][3] - dp[previ][prevj][3];
int index = 0;
for (int k = 0; k < count4; k++) ans[index++].push_back('4');
for (int k = 0; k < count7; k++) ans[index++].push_back('7');
for (int k = 0; k < 6 - count4 - count7; k++)
ans[index++].push_back('0');
i = previ;
j = prevj;
}
long long sum = 0;
for (int i = 0; i < 6; i++) {
cout << toNum(ans[i]) << " ";
sum += toNum(ans[i]);
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> u[50];
int t, m, f[25][50], s[25];
long long n, ans[6], pw[20];
void init() {
int tab[] = {0, 4, 7};
for (int(i) = (0); (i) <= ((3) - 1); (i)++)
for (int(j) = (0); (j) <= ((3) - 1); (j)++)
for (int(k) = (0); (k) <= ((3) - 1); (k)++)
for (int(x) = (0); (x) <= ((3) - 1); (x)++)
for (int(y) = (0); (y) <= ((3) - 1); (y)++)
for (int(z) = (0); (z) <= ((3) - 1); (z)++) {
int now = tab[i] + tab[j] + tab[k] + tab[x] + tab[y] + tab[z];
if (u[now].empty())
u[now] = {tab[i], tab[j], tab[k], tab[x], tab[y], tab[z]};
}
pw[0] = 1;
for (int(i) = (1); (i) <= (18); (i)++) pw[i] = pw[i - 1] * 10;
}
void dfs(int pos, int rem) {
int now = rem * 10 + s[pos];
if (now > 46) return;
for (int(i) = (0); (i) <= ((5) - 1); (i)++) {
int need = now - i;
if (need < 0) continue;
if (!u[need].empty() && f[pos + 1][i] == -1) {
f[pos + 1][i] = rem;
if (pos < m) dfs(pos + 1, i);
}
}
}
int main() {
init();
scanf("%d", &t);
while (t--) {
scanf("%lld", &n);
m = 0;
while (n) {
s[++m] = n % 10;
n /= 10;
}
reverse(s + 1, s + m + 1);
memset(f, -1, sizeof(f));
dfs(1, 0);
if (f[m + 1][0] == -1) {
puts("-1");
continue;
}
memset(ans, 0, sizeof(ans));
int x = 0;
for (int(i) = (m + 1); (i) >= (2); (i)--) {
int d = f[i][x] * 10 - x + s[i - 1];
for (int(j) = (0); (j) <= ((6) - 1); (j)++)
ans[j] += u[d][j] * pw[m + 1 - i];
x = f[i][x];
}
for (int(i) = (0); (i) <= ((6) - 1); (i)++) printf("%lld ", ans[i]);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
vector<int> add[43];
void dfs(int cur, int sum, vector<int> &v) {
if (cur == 6) {
add[sum] = v;
return;
}
v.push_back(0);
dfs(cur + 1, sum, v);
v.pop_back();
v.push_back(4);
dfs(cur + 1, sum + 4, v);
v.pop_back();
v.push_back(7);
dfs(cur + 1, sum + 7, v);
v.pop_back();
}
bool dp[N][10];
int from[N][10];
int trans[N][10];
int a[N];
void print(vector<int> v) {
bool p = false;
for (auto &x : v) {
if (x != 0) p = true;
if (p) cout << x;
}
if (!p) cout << 0;
}
int main() {
vector<int> v;
dfs(0, 0, v);
ios ::sync_with_stdio(false);
int kase;
cin >> kase;
while (kase--) {
string s;
cin >> s;
reverse(s.begin(), s.end());
memset(a, 0, sizeof(a));
for (int i = 0; i < s.size(); i++) a[i] = s[i] - '0';
memset(dp, 0, sizeof(dp));
dp[0][0] = true;
for (int i = 0; i < N - 1; i++)
for (int j = 0; j < 10; j++)
for (int k = 0; k <= 42; k++)
if (dp[i][j] && (j + k) % 10 == a[i] && add[k].size()) {
int t = (j + k) / 10;
dp[i + 1][t] = true;
trans[i + 1][t] = k;
from[i + 1][t] = j;
}
if (dp[N - 1][0]) {
vector<int> ans[6];
int t = 0;
for (int i = N - 1; i > 0; i--) {
for (int j = 0; j < 6; j++) ans[j].push_back(add[trans[i][t]][j]);
t = from[i][t];
}
for (int i = 0; i < 6; i++) {
print(ans[i]);
cout << ' ';
}
cout << '\n';
} else
cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x < 0 ? -x : x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
const int INF = (int)1e+9 + 7;
const int d[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 n;
long long p[19];
vector<long long> ans;
map<pair<long long, int>, bool> cache;
pair<int, int> f[100];
bool rec(long long q) {
if (!q) return true;
for (int i = 0; i < 28; i++) {
if ((q - d[i]) % 10 || d[i] > q)
continue;
else {
ans.push_back(d[i]);
if (rec((q - d[i]) / 10)) return true;
ans.pop_back();
}
}
return false;
}
int main() {
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++) f[i * 4 + j * 7] = pair<int, int>(i, j);
cin >> n;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
ans.clear();
if (rec(a)) {
long long q[6];
memset(q, 0, sizeof(q));
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < f[ans[i]].first; j++) q[j] += 4 * p[i];
for (int j = f[ans[i]].first; j < f[ans[i]].first + f[ans[i]].second;
j++)
q[j] += 7 * p[i];
}
for (int j = 0; j < 6; j++) cout << q[j] << ' ';
} else
cout << -1;
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int fs[43][2], d[20], dp[20][10], r[20][10], from[20][10];
vector<int> pos;
int main() {
memset((fs), -1, sizeof((fs)));
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++) {
fs[i * 7 + j * 4][0] = i;
fs[i * 7 + j * 4][1] = j;
}
for (int i = 0; i <= 42; i++) {
if (fs[i][0] != -1) pos.push_back(i);
}
int ___T, case_n = 1;
scanf("%d ", &___T);
while (___T-- > 0) {
long long n;
cin >> n;
for (int i = 0; i < 20; i++) {
d[i] = n % 10;
n /= 10;
}
memset((dp), -1, sizeof((dp)));
memset((r), 0, sizeof((r)));
dp[0][0] = 0;
for (int i = 0; i < 19; i++) {
for (int j = 0; j < 10; j++) {
if (dp[i][j] != -1) {
for (int k = 0; k < ((int)(pos).size()); k++) {
if (pos[k] % 10 == (d[i] - j + 100) % 10) {
dp[i + 1][(j + pos[k]) / 10] = k;
from[i + 1][(j + pos[k]) / 10] = j;
}
}
}
}
}
if (dp[19][0] != -1) {
int x = 19, y = 0;
while (x) {
int v = pos[dp[x][y]];
int cnt = 0;
for (int i = 0; i < fs[v][0]; i++) r[x - 1][cnt++] = 7;
for (int i = 0; i < fs[v][1]; i++) r[x - 1][cnt++] = 4;
y = from[x][y];
x--;
}
for (int i = 0; i < 6; i++) {
long long tmp = 0;
for (int j = 18; j >= 0; j--) tmp = tmp * 10 + r[j][i];
if (i) printf(" ");
cout << tmp;
}
puts("");
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[20];
bool f[20][20];
int t[20][20][2];
vector<int> res[10];
int cal(int x) {
int res = 0;
for (int i = 1; i <= 6; i++) {
if (x % 3 == 0)
res += 0;
else if (x % 3 == 1)
res += 4;
else
res += 7;
x /= 3;
}
return res;
}
int main() {
int o;
scanf("%d", &o);
while (o--) {
long long s;
int r = 0;
cin >> s;
while (s) {
a[++r] = s % 10;
s /= 10;
}
memset(f, 0, sizeof(f));
f[1][0] = true;
for (int i = 1; i <= r; i++)
for (int j = 0; j < 5; j++)
if (f[i][j]) {
for (int k4 = 0; k4 <= 6; k4++)
for (int k7 = 0; k7 + k4 <= 6; k7++) {
int tmp = k4 * 4 + k7 * 7 + j;
if (tmp % 10 == a[i]) {
f[i + 1][tmp / 10] = true;
t[i + 1][tmp / 10][0] = k4;
t[i + 1][tmp / 10][1] = k7;
}
}
}
if (f[r + 1][0] == false)
printf("-1\n");
else {
int x = r + 1, y = 0;
for (int i = 1; i <= 6; i++) res[i].clear();
while (x > 1) {
int k4 = t[x][y][0], k7 = t[x][y][1];
int sum = k4 * 4 + k7 * 7;
for (int i = 1; i <= k4; i++) res[i].push_back(4);
for (int i = k4 + 1; i <= k4 + k7; i++) res[i].push_back(7);
for (int i = k4 + k7 + 1; i <= 6; i++) res[i].push_back(0);
x--;
y = a[x] - sum + 10 * y;
}
for (int i = 1; i <= 6; i++) {
bool t = false;
for (int j = 0; j < res[i].size(); j++) {
if (res[i][j] == 0) {
if (t == true) printf("0");
} else {
t = true;
printf("%d", res[i][j]);
}
}
if (t == false) printf("0");
printf("%c", i == 6 ? '\n' : ' ');
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long INF = 2e18;
const int INFi = 2e9;
const int maxN = 2e5 + 5;
const int P = 998244353;
const int md = 1e9 + 7;
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
void solve() {
unsigned long long n;
cin >> n;
unsigned long long n1 = n;
vector<vector<int>> dp(21, vector<int>(10));
vector<vector<array<int, 3>>> pref(21, vector<array<int, 3>>(10));
dp[0][0] = 1;
vector<int> to(21);
for (int i = 1; i < 21; ++i) {
to[i] = n % 10;
n /= 10;
}
for (int i = 1; i < 21; ++i) {
for (int j = 0; (j) < 10; ++(j)) {
if (dp[i - 1][j]) {
for (int cnt4 = 0; cnt4 < 7; ++cnt4) {
for (int cnt7 = 0; cnt4 + cnt7 < 7; ++cnt7) {
int s = j + cnt4 * 4 + cnt7 * 7;
if (s % 10 == to[i]) {
dp[i][s / 10] = 1;
pref[i][s / 10] = {j, cnt4, cnt7};
}
}
}
}
}
}
if (!dp[20][0]) {
cout << "-1\n";
return;
}
vector<pair<int, int>> path;
for (int i = 20, j = 0; i >= 1; --i) {
path.emplace_back(pref[i][j][1], pref[i][j][2]);
j = pref[i][j][0];
}
vector<unsigned long long> ans(6, 0);
unsigned long long cur = 1;
reverse((path).begin(), (path).end());
for (auto x : path) {
for (int i = 0; (i) < x.first; ++(i)) {
ans[i] += cur * 4;
}
for (int i = x.first; i < x.first + x.second; ++i) {
ans[i] += cur * 7;
}
cur *= 10;
}
unsigned long long s = 0;
for (int i = 0; (i) < 6; ++(i)) s += ans[i];
if (s != n1) {
cout << "-1\n";
return;
}
for (int i = 0; (i) < 6; ++(i)) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tests;
cin >> tests;
for (int _ = 0; (_) < tests; ++(_)) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[7][149];
int pre[7][149];
int zc[149][7];
inline void Re(int i, int j, int x, int y) {
if (dp[i][j]) return;
dp[i][j] |= dp[x][y];
if (dp[i][j]) pre[i][j] = y;
}
void init() {
dp[0][0] = 1;
for (int i = 1; i <= 6; i++) {
for (int j = 0; j <= 48; j++)
if (dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j];
pre[i][j] = j;
}
for (int j = 48; j >= 4; j--) {
if (j >= 7) Re(i, j, i - 1, j - 7);
Re(i, j, i - 1, j - 4);
}
}
for (int i = (1); i <= (6); i++)
for (int j = (1); j <= (48); j++)
if (dp[i][j]) {
for (int k = (1); k <= (i - 1); k++) zc[j][k] = zc[pre[i][j]][k];
zc[j][i] = j - pre[i][j];
}
}
bool g[20][6];
int p1[20][6], p2[20][6];
int dig[20];
void PR(int x) {
long long X[7];
memset(X, 0, sizeof X);
for (int j = (1); j <= (6); j++) X[j] = zc[dig[19] + x * 10][j];
long long base = 10;
for (int i = 19; i >= 1; i--) {
for (int j = 1; j <= 6; j++) X[j] += base * 1ll * zc[p1[i][x]][j];
x = p2[i][x];
base *= 10ll;
}
for (int i = (1); i <= (6); i++) printf("%I64d\n", X[i]);
}
void Work(long long val) {
memset(dig, 0, sizeof dig);
memset(g, 0, sizeof g);
for (int i = (19); i >= (1); i--) {
dig[i] = val % 10;
val /= 10ll;
}
g[1][0] = 1;
for (int i = (1); i <= (18); i++)
for (int jw = (0); jw <= (5); jw++)
if (g[i][jw]) {
int al = jw * 10 + dig[i];
for (int k = (0); k <= (48); k++)
if (k <= al && dp[6][k] && al - k <= 5)
if (!g[i + 1][al - k]) {
g[i + 1][al - k] = 1;
p1[i + 1][al - k] = k;
p2[i + 1][al - k] = jw;
}
}
for (int i = (0); i <= (5); i++)
if (g[19][i] && dp[6][i * 10 + dig[19]]) {
PR(i);
return;
}
printf("-1\n");
}
int main() {
int t;
scanf("%d", &t);
init();
while (t--) {
long long x;
scanf("%I64d", &x);
Work(x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve();
void precalc();
int main() {
int t = 1;
precalc();
cin >> t;
while (t--) solve();
return 0;
}
vector<long long> composition[60];
void precalc() {
for (long long i = 0; i <= 6; ++i)
for (long long j = 0; i + j <= 6; ++j) {
long long k = 6 - i - j;
composition[j * 4 + k * 7].push_back(i);
composition[j * 4 + k * 7].push_back(j);
composition[j * 4 + k * 7].push_back(k);
}
}
pair<long long, long long> pred[20][6];
void solve() {
long long n;
cin >> n;
vector<long long> now;
long long k = n;
for (long long i = 0; i < 19; ++i) {
now.push_back(k % 10);
k /= 10;
}
for (long long i = 0; i < 20; ++i)
for (long long j = 0; j < 6; ++j) pred[i][j] = make_pair(-1, -1);
for (long long i = 0; i < 60; ++i)
if (composition[i].size() == 3 && (i % 10) == now[0]) {
pred[0][i / 10] = make_pair(0, i);
}
for (long long i = 0; i < 18; ++i)
for (long long carry = 0; carry < 6; ++carry) {
if (pred[i][carry].first == -1) continue;
for (long long nex = 0; nex < 60; ++nex)
if (composition[nex].size() == 3) {
long long nexSum = nex + carry;
if (nexSum % 10 != now[i + 1]) continue;
pred[i + 1][nexSum / 10] = make_pair(carry, nex);
}
}
if (pred[18][0].first == -1) {
cout << "-1\n";
return;
}
vector<long long> res[6];
long long cur = 18;
long long sum = pred[18][0].second;
long long carry = 0;
do {
for (long long i = 0; i < composition[sum][0]; ++i) res[i].push_back(0);
for (long long i = composition[sum][0];
i < composition[sum][0] + composition[sum][1]; ++i)
res[i].push_back(4);
for (long long i = composition[sum][0] + composition[sum][1]; i < 6; ++i)
res[i].push_back(7);
sum = pred[cur][carry].second;
carry = pred[cur][carry].first;
--cur;
} while (cur >= 0);
for (long long i = 0; i < composition[sum][0]; ++i) res[i].push_back(0);
for (long long i = composition[sum][0];
i < composition[sum][0] + composition[sum][1]; ++i)
res[i].push_back(4);
for (long long i = composition[sum][0] + composition[sum][1]; i < 6; ++i)
res[i].push_back(7);
for (long long i = 0; i < 6; ++i) {
long long cur = 0;
for (long long j = 0; j < res[i].size(); ++j) cur = cur * 10 + res[i][j];
cout << cur << ' ';
}
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
struct ww {
int a, b, i, j;
} f[20][5];
int i, j, n, m;
long long k, an[7];
void dfs(int x, int y, long long z) {
if (x == 1) return;
int i;
for (i = 1; i <= f[x][y].i; i++) an[i] += z * 7;
for (i = 1; i <= f[x][y].j; i++) an[7 - i] += z * 4;
dfs(x - 1, f[x][y].b, z / 10);
}
inline void work(long long x) {
int i, j, g[20], n, u, r;
for (n = 0; x; x /= 10) g[++n] = x % 10;
long long k = 1;
for (i = 1; i <= n - 1; i++) k *= 10;
memset(f, 0, sizeof(f));
f[1][0].a = 1;
for (i = 1; i <= n; i++)
for (j = 0; j <= 4; j++)
if (f[i][j].a) {
int A = 0, B = g[i];
B -= j;
if (B < 0) A++, B += 10;
for (u = 0; u <= 6; u++)
for (r = 0; r <= 6 - u; r++)
if ((u * 7 + 4 * r) % 10 == B) {
int C = A + (u * 7 + 4 * r) / 10;
f[i + 1][C].a = 1;
f[i + 1][C].b = j;
f[i + 1][C].i = u;
f[i + 1][C].j = r;
}
}
if (!f[n + 1][0].a) {
printf("-1\n");
return;
}
memset(an, 0, sizeof(an));
dfs(n + 1, 0, k);
for (i = 1; i <= 6; i++) printf("%I64d ", an[i]);
printf("\n");
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &k), work(k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
int v[3] = {0, 4, 7};
bool dp[32][256];
bool vis[32][256];
vector<int> sol[32][256];
bool calc(int i, int h) {
if (i == str.size()) return !h;
if (!vis[i][h]) {
vis[i][h] = true;
sol[i][h].clear();
dp[i][h] = false;
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 f = 0; f < 3; ++f)
if ((v[a] + v[b] + v[c] + v[d] + v[e] + v[f] + h) % 10 ==
str[i] - '0' &&
calc(i + 1,
(v[a] + v[b] + v[c] + v[d] + v[e] + v[f] + h) / 10)) {
sol[i][h].push_back(a);
sol[i][h].push_back(b);
sol[i][h].push_back(c);
sol[i][h].push_back(d);
sol[i][h].push_back(e);
sol[i][h].push_back(f);
return dp[i][h] = true;
}
}
return dp[i][h];
}
string Sol[6];
void print(int i, int h) {
if (i == str.size()) {
return;
}
int x = h;
for (int j = 0; j < sol[i][h].size(); ++j) {
x += v[sol[i][h][j]];
Sol[j] += v[sol[i][h][j]] + '0';
}
print(i + 1, x / 10);
}
long long tr(string &s) {
long long r = 0;
for (int i = 0; i < s.size(); ++i) r = r * 10 + s[i] - '0';
return r;
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> str;
reverse(str.begin(), str.end());
memset(vis, 0, sizeof(vis));
if (calc(0, 0)) {
print(0, 0);
for (int i = 0; i < 6; ++i) {
reverse(Sol[i].begin(), Sol[i].end());
if (i) cout << " ";
cout << tr(Sol[i]);
Sol[i] = "";
}
cout << endl;
} else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long CARRY = 6;
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 (current_carry == 5)
while (true) {
}
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;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
vector<vector<long long>> ans1(1000);
vector<vector<long long>> ans2(500000);
void split(int t) {
const int C = 100;
if (t < C) {
ans2[t] = ans1[t];
return;
}
for (int i = (0); i < (5); ++i) {
if (ans1[C * i + t % C].size() == 0) {
continue;
}
int t2 = (t - (C * i + t % C)) / C;
if (t2 < 0 || ans2[t2].size() == 0) {
continue;
}
ans2[t] = ans2[t2];
for (int j = (0); j < (6); ++j) {
ans2[t][j] *= C;
ans2[t][j] += ans1[C * i + t % C][j];
}
return;
}
}
vector<long long> dfs(long long t) {
const int C = 100000;
if (t < C) {
return ans2[t];
}
for (int i = (0); i < (5); ++i) {
if (ans2[C * i + t % C].size() == 0) {
continue;
}
long long t2 = (t - (C * i + t % C)) / C;
if (t2 < 0) {
continue;
}
vector<long long> ans = dfs(t2);
if (ans.size() == 0) {
continue;
}
for (int j = (0); j < (6); ++j) {
ans[j] *= C;
ans[j] += ans2[C * i + t % C][j];
}
return ans;
}
return {};
}
int main() {
for (int i = (0); i < (531441); ++i) {
int t = i;
int sum = 0;
vector<long long> x(6);
for (int j = (0); j < (6); ++j) {
for (int k = (0); k < (2); ++k) {
x[j] *= 10;
x[j] += t % 3 == 0 ? 0 : (t % 3 == 1 ? 4 : 7);
t /= 3;
}
sum += x[j];
}
if (ans1[sum].size() == 0) {
ans1[sum] = x;
}
}
for (int i = (0); i < (500000); ++i) {
split(i);
}
int n;
cin >> n;
for (int i = (0); i < (n); ++i) {
long long x;
cin >> x;
vector<long long> ans = dfs(x);
if (ans.size() == 0) {
cout << -1 << "\n";
} else {
for (auto j : ans) {
cout << j << " ";
}
cout << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f, g, h, i, j, k;
int len;
int T;
bool F[26][12];
char w[26];
pair<int, int> qq[26][12];
pair<int, int> GG[26][12];
int an[26][12];
void Get_An(int x, int y) {
int ii, jj, kk;
if (x == 0) return;
kk = 0;
for (ii = 1; ii <= GG[x][y].first; ii++) an[x - 1][++kk] = 4;
for (ii = 1; ii <= GG[x][y].second; ii++) an[x - 1][++kk] = 7;
Get_An(qq[x][y].first, qq[x][y].second);
}
void Work() {
memset(F, false, sizeof(F));
for (i = 1; i <= len / 2; i++) swap(w[i], w[len + 1 - i]);
F[1][0] = true;
for (i = 1; i <= len; i++)
for (j = 0; j <= 9; j++)
if (F[i][j]) {
for (c = 0; c <= 6; c++)
for (d = 6 - c; d >= 0; d--) {
e = j + c * 4 + d * 7;
if (e % 10 == w[i] - '0' && F[i + 1][e / 10] == false) {
F[i + 1][e / 10] = true;
qq[i + 1][e / 10] = make_pair(i, j);
GG[i + 1][e / 10] = make_pair(c, d);
}
}
}
if (F[len + 1][0]) {
memset(an, 0, sizeof(an));
Get_An(len + 1, 0);
for (i = 1; i <= 6; i++) {
k = len;
while (k > 1 && an[k][i] == 0) k--;
for (j = k; j >= 1; j--) printf("%d", an[j][i]);
cout << " ";
}
cout << endl;
} else
cout << -1 << endl;
}
int main() {
cin >> T;
while (T--) {
scanf("%s", w + 1);
len = strlen(w + 1);
Work();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int dp[20][54][7];
string ans[7];
int fun(int pos, int sum, int lf) {
if (pos == ((int)(s.size()))) {
return sum == 0;
}
int& ret = dp[pos][sum][lf];
if (ret != -1) return ret;
ret = 0;
int t1;
if (!lf) {
t1 = sum % 10;
if (t1 == (s[pos] - '0')) {
ret |= fun(pos + 1, sum / 10, 6);
}
return ret;
}
ret |= fun(pos, sum, lf - 1);
ret |= fun(pos, sum + 4, lf - 1);
ret |= fun(pos, sum + 7, lf - 1);
return ret;
}
void fun2(int pos, int sum, int lf) {
if (pos == ((int)(s.size()))) {
return;
}
int ret;
ret = 0;
int t1;
if (!lf) {
fun2(pos + 1, sum / 10, 6);
return;
}
ret |= fun(pos, sum, lf - 1);
if (ret) {
ans[lf] += "0";
fun2(pos, sum, lf - 1);
return;
}
ret |= fun(pos, sum + 4, lf - 1);
if (ret) {
ans[lf] += "4";
fun2(pos, sum + 4, lf - 1);
return;
}
ret |= fun(pos, sum + 7, lf - 1);
if (ret) {
ans[lf] += "7";
fun2(pos, sum + 7, lf - 1);
return;
}
}
string form(string s) {
string ret = "";
for (int i(0), _n(((int)(s.size()))); i < _n; ++i) {
if (s[i] == '0') {
if (((int)(ret.size()))) ret += s[i];
} else
ret += s[i];
}
if (!((int)(ret.size()))) return "0";
return ret;
}
int main() {
int test;
cin >> test;
for (int i(0), _n(test); i < _n; ++i) {
cin >> s;
reverse(s.begin(), s.end());
memset(dp, -1, sizeof(dp));
for (int i(0), _n(7); i < _n; ++i) ans[i] = "";
if (!fun(0, 0, 6)) {
cout << -1 << endl;
} else {
fun2(0, 0, 6);
for (int i(0), _n(7); i < _n; ++i) reverse(ans[i].begin(), ans[i].end());
for (int i(0), _n(6); i < _n; ++i) cout << form(ans[i + 1]) << " ";
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int S = 6;
const int P = 28;
map<int, pair<int, int> > od;
vector<int> get_poss() {
set<int> poss;
for (int i = 0; i <= S; i++)
for (int j = 0; i + j <= S; j++) {
poss.insert(i * 7 + j * 4);
od[i * 7 + j * 4] = make_pair(i, j);
}
return vector<int>(poss.begin(), poss.end());
}
vector<int> comb = get_poss();
const int K = 21;
const int D = 10;
int tab[6][K];
void solve(long long s) {
vector<int> poss[K][D];
int cyfry[K];
int z = 0;
while (s) {
int r = s % 10;
cyfry[z] = r;
s /= 10;
if (z) {
for (typeof((comb).begin()) it = ((comb).begin()); it != (comb).end();
++it) {
for (int i = 0; i < (10); ++i) {
if (!poss[z][i].empty())
if ((i + *it % 10) % 10 == r) {
poss[z + 1][(*it + i) / 10].push_back(*it);
}
}
}
} else {
for (typeof((comb).begin()) it = ((comb).begin()); it != (comb).end();
++it)
if (*it % 10 == r) {
poss[1][*it / 10].push_back(*it);
}
}
z++;
}
if (!poss[z][0].empty()) {
int cyf = 0;
for (int i = 0; i < (6); ++i)
for (int j = 0; j < (K); ++j) tab[i][j] = 0;
while (z - 1 >= 0) {
int w = poss[z][cyf][0];
pair<int, int> c = od[w];
for (int i = 0; i < (c.first); ++i) tab[i][z - 1] = 7;
for (int i = 0; i < (c.second); ++i) tab[i + c.first][z - 1] = 4;
cyf = (10 + cyfry[z - 1] - w % 10) % 10;
z--;
}
long long ans[6];
for (int i = 0; i < (6); ++i) {
long long pot = 1;
ans[i] = 0LL;
for (int j = 0; j < (K); ++j) {
ans[i] += tab[i][j] * pot;
pot *= 10;
}
cout << ans[i] << " ";
}
cout << endl;
return;
}
cout << -1 << endl;
}
int main() {
ios::sync_with_stdio(0);
get_poss();
long long a;
int t;
cin >> t;
for (int i = 0; i < (t); ++i) {
cin >> a;
solve(a);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t;
long long n;
bool dp[30][30];
pair<int, pair<int, int> > pre[30][30];
int ans[30][30];
inline void build(long long n) {
vector<int> d;
d.clear();
while (n) {
d.push_back(n % 10);
n /= 10;
}
while ((int)d.size() < 19) d.push_back(0);
reverse(d.begin(), d.end());
memset(dp, false, sizeof(dp));
dp[0][0] = true;
int give;
for (int i = 0; i < 19; i++)
for (int j = 0; j < 10; j++)
if (dp[i][j]) {
for (int k4 = 0; k4 <= 6; k4++)
for (int k7 = 0; k7 <= 6 - k4; k7++) {
if ((j + 4 * k4 + 7 * k7) % 10 != d[18 - i]) continue;
give = (j + 4 * k4 + 7 * k7) / 10;
dp[i + 1][give] = true;
pre[i + 1][give] = make_pair(j, make_pair(k4, k7));
}
}
if (!dp[19][0])
cout << "-1\n";
else {
memset(ans, 0, sizeof(ans));
int h = 0, f4, f7;
for (int i = 19; i; i--) {
f4 = pre[i][h].second.first;
f7 = pre[i][h].second.second;
for (int j = 1; j <= f4; j++) ans[j][i] = 4;
for (int j = f4 + 1; j <= f4 + f7; j++) ans[j][i] = 7;
h = pre[i][h].first;
}
int beg;
for (int i = 1; i <= 6; i++) {
beg = 19;
while (beg >= 1 && ans[i][beg] == 0) beg--;
if (beg < 1)
cout << "0 ";
else {
for (int j = beg; j >= 1; j--) cout << ans[i][j];
cout << " ";
}
}
cout << "\n";
}
}
int main() {
srand(time(0));
ios_base::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> n;
build(n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T Dist(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Chkbit(int N, int pos) { return (bool)(N & (1 << pos)); }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
long long int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
int ar[22], n, dp[20][10];
char s[22];
int Solve(int pos, int carry) {
if (pos == -1) {
return (!carry);
}
int &res = dp[pos][carry];
if (res != -1) return res;
res = 0;
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6; j++) {
if (i + j > 6) continue;
int tot = (carry + i * 4 + j * 7);
if (tot % 10 == ar[pos]) {
res |= Solve(pos - 1, tot / 10);
}
if (res) break;
}
if (res) break;
}
return res;
}
int Store[10][21];
void Path(int pos, int carry) {
if (pos == -1) {
return;
}
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6; j++) {
if (i + j > 6) continue;
int tot = (carry + i * 4 + j * 7);
if (tot % 10 == ar[pos]) {
int tp = Solve(pos - 1, tot / 10);
if (tp) {
int id = 0;
for (int k = 0; k < i; k++) Store[id++][pos] = 4;
for (int k = 0; k < j; k++) Store[id++][pos] = 7;
Path(pos - 1, tot / 10);
return;
}
}
}
}
}
int main() {
int t;
t = in<int>();
for (int cs = 1; cs < t + 1; cs++) {
scanf("%s", &s);
n = strlen(s);
for (int i = 0; i < n; i++) ar[i] = (s[i] - '0');
memset(dp, -1, sizeof(dp));
memset(Store, 0, sizeof(Store));
int ans = Solve(n - 1, 0);
if (ans) {
Path(n - 1, 0);
long long int Sum = 0;
for (int i = 0; i < 6; i++) {
long long int ans = 0;
for (int j = 0; j < n; j++) {
ans = ans * 10 + Store[i][j];
}
printf("%lld ", ans);
}
printf("\n");
} else {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
char S[20], A[6][22];
bool D[22][10];
int T[22][10], P[22][10];
int main() {
cin >> N;
for (int s = 1; s <= N; ++s) {
cin >> S;
int size;
for (size = 0; S[size] != 0; ++size)
;
memset(D, 0, sizeof(D));
D[0][0] = true;
for (int i = 0; i <= 19; ++i)
for (int j = 0; j <= 4; ++j)
if (D[i][j] == true) {
for (int x = 0; x <= 6; ++x)
for (int y = 0; x + y <= 6; ++y) {
int valnow = j + 4 * x + 7 * y;
if ((size - i - 1 < 0 && valnow % 10 == 0) ||
(size - i - 1 >= 0 && valnow % 10 == S[size - i - 1] - '0')) {
D[i + 1][valnow / 10] = true;
T[i + 1][valnow / 10] = j;
P[i + 1][valnow / 10] = 4 * x + 7 * y;
}
}
}
if (D[20][0] == true) {
int now = 20, aux = 0;
while (now != 0) {
for (int x = 0; x <= 6; ++x)
for (int y = 0; x + y <= 6; ++y)
if (4 * x + 7 * y == P[now][aux]) {
for (int k = 0; k < 6; ++k)
if (1 + k <= x)
A[k][now - 1] = '4';
else if (1 + k <= x + y)
A[k][now - 1] = '7';
else
A[k][now - 1] = '0';
}
aux = T[now][aux];
--now;
}
for (int k = 0; k < 6; ++k) {
reverse(A[k], A[k] + 20);
int begnow = 0;
while (begnow < 20 && A[k][begnow] == '0') ++begnow;
if (begnow == 20)
cout << 0 << ' ';
else
cout << A[k] + begnow << ' ';
}
cout << '\n';
} else
cout << -1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
int _max(int x, int y) { return x > y ? x : y; }
int _min(int x, int y) { return x < y ? x : y; }
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * f;
}
void put(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) put(x / 10);
putchar(x % 10 + '0');
}
struct node {
int x, c;
} last[20][10];
int sta[1000], tp;
vector<int> q[45];
int len, qq[20];
int f[20][10];
long long ll, pp[7];
void dfs(int k, int sum) {
if (k == 7) {
sta[++tp] = sum;
q[sum].clear();
for (int i = 1; i <= ll; i++) q[sum].push_back(pp[i]);
return;
}
pp[++ll] = 7, dfs(k + 1, sum + 7);
pp[ll] = 4, dfs(k + 1, sum + 4);
pp[ll] = 0, dfs(k + 1, sum), --ll;
}
int main() {
dfs(1, 0);
sort(sta + 1, sta + tp + 1);
tp = unique(sta + 1, sta + tp + 1) - (sta + 1);
int T = read();
while (T--) {
long long x = read();
len = 0;
while (x) qq[++len] = x % 10, x /= 10;
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (int i = 1; i <= len; i++) {
for (int j = 0; j <= 9; j++)
if (f[i - 1][j]) {
for (int k = 1; k <= tp; k++)
if ((sta[k] + j) % 10 == qq[i]) {
f[i][(sta[k] + j) / 10] = 1;
last[i][(sta[k] + j) / 10] = node{k, j};
}
}
}
if (!f[len][0])
puts("-1");
else {
int o = 0;
for (int i = len; i >= 1; i--) {
qq[i] = last[i][o].x;
o = last[i][o].c;
}
memset(pp, 0, sizeof(pp));
for (int i = len; i >= 1; i--) {
for (int j = 1; j <= 6; j++) pp[j] = pp[j] * 10 + q[sta[qq[i]]][j - 1];
}
for (int i = 1; i <= 6; i++) put(pp[i]), putchar(' ');
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename C, typename T = decay<decltype(*begin(declval<C>()))>,
typename enable_if<!is_same<C, string>::value>::type * = nullptr>
ostream &operator<<(ostream &os, const C &c) {
bool f = true;
os << "[";
for (const auto &x : c) {
if (!f) os << ", ";
f = false;
os << x;
}
return os << "]";
}
template <typename T>
void debug(string s, T x) {
cerr << s << " = " << x << "\n";
}
template <typename T, typename... Args>
void debug(string s, T x, Args... args) {
cerr << s.substr(0, s.find(',')) << " = " << x << " | ";
debug(s.substr(s.find(',') + 2), args...);
}
const int digits[] = {0, 4, 7};
set<int> dp[25];
map<int, array<int, 6>> par[25];
array<long long, 6> solve(const vector<int> &v) {
int n = v.size();
for (int i = 0; i <= n; i++) {
dp[i].clear();
par[i].clear();
}
dp[0].insert(0);
for (int i = 0; i < n; i++)
for (int j : dp[i])
for (int a : digits)
for (int b : digits)
for (int c : digits)
for (int d : digits)
for (int e : digits)
for (int f : digits) {
int sum = a + b + c + d + e + f + j;
if (sum % 10 == v[i]) {
dp[i + 1].insert(sum / 10);
par[i + 1][sum / 10] = {a, b, c, d, e, f};
}
}
if (!dp[n].count(0)) return {-1, -1, -1, -1, -1, -1};
array<long long, 6> ret{0, 0, 0, 0, 0, 0};
int carry = 0;
for (int i = n; i > 0; i--) {
assert(par[i].count(carry));
array<int, 6> &cur = par[i][carry];
carry = 10 * carry + v[i - 1];
for (int j = 0; j < 6; j++) {
ret[j] = 10 * ret[j] + cur[j];
carry -= cur[j];
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<int> v;
while (n > 0) {
v.push_back(n % 10);
n /= 10;
}
array<long long, 6> ret = solve(v);
if (ret[0] == -1) {
cout << "-1\n";
} else {
for (int i = 0; i < 6; i++) cout << ret[i] << " ";
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tg, ans[22];
int state[22][22], fa_inc[22][22], fa_n4[22][22], fa_n7[22][22];
int t, cs = 0, dg[22];
int main() {
scanf("%d", &t);
for (cs = 1; cs <= t; ++cs) {
scanf("%I64d", &tg);
for (int i = 0; i < 19; ++i) dg[i] = tg % 10, tg /= 10;
state[0][0] = cs;
for (int i = 0; i < 19; ++i) {
for (int j = 0; j < 10; ++j) {
if (state[i][j] != cs) continue;
for (int n4 = 0; n4 <= 6; ++n4) {
for (int n7 = 0; n7 + n4 <= 6; ++n7) {
int nj = (j + n4 * 4 + n7 * 7);
if (nj % 10 == dg[i]) {
state[i + 1][nj / 10] = cs;
fa_inc[i + 1][nj / 10] = j;
fa_n4[i + 1][nj / 10] = n4;
fa_n7[i + 1][nj / 10] = n7;
}
}
}
}
}
if (state[19][0] == cs) {
for (int i = 0; i < 6; ++i) ans[i] = 0;
for (int i = 19, j = 0; i > 0; --i) {
int n4 = fa_n4[i][j], n7 = fa_n7[i][j];
for (int pos = 0; pos < 6; ++pos) {
ans[pos] *= 10;
if (pos < n4)
ans[pos] += 4;
else if (pos < n4 + n7)
ans[pos] += 7;
}
j = fa_inc[i][j];
}
for (int i = 0; i < 5; ++i) printf("%I64d ", ans[i]);
printf("%I64d\n", ans[5]);
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int d[3] = {0, 4, 7};
set<int> ss;
bool flag[60];
vector<int> v[60], tmp, ans;
int t;
char n[30];
set<int> a[30];
void dfs(int k, int s) {
if (k == 6) {
ss.insert(s);
v[s] = tmp;
} else {
tmp.push_back(0);
dfs(k + 1, s);
tmp.pop_back();
tmp.push_back(4);
dfs(k + 1, s + 4);
tmp.pop_back();
tmp.push_back(7);
dfs(k + 1, s + 7);
tmp.pop_back();
}
}
void dfs2(int k, int md) {
if (k == 0) {
ans.push_back(*a[0].begin() - md);
return;
}
for (set<int>::iterator ai = a[k].begin(); ai != a[k].end(); ai++) {
int kk = *ai;
if (flag[kk - md]) {
ans.push_back(kk - md);
dfs2(k - 1, kk / 10);
return;
}
}
}
int main() {
tmp.clear();
dfs(0, 0);
memset(flag, false, sizeof(flag));
for (set<int>::iterator si = ss.begin(); si != ss.end(); si++) {
flag[*si] = true;
}
scanf("%d", &t);
int ca = 0;
while (t--) {
int len = 0;
scanf("%s", n);
len = strlen(n);
for (int i = 0; i < 20; i++) a[i].clear();
a[0].insert(n[0] - '0');
for (int i = 1; i < len; i++)
for (set<int>::iterator ai = a[i - 1].begin(); ai != a[i - 1].end();
ai++) {
int k = *ai;
for (int j = 0; j <= 4; j++)
if (k >= j && flag[k - j]) a[i].insert(j * 10 + n[i] - '0');
}
int pass = -1;
for (set<int>::iterator ai = a[len - 1].begin(); ai != a[len - 1].end();
ai++)
if (flag[*ai]) pass = *ai;
if (pass == -1)
puts("-1");
else {
ans.clear();
dfs2(len - 1, 0);
for (int k = 0; k < 6; k++) {
long long X = 0;
for (int i = ans.size() - 1; i >= 0; i--) X = X * 10 + v[ans[i]][k];
printf("%I64d", X);
if (k < 5) printf(" ");
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int rsp[20];
long long ls[20][50];
long long maxi[20];
int cnt = 0;
bool func(long long x, int i) {
if (i == 0) {
for (int j = 0; j < cnt; j++) {
if (x == ls[i][j]) {
rsp[i] = j;
return true;
}
}
} else {
for (int j = 0; j < cnt; j++) {
if (x - ls[i][j] >= 0 && x - ls[i][j] <= maxi[i - 1]) {
rsp[i] = j;
if (func(x - ls[i][j], i - 1)) return true;
}
}
}
return false;
}
pair<int, pair<int, int> > ls2[50];
long long g[10];
int main() {
for (int i = 0; i < 7; i++)
for (int j = 0; j < 7 - i; j++) {
ls2[cnt++] = make_pair(i * 4 + j * 7, make_pair(i, j));
}
sort(ls2, ls2 + cnt);
for (int i = 0; i < cnt; i++) ls[0][i] = ls2[i].first;
for (int i = 1; i < 18; i++) {
for (int j = 0; j < cnt; j++) {
ls[i][j] = ls[i - 1][j] * 10LL;
}
}
maxi[0] = ls[0][cnt - 1];
for (int i = 1; i < 18; i++) {
maxi[i] = maxi[i - 1] + ls[i][cnt - 1];
}
int cas;
scanf("%d", &cas);
for (int u = 0; u < cas; u++) {
long long v;
scanf("%lld", &v);
if (func(v, 17)) {
for (int i = 0; i < 6; i++) g[i] = 0;
for (int i = 0; i < 18; i++) {
int k7 = ls2[rsp[i]].second.second;
int k4 = ls2[rsp[i]].second.first;
for (int j = 0; j < k7; j++) g[j] += ls[i][2];
for (int j = k7; j < k7 + k4; j++) g[j] += ls[i][1];
}
for (int i = 0; i < 6; i++) {
if (i) printf(" ");
printf("%lld", g[i]);
}
printf("\n");
} else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long n;
scanf("%I64d", &n);
bool B[2][10] = {0};
long long a[2][10][6] = {0};
bool b = 0;
B[0][0] = 1;
long long pp = 1;
while (n > 0) {
for (int J = 0; J < 10; J++) {
if (!B[b][J]) {
continue;
}
B[b][J] = 0;
int p;
if (n % 10 < J) {
p = 1;
} else {
p = 0;
}
long long m = n - J;
for (int i = 0; i <= 6; i++) {
for (int j = 0; i + j <= 6; j++) {
int k = 4 * i + j * 7;
if (k % 10 == m % 10) {
int P = p + k / 10;
B[!b][P] = 1;
for (int l = 0; l < 6; l++) {
if (l < i) {
a[!b][P][l] = a[b][J][l] + pp * 4;
} else if (l < i + j) {
a[!b][P][l] = a[b][J][l] + pp * 7;
} else {
a[!b][P][l] = a[b][J][l];
}
}
}
}
}
}
n /= 10;
pp *= 10;
b = !b;
}
if (!B[b][0]) {
printf("-1\n");
} else {
for (int i = 0; i < 6; i++) {
printf("%I64d%c", a[b][0][i], i == 5 ? '\n' : ' ');
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int LUCKY[3] = {0, 4, 7};
const int BASE = 10;
class State {
public:
State() : digits(), sum(0) {
for (int i = 0; i < 6; ++i) digits[i] = 0;
}
State(int _digits[6]) : digits(), sum(0) {
for (int i = 0; i < 6; ++i) sum += (digits[i] = _digits[i]);
}
int Units() const { return sum % BASE; }
int Tens() const { return (sum / BASE) % BASE; }
int Sum() const { return sum; }
int GetDigit(const int index) const { return digits[index]; }
void SetDigit(const int index, const int value) {
sum -= digits[index];
digits[index] = value;
sum += digits[index];
}
private:
int digits[6], sum;
};
vector<State> Rules;
vector<int> Number, LuckyNumbers[6];
bool Solution;
void GenerateRules(const int n, State &state) {
if (n == 6) {
bool valid = true;
for (const auto &r : Rules)
if (r.Sum() == state.Sum()) valid = false;
if (valid) Rules.push_back(state);
return;
}
for (int i = 0; i < 3; ++i) {
state.SetDigit(n, LUCKY[i]);
GenerateRules(n + 1, state);
}
}
void GenerateRules() {
State state;
GenerateRules(0, state);
}
void Solve() {
int n = int(Number.size());
vector<vector<int> > dp =
vector<vector<int> >(n + 1, vector<int>(BASE, false));
vector<vector<int> > father =
vector<vector<int> >(n + 1, vector<int>(BASE, -1));
dp[0][0] = true;
for (int prefix = 0; prefix < n; ++prefix) {
for (int last = 0; last < BASE; ++last) {
if (!dp[prefix][last]) continue;
for (int i = 0; i < int(Rules.size()); ++i) {
State r = Rules[i];
if ((last + r.Units()) % BASE != Number[prefix]) continue;
dp[prefix + 1][r.Tens() + (last + r.Units()) / BASE] = true;
father[prefix + 1][r.Tens() + (last + r.Units()) / BASE] = i;
}
}
}
if (!dp[n][0]) {
Solution = false;
return;
}
Solution = true;
for (int i = 0; i < 6; ++i) LuckyNumbers[i] = vector<int>(n, 0);
for (int prefix = n, last = 0; prefix > 0; --prefix) {
State r = Rules[father[prefix][last]];
for (int i = 0; i < 6; ++i) LuckyNumbers[i][prefix - 1] = r.GetDigit(i);
last = (Number[prefix - 1] - r.Units() + BASE) % BASE;
}
}
void Read() {
string number;
cin >> number;
Number = vector<int>();
for (int i = int(number.length()) - 1; i >= 0; --i)
Number.push_back(int(number[i]) - int('0'));
}
void Print() {
if (!Solution) {
cout << "-1\n";
return;
}
for (int i = 0; i < 6; ++i) {
for (; int(LuckyNumbers[i].size()) > 1 && LuckyNumbers[i].back() == 0;
LuckyNumbers[i].pop_back())
;
for (int j = int(LuckyNumbers[i].size()) - 1; j >= 0; --j)
cout << LuckyNumbers[i][j];
cout << " ";
}
cout << "\n";
}
int main() {
GenerateRules();
int testCount;
cin >> testCount;
for (; testCount > 0; --testCount) {
Read();
Solve();
Print();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void quit() {
fflush(stdout);
exit(0);
}
long long int num;
int dig[50];
int poss[50];
int dp[50][10];
int bt[50][10];
int ans[6][50];
char buf[50];
int ndig;
void solve() {
cin >> num;
ndig = 0;
long long int tmp = num;
while (tmp) {
dig[ndig++] = tmp % 10;
tmp /= 10;
}
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 10; j++) dp[i][j] = -1;
}
memset(ans, 0, sizeof(ans));
dp[0][0] = 0;
for (int curdig = 0; curdig < ndig; curdig++) {
for (int carry = 0; carry < 10; carry++) {
if (dp[curdig][carry] < 0) continue;
for (int add = 0; add < 50; add++) {
if (poss[add] < 0) continue;
int realadd = add + carry;
if (realadd % 10 == dig[curdig]) {
dp[curdig + 1][realadd / 10] = add;
bt[curdig + 1][realadd / 10] = carry;
}
}
}
}
if (dp[ndig][0] < 0) {
cout << -1 << endl;
return;
}
int curcarry = 0;
for (int i = ndig; i > 0; i--) {
int add = dp[i][curcarry];
int n7 = poss[add] / 10, n4 = poss[add] % 10;
for (int j = 0; j < n7; j++) {
ans[j][i - 1] = 7;
}
for (int j = 0; j < n4; j++) {
ans[j + n7][i - 1] = 4;
}
curcarry = bt[i][curcarry];
}
for (int curnum = 0; curnum < 6; curnum++) {
int len = 0;
for (int i = 49; i >= 0; i--) {
if (ans[curnum][i]) {
len = i + 1;
break;
}
}
if (len == 0) {
cout << 0;
} else {
for (int i = 0; i < len; i++) {
buf[i] = '0' + ans[curnum][len - 1 - i];
}
buf[len] = 0;
cout << buf;
}
if (curnum == 5)
cout << endl;
else
cout << ' ';
}
}
int main(int argc, char** argv) {
for (int i = 0; i < 50; i++) {
poss[i] = -1;
}
for (int n0 = 0; n0 <= 6; n0++) {
for (int n4 = 0; n4 <= 6 - n0; n4++) {
int n7 = 6 - n0 - n4;
int num = n4 * 4 + n7 * 7;
poss[num] = 10 * n7 + n4;
}
}
int nC;
cin >> nC;
while (nC--) solve();
quit();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T __in() {
T v;
cin >> v;
return v;
}
string num;
int dp[20][20];
int call(int p, int c) {
if (p == ((int)num.size())) return c == 0;
int &ret = dp[p][c];
if (ret != -1) return ret;
ret = 0;
for (int f = 0; f <= 6; f++)
for (int s = 0; s + f <= 6; s++) {
int sum = (f)*4 + (s)*7 + c;
if (sum % 10 == num[p] - '0')
if (call(p + 1, sum / 10)) return ret = 1;
}
return ret;
}
void solve() {
memset((dp), (-1), sizeof(dp));
;
if (!call(0, 0)) {
cout << -1 << endl;
return;
}
int p = 0, c = 0;
string ans[6];
while (p < ((int)num.size())) {
for (__typeof(7) f = 0; f < (7); f++) {
int found = 0;
for (int s = 0; s + f < 7; s++) {
int sum = f * 4 + s * 7 + c;
if (sum % 10 == num[p] - '0' && call(p + 1, sum / 10)) {
found = 1;
int k = 0;
while (k < f) ans[k++] += '4';
while (k < s + f) ans[k++] += '7';
while (k < 6) ans[k++] += '0';
c = sum / 10;
p++;
break;
}
}
if (found) break;
}
}
for (__typeof(6) i = 0; i < (6); i++) reverse(ans[i].begin(), ans[i].end());
for (__typeof(6) i = 0; i < (6); i++) {
if (i) cout << " ";
int f = 0;
for (__typeof(((int)ans[i].size())) j = 0; j < (((int)ans[i].size()));
j++) {
if (ans[i][j] != '0') f = 1;
if (f) cout << ans[i][j];
}
if (!f) cout << 0;
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
int test;
cin >> test;
while (test--) {
cin >> num;
reverse(num.begin(), num.end());
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 20;
int t;
int n;
int digits[N_MAX];
int lucky[] = {0, 4, 7};
bool dp[N_MAX][5];
tuple<int, int, int, int, int, int> step[N_MAX][5];
int prevt[N_MAX][5];
long long ans[7];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
long long val;
cin >> val;
n = 0;
while (val > 0) {
digits[++n] = val % 10;
val /= 10;
}
for (int i = 0; i <= n; i++)
for (int t = 0; t <= 4; t++) dp[i][t] = false;
dp[0][0] = true;
for (int i = 0; i < n; i++)
for (int t = 0; t <= 4; t++)
if (dp[i][t] == true) {
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++) {
int sum = lucky[a] + lucky[b] + lucky[c] + lucky[d] +
lucky[e] + lucky[f] + t;
if (sum % 10 == digits[i + 1]) {
dp[i + 1][sum / 10] = true;
step[i + 1][sum / 10] = make_tuple(a, b, c, d, e, f);
prevt[i + 1][sum / 10] = t;
}
}
}
if (dp[n][0] == true) {
long long p10 = 1;
for (int i = 1; i < n; i++) p10 *= 10;
for (int i = 1; i <= 6; i++) ans[i] = 0;
int pos = n;
int t = 0;
while (pos > 0) {
int a, b, c, d, e, f;
tie(a, b, c, d, e, f) = step[pos][t];
ans[1] += lucky[a] * p10;
ans[2] += lucky[b] * p10;
ans[3] += lucky[c] * p10;
ans[4] += lucky[d] * p10;
ans[5] += lucky[e] * p10;
ans[6] += lucky[f] * p10;
p10 /= 10;
t = prevt[pos][t];
pos--;
}
for (int i = 1; i <= 6; i++) cout << ans[i] << " ";
cout << "\n";
} else
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:33554432")
using namespace std;
const int a[3] = {0, 4, 7};
int n;
char num[1 << 5];
int len;
int used[20][6];
int path[20][6][6];
int M[1 << 8];
int C[1 << 8];
int go(int pos, int carry) {
if (pos == -1) return carry == 0;
if (used[pos][carry]) return 0;
used[pos][carry] = 1;
for (int i1 = 0; i1 < 3; ++i1)
for (int i2 = i1; i2 < 3; ++i2)
for (int i3 = i2; i3 < 3; ++i3)
for (int i4 = i3; i4 < 3; ++i4)
for (int i5 = i4; i5 < 3; ++i5)
for (int i6 = i5; i6 < 3; ++i6) {
int s = a[i1] + a[i2] + a[i3] + a[i4] + a[i5] + a[i6] + carry;
if (M[s] == num[pos] - '0') {
if (go(pos - 1, C[s])) {
path[pos][carry][0] = i1;
path[pos][carry][1] = i2;
path[pos][carry][2] = i3;
path[pos][carry][3] = i4;
path[pos][carry][4] = i5;
path[pos][carry][5] = i6;
return 1;
}
}
}
return 0;
}
long long nums[6];
int main() {
scanf("%d", &n);
for (int i = 0; i < 1 << 8; ++i) {
C[i] = i / 10;
M[i] = i % 10;
}
for (int i = 0; i < n; ++i) {
scanf("%s", num);
int len = strlen(num);
memset(used, 0, sizeof(used));
if (!go(len - 1, 0))
printf("-1\n");
else {
int pos = len - 1;
int carry = 0;
memset(nums, 0, sizeof(nums));
long long cur = 1;
while (pos >= 0) {
int to = 0;
for (int j = 0; j < 6; ++j) {
nums[j] += cur * a[path[pos][carry][j]];
to += a[path[pos][carry][j]];
}
to += carry;
pos--;
carry = to / 10;
cur *= 10;
}
for (int i = 0; i < 6; ++i) printf("%I64d ", nums[i]);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[100];
long long base[20];
struct NODE {
int a, i4, i7;
NODE(int i, int j) {
i4 = i;
i7 = j;
a = i4 * 4 + i7 * 7;
};
bool operator<(const NODE &x) const { return a < x.a; };
};
vector<NODE> v;
int way[100];
bool dfs(long long remain, int a) {
if (a == 0) {
if ((remain == 0)) return true;
return false;
}
if (remain > f[a]) return false;
for (int i = 0; i < v.size(); ++i) {
if (remain < v[i].a * base[a]) break;
way[a] = i;
if (dfs(remain - v[i].a * base[a], a - 1)) return true;
}
return false;
}
void gao(long long x) {
if (!dfs(x, 18)) {
printf("-1\n");
return;
}
long long ret[10] = {0};
for (int i = 1, now = 0; i <= 18; ++i) {
int k = way[i];
for (int j = 0; j < v[k].i4; ++j) {
ret[now] += base[i] * 4;
now = (now + 1) % 6;
}
for (int j = 0; j < v[k].i7; ++j) {
ret[now] += base[i] * 7;
now = (now + 1) % 6;
}
}
for (int i = 0; i < 6; ++i) cout << ret[i] << ((i == 5) ? '\n' : ' ');
}
int main() {
int n;
for (int i = 0; i <= 6; ++i)
for (int j = 0; j + i <= 6; ++j) v.push_back(NODE(i, j));
sort(v.begin(), v.end());
for (int i = 1; i <= 18; ++i) {
f[i] = f[i - 1] * 10 + 42;
if (i == 1)
base[i] = 1;
else
base[i] = base[i - 1] * 10;
}
int t;
while (cin >> t) {
for (int i = 0; i < t; ++i) {
long long x;
cin >> x;
gao(x);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int T;
bool f[20][5];
long long n, m, a[20], ans[20][5][7], b[7], ten[18];
void dfs(int i, int t, int S) {
int k, p;
if (t > 6) {
p = a[i] - S % 10;
if (p < 0) p += 10;
if (p <= 4 && f[i - 1][p]) {
f[i][(S + p) / 10] = 1;
for (k = 1; k <= 6; k++)
ans[i][(S + p) / 10][k] = ans[i - 1][p][k] + ten[i - 1] * b[k];
}
return;
}
b[t] = 0, dfs(i, t + 1, S);
b[t] = 7, dfs(i, t + 1, S + 7);
b[t] = 4, dfs(i, t + 1, S + 4);
b[t] = 0;
}
void work() {
int i;
scanf("%I64d", &n), m = 0;
while (n) a[++m] = n % 10, n /= 10;
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (i = 1; i <= m; i++) dfs(i, 1, 0);
if (!f[m][0])
printf("-1\n");
else {
for (i = 1; i <= 6; i++)
printf(
"%I64d"
" ",
ans[m][0][i]);
printf("\n");
}
}
int main() {
int i;
cin >> T;
ten[0] = 1;
for (i = 1; i <= 19; i++) ten[i] = ten[i - 1] * 10;
while (T--) work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
string way[25][50];
bool dp[25][50];
int add, a[] = {0, 4, 7};
string tmp;
vector<pair<string, int> > rec;
void dfs(int pos) {
if (pos == 6) {
rec.push_back(make_pair(tmp, add));
return;
}
for (int i = 0; i < 3; i++) {
add += a[i];
tmp[pos] = (char)('0' + a[i]);
dfs(pos + 1);
add -= a[i];
}
}
int main() {
int cas;
tmp = string(6, '0');
add = 0;
dfs(0);
cin >> cas;
while (cas--) {
string str;
cin >> str;
str = '0' + str;
reverse(str.begin(), str.end());
int n = (int)str.size();
memset(dp, false, sizeof(dp));
dp[0][0] = true;
int mx = 0;
way[0][0] = string(200, '0');
for (int i = 0; i < n; i++) {
for (int j = 0; j <= mx; j++) {
if (!dp[i][j]) continue;
for (int k = 0; k < (int)rec.size(); k++) {
pair<string, int> &tmp = rec[k];
int mod = (j + tmp.second) % 10;
if (mod != (int)(str[i] - '0')) continue;
int newj = (j + tmp.second) / 10;
mx = max(mx, newj);
if (dp[i + 1][newj]) continue;
dp[i + 1][newj] = true;
string newStr = way[i][j];
for (int a = 0; a < 6 && a * n + i < 200; a++) {
newStr[a * n + i] = tmp.first[a];
}
way[i + 1][newj] = newStr;
}
}
}
if (!dp[n][0])
puts("-1");
else {
string s = way[n][0];
for (int i = 0; i < 6; i++) {
string tmp = "";
for (int j = 0; j < n; j++) {
tmp += s[i * n + j];
}
reverse(tmp.begin(), tmp.end());
int j = 0;
while (j < (int)tmp.size() && tmp[j] == '0') j++;
if (j == (int)tmp.size())
putchar('0');
else
cout << tmp.substr(j, (int)tmp.size() - j);
cout << (i == 5 ? '\n' : ' ');
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const double PI = acos(-1.0);
const int MAX = 1e5 + 5;
int T;
long long N;
int A[50][6];
int C[6];
int dig[19];
bool vis[19][50];
int dp[19][50][6];
int res[19][6];
void get(int k) {
if (k == 6) {
int sum = 0;
for (int i = 0; i < 6; i++) {
sum += C[i];
}
if (A[sum][0] != -1) return;
for (int i = 0; i < 6; i++) {
A[sum][i] = C[i];
}
return;
}
C[k] = 0;
get(k + 1);
C[k] = 4;
get(k + 1);
C[k] = 7;
get(k + 1);
}
bool getdp(int k, int a) {
if (a >= 50) {
return false;
}
if (k == -1) return (a == 0);
if (vis[k][a]) {
if (dp[k][a][0] == -1) return false;
return true;
}
a += dig[k];
vis[k][a] = true;
for (int i = 0; i <= a; i++) {
if (A[i][0] == -1) continue;
for (int j = 0; j < 6; j++) {
res[k][j] = A[i][j];
}
bool ok = getdp(k - 1, 10 * (a - i));
if (ok) {
return true;
}
}
return false;
}
void solve() {
memset(dp, -1, sizeof(dp));
memset(vis, 0, sizeof(vis));
for (int j = 0; j < 19; j++) {
dig[j] = N % 10;
N /= 10;
}
bool ok = getdp(18, 0);
if (!ok) {
cout << "-1\n";
return;
}
for (int i = 0; i < 6; i++) {
long long v = 0;
for (int j = 18; j >= 0; j--) {
v = v * 10 + res[j][i];
}
cout << v << " ";
}
cout << '\n';
}
int main() {
memset(A, -1, sizeof(A));
get(0);
cin >> T;
for (int i = 0; i < T; i++) {
cin >> N;
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
map<long long, bool> MP;
int deg[10], a[10][10], b[10][10];
int aa[30], bb[30];
bool find(long long x, int k) {
if (MP.count(x)) return false;
int i, j;
if (x == 0) {
long long ans[10];
memset(ans, 0, sizeof(ans));
for (i = k - 1; i >= 0; i--) {
j = 0;
while (aa[i]) {
ans[j] = ans[j] * 10 + 4;
j++;
aa[i]--;
}
while (bb[i]) {
ans[j] = ans[j] * 10 + 7;
j++;
bb[i]--;
}
while (j < 6) {
ans[j] = ans[j] * 10;
j++;
}
}
for (i = 0; i < 6; i++) {
if (i) printf(" ");
printf("%I64d", ans[i]);
}
puts("");
return true;
}
long long xx;
MP[x] = false;
j = x % 10;
for (i = 0; i < deg[j]; i++) {
aa[k] = a[j][i];
bb[k] = b[j][i];
xx = x - aa[k] * 4 - bb[k] * 7;
if (xx < 0) continue;
if (find(xx / 10, k + 1)) return true;
}
return false;
}
int main() {
int i, j, k, t, T;
long long N;
for (j = 0; j <= 6; j++)
for (k = 0; k + j <= 6; k++) {
i = (j * 4 + k * 7) % 10;
a[i][deg[i]] = j;
b[i][deg[i]] = k;
deg[i]++;
}
for (scanf("%d", &T); T--;) {
scanf("%I64d", &N);
MP.clear();
if (!find(N, 0)) puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T;
int fours[100];
int sevens[100];
bool ok[100];
int dp[100][10];
int pc[100][10];
int main() {
for (int f = 0; f <= 6; ++f) {
for (int s = 0; s + f <= 6; ++s) {
int val = f * 4 + s * 7;
ok[val] = true;
fours[val] = f;
sevens[val] = s;
}
}
scanf("%d", &T);
for (int i = 0; i < T; ++i) {
long long num;
scanf("%I64d", &num);
for (int i = 0; i < 5; ++i) {
dp[0][i] = -1;
}
dp[0][0] = 0;
int d = 1;
while (num != 0) {
int dig = num % 10;
num /= 10;
for (int i = 0; i < 5; ++i) {
dp[d][i] = -1;
}
for (int oldcarry = 0; oldcarry < 5; ++oldcarry) {
if (dp[d - 1][oldcarry] != -1) {
for (int newcarry = 0; newcarry < 5; ++newcarry) {
int needed = dig + 10 * newcarry - oldcarry;
if (needed >= 0 && ok[needed]) {
dp[d][newcarry] = needed;
pc[d][newcarry] = oldcarry;
}
}
}
}
++d;
}
--d;
if (dp[d][0] != -1) {
long long results[6] = {0, 0, 0, 0, 0, 0};
for (int cc = 0; d > 0; --d) {
int current = dp[d][cc];
for (int i = 0; i < 6; ++i) results[i] *= 10;
for (int i = 0; i < fours[current]; ++i) results[i] += 4;
for (int i = 0; i < sevens[current]; ++i)
results[i + fours[current]] += 7;
cc = pc[d][cc];
}
printf("%I64d %I64d %I64d %I64d %I64d %I64d\n", results[0], results[1],
results[2], results[3], results[4], results[5]);
} else {
printf("-1\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long> failed;
vector<int> prec[10][5];
void go(long long x, vector<long long> &res) {
if (x < 0 || failed.find(x) != failed.end()) return;
if (x == 0) {
res = vector<long long>(6, 0);
return;
}
int last = x % 10;
for (int i = 0; i < 5; i++)
if (!prec[last][i].empty()) {
go((x - last) / 10 - i, res);
if (!res.empty()) {
for (int j = 0; j < 6; j++) res[j] = 10 * res[j] + prec[last][i][j];
return;
}
}
failed.insert(x);
}
int main() {
for (int i = 0; i < 3 * 3 * 3 * 3 * 3 * 3; i++) {
vector<int> v;
int sum = 0;
int t = i;
for (int j = 0; j < 6; j++) {
int x = t % 3;
t /= 3;
if (x == 1)
x = 4;
else if (x == 2)
x = 7;
v.push_back(x);
sum += x;
}
prec[sum % 10][sum / 10] = v;
}
int tst;
scanf("%d", &tst);
while (tst-- > 0) {
failed.clear();
long long x;
scanf("%lld", &x);
vector<long long> res;
go(x, res);
if (res.empty()) {
printf("-1\n");
continue;
}
for (int i = 0; i < 6; i++)
printf(
"%lld"
"%c",
res[i], " \n"[i == 5]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
long long w;
};
long long MOD = 1000000007;
long long _MOD = 1000000009;
double EPS = 1e-10;
bool f(int i, int c, vector<int>& a, vector<vector<bool> >& vis,
vector<unsigned long long>& b) {
if (i == 19) return !c;
if (vis[i][c]) return false;
vis[i][c] = true;
for (int x = 0; x <= 6; x++)
for (int y = x; y <= 6; y++) {
int z = (y - x) * 4 + (6 - y) * 7 + c;
if (z % 10 == a[i] && f(i + 1, z / 10, a, vis, b)) {
for (int k = 0; k < 6; k++) {
b[k] *= 10;
if (x <= k && k < y) b[k] += 4;
if (y <= k) b[k] += 7;
}
return true;
}
}
return false;
}
int main() {
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
vector<int> a(19);
for (int t = 0; t < 19; t++) {
a[t] = n % 10;
n /= 10;
}
vector<vector<bool> > vis(19, vector<bool>(10));
vector<unsigned long long> b(6);
if (f(0, 0, a, vis, b)) {
for (int k = 0; k < 6; k++) cout << b[k] << ' ';
cout << endl;
} else
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string second;
int dp[20][12];
long long lucky[] = {0, 4, 7};
string s1, s2, s3, s4, s5, s6;
void printer(string second) {
long long ans = 0;
for (int i = second.size() - 1; i >= 0; i--) {
ans = ans * 10LL + (second[i] - '0');
}
cout << ans << " ";
}
bool done;
int ways(int n, int rem) {
if (done) {
return 1;
}
if (n == second.size() && rem == 0) {
printer(s1), printer(s2);
printer(s3), printer(s4);
printer(s5), printer(s6);
done = true;
return 1;
}
if (n == second.size()) {
return 0;
}
if (dp[n][rem] != -1) {
return dp[n][rem];
}
int ans = 0;
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 x = rem + lucky[a] + lucky[b] + lucky[c] + lucky[d] +
lucky[e] + lucky[first];
if ((x % 10) == (second[n] - '0') && !done) {
string alt1 = s1, alt2 = s2, alt3 = s3, alt4 = s4, alt5 = s5,
alt6 = s6;
s1 += lucky[a] + '0';
s2 += lucky[b] + '0';
s3 += lucky[c] + '0';
s4 += lucky[d] + '0';
s5 += lucky[e] + '0';
s6 += lucky[first] + '0';
ans += ways(n + 1, x / 10);
s1 = alt1;
s2 = alt2;
s3 = alt3;
s4 = alt4;
s5 = alt5;
s6 = alt6;
}
}
}
}
}
}
}
return dp[n][rem] = ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> second;
reverse(second.begin(), second.end());
memset(dp, -1, sizeof dp);
done = false;
ways(0, 0);
if (!done) {
cout << "-1";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 20, A = 7;
long long int n;
deque<long long int> a;
deque<pair<long long int, long long int> > p[10];
void Quay(long long int l, long long int h, long long int sum,
long long int mask) {
if (l > h) {
p[sum % 10].push_back({sum, mask});
} else {
Quay(l + 1, h, sum, mask * 10);
Quay(l + 1, h, sum + 4, mask * 10 + 4);
Quay(l + 1, h, sum + 7, mask * 10 + 7);
}
}
void Inp() {
cin >> n;
a.clear();
a.push_back(0);
for (int i = 1; i < N; i++) {
a.push_back(n % 10);
n = n / 10;
}
}
long long int dp[N][A], trace[N][A];
void Solve() {
fill_n(&dp[0][0], sizeof(dp) / sizeof(dp[0][0]), -1);
dp[0][0] = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < A; j++) {
if (dp[i][j] != -1) {
long long int vt = (a[i + 1] - j + 100) % 10;
for (auto v : p[vt]) {
long long int k = v.first + j;
if ((k % 10) == a[i + 1]) {
dp[i + 1][k / 10] = v.second;
trace[i + 1][k / 10] = j;
}
}
}
}
}
}
deque<long long int> ans[7];
void Add(long long int k) {
for (int i = 1; i <= 6; i++) {
ans[i].push_front(k % 10);
k = k / 10;
}
}
void Out() {
for (int i = 1; i <= 6; i++) {
while (ans[i].size() > 1) {
if (ans[i].back() == 0) {
ans[i].pop_back();
} else {
break;
}
}
for (int j = ans[i].size() - 1; j >= 0; j--) {
putchar(ans[i][j] + '0');
}
putchar(' ');
}
putchar('\n');
}
void Trace() {
if (dp[N - 1][0] == -1) {
putchar('-');
putchar('1');
putchar('\n');
return;
}
for (int i = 1; i <= 6; i++) {
ans[i].clear();
}
long long int k = 0;
for (int i = N - 1; i > 0; i--) {
Add(dp[i][k]);
k = trace[i][k];
}
Out();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T;
cin >> T;
Quay(1, 6, 0, 0);
while (T--) {
Inp();
Solve();
Trace();
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct num_6 {
int a[10];
};
vector<num_6> act;
string dest[10];
vector<int> num;
num_6 glo;
int val[] = {0, 4, 7};
set<int> myset;
void rec(int i, int j, int nu) {
if (i == 3) return;
if (j == 6) {
if (myset.count(nu) == 0) {
myset.insert(nu);
num.push_back(nu);
act.push_back(glo);
}
return;
}
rec(i + 1, j, nu);
glo.a[j] = val[i];
rec(i, j + 1, nu + val[i]);
}
string str;
int dp[22][11], len;
int memoize(int dig, int cary) {
if (dig == -1 && !cary) return 1;
if (dig < 0) return 0;
if (dp[dig][cary] != -1) return dp[dig][cary];
int ans = 0;
for (int i = int(0); i <= int(27); i++) {
if (str[dig] - '0' == (cary + num[i]) % 10)
ans |= memoize(dig - 1, (cary + num[i]) / 10);
if (ans) break;
}
return dp[dig][cary] = ans;
}
void print(int dig, int cary) {
if (dig == -1) return;
for (int i = int(0); i <= int(27); i++) {
if (str[dig] - '0' == (cary + num[i]) % 10) {
if (memoize(dig - 1, (cary + num[i]) / 10)) {
for (int j = int(0); j <= int(5); j++) {
dest[j] += ('0' + act[i].a[j]);
}
print(dig - 1, (cary + num[i]) / 10);
break;
}
}
}
}
int main() {
rec(0, 0, 0);
int t;
scanf("%d", &t);
while (t--) {
memset(dp, -1, sizeof(dp));
cin >> str;
len = str.length();
int ans = memoize(len - 1, 0);
if (ans) {
for (int i = int(0); i <= int(6); i++) dest[i] = "";
print(len - 1, 0);
for (int i = int(0); i <= int(5); i++) {
reverse(dest[i].begin(), dest[i].end());
int j = 0;
int len = dest[i].length();
while (j <= len - 2) {
if (dest[i][j] != '0') break;
j++;
}
for (int k = int(j); k <= int(len - 1); k++) {
printf("%c", dest[i][k]);
}
printf(" ");
}
printf("\n");
} else {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100][4];
int all;
unsigned long long M;
int d[100], np;
unsigned long long te[100];
void prework() {
all = 0;
for (int i = 0; i <= 6; i++)
for (int j = 0; j <= 6 - i; j++) {
int k = 6 - i - j;
a[++all][0] = j * 4 + k * 7;
a[all][1] = i;
a[all][2] = i + j;
a[all][3] = i + j + k;
}
te[0] = 1;
for (int i = 1; i <= 18; i++) te[i] = te[i - 1] * 10;
}
bool check(unsigned long long a, unsigned long long b, int p) {
int aa = a / te[p - 1] % 10;
int bb = b / te[p - 1] % 10;
return aa == bb;
}
bool work(unsigned long long mul, unsigned long long now, int p) {
if (mul == now) return true;
for (int i = 1; i <= all; i++) {
if (mul - now < a[i][0] * te[p]) continue;
unsigned long long ne = now + a[i][0] * te[p];
if (!check(mul, ne, p + 1)) continue;
d[p] = i;
np = p;
if (work(mul, ne, p + 1)) return true;
}
return false;
}
int dig[6][20];
void output() {
for (int i = 0; i <= np; i++) {
for (int j = 0; j < a[d[i]][1]; j++) dig[j][i] = 0;
for (int j = a[d[i]][1]; j < a[d[i]][2]; j++) dig[j][i] = 4;
for (int j = a[d[i]][2]; j < a[d[i]][3]; j++) dig[j][i] = 7;
}
for (int i = 0; i < 6; i++) {
unsigned long long now = 0;
for (int j = 0; j <= np; j++) now += te[j] * dig[i][j];
cout << now << " ";
}
cout << endl;
}
int main() {
prework();
int T;
cin >> T;
unsigned long long N;
while (T--) {
memset(dig, 0, sizeof(dig));
cin >> N;
if (work(N, 0, 0))
output();
else
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
int f[20][4], sw;
int go(long long n, int K) {
int w;
if (n == 0) {
sw = 1;
long long d[6], j = 1;
memset(d, 0, sizeof(d));
for (int i = 0; i < K; i++, j *= 10) {
w = 0;
while (f[i][0]) d[w++] += 4 * j, f[i][0]--;
while (f[i][1]) d[w++] += 7 * j, f[i][1]--;
}
for (int i = 0; i < 6; i++) printf("%I64d ", d[i]);
printf("\n");
return 1;
}
long long k = n % 10;
for (int i = 0; i <= 6; i++) {
for (int j = 0; i + j <= 6; j++) {
long long w = i * 4 + j * 7;
if (w % 10 == k && n >= w) {
f[K][0] = i;
f[K][1] = j;
f[K][2] = 6 - (i + j);
go((n - w) / 10, K + 1);
if (sw) return 1;
}
}
}
return 0;
}
int main() {
int runs;
for (scanf("%d", &runs); runs--;) {
long long n;
sw = 0;
scanf("%I64d", &n);
if (!go(n, 0)) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[20];
int mem[20][5];
int cat[20][5];
int mnz[20][5];
int mns[20][5];
int dp(int id, int c) {
if (id == 20) return c == 0;
if (cat[id][c]) return mem[id][c];
for (int i = 0; i <= 6; ++i) {
for (int j = 0; j + i <= 6; ++j) {
int nz = i, ns = j, nf = 6 - nz - ns;
int d = c * 10 + arr[id];
int s = ns * 7 + nf * 4;
if (s > d) continue;
if (d - s > 4) continue;
if (dp(id + 1, d - s)) {
cat[id][c] = 1;
mnz[id][c] = nz;
mns[id][c] = ns;
return mem[id][c] = true;
}
}
}
cat[id][c] = 1;
return mem[id][c] = false;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
long long n;
cin >> n;
for (int i = 19; i >= 0; --i) {
arr[i] = n % 10;
n /= 10;
}
memset(cat, 0, sizeof(cat));
int t = dp(0, 0);
if (t == 0) {
cout << -1 << endl;
} else {
int id = 0, c = 0;
long long arr2[] = {0, 0, 0, 0, 0, 0};
while (id < 20) {
int nz = mnz[id][c];
int ns = mns[id][c];
int nf = 6 - nz - ns;
for (int i = 0; i < nz; ++i) arr2[i] = 10 * arr2[i] + 0;
for (int i = nz; i < nz + nf; ++i) arr2[i] = 10 * arr2[i] + 4;
for (int i = nz + nf; i < nz + nf + ns; ++i) arr2[i] = 10 * arr2[i] + 7;
c = 10 * c + arr[id] - 4 * nf - 7 * ns;
id++;
}
for (int i = 0; i < 6; ++i) cout << arr2[i] << " ";
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-12;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
string s;
long long ans[7];
set<pair<int, int> > was;
inline bool rec(int v, int add) {
if (was.count(make_pair(v, add))) return false;
was.insert(make_pair(v, add));
if (v == s.size()) {
return add == 0;
}
for (int zeroes = 0; zeroes < 7; zeroes++) {
for (int fours = 0; fours + zeroes < 7; fours++) {
int sevens = 6 - fours - zeroes;
int val = sevens * 7 + fours * 4 + add;
if (val % 10 == s[v] - '0') {
if (rec(v + 1, val / 10)) {
for (int i = 0; i < zeroes; i++) ans[i] *= 10;
for (int i = zeroes; i < zeroes + fours; i++)
ans[i] = ans[i] * 10 + 4;
for (int i = zeroes + fours; i < 6; i++) ans[i] = ans[i] * 10 + 7;
return true;
}
}
}
}
return false;
}
void Solve() {
cin >> s;
reverse((s).begin(), (s).end());
memset(ans, 0, sizeof ans);
was.clear();
if (rec(0, 0)) {
for (long long(i) = 0; (i) < (long long)(6); (i)++) cout << ans[i] << " ";
cout << endl;
} else
puts("-1");
}
int main(void) {
int T;
scanf("%d", &T);
for (long long(i) = 0; (i) < (long long)(T); (i)++) Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[100];
int sum[1000];
int bit[100][10], a[10];
int b[100];
int cnt = 0;
int dp[30][20];
int pre[30][20], rem[30][20];
void dfs(int d, int s) {
if (d == 6) {
if (vis[s]) return;
vis[s] = 1;
sum[cnt] = s;
memcpy(bit[cnt], a, sizeof(a));
cnt++;
return;
}
a[d] = 0;
dfs(d + 1, s + 0);
a[d] = 4;
dfs(d + 1, s + 4);
a[d] = 7;
dfs(d + 1, s + 7);
}
long long ans[10];
int main() {
dfs(0, 0);
int T, n;
long long x;
scanf("%d", &T);
while (T--) {
n = 0;
cin >> x;
while (x) {
b[++n] = x % 10;
x /= 10;
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int nn = 20;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= 10; ++j)
if (dp[i - 1][j]) {
for (int k = 0; k < cnt; ++k) {
x = sum[k] + j;
if (x % 10 != b[i]) continue;
dp[i][x / 10] |= dp[i - 1][j];
pre[i][x / 10] = (i - 1) * nn + j;
rem[i][x / 10] = k;
}
}
if (dp[n][0]) {
memset(ans, 0, sizeof(ans));
int x, y, k;
k = rem[n][0];
for (int i = 0; i < 6; ++i) {
ans[i] = bit[k][i];
}
x = pre[n][0];
while (x) {
y = x % nn, x = x / nn;
k = rem[x][y];
for (int i = 0; i < 6; ++i) {
ans[i] = 10 * ans[i] + bit[k][i];
}
x = pre[x][y];
}
long long haha = 0;
for (int i = 0; i < 6; ++i) {
haha += ans[i];
cout << ans[i] << " ";
}
cout << endl;
} else
puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int opt[N][N], pre[N][N][3], a[N], len;
long long ans[N];
int main() {
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
len = 0;
for (; n; n /= 10) a[++len] = n % 10;
memset(opt, 0, sizeof opt);
memset(ans, 0, sizeof ans);
opt[0][0] = 1;
for (int i = 0; i < len; ++i)
for (int j = 0; j < 5; ++j)
if (opt[i][j])
for (int x = 0; x <= 6; ++x)
for (int y = 0; x + y <= 6; ++y) {
int sum = j + x * 4 + y * 7, nj = sum / 10;
if (sum % 10 == a[i + 1])
opt[i + 1][nj] = 1, pre[i + 1][nj][0] = j,
pre[i + 1][nj][1] = x, pre[i + 1][nj][2] = y;
}
if (opt[len][0]) {
for (int i = len, j = 0; i > 0; --i) {
int x = pre[i][j][1], y = pre[i][j][2];
for (int k = 0; k < x; ++k) ans[k] = ans[k] * 10 + 4;
for (int k = x; k < x + y; ++k) ans[k] = ans[k] * 10 + 7;
for (int k = x + y; k < 6; ++k) ans[k] = ans[k] * 10;
j = pre[i][j][0];
}
for (int k = 0; k < 6; ++k) printf(k == 5 ? "%I64d\n" : "%I64d ", ans[k]);
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[50100][10], cnt, p[110][10], val[110];
bool fg[50100];
int T;
long long m;
void pre() {
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6 - i; j++) {
for (int id = 0; id < 6; id++) {
if (id < i) {
p[cnt][id] = 0;
continue;
}
if (id < i + j) {
p[cnt][id] = 4;
val[cnt] += 4;
continue;
}
p[cnt][id] = 7;
val[cnt] += 7;
}
cnt++;
}
}
fg[0] = 1;
for (int dit = 1; dit <= 4; dit++) {
for (int j = 0; j < 50100; j++)
if (fg[j]) {
for (int k = 0; k < cnt; k++) {
int xx = j * 10 + val[k];
if (xx >= 50100 || fg[xx]) continue;
fg[xx] = true;
for (int t = 0; t < 6; t++) dp[xx][t] = dp[j][t] * 10 + p[k][t];
}
}
}
}
long long ans[10];
bool can(long long x) {
if (x <= 50000 && fg[x]) {
for (int i = 0; i < 6; i++) ans[i] = dp[x][i];
return true;
}
if (x < 10000) return false;
int y = x % 10000;
x /= 10000;
for (int i = 0; i <= 4; i++)
if (fg[y + i * 10000]) {
if (can(x - i)) {
for (int j = 0; j < 6; j++)
ans[j] = ans[j] * 10000 + dp[y + i * 10000][j];
return true;
}
}
return false;
}
int main() {
pre();
for (scanf("%d", &T); T--;) {
scanf("%I64d", &m);
if (can(m)) {
for (int i = 0; i < 6; i++) printf("%I64d ", ans[i]);
puts("");
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Max(int a, int b) { return (((b - a) >> (32 - 1)) & (a ^ b)) ^ b; }
int Min(int a, int b) { return (((b - a) >> (32 - 1)) & (a ^ b)) ^ a; }
long long GCD(long long a, long long b) { return b != 0 ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) { return a * (b / GCD(a, b)); }
long long Pow(long long n, long long e) {
if (e == 0) return 1;
if (e == 1)
return n;
else if (e & 1) {
long long t = Pow(n, e / 2);
return n * t * t;
} else {
long long t = Pow(n, e / 2);
return t * t;
}
}
bool used[20][20];
bool dp[20][20];
int nextt[20][20];
int fours[20][20];
int sevens[20][20];
string num;
bool DP(int id, int carry) {
if (id == (int)(num).size()) {
if (carry == 0) return true;
return false;
}
if (used[id][carry]) return dp[id][carry];
used[id][carry] = true;
for (int f = 0, max_ = (7); f < max_; ++f)
for (int s = 0, max_ = (7); s < max_; ++s) {
if (f + s > 6) continue;
int n = 4 * f + 7 * s;
int c = n / 10;
int r = n % 10;
if (carry < c) continue;
int req = (num[id] - '0') - r;
if (carry > c) req += 10 * (carry - c);
if (req < 0 || req > 10) continue;
bool res = DP(id + 1, req);
if (res) {
fours[id][carry] = f;
sevens[id][carry] = s;
nextt[id][carry] = req;
return dp[id][carry] = true;
}
}
return dp[id][carry] = false;
}
int main() {
long long N;
int T;
scanf("%d", &T);
for (int i = 0, max_ = (T); i < max_; ++i) {
cin >> num;
memset(used, false, sizeof(used));
;
memset(dp, false, sizeof(dp));
;
bool r = DP(0, 0);
if (r) {
long long r[6] = {0, 0, 0, 0, 0, 0};
int carry = 0;
long long exp = Pow(10, (int)(num).size() - 1);
for (int i = 0, max_ = ((int)(num).size()); i < max_; ++i) {
for (int j = 0, max_ = (fours[i][carry]); j < max_; ++j)
r[j] += 4 * exp;
for (int j = 0, max_ = (sevens[i][carry]); j < max_; ++j)
r[j + fours[i][carry]] += 7 * exp;
carry = nextt[i][carry];
exp /= 10;
}
printf("%I64d %I64d %I64d %I64d %I64d %I64d\n", r[0], r[1], r[2], r[3],
r[4], r[5]);
} else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> b;
int id[33], cnt4[33], cnt7[33];
long long p10[20], mx[20];
int att(long long n, int i) {
if (i == 0) {
for (int j = 0; j < int(b.size()); j++)
if (b[j] == n) {
id[0] = j;
return 1;
}
return 0;
}
for (int j = 0; j < int(b.size()); j++) {
long long nn = n - p10[i] * b[j];
if (nn < 0) continue;
if (nn > mx[i - 1]) continue;
id[i] = j;
if (att(nn, i - 1)) return 1;
}
return 0;
}
void solve(long long n) {
memset(id, 0, sizeof id);
int found = 0;
for (int i = 0; i <= 17; i++)
if (mx[i] >= n)
if (att(n, i)) {
found = 1;
break;
}
if (!found) {
puts("-1");
return;
}
long long ans[6] = {0};
for (int i = 0; i <= 17; i++) {
for (int j = 0; j < cnt4[id[i]]; j++) ans[j] += p10[i] * 4;
for (int j = cnt4[id[i]]; j < cnt4[id[i]] + cnt7[id[i]]; j++)
ans[j] += p10[i] * 7;
}
long long sum = 0;
for (int i = 0; i < 6; i++) cout << ans[i] << (i == 5 ? '\n' : ' ');
}
int main() {
for (int i = 0; i <= 17; i++) p10[i] = i ? p10[i - 1] * 10 : 1;
for (int i = 0; i <= 17; i++) mx[i] = mx[i - 1] + p10[i] * 42;
for (int i = 0; i <= 6; i++)
for (int j = 0; j + i <= 6; j++) {
b.push_back(i * 7 + j * 4);
cnt4[b.size() - 1] = j;
cnt7[b.size() - 1] = i;
}
int test;
long long n;
cin >> test;
while (test--) {
cin >> n;
solve(n);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int d[20][10], step[20][10];
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long t;
cin >> t;
int len = 0, num[20];
long long ans[6] = {0};
while (t) {
num[++len] = t % 10;
t /= 10;
}
memset(d, 0, sizeof(d));
d[0][0] = 1;
for (int i = 1; i <= len; i++)
for (int j = 0; j <= 5; j++) {
int need = num[i] + j * 10;
for (int k = 0; k <= 6; k++)
for (int l = 0; l + k <= 6; l++)
if (need - 4 * k - 7 * l <= 5 && need - 4 * k - 7 * l >= 0 &&
d[i - 1][need - 4 * k - 7 * l]) {
d[i][j] = 1;
step[i][j] = k * 10 + l;
}
}
if (d[len][0]) {
int c = 0;
for (int i = len; i >= 1; i--) {
int four = step[i][c] / 10, seven = step[i][c] % 10;
for (int j = 0; j < four; j++) ans[j] = ans[j] * 10 + 4;
for (int j = four; j < four + seven; j++) ans[j] = ans[j] * 10 + 7;
for (int j = four + seven; j < 6; j++) ans[j] = ans[j] * 10;
c = 10 * c + num[i] - 4 * four - 7 * seven;
}
for (int i = 0; i < 6; i++) cout << ans[i] << ' ';
printf("\n");
} else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int c[20];
bool vis[20][10];
int A[20][10], B[20][10];
long long P[20];
long long res[7];
int main() {
P[0] = 1;
for (int i = 1; i <= 18; ++i) P[i] = P[i - 1] * 10;
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
int len = 0;
while (n) c[++len] = n % 10, n /= 10;
memset(vis, false, sizeof(vis));
vis[0][0] = true;
for (int i = 0; i < len; ++i) {
for (int j = 0; j < 20; ++j)
if (j < 10 && vis[i][j]) {
for (int a = 0; a <= 6; ++a) {
for (int b = 0; a + b <= 6; ++b) {
int tmp = a * 4 + b * 7 + j;
if ((tmp % 10) != c[i + 1]) continue;
vis[i + 1][tmp / 10] = true;
A[i + 1][tmp / 10] = a;
B[i + 1][tmp / 10] = b;
}
}
}
}
if (!vis[len][0]) {
puts("-1");
continue;
}
int m = 0;
memset(res, 0, sizeof(res));
for (int i = len; i >= 1; --i) {
int a = A[i][m];
int b = B[i][m];
int tmp = a * 4 + b * 7;
m = m * 10 + c[i] - tmp;
int j = 1;
for (; j <= a; ++j) res[j] += 4 * P[i - 1];
for (; j <= a + b; ++j) res[j] += 7 * P[i - 1];
}
for (int i = 1; i <= 6; ++i) cout << res[i] << ' ';
puts("");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.