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