text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
inline void Add(int &a, int b) {
a += b;
a >= 1000000007 ? a -= 1000000007 : 1;
}
inline void Sub(int a, int b) {
a -= b;
a < 0 ? a += 1000000007 : 1;
}
inline int add(int a, int b) {
a += b;
return a >= 1000000007 ? a - 1000000007 : a;
}
const int Q = 1 << 20;
char ss[Q], s[Q];
struct dt {
int st, d, num;
int sm;
};
vector<dt> g, mem, u;
long long ID(int st, int d, int num) {
return 2000000000000LL * st + 1000005LL * d + num;
}
unordered_map<long long, int> rem;
int f[Q];
int G(int st, int d, int num) {
if (num == 1) return f[st - 1];
long long dd = ID(st, d, num);
int val = rem[dd];
if (val) return val < 0 ? 0 : val;
val = add(G(st, d, num - 1), f[st + (num - 1) * d - 1]);
rem[dd] = val ? val : -1;
return (val);
}
void Upd(dt h) { rem[ID(h.st, h.d, h.num)] = h.sm; }
void Get(dt &h) { h.sm = G(h.st, h.d, h.num); }
int main() {
scanf("%s", ss + 1);
int nn = strlen(ss + 1), n = 0;
for (int i = 1, j = nn; i < j; i++, j--) s[++n] = ss[i], s[++n] = ss[j];
s[0] = '#', s[n + 1] = '&';
f[0] = 1;
for (int i = 1; i <= n; i++) {
mem.clear();
for (dt h : g)
if (s[i] == s[h.st - 1]) {
if (s[i] != s[h.st + h.d - 1])
mem.push_back((dt){h.st - 1, -1, 1, f[h.st - 2]});
else
--h.st, Get(h), mem.push_back(h);
} else {
if (h.num == 1) continue;
Sub(h.sm, f[h.st - 1]);
h.st += h.d, --h.num;
Upd(h);
if (s[i] == s[h.st - 1]) --h.st, Get(h), mem.push_back(h);
}
if (s[i] == s[i - 1]) mem.push_back((dt){i - 1, -1, 1, f[i - 2]});
mem.push_back((dt){i, -1, 1, f[i - 1]});
for (int j = 0; j < (int)mem.size() - 1; j++)
if (mem[j].num == 1) mem[j].d = mem[j + 1].st - mem[j].st;
u.clear();
for (int j = 0; j < (int)mem.size(); j++)
if (mem[j].num == 1)
u.push_back(mem[j]);
else {
dt h = mem[j];
int mr = h.st + (h.num - 1) * h.d;
if (h.d != mem[j + 1].st - mr) {
Sub(h.sm, f[mr - 1]);
--h.num;
Upd(h);
u.push_back(h);
u.push_back((dt){mr, mem[j + 1].st - mr, 1, f[mr - 1]});
} else
u.push_back(h);
}
g.clear();
int tp = -1;
for (int j = 0; j < (int)u.size(); j++)
if (tp < 0 || g[tp].d != u[j].d)
g.push_back(u[j]), ++tp;
else
Add(g[tp].sm, u[j].sm), g[tp].num += u[j].num, Upd(g[tp]);
if ((i & 1) ^ 1)
for (dt h : g) Add(f[i], h.sm);
}
cerr << rem.size();
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char c[2000010], a[2000010];
const int mod = 1e9 + 7;
int n, tot, last, top[2000010], diff[2000010], ans[2000010], f[2000010];
struct PT {
int ch[26], len, fa;
} tr[2000010];
void init() {
tr[++tot].len = -1;
tr[0].fa = tr[1].fa = 1;
top[0] = 1;
}
void insert(int now, int c) {
int x = last;
while (a[now] != a[now - tr[x].len - 1]) x = tr[x].fa;
if (!tr[x].ch[c]) {
int nx = ++tot, k = tr[x].fa;
tr[nx].len = tr[x].len + 2;
while (a[now] != a[now - tr[k].len - 1]) k = tr[k].fa;
tr[nx].fa = tr[k].ch[c];
tr[x].ch[c] = tot;
diff[nx] = tr[nx].len - tr[tr[nx].fa].len;
if (diff[nx] == diff[tr[nx].fa])
top[nx] = top[tr[nx].fa];
else
top[nx] = tr[nx].fa;
}
last = tr[x].ch[c];
}
int main() {
scanf("%s", c + 1);
int len = strlen(c + 1);
for (int i = 1; i <= len; i++) {
if (i & 1)
a[i] = c[(i + 1) / 2];
else
a[i] = c[(len - i / 2 + 1)];
}
init();
ans[0] = 1;
for (int i = 1; i <= len; i++) {
insert(i, a[i] - 'a');
int x = last;
for (; x; x = top[x]) {
f[x] = ans[i - tr[top[x]].len - diff[x]];
if (top[x] != tr[x].fa) f[x] = (f[x] + f[tr[x].fa]) % mod;
if (i % 2 == 0) ans[i] = (ans[i] + f[x]) % mod;
}
}
cout << ans[len];
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[1000006], origin[1000006];
int ch[1000006][27], fail[1000006], diff[1000006], anc[1000006], len[1000006],
total, last;
int f[1000006], g[1000006];
const int mod = 1e9 + 7;
void init() {
s[0] = '#';
len[1] = -1;
fail[0] = total = 1;
}
int getfail(int u, int n) {
while (s[n - len[u] - 1] != s[n]) u = fail[u];
return u;
}
void append(int c, int n) {
int v = getfail(last, n);
if (!ch[v][c]) {
int u = ++total;
len[u] = len[v] + 2;
fail[u] = ch[getfail(fail[v], n)][c];
ch[v][c] = u;
diff[u] = len[u] - len[fail[u]];
anc[u] = diff[u] == diff[fail[u]] ? anc[fail[u]] : fail[u];
}
last = ch[v][c];
}
int main() {
scanf("%s", origin + 1);
init();
n = (int)strlen(origin + 1);
if (n & 1) {
puts("");
return 0;
}
for (int i = 1; i <= n; i += 2) s[i] = origin[i / 2 + 1];
for (int i = 2; i <= n; i += 2) s[i] = origin[n - i / 2 + 1];
g[0] = 1;
for (int i = 1; i <= n; ++i) {
append(s[i] - 'a' + 1, i);
for (int j = last; j; j = anc[j]) {
f[j] = g[i - diff[j] - len[anc[j]]];
if (anc[j] != fail[j]) f[j] = (f[j] + f[fail[j]]) % mod;
if (i & 1) continue;
g[i] = (g[i] + f[j]) % mod;
}
}
printf("%d\n", g[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int MOD = 1e9 + 7;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
inline void Inc(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
char ss[MAXN], s[MAXN];
struct PAM {
int tot, last, ch[MAXN][26], fa[MAXN], maxl[MAXN];
int dif[MAXN], ff[MAXN], g[MAXN], dp[MAXN];
void Extend(int x, int i) {
int p = last;
while (s[i - maxl[p] - 1] != s[i]) {
p = fa[p];
}
if (!ch[p][x]) {
int np = ++tot, q = fa[p];
maxl[np] = maxl[p] + 2;
while (s[i - maxl[q] - 1] != s[i]) {
q = fa[q];
}
fa[np] = ch[q][x];
ch[p][x] = np;
dif[np] = maxl[np] - maxl[fa[np]];
if (dif[np] == dif[fa[np]]) {
ff[np] = ff[fa[np]];
} else {
ff[np] = fa[np];
}
}
last = ch[p][x];
}
void solve() {
scanf("%s", ss + 1);
int n = strlen(ss + 1);
if (n & 1) {
printf("0\n");
return;
}
for (int i = 1, j = n; i <= j; ++i, --j) {
s[i * 2 - 1] = ss[i];
s[i * 2] = ss[j];
}
fa[0] = fa[1] = tot = 1;
maxl[1] = -1;
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
Extend(s[i] - 'a', i);
for (int j = last; j; j = ff[j]) {
g[j] = dp[i - maxl[ff[j]] - dif[j]];
if (fa[j] ^ ff[j]) {
Inc(g[j], g[fa[j]]);
}
if (!(i & 1)) {
Inc(dp[i], g[j]);
}
}
}
printf("%d\n", dp[n]);
}
} pam;
int main() {
pam.solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1000000 + 5;
inline int add(int x, int y) {
x += y;
return x >= mod ? x -= mod : x;
}
namespace pam {
int sz, tot, last;
int ch[maxn][26], len[maxn], fail[maxn];
int cnt[maxn], dep[maxn], dif[maxn], slink[maxn];
char s[maxn];
int node(int l) {
sz++;
memset(ch[sz], 0, sizeof(ch[sz]));
len[sz] = l;
fail[sz] = 0;
cnt[sz] = 0;
dep[sz] = 0;
return sz;
}
void clear() {
sz = -1;
last = 0;
s[tot = 0] = '$';
node(0);
node(-1);
fail[0] = 1;
}
int getfail(int x) {
while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
return x;
}
void insert(char c) {
s[++tot] = c;
int now = getfail(last);
if (!ch[now][c - 'a']) {
int x = node(len[now] + 2);
fail[x] = ch[getfail(fail[now])][c - 'a'];
dep[x] = dep[fail[x]] + 1;
ch[now][c - 'a'] = x;
dif[x] = len[x] - len[fail[x]];
if (dif[x] == dif[fail[x]])
slink[x] = slink[fail[x]];
else
slink[x] = fail[x];
}
last = ch[now][c - 'a'];
cnt[last]++;
}
} // namespace pam
using pam::dif;
using pam::fail;
using pam::len;
using pam::slink;
int n, dp[maxn], g[maxn];
char s[maxn], t[maxn];
int main() {
pam::clear();
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1, j = 0; i <= n; i++) t[++j] = s[i], t[++j] = s[n - i + 1];
dp[0] = 1;
for (int i = 1; i <= n; i++) {
pam::insert(t[i]);
for (int x = pam::last; x > 1; x = slink[x]) {
g[x] = dp[i - len[slink[x]] - dif[x]];
if (dif[x] == dif[fail[x]]) g[x] = add(g[x], g[fail[x]]);
if (i % 2 == 0) dp[i] = add(dp[i], g[x]);
}
}
printf("%d", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, Mo = 1000000007;
int cnt = 1, la;
char a[N], s[N];
int fa[N], l[N], ch[N][26], f[N], w[N], g[N], fr[N];
inline int insert(int i) {
int c = s[i] - 'a';
while (s[i] != s[i - l[la] - 1]) la = fa[la];
if (!ch[la][c]) {
int x = fa[la];
l[++cnt] = l[la] + 2;
while (s[i] != s[i - l[x] - 1]) x = fa[x];
fa[cnt] = x = ch[x][c], ch[la][c] = cnt;
fr[cnt] = (l[cnt] <= l[fa[x]] * 2 ? fr[x] : cnt);
}
return la = ch[la][c];
}
int main() {
scanf("%s", a + 1);
int n = strlen(a + 1);
for (int i = 1, l = 1, r = n; i <= n; i += 2)
s[i] = a[l++], s[i + 1] = a[r--];
fa[0] = f[0] = 1, l[1] = -1;
for (int i = 1; i <= n; i++) {
int x = insert(i);
while (x > 1) {
int y = fr[x];
if (y == x)
g[x] = f[i - l[x]];
else
g[x] = (g[fa[x]] + f[i - l[y]]) % Mo;
if (~i & 1) f[i] = (f[i] + g[x]) % Mo;
x = fa[y];
}
}
cout << f[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005], t[1000005];
int f[1000005], g[1000005], n;
int ch[1000005][26], len[1000005], fa[1000005], cnt, lst, anc[1000005],
diff[1000005];
void init() {
cnt = 1;
len[1] = -1, fa[0] = fa[1] = anc[0] = 1;
}
void extend(int x, int n, char *s) {
int p = lst, np, nq;
while (s[n] != s[n - len[p] - 1]) p = fa[p];
if (!ch[p][x]) {
len[np = ++cnt] = len[p] + 2;
nq = fa[p];
while (s[n] != s[n - len[nq] - 1]) nq = fa[nq];
nq = ch[nq][x];
fa[np] = nq;
ch[p][x] = np;
diff[np] = len[np] - len[nq];
anc[np] = (diff[np] == diff[nq] ? anc[nq] : nq);
}
lst = ch[p][x];
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
init();
if (n & 1) return puts("0"), 0;
for (int i = 1, l = 1, r = n; i <= n; i++)
if (i & 1)
s[i] = t[l++];
else
s[i] = t[r--];
g[0] = 1;
for (int i = 1; i <= n; i++) {
extend(s[i] - 'a', i, s);
for (int p = lst; p; p = anc[p]) {
f[p] = g[i - len[anc[p]] - diff[p]];
if (anc[p] != fa[p]) (f[p] += f[fa[p]]) %= 1000000007;
if (!(i & 1)) (g[i] += f[p]) %= 1000000007;
}
}
printf("%d\n", g[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXLEN = 1000000;
const int MOD = 1000000007;
const int MAXALPH = 26;
struct ETNode {
int len, suff, idx, diff, slink;
int nxt[MAXALPH];
ETNode(int len, int suff, int idx) : len(len), suff(suff), idx(idx) {
memset(nxt, -1, sizeof(nxt));
}
};
struct EERTREE {
int IMAG, ZERO, at;
char *s;
int idx;
vector<ETNode> nodes;
void init(char *_s) {
s = _s;
idx = 0;
nodes.clear();
IMAG = 0, ZERO = 1, at = ZERO;
nodes.push_back(ETNode(-1, IMAG, -1));
nodes.push_back(ETNode(0, IMAG, -1));
nodes[IMAG].diff = -1, nodes[IMAG].slink = IMAG, nodes[ZERO].diff = -1,
nodes[ZERO].slink = IMAG;
}
void grow() {
while (s[idx] != s[idx - 1 - nodes[at].len]) at = nodes[at].suff;
int x = s[idx] - 'a';
if (nodes[at].nxt[x] == -1) {
int suff = nodes[at].suff;
while (s[idx] != s[idx - 1 - nodes[suff].len]) suff = nodes[suff].suff;
int to = ((int)(nodes).size());
nodes.push_back(ETNode(nodes[at].len + 2,
at == IMAG ? ZERO : nodes[suff].nxt[x], idx));
nodes[to].diff = nodes[to].len - nodes[nodes[to].suff].len;
nodes[to].slink = nodes[to].diff == nodes[nodes[to].suff].diff
? nodes[nodes[to].suff].slink
: nodes[to].suff;
nodes[at].nxt[x] = to;
}
at = nodes[at].nxt[x], ++idx;
}
void print(int at, int dep = 0) {
for (int i = (0); i < (dep); ++i) printf(" ");
printf("%d=", at);
if (at == IMAG)
printf("IMAG");
else if (at == ZERO)
printf("ZERO");
else
for (int i = (0); i < (nodes[at].len); ++i)
printf("%c", s[nodes[at].idx - i]);
printf(" [%d,%d,%d]\n", nodes[at].suff, nodes[at].diff, nodes[at].slink);
for (int x = (0); x < (MAXALPH); ++x)
if (nodes[at].nxt[x] != -1) print(nodes[at].nxt[x], dep + 1);
}
void print() {
print(IMAG);
print(ZERO);
}
};
char s[MAXLEN + 1];
int slen;
char t[MAXLEN + 1];
EERTREE et;
int dp[MAXLEN + 1];
int sdp[MAXLEN + 2];
void inc(int &a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
void run() {
scanf("%s", s);
slen = strlen(s);
assert(slen % 2 == 0);
for (int i = (0); i < (slen / 2); ++i)
t[2 * i + 0] = s[i], t[2 * i + 1] = s[slen - i - 1];
t[slen] = '\0';
dp[0] = 1;
et.init(t);
for (int i = (0); i < (slen); ++i) {
et.grow();
dp[i + 1] = 0;
for (int x = et.at; et.nodes[x].len > 0; x = et.nodes[x].slink) {
sdp[x] = 0;
inc(sdp[x],
dp[i + 1 - et.nodes[et.nodes[x].slink].len - et.nodes[x].diff]);
if (et.nodes[x].diff == et.nodes[et.nodes[x].suff].diff)
inc(sdp[x], sdp[et.nodes[x].suff]);
if ((i + 1) % 2 == 0) inc(dp[i + 1], sdp[x]);
}
}
printf("%d\n", dp[slen]);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int data = 0, m = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') {
m = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
data = (data << 1) + (data << 3) + (ch ^ 48);
ch = getchar();
}
return (m) ? data : -data;
}
int fail[1000005], up[1000005], len[1000005], ch[1000005][26], f[1000005],
g[1000005], p, oo, n, m, cl, last, Delta[1000005];
char s[1000005], str[1000005];
inline void Init() {
fail[0] = fail[1] = ++oo;
len[1] = -1;
return;
}
inline void Extend(int c, int pos) {
p = last;
while (s[pos] != s[pos - len[p] - 1]) p = fail[p];
if (!ch[p][c]) {
cl = fail[p];
++oo;
while (s[pos] != s[pos - len[cl] - 1]) cl = fail[cl];
cl = ch[cl][c];
fail[oo] = cl;
ch[p][c] = oo;
len[oo] = len[p] + 2;
}
p = ch[p][c];
last = p;
Delta[p] = len[p] - len[fail[p]];
up[p] = (Delta[p] == Delta[fail[p]]) ? up[fail[p]] : p;
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n / 2; i++) s[2 * i - 1] = str[i];
for (int i = n; i > n / 2; i--) s[2 * (n - i + 1)] = str[i];
Init();
f[0] = 1;
for (int i = 1; i <= n; i++) {
Extend(s[i] - 'a', i);
f[i] = 0;
for (int x = last; x > 1; x = fail[p]) {
p = up[x];
g[x] = (x ^ p) ? g[fail[x]] : 0;
g[x] = (g[x] + f[i - len[p]]) % 1000000007;
if (i % 2 == 0) f[i] = (f[i] + g[x]) % 1000000007;
}
}
cout << f[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
namespace QiShiBuShiTaoLuTi2333 {
const int N = 1000100, INF = 1000000007, MOD = 1000000007;
inline void inc(int a, int &b) { b = (a + b) % MOD; }
struct node {
int pos, delta, k;
int lastpos() { return pos + delta * (k - 1); }
node(int a = 0, int b = 0, int c = 0) : pos(a), delta(b), k(c) {}
bool operator<(const node &A) const { return pos < A.pos; }
};
std::vector<node> G[N];
char s[N], t[N];
int n;
void calc(int p) {
std::vector<node> G0, G1;
for (auto A : G[p - 1]) {
node B = A;
B.pos--;
if (t[A.pos - 1] == t[p]) G0.push_back(B);
}
for (int i = 0; i < (int)G0.size(); i++) {
if (!i) {
G1.push_back(node(G0[i].pos, INF, 1));
if (G0[i].k > 1)
G1.push_back(node(G0[i].pos + G0[i].delta, G0[i].delta, G0[i].k - 1));
} else if (G0[i].pos - G0[i - 1].lastpos() != G0[i].delta) {
G1.push_back(node(G0[i].pos, G0[i].pos - G0[i - 1].lastpos(), 1));
if (G0[i].k > 1)
G1.push_back(node(G0[i].pos + G0[i].delta, G0[i].delta, G0[i].k - 1));
} else
G1.push_back(G0[i]);
}
if (p > 1 && t[p] == t[p - 1]) {
if (G1.empty())
G1.push_back(node(p - 1, INF, 1));
else
G1.push_back(node(p - 1, p - 1 - G1[G1.size() - 1].lastpos(), 1));
}
if (G1.empty())
G1.push_back(node(p, INF, 1));
else
G1.push_back(node(p, p - G1[G1.size() - 1].lastpos(), 1));
int tot = 0;
G[p].push_back(G1[0]);
for (int i = 1; i < (int)G1.size(); i++) {
if (G[p][tot].delta == G1[i].delta)
G[p][tot].k += G1[i].k;
else
G[p].push_back(G1[i]), tot++;
}
}
int f[N];
void initialize() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n / 2; i++) t[i * 2 - 1] = s[i];
for (int i = 1; i <= n / 2; i++) t[i * 2] = s[n - i + 1];
}
int sum[N];
void solve() {
initialize();
f[0] = 1;
for (int i = 1; i <= n; i++) {
calc(i);
for (auto A : G[i]) {
int x = A.pos - A.delta, u = A.lastpos(), res = 0;
inc(f[u - 1], res);
if (A.k > 1) inc(sum[x], res);
if (x > 0) sum[x] = res;
inc(res, f[i]);
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
}
} // namespace QiShiBuShiTaoLuTi2333
int main() {
QiShiBuShiTaoLuTi2333::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, mod = 1e9 + 7;
int ch[N][26], fa[N], g[N], f[N], tot, lst, nxt[N], l[N], s[N], dif[N], pos[N];
char t[N];
int read() {
int x = 0;
char c = getchar(), flag = '+';
while (!isdigit(c)) flag = c, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return flag == '-' ? -x : x;
}
int Insert(int x, int c) {
int p = lst;
while (s[x - l[p] - 1] ^ c) p = fa[p];
if (!ch[p][c]) {
int now = ++tot, q = fa[p];
l[now] = l[p] + 2;
while (s[x - l[q] - 1] ^ c) q = fa[q];
int t = ch[q][c];
dif[now] = l[now] - l[t];
fa[now] = t;
if (dif[now] == dif[t])
nxt[now] = nxt[t];
else
nxt[now] = t;
ch[p][c] = now;
}
return lst = ch[p][c];
}
int main() {
scanf("%s", t + 1);
int n = strlen(t + 1);
for (int i = 1; i <= n; i++) {
if (i & 1)
s[i] = t[i + 1 >> 1] - 'a';
else
s[i] = t[n - i / 2 + 1] - 'a';
}
s[0] = -1;
tot = 1, l[1] = -1, fa[0] = 1;
for (int i = 1; i <= n; i++) pos[i] = Insert(i, s[i]);
f[0] = 1;
for (int i = 1; i <= n; i++) {
for (int x = pos[i]; x; x = nxt[x]) {
g[x] = f[i - l[nxt[x]] - dif[x]];
if (dif[x] == dif[fa[x]])
g[x] = g[x] + g[fa[x]] >= mod ? g[x] + g[fa[x]] - mod : g[x] + g[fa[x]];
if (!(i & 1)) f[i] = f[i] + g[x] >= mod ? f[i] + g[x] - mod : f[i] + g[x];
}
}
cout << f[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
struct modint {
int x;
modint(int o = 0) { x = o; }
modint &operator=(int o) { return x = o, *this; }
modint &operator+=(modint o) {
return x = x + o.x >= 1000000007 ? x + o.x - 1000000007 : x + o.x, *this;
}
modint &operator-=(modint o) {
return x = x - o.x < 0 ? x - o.x + 1000000007 : x - o.x, *this;
}
modint &operator*=(modint o) { return x = 1ll * x * o.x % 1000000007, *this; }
modint &operator^=(int b) {
modint a = *this, c = 1;
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return x = c.x, *this;
}
modint &operator/=(modint o) { return *this *= o ^= 1000000007 - 2; }
modint &operator+=(int o) {
return x = x + o >= 1000000007 ? x + o - 1000000007 : x + o, *this;
}
modint &operator-=(int o) {
return x = x - o < 0 ? x - o + 1000000007 : x - o, *this;
}
modint &operator*=(int o) { return x = 1ll * x * o % 1000000007, *this; }
modint &operator/=(int o) { return *this *= ((modint(o)) ^= 1000000007 - 2); }
template <class I>
friend modint operator+(modint a, I b) {
return a += b;
}
template <class I>
friend modint operator-(modint a, I b) {
return a -= b;
}
template <class I>
friend modint operator*(modint a, I b) {
return a *= b;
}
template <class I>
friend modint operator/(modint a, I b) {
return a /= b;
}
friend modint operator^(modint a, int b) { return a ^= b; }
friend bool operator==(modint a, int b) { return a.x == b; }
friend bool operator!=(modint a, int b) { return a.x != b; }
bool operator!() { return !x; }
modint operator-() { return x ? 1000000007 - x : 0; }
};
inline modint qpow(modint a, int b) { return a ^ b; }
int n;
char s[1000005], qwq[1000005];
int ch[1000005][26], len[1000005], fa[1000005], lst, cnt;
int dif[1000005], lnk[1000005];
inline void init() {
len[0] = 0, len[1] = -1;
fa[0] = 1, fa[1] = 1, lnk[0] = 1, cnt = 1;
}
int getfa(int x, int n) {
while (s[n - len[x] - 1] != s[n]) x = fa[x];
return x;
}
void ins(int c, int n) {
int p = getfa(lst, n);
if (!ch[p][c]) {
int u = ++cnt, t = getfa(fa[p], n);
len[u] = len[p] + 2, fa[u] = ch[t][c];
ch[p][c] = u;
dif[u] = len[u] - len[fa[u]];
lnk[u] = (dif[u] == dif[fa[u]]) ? lnk[fa[u]] : fa[u];
}
lst = ch[p][c];
}
modint f[1000005], g[1000005];
signed main() {
scanf("%s", qwq + 1), n = strlen(qwq + 1);
if (n & 1) {
puts("0");
return 0;
}
init();
int tl = 1, tr = n;
for (register int i = (1); i <= (n); ++i)
if (i & 1)
s[i] = qwq[tl], ++tl;
else
s[i] = qwq[tr], --tr;
f[0] = 1;
for (register int i = (1); i <= (n); ++i) {
ins(s[i] - 'a', i);
for (int k = lst; k; k = lnk[k]) {
g[k] = f[i - len[lnk[k]] - dif[k]];
if (lnk[k] != fa[k]) g[k] += g[fa[k]];
if (i % 2 == 0) f[i] += g[k];
}
}
cout << f[n].x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const int mod = 1e9 + 7;
int n;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count() *
((uint64_t) new char | 1));
uniform_int_distribution<int> distr(0.1 * mod, 0.9 * mod);
const array<int, 2> base = {distr(rng), distr(rng)};
array<int, 2> operator+(array<int, 2> l, array<int, 2> r) {
for (int i = 0; i < 2; i++) {
if ((l[i] += r[i]) >= mod) l[i] -= mod;
}
return l;
}
array<int, 2> operator-(array<int, 2> l, array<int, 2> r) {
for (int i = 0; i < 2; i++) {
if ((l[i] -= r[i]) < 0) l[i] += mod;
}
return l;
}
array<int, 2> operator*(array<int, 2> l, array<int, 2> r) {
for (int i = 0; i < 2; i++) {
l[i] = 1ll * l[i] * r[i] % mod;
}
return l;
}
array<int, 2> makeH(char c) { return {c, c}; }
vector<array<int, 2> > pows = {{1, 1}};
struct HashRange {
string s;
vector<array<int, 2> > cum = {{0, 0}};
void add(char c) {
s += c;
cum.push_back(cum.back() * base + makeH(c));
}
void add(string x) {
for (auto u : x) add(u);
}
void extend(int len) {
while ((int)pows.size() < (int)s.size()) {
pows.push_back(base * pows.back());
}
}
array<int, 2> hash(int l, int r) {
int len = r - l + 1;
extend(len);
return cum[r + 1] - cum[l] * pows[len];
}
bool operator==(HashRange &rhs) { return cum.back() == rhs.cum.back(); }
};
HashRange hr;
string st;
map<array<int, 2>, int> msi;
vector<int> v = {-1};
int t;
struct node {
map<int, int> nxt, prv;
int link = 0, len = 0;
int acc = 0;
int diff = 0;
int slink = 0;
node() {}
};
vector<node> eer;
int suff;
int series_ans[N], dp[N];
int s[N];
int c = 0;
int get_link(int x) {
while (s[c - eer[x].len - 2] != s[c - 1]) {
x = eer[x].link;
}
return x;
}
bool extend(int ch) {
s[c++] = ch;
suff = get_link(suff);
if (eer[suff].nxt[ch]) {
suff = eer[suff].nxt[ch];
return 0;
}
int lst = suff;
suff = eer.size();
eer.push_back(node());
eer[suff].len = 2 + eer[lst].len;
eer[suff].link = eer[get_link(eer[lst].link)].nxt[ch];
eer[lst].nxt[ch] = suff;
eer[suff].diff = eer[suff].len - eer[eer[suff].link].len;
if (eer[suff].diff == eer[eer[suff].link].diff) {
eer[suff].slink = eer[eer[suff].link].slink;
} else {
eer[suff].slink = eer[suff].link;
}
return 1;
}
void process() {
eer.push_back(node()), eer.push_back(node());
eer[0].link = 1;
eer[1].len = -1;
s[c++] = -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> st;
hr.add(st);
n = st.size();
int l = 0;
for (int i = 0; i < n / 2; ++i) {
array<int, 2> lhs = hr.hash(l, i);
if (lhs == hr.hash(n - i - 1, n - l - 1)) {
if (msi[lhs] == 0) {
msi[lhs] = ++t;
}
v.push_back(msi[lhs]);
l = i + 1;
}
}
if (l != st.size() / 2) {
return cout << 0, 0;
}
dp[0] = 1;
process();
for (int i = 1; i < v.size(); ++i) {
extend(v[i]);
for (int u = suff; eer[u].len > 0; u = eer[u].slink) {
series_ans[u] = (dp[i - (eer[eer[u].slink].len + eer[u].diff)]) % mod;
if (eer[u].diff == eer[eer[u].link].diff)
series_ans[u] = (series_ans[u] + series_ans[eer[u].link]) % mod;
dp[i] = (dp[i] + series_ans[u]) % mod;
}
}
cout << dp[v.size() - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
char ch[1000012], s[1000012];
int cz[1000012][27], fl[1000012], len[1000012], la, js, n, dp[1000012],
dif[1000012], slink[1000012], g[1000012];
void ada(char c, int wh) {
int p = la;
while (ch[wh - len[p] - 1] != c) p = fl[p];
if (!cz[p][c - 'a']) {
++js;
len[js] = len[p] + 2;
int tp = fl[p];
while (ch[wh - len[tp] - 1] != c) tp = fl[tp];
fl[js] = cz[tp][c - 'a'];
cz[p][c - 'a'] = js;
dif[js] = len[js] - len[fl[js]];
if (dif[js] == dif[fl[js]])
slink[js] = slink[fl[js]];
else
slink[js] = fl[js];
}
la = cz[p][c - 'a'];
}
bool cmp(int x, int y) { return len[x] > len[y]; }
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int tot = 0;
for (int i = 1, j = n; i < j; i++, j--) ch[++tot] = s[i], ch[++tot] = s[j];
fl[0] = 1;
fl[1] = 1;
len[1] = -1;
js = la = 1;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
ada(ch[i], i);
for (int x = la; x > 1; x = slink[x]) {
g[x] = dp[i - dif[x] - len[slink[x]]];
if (dif[x] == dif[fl[x]]) g[x] = (g[x] + g[fl[x]]) % p;
if (i % 2 == 0) dp[i] = (dp[i] + g[x]) % p;
}
}
printf("%d\n", dp[n]);
}
|
#include <bits/stdc++.h>
const int mxN(1000233), p(1000000007), sta(0), debug(0);
int n, str[mxN];
inline void init() {
if (sta == 1 || sta == 2) freopen("a.in", "r", stdin);
static char s[mxN];
scanf("%s", s);
n = strlen(s);
if (n & 1) {
puts("0");
exit(0);
}
for (int i = 0, j = n - 1; i < j; ++i, --j)
str[i << 1 | 1] = s[i] - 'a', str[(i + 1) << 1] = s[j] - 'a';
str[0] = -1;
}
namespace PT {
struct D {
int l, d, v;
D *f, *a, *e[26];
} ar[mxN], *ed = ar;
int m;
inline void init() {
m = 2;
ar->f = ar + 1;
ar[1].l = -1;
}
inline void insert(int n) {
int c = str[n];
D *u = ed;
for (; c != str[n - u->l - 1]; u = u->f)
;
if (u->e[c]) {
ed = u->e[c];
return;
}
D *v = u->e[c] = ed = ar + m++;
v->l = u->l + 2;
if (u == ar + 1) {
v->f = v->a = ar;
v->d = 1;
return;
}
for (u = u->f; c != str[n - u->l - 1]; u = u->f)
;
v->f = u->e[c];
v->a = (v->d = v->l - v->f->l) == v->f->d ? v->f->a : v->f;
}
} // namespace PT
int main() {
init();
PT::init();
static int f[mxN];
f[0] = 1;
for (int i = 1; i <= n; ++i) {
PT::insert(i);
if (debug) {
using namespace PT;
printf("%d\n", str[i]);
printf("%ld %ld %ld\n", ed - ar, ed->f - ar, ed->a - ar);
}
for (PT::D *u = PT::ed; u != PT::ar; u = u->a) {
u->v = f[i - u->a->l - u->d];
if (u->f != u->a) u->v = (u->v + u->f->v) % p;
if (~i & 1) f[i] = (f[i] + u->v) % p;
}
}
printf("%d\n", (f[n] + p) % p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int inf = 2e9 + 7;
double eps = 1e-6;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const double pi = acos(-1.0);
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
void add(long long& a, long long b) {
a += b;
((a >= mod) && (a -= mod));
((a < 0) && (a += mod));
}
long long exgcd(long long a, long long b, long long& x, long long& y) {
long long c;
return !b ? (x = 1, y = 0, a)
: (c = exgcd(b, a % b, y, x), y -= (a / b) * x, c);
}
long long INV(long long a) {
long long x, y;
exgcd(a, mod, x, y);
x %= mod;
if (x < 0) x += mod;
return x;
}
char s[N], t[N];
int dp[N], g[N];
class Pam {
public:
int sz, tot, last;
int cnt[N], ch[N][26], len[N], fail[N], dif[N], slink[N];
char s[N];
int node(int l) {
sz++;
memset(ch[sz], 0, sizeof(ch[sz]));
len[sz] = l;
fail[sz] = cnt[sz] = 0;
return sz;
}
void init() {
sz = -1;
last = 0;
s[tot = 0] = '$';
node(0);
node(-1);
fail[0] = 1;
}
int getfail(int x) {
while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
return x;
}
void insert(int c) {
s[++tot] = c;
int now = getfail(last);
if (!ch[now][c]) {
int x = node(len[now] + 2);
fail[x] = ch[getfail(fail[now])][c];
ch[now][c] = x;
dif[x] = len[x] - len[fail[x]];
if (dif[x] == dif[fail[x]])
slink[x] = slink[fail[x]];
else
slink[x] = fail[x];
}
last = ch[now][c];
cnt[last]++;
}
void addtimes() {
for (int i = sz; i >= 2; --i) cnt[fail[i]] += cnt[i];
}
void work() {
dp[0] = 1;
int w = strlen(t + 1);
for (int i = 1; i <= w; ++i) {
insert(t[i] - 'a');
for (int x = last; x > 1; x = slink[x]) {
g[x] = dp[i - len[slink[x]] - dif[x]];
if (dif[x] == dif[fail[x]]) g[x] = (g[x] + g[fail[x]]) % mod;
if (i % 2 == 0) dp[i] = (dp[i] + g[x]) % mod;
}
}
cout << dp[w];
}
} pam;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s + 1;
int w = strlen(s + 1);
for (int i = 1; i <= w; ++i)
t[i] = ((i & 1) ? s[(i + 1) / 2] : s[w + 1 - i / 2]);
pam.init();
pam.work();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool cmax(T& x, T y) {
return y > x ? x = y, true : false;
}
template <typename T>
inline bool cmin(T& x, T y) {
return y < x ? x = y, true : false;
}
const int MAXN = 1e6 + 5;
const int oo = 0x3f3f3f3f;
const int mod = 1e9 + 7;
inline int add(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
inline int pop(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b) { return 1LL * a * b % mod; }
int N;
int cnt = 1, now, son[MAXN][26], pre[MAXN], spre[MAXN], len[MAXN], diff[MAXN];
char s[MAXN], ss[MAXN];
int f[MAXN], g[MAXN];
void extend(int o, int nxt) {
while (s[o - len[now] - 1] != s[o]) now = pre[now];
if (!son[now][nxt]) {
int np = ++cnt;
len[np] = len[now] + 2;
int anc = pre[now];
while (s[o - len[anc] - 1] != s[o]) anc = pre[anc];
pre[np] = son[anc][nxt];
son[now][nxt] = np;
diff[np] = len[np] - len[pre[np]];
spre[np] = diff[np] == diff[pre[np]] ? spre[pre[np]] : pre[np];
}
now = son[now][nxt];
}
int main() {
scanf("%s", ss + 1);
N = strlen(ss + 1);
for (int i = 1; i <= N / 2; i++) s[(i << 1) - 1] = ss[i];
for (int i = 1; i <= N / 2; i++) s[i << 1] = ss[N - i + 1];
pre[0] = pre[1] = 1;
len[1] = -1;
f[0] = 1;
for (int i = 1; i <= N; i++) {
extend(i, s[i] - 'a');
for (int v = now; len[v] > 0; v = spre[v]) {
g[v] = diff[v] == diff[pre[v]] ? g[pre[v]] : 0;
int o = i - len[spre[v]] - diff[v];
g[v] = add(g[v], f[o]);
f[i] = add(f[i], g[v]);
}
if ((i & 1)) f[i] = 0;
}
printf("%d\n", f[N]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline void read(int *a, int n) {
for (int i = 0; i < n; i++) a[i] = in();
}
inline void readL(int *a, int n) {
for (int i = 0; i < n; i++) a[i] = lin();
}
const int maxn = 2e6 + 10;
const int mod = 1e9 + 7;
const int MAX_VAL = 1e18 + 10;
const int MAGIC = 350;
struct eertree {
int suff_link[maxn], len[maxn], curStringLen, sz,
preNode = 0, nxt[maxn][26], chain_diff[maxn], prev_chain_link[maxn];
string T = "";
inline int doJob(int node) {
while (T[curStringLen - 2 - len[node]] != T[curStringLen - 1])
node = suff_link[node];
return node;
}
inline void add_letter(int ch) {
T += char(ch + 'a');
curStringLen++;
preNode = doJob(preNode);
if (nxt[preNode][ch]) {
preNode = nxt[preNode][ch];
return;
}
len[sz] = len[preNode] + 2;
suff_link[sz] = nxt[doJob(suff_link[preNode])][ch];
chain_diff[sz] = len[sz] - len[suff_link[sz]];
prev_chain_link[sz] = (chain_diff[sz] == chain_diff[suff_link[sz]])
? prev_chain_link[suff_link[sz]]
: suff_link[sz];
preNode = nxt[preNode][ch] = sz++;
}
inline void init() {
suff_link[0] = 1;
len[0] = 0;
len[1] = -1;
curStringLen = 1;
T += "!";
sz = 2;
}
} et;
int dp_chain[maxn], dp[maxn];
int32_t main() {
string s;
cin >> s;
int n = (int)s.size();
string t = "";
for (int i = 0; i < n / 2; i++) {
t += s[i];
t += s[n - i - 1];
;
}
dp[0] = 1;
et.init();
for (int i = 1; i <= n; i++) {
et.add_letter(t[i - 1] - 'a');
bool fl = i & 1;
for (int cur = et.preNode; et.len[cur] > 0; cur = et.prev_chain_link[cur]) {
dp_chain[cur] =
dp[i - (et.len[et.prev_chain_link[cur]] + et.chain_diff[cur])];
if (et.chain_diff[cur] == et.chain_diff[et.suff_link[cur]])
(dp_chain[cur] += dp_chain[et.suff_link[cur]]) %= mod;
(dp[i] += dp_chain[cur]) %= mod;
}
if (fl) dp[i] = 0;
}
cout << dp[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, mo = 1000000007;
int n;
char s[N];
char t[N];
int diff[N];
int anc[N];
int g[N];
int f[N];
struct PAM {
int last, tot;
struct node {
int son[26];
int ff, len;
} t[N];
void init() {
last = 0;
tot = 1;
t[1].len = -1;
t[0].ff = t[1].ff = 1;
anc[0] = 1;
}
void extend(int c, int n) {
int p = last;
while (s[n - t[p].len - 1] != s[n]) p = t[p].ff;
if (!t[p].son[c]) {
int v = ++tot, k = t[p].ff;
t[v].len = t[p].len + 2;
while (s[n - t[k].len - 1] != s[n]) k = t[k].ff;
t[v].ff = t[k].son[c];
t[p].son[c] = v;
diff[v] = t[v].len - t[t[v].ff].len;
anc[v] = (diff[v] == diff[t[v].ff]) ? anc[t[v].ff] : t[v].ff;
}
last = t[p].son[c];
}
} pam;
void get_read() { scanf("%s", t + 1); }
void add(int &x, int y) {
x += y;
if (x >= mo) x -= mo;
}
void get_work() {
pam.init();
n = strlen(t + 1);
if (n & 1) {
puts("0");
return;
}
int l = 0, r = n + 1;
int tmp = 0;
while (tmp < n) s[++tmp] = t[++l], s[++tmp] = t[--r];
f[0] = 1;
for (int i = 1; i <= n; ++i) {
pam.extend(s[i] - 'a', i);
for (int k = pam.last; k; k = anc[k]) {
g[k] = f[i - pam.t[anc[k]].len - diff[k]];
if (pam.t[k].ff != anc[k]) add(g[k], g[pam.t[k].ff]);
if (!(i & 1)) add(f[i], g[k]);
}
}
printf("%d", f[n]);
}
int main() {
get_read();
get_work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005, maxk = 27, mod = 1000000007;
int n;
int f[maxn];
string s, ss;
struct Palindrome_AutoMaton {
int slen, tot, last;
int chd[maxn][maxk], fail[maxn], len[maxn], dif[maxn], slink[maxn], sum[maxn];
string s;
int getfail(int x, int i) {
while (i - len[x] - 1 < 0 || s[i - len[x] - 1] != s[i]) x = fail[x];
return x;
}
int insert(int last, int x, int i) {
int pos = getfail(last, i);
if (chd[pos][x] == 0) {
tot++, fail[tot] = chd[getfail(fail[pos], i)][x];
chd[pos][x] = tot, len[tot] = len[pos] + 2;
dif[tot] = len[tot] - len[fail[tot]];
if (dif[tot] == dif[fail[tot]])
slink[tot] = slink[fail[tot]];
else
slink[tot] = fail[tot];
}
return chd[pos][x];
}
void init(int klen, string k) {
memset(chd, 0, sizeof(chd));
memset(fail, 0, sizeof(fail));
memset(len, 0, sizeof(len));
memset(sum, 0, sizeof(sum));
memset(dif, 0, sizeof(dif));
memset(slink, 0, sizeof(slink));
s = k, slen = klen, tot = 1;
fail[0] = 1, fail[1] = 0, len[0] = 0, len[1] = -1;
}
void dp() {
last = 0;
f[0] = 1;
for (int i = 1; i <= slen; i++) {
last = insert(last, s[i] - 96, i);
for (int pos = last; pos > 1; pos = slink[pos]) {
sum[pos] = f[i - (len[slink[pos]] + dif[pos])];
if (dif[pos] == dif[fail[pos]])
sum[pos] = (sum[pos] + sum[fail[pos]]) % mod;
if (i % 2 == 0) f[i] = (f[i] + sum[pos]) % mod;
}
}
}
} PAM;
int main() {
cin >> s;
if ((int)(s.size()) % 2 == 1) {
puts("0");
return 0;
}
n = s.size(), s = " " + s;
for (int i = 1; i <= n / 2; i++) ss += s[i], ss += s[n - i + 1];
ss = " " + ss;
PAM.init(n, ss);
PAM.dp();
printf("%d\n", f[s.size() - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace fast_io {
char buf[1 << 12], *p1 = buf, *p2 = buf, sr[1 << 23], z[23], nc;
int C = -1, Z = 0, Bi = 0, ny;
inline char gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 12, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
ny = 1;
while (nc = gc(), (nc < 48 || nc > 57) && nc != EOF)
if (nc == 45) ny = -1;
Bi = 1;
if (nc < 0) return nc;
x = nc - 48;
while (nc = gc(), 47 < nc && nc < 58 && nc != EOF)
x = (x << 3) + (x << 1) + (nc ^ 48), Bi++;
return x * ny;
}
inline double gf() {
int a = read(), y = ny, b = (nc != '.') ? 0 : read();
return (b ? a + (double)b / pow(10, Bi) * y : a);
}
inline int gs(char *s) {
char c, *t = s;
while (c = gc(), c <= 32)
;
*s++ = c;
while (c = gc(), c > 32) *s++ = c;
return s - t;
}
inline void ot() {
fwrite(sr, 1, C + 1, stdout);
C = -1;
}
inline void flush() {
if (C > 1 << 22) ot();
}
template <typename T>
inline void write(T x, char t) {
int y = 0;
if (x < 0) y = 1, x = -x;
while (z[++Z] = x % 10 + 48, x /= 10)
;
if (y) z[++Z] = '-';
while (sr[++C] = z[Z], --Z)
;
sr[++C] = t;
flush();
}
inline void write(char *s) {
int l = strlen(s);
for (int i = 0; i < l; i++) sr[++C] = *s++;
sr[++C] = '\n';
flush();
}
}; // namespace fast_io
using namespace fast_io;
const int N = 1e6 + 5, p = 1e9 + 7;
int n, m, k, tot, ch[N][26], len[N], fa[N], d[N], anc[N], f[N], g[N], lst;
char s[N], t[N];
inline void M(int &x) {
x -= p;
x += x >> 31 & p;
}
inline void init() { len[tot = 1] = -1, fa[0] = fa[1] = anc[0] = 1; }
inline void ins(int c, int n) {
int p = lst;
while (s[n - len[p] - 1] ^ s[n]) p = fa[p];
if (!ch[p][c]) {
int v = ++tot, q = fa[p];
len[v] = len[p] + 2;
while (s[n - len[q] - 1] ^ s[n]) q = fa[q];
fa[v] = ch[q][c], ch[p][c] = v, d[v] = len[v] - len[fa[v]];
anc[v] = (d[v] == d[fa[v]]) ? anc[fa[v]] : fa[v];
}
lst = ch[p][c];
}
int main() {
n = gs(t + 1);
f[0] = 1, init();
if (n & 1) return write("0"), ot(), 0;
for (int i = 1; i <= n; i += 2) s[i] = t[i / 2 + 1];
for (int i = 2; i <= n; i += 2) s[i] = t[n - i / 2 + 1];
for (int i = 1; i <= n; i++) {
ins(s[i] - 'a', i);
for (int k = lst; k; k = anc[k]) {
g[k] = f[i - len[anc[k]] - d[k]];
if (anc[k] ^ fa[k]) M(g[k] += g[fa[k]]);
if (!(i & 1)) M(f[i] += g[k]);
}
}
write(f[n], '\n');
return ot(), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct palindromic_tree {
int n, act;
vector<map<char, int> > list;
vector<int> link, slink, diff, len;
string s;
void add_node() {
n++;
list.emplace_back();
link.emplace_back();
slink.emplace_back();
diff.emplace_back();
len.emplace_back();
}
palindromic_tree() {}
palindromic_tree(string _s) {
n = -1;
act = 0;
list.clear();
link = slink = diff = len = {};
s = _s;
add_node();
len[0] = -1;
add_node();
link[1] = 0;
act = 1;
}
void add_letter(int id) {
while (act != 0 && s[id] != s[id - len[act] - 1]) act = link[act];
if (s[id] == s[id - len[act] - 1]) {
if (list[act][s[id]] == 0) {
add_node();
list[act][s[id]] = n;
len[n] = len[act] + 2;
if (act != 0) {
link[n] = link[act];
while (link[n] != 0 && s[id] != s[id - len[link[n]] - 1])
link[n] = link[link[n]];
if (s[id] == s[id - len[link[n]] - 1]) link[n] = list[link[n]][s[id]];
} else {
link[n] = 1;
}
diff[n] = len[n] - len[link[n]];
if (diff[n] == diff[link[n]])
slink[n] = slink[link[n]];
else
slink[n] = link[n];
}
act = list[act][s[id]];
}
}
};
string s, aux;
int n, i, j;
long long dp[1000011], serie[1000011];
int main() {
cin >> s;
n = s.size();
aux = "@";
i = 0;
j = n - 1;
while (i < j) {
aux.push_back(s[i++]);
aux.push_back(s[j--]);
}
palindromic_tree PT(aux);
dp[0] = 1;
for (i = 1; i <= n; i++) {
PT.add_letter(i);
for (int act = PT.act; act != 0; act = PT.slink[act]) {
serie[act] = dp[i - (PT.len[PT.slink[act]] + PT.diff[act])];
if (PT.diff[act] == PT.diff[PT.link[act]]) {
serie[act] += serie[PT.link[act]];
serie[act] %= 1000000007;
}
dp[i] += serie[act];
dp[i] %= 1000000007;
}
if (i & 1) dp[i] = 0;
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
char s[maxn], ss[maxn];
int n;
long long f[maxn], ans[maxn];
int len[maxn], fail[maxn], ch[maxn][26], last = 1, tot = 1, fa[maxn], cha[maxn];
int getfail(int x, int i) {
while (i - len[x] - 1 < 0 || s[i - len[x] - 1] != s[i]) x = fail[x];
return x;
}
int main() {
scanf("%s", ss + 1);
n = strlen(ss + 1);
for (int i = 1; i <= n; i += 2) s[i] = ss[(i + 1) >> 1];
reverse(ss + 1, ss + n + 1);
for (int i = 2; i <= n; i += 2) s[i] = ss[(i + 1) >> 1];
if (n & 1) {
printf("0\n");
return 0;
}
len[1] = -1;
fail[0] = fail[1] = 1;
ans[0] = 1;
fa[0] = 1;
for (int i = 1; i <= n; i++) {
int cur = last;
cur = getfail(cur, i);
if (!ch[cur][s[i] - 'a']) {
fail[++tot] = ch[getfail(fail[cur], i)][s[i] - 'a'];
len[tot] = len[cur] + 2;
ch[cur][s[i] - 'a'] = tot;
cha[tot] = len[tot] - len[fail[tot]];
fa[tot] = (cha[tot] == cha[fail[tot]]) ? fa[fail[tot]] : fail[tot];
}
last = ch[cur][s[i] - 'a'];
for (int j = last; j; j = fa[j]) {
f[j] = ans[i - len[fa[j]] - cha[j]];
if (fa[j] != fail[j]) f[j] = (f[j] + f[fail[j]]) % mod;
if (i % 2 == 0) ans[i] = (ans[i] + f[j]) % mod;
}
}
printf("%lld", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace zzc {
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int len[maxn], fail[maxn], g[maxn], f[maxn], slink[maxn], dif[maxn],
trans[maxn][26];
int n, tot, lst, le;
char ch[maxn], s[maxn];
inline void init() {
len[0] = 0;
len[1] = -1;
fail[0] = 1;
fail[1] = 0;
tot = 1;
lst = 0;
}
inline int get_fail(int x) {
while (ch[le - len[x] - 1] != ch[le]) x = fail[x];
return x;
}
inline void insert(char c) {
ch[++le] = c;
int p = get_fail(lst);
if (!trans[p][c - 'a']) {
int cur = ++tot;
len[cur] = len[p] + 2;
int tmp = get_fail(fail[p]);
fail[cur] = trans[tmp][c - 'a'];
trans[p][c - 'a'] = cur;
dif[cur] = len[cur] - len[fail[cur]];
if (dif[cur] == dif[fail[cur]])
slink[cur] = slink[fail[cur]];
else
slink[cur] = fail[cur];
}
lst = trans[p][c - 'a'];
}
void work() {
init();
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (register int i = 1, j = 0; i <= (n + 1) >> 1; i++)
s[++j] = ch[i], s[++j] = ch[n - i + 1];
f[0] = 1;
for (register int i = 1; i <= n; i++) {
insert(s[i]);
for (register int x = lst; x > 1; x = slink[x]) {
g[x] = f[i - len[slink[x]] - dif[x]];
if (dif[x] == dif[fail[x]]) g[x] = (g[x] + g[fail[x]]) % mod;
if (i % 2 == 0) f[i] = (f[i] + g[x]) % mod;
}
}
printf("%d\n", f[n]);
}
} // namespace zzc
int main() {
zzc::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
char s[N], t[N];
int n;
void Init() {
scanf("%s", t + 1);
n = strlen(t + 1);
int l = 1, r = n;
int s0 = 0;
while (l <= r) {
s[++s0] = t[l++];
if (l <= r) s[++s0] = t[r--];
}
}
const int mo = 1e9 + 7;
long long f[N];
struct hwt {
int n;
int son[N][26], fa[N], len[N], tot, la;
int dta[N], to[N];
long long g[N];
void build() {
tot = 1;
la = 0;
fa[0] = fa[1] = 1;
len[0] = 0;
len[1] = -1;
s[0] = -1;
}
int gf(int x) {
while (s[n - len[x] - 1] != s[n]) x = fa[x];
return x;
}
void add(int c) {
n++;
int p = gf(la);
if (!son[p][c]) {
int q = ++tot;
len[q] = len[p] + 2;
fa[q] = son[gf(fa[p])][c];
son[p][c] = q;
dta[q] = len[q] - len[fa[q]];
to[q] = (dta[q] == dta[fa[q]] ? to[fa[q]] : fa[q]);
}
p = son[p][c];
la = p;
for (int x = la; x; x = to[x]) {
g[x] = f[n - len[to[x]] - dta[x]];
if (to[x] != fa[x]) g[x] = (g[x] + g[fa[x]]) % mo;
}
}
long long calc() {
long long ans = 0;
for (int x = la; x; x = to[x]) {
ans = (ans + g[x]) % mo;
}
return ans;
}
} suf;
int main() {
Init();
suf.build();
f[0] = 1;
for (int i = 1, _b = n; i <= _b; i++) {
suf.add(s[i] - 'a');
f[i] = suf.calc();
if (i & 1) f[i] = 0;
}
printf("%lld\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long LINF = 2e16;
const int magic = 348;
const int MOD = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1);
template <typename T>
inline void Get(T &first) {
bool f;
char ch;
T res;
while (!isdigit(ch = getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
first = (f ? res : (-res));
}
template <typename T1, typename... T2>
inline void Get(T1 &first, T2 &...second) {
Get(first);
Get(second...);
}
struct fastio {
static const int S = 1e7;
char rbuf[S + 48], wbuf[S + 48];
int rpos, wpos, len;
fastio() { rpos = len = wpos = 0; }
inline char Getchar() {
if (rpos == len) rpos = 0, len = fread(rbuf, 1, S, stdin);
if (!len) return EOF;
return rbuf[rpos++];
}
template <typename T>
inline void Get(T &first) {
char ch;
bool f;
T res;
while (!isdigit(ch = Getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = Getchar())) res = res * 10 + ch - '0';
first = (f ? res : (-res));
}
template <typename T1, typename... T2>
inline void Get(T1 &first, T2 &...second) {
Get(first);
Get(second...);
}
inline void getstring(char *s) {
char ch;
while ((ch = Getchar()) <= 32) {
}
for (; ch > 32; ch = Getchar()) *s++ = ch;
*s = '\0';
}
inline void flush() {
fwrite(wbuf, 1, wpos, stdout);
fflush(stdout);
wpos = 0;
}
inline void Writechar(char ch) {
if (wpos == S) flush();
wbuf[wpos++] = ch;
}
template <typename T>
inline void Print(T first, char ch) {
char s[20];
int pt = 0;
if (first == 0)
s[++pt] = '0';
else {
if (first < 0) Writechar('-'), first = -first;
while (first) s[++pt] = '0' + first % 10, first /= 10;
}
while (pt) Writechar(s[pt--]);
Writechar(ch);
}
template <typename T1, typename... T2>
inline void Print(T1 &first, T2 &...second) {
Print(first, ' ');
Print(second..., ' ');
Writechar('\n');
}
inline void printstring(char *s) {
int pt = 1;
while (s[pt] != '\0') Writechar(s[pt++]);
}
} io;
template <typename T>
inline void check_max(T &first, T cmp) {
first = max(first, cmp);
}
template <typename T>
inline void check_min(T &first, T cmp) {
first = min(first, cmp);
}
template <typename T>
inline T myabs(T first) {
return first >= 0 ? first : -first;
}
template <typename T>
inline T gcd(T first, T second) {
return second == 0 ? first : gcd(second, first % second);
}
template <typename T>
inline T add(T first) {
if (first >= MOD) first -= MOD;
return first;
}
template <typename T>
inline T add(T first, int MO) {
if (first >= MO) first -= MO;
return first;
}
template <typename T>
inline T sub(T first) {
if (first < 0) first += MOD;
return first;
}
template <typename T>
inline T sub(T first, int MO) {
if (first < 0) first += MO;
return first;
}
template <typename T>
inline T mul(T first, T second) {
return 1ll * first * second % MOD;
}
template <typename T>
inline T mul(T first, T second, int MO) {
return 1ll * first * second % MO;
}
template <typename T>
inline void Add(T &first, T second) {
first = add(first + second);
}
template <typename T>
inline void Add(T &first, T second, int MO) {
first = add(first + second, MO);
}
template <typename T>
inline void Sub(T &first, T second) {
first = sub(first - second);
}
template <typename T>
inline void Sub(T &first, T second, int MO) {
first = sub(first - second, MO);
}
template <typename T>
inline void Mul(T &first, T second) {
first = mul(first, second);
}
template <typename T>
inline void Mul(T &first, T second, int MO) {
first = mul(first, second, MO);
}
template <typename T>
inline int quick_pow(int first, T second) {
int res = 1;
while (second) {
if (second & 1) res = 1ll * res * first % MOD;
first = 1ll * first * first % MOD;
second >>= 1;
}
return res;
}
template <typename T>
inline int quick_pow(int first, T second, int MO) {
int res = 1;
while (second) {
if (second & 1) res = 1ll * res * first % MO;
first = 1ll * first * first % MO;
second >>= 1;
}
return res;
}
const int MAXN = 1e6;
char s[MAXN + 48], ss[MAXN + 48];
int n;
int dp[MAXN + 48];
namespace PAM {
int nxt[MAXN + 48][27], fail[MAXN + 48], slink[MAXN + 48], len[MAXN + 48],
diff[MAXN + 48], serie[MAXN + 48], last, tot;
inline int Create() {
++tot;
memset(nxt[tot], 0, sizeof(nxt[tot]));
fail[tot] = slink[tot] = len[tot] = 0;
return tot;
}
inline void init() {
len[0] = 0;
len[1] = -1;
fail[0] = 1;
fail[1] = 0;
slink[0] = slink[1] = 0;
diff[0] = 1;
diff[1] = -1;
memset(nxt[0], 0, sizeof(nxt[0]));
memset(nxt[1], 0, sizeof(nxt[1]));
tot = last = 1;
}
inline int getfail(int pos, int first) {
while (s[pos] != s[pos - len[first] - 1]) first = fail[first];
return first;
}
inline void extend(int pos) {
int w = s[pos] - 'a' + 1, fa = getfail(pos, last);
if (!nxt[fa][w]) {
int cur = Create();
len[cur] = len[fa] + 2;
int tmp = getfail(pos, fail[fa]);
fail[cur] = nxt[tmp][w];
diff[cur] = len[cur] - len[fail[cur]];
if (diff[cur] == diff[fail[cur]])
slink[cur] = slink[fail[cur]];
else
slink[cur] = fail[cur];
nxt[fa][w] = cur;
}
last = nxt[fa][w];
}
inline void calc_dp(int pos) {
for (register int v = last; len[v] > 0; v = slink[v]) {
serie[v] = dp[pos - (len[slink[v]] + diff[v])];
if (diff[v] == diff[fail[v]]) Add(serie[v], serie[fail[v]]);
Add(dp[pos], serie[v]);
}
if (pos & 1) dp[pos] = 0;
}
inline void build() {
dp[0] = 1;
init();
for (register int i = int(1); i <= int(n); i++) {
extend(i), calc_dp(i);
}
}
} // namespace PAM
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
if (n & 1) {
puts("0");
return 0;
}
for (register int i = 1, j = n, pt = 1; i < j; i++, j--, pt += 2)
ss[pt] = s[i], ss[pt + 1] = s[j];
for (register int i = int(1); i <= int(n); i++) s[i] = ss[i];
PAM::build();
printf("%d\n", dp[n]);
io.flush();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int read() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
const int MaxN = 2001234, P = 1e9 + 7;
int n;
char s[MaxN];
namespace PAM {
char s[MaxN];
int ch[MaxN][26], fail[MaxN], len[MaxN], par[MaxN], dif[MaxN], lst, cnt;
void extend(int i) {
int p = lst, c = s[i] - 'a';
while (s[i - len[p] - 1] != s[i]) p = fail[p];
if (!ch[p][c]) {
int np = ++cnt, q = fail[p];
len[np] = len[p] + 2;
while (s[i - len[q] - 1] != s[i]) q = fail[q];
fail[np] = ch[q][c];
ch[p][c] = np;
dif[np] = len[np] - len[fail[np]];
if (dif[np] == dif[fail[np]])
par[np] = par[fail[np]];
else
par[np] = fail[np];
}
lst = ch[p][c];
}
void init() {
cnt = fail[0] = 1;
len[1] = -1;
len[0] = 0;
}
int f[MaxN], g[MaxN];
int dp() {
f[0] = 1;
for (int i = 1; i <= n; i++) {
extend(i);
for (int p = lst; p; p = par[p]) {
g[p] = f[i - len[par[p]] - dif[p]];
if (dif[p] == dif[fail[p]]) (g[p] += g[fail[p]]) %= P;
(f[i] += g[p]) %= P;
}
if (i & 1) f[i] = 0;
}
return f[n];
}
} // namespace PAM
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i * 2 <= n; i++) {
PAM ::s[i * 2 - 1] = s[i];
PAM ::s[i * 2] = s[n - i + 1];
}
PAM ::init();
cout << PAM ::dp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <typename T>
struct modular {
constexpr modular() : val(0) {}
constexpr modular(const modular<T>& _m) : val(_m.val) {}
template <typename U>
constexpr modular(const U& _r = U()) {
val = -MOD <= _r && _r < MOD ? _r : _r % MOD;
if (val < 0) {
val += MOD;
}
}
const T operator()() { return val; }
template <typename U>
explicit operator U() const {
return static_cast<U>(val);
}
modular<T>& operator+=(const modular<T>& _m) {
if ((val += _m.val) >= MOD) {
val -= MOD;
}
return *this;
}
modular<T>& operator-=(const modular<T>& _m) {
if ((val -= _m.val) < 0) {
val += MOD;
}
return *this;
}
modular<T>& operator*=(const modular<T>& _m) {
val = modular<T>(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val))
.val;
return *this;
}
modular<T>& operator/=(const modular<T>& _m) {
T a = _m.val, b = MOD, u = 0, v = 1;
while (a != 0) {
T q = b / a;
b -= q * a;
swap(a, b);
u -= q * v;
swap(u, v);
}
return *this *= u;
}
modular<T>& operator=(const modular<T>& _m) {
val = _m.val;
return *this;
}
template <typename U>
modular<T>& operator+=(const U& _r) {
return *this += modular<T>(_r);
}
template <typename U>
modular<T>& operator-=(const U& _r) {
return *this -= modular<T>(_r);
}
template <typename U>
modular<T>& operator*=(const U& _r) {
return *this *= modular<T>(_r);
}
template <typename U>
modular<T>& operator/=(const U& _r) {
return *this /= modular<T>(_r);
}
template <typename U>
modular<T>& operator=(const U& _r) {
val = modular<T>(_r).val;
return *this;
}
modular<T> operator-() { return modular<T>(-val); }
template <typename U>
friend bool operator==(const modular<U>&, const modular<U>&);
friend std::istream& operator>>(std::istream& os, modular<T>& _m) {
os >> _m.val;
_m *= 1;
return os;
}
friend std::ostream& operator<<(std::ostream& os, const modular<T>& _m) {
return os << _m.val;
}
template <typename U>
modular<T> exp(U e) {
modular<T> res = 1;
modular<T> b = val;
if (e < 0) {
b = 1 / b;
e *= -1;
}
for (; e; e >>= 1) {
if (e & 1) {
res *= b;
}
b *= b;
}
return res;
}
private:
T val;
};
template <typename T>
inline modular<T> operator+(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T>
inline modular<T> operator-(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T>
inline modular<T> operator*(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T>
inline modular<T> operator/(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T>
inline bool operator==(const modular<T>& _lhs, const modular<T>& _rhs) {
return _lhs.val == _rhs.val;
}
template <typename T, typename U>
inline bool operator==(const modular<T>& _lhs, const U& _rhs) {
return _lhs == modular<T>(_rhs);
}
template <typename T, typename U>
inline bool operator==(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) == _rhs;
}
template <typename T>
inline bool operator!=(const modular<T>& _lhs, const modular<T>& _rhs) {
return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const modular<T>& _lhs, const U& _rhs) {
return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const U& _lhs, const modular<T>& _rhs) {
return !(_lhs == _rhs);
}
struct PalindromicTree {
using T = char;
using Ptr = int;
T* s;
int n;
vector<array<Ptr, 26>> tr;
vector<Ptr> fail, slink;
vector<int> len, cnt, sz;
vector<int> diff;
vector<modular<int>> dp, g;
Ptr vc, crt;
PalindromicTree(T* _s, int _n)
: s(_s),
n(_n),
tr(n + 2),
fail(n + 2),
slink(n + 2),
len(n + 2),
cnt(n + 2),
sz(n + 2),
diff(n + 2),
dp(n + 1),
g(n + 2) {
build();
}
void build() {
fail[0] = 1;
len[1] = -1;
vc = 2;
crt = 1;
s[0] = '$';
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int c = s[i] - 'a';
Ptr u = crt;
while (s[i - len[u] - 1] != s[i]) u = fail[u];
if (!tr[u][c]) {
Ptr v = fail[u];
while (s[i - len[v] - 1] != s[i]) v = fail[v];
cnt[vc] = cnt[fail[vc] = tr[v][c]] + 1;
len[tr[u][c] = vc] = len[u] + 2;
diff[vc] = len[vc] - len[fail[vc]];
slink[vc] = (diff[vc] == diff[fail[vc]] ? slink[fail[vc]] : fail[vc]);
++vc;
}
crt = tr[u][c];
++sz[crt];
for (int x = crt; x > 1; x = slink[x]) {
g[x] = dp[i - diff[x] - len[slink[x]]];
if (diff[x] == diff[fail[x]]) g[x] += g[fail[x]];
dp[i] += g[x];
}
if (i & 1) dp[i] = 0;
}
cout << dp[n];
}
};
const int N = 1e6 + 10;
char s[N];
void solve() {
string t;
cin >> t;
int n = t.size();
for (int i = 0; i < n / 2; i++) {
s[1 + i * 2] = t[i];
s[n - i * 2] = t[n / 2 + i];
}
PalindromicTree pt(s, n);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
inline int fmo(int x) { return x + ((x >> 31) & 1000000007); }
int n;
char str[1000005], s[1000005];
struct node {
int len, dif, f;
node *fa, *top, *ch[26];
} t[1000005], *rt = t, *lst = t;
int tot;
inline node *nw(int len) {
node *p = t + (++tot);
p->len = len;
p->fa = p->top = rt;
for (int i = 0; i < 26; i++) p->ch[i] = rt;
return p;
}
inline node *gfa(node *p, int pos) {
while (s[pos] != s[pos - p->len - 1]) p = p->fa;
return p;
}
inline void init() {
rt->top = rt;
rt->fa = t + 1;
for (int i = 0; i < 26; i++) rt->ch[i] = rt;
nw(-1);
}
inline void ins(int c, int pos) {
node *p = gfa(lst, pos);
if (p->ch[c] == rt) {
node *q = nw(p->len + 2);
q->fa = gfa(p->fa, pos)->ch[c];
p->ch[c] = q;
q->dif = q->len - q->fa->len;
q->top = q->dif == q->fa->dif ? q->fa->top : q->fa;
}
lst = p->ch[c];
}
int f[1000005];
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1, l = 1, r = n; i <= n; i++) s[i] = str[(i & 1) ? l++ : r--];
init();
f[0] = 1;
for (int i = 1; i <= n; i++) {
ins(s[i] - 'a', i);
for (node *p = lst; p != rt; p = p->top) {
p->f = f[i - p->top->len - p->dif];
if (p->top != p->fa) p->f = fmo(p->f + p->fa->f - 1000000007);
if (i % 2 == 0) f[i] = fmo(f[i] + p->f - 1000000007);
}
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")
using namespace std;
const int N = 1000005, P = 1e9 + 7;
int S[N], n, fail[N], e[N][26], len[N], ec, last, anc[N], diff[N], m, dp[N],
val[N];
char s[N];
inline int newnode(int l) {
len[++ec] = l;
return ec;
}
inline void init() {
last = 1;
while (n) S[n--] = 0;
S[0] = -1;
while (~ec)
len[ec] = fail[ec] = 0, memset(e[ec], 0, sizeof((e[ec])[0]) * (26)), ec--;
newnode(0);
newnode(-1);
fail[0] = 1;
}
inline int match(int p) {
while (S[n] != S[n - len[p] - 1]) p = fail[p];
return p;
}
inline void extend(int c) {
S[++n] = c;
int cur = match(last);
if (!e[cur][c]) {
int p = newnode(len[cur] + 2);
fail[p] = e[match(fail[cur])][c];
e[cur][c] = p;
diff[p] = len[p] - len[fail[p]];
anc[p] = diff[p] == diff[fail[p]] ? anc[fail[p]] : fail[p];
}
last = e[cur][c];
}
int main() {
scanf("%s", s + 1);
m = strlen(s + 1);
for (register int i = 1, _lim_ = m >> 1; i <= _lim_; i++)
S[(i << 1) - 1] = s[i] - 'a';
for (register int i = 1, _lim_ = m >> 1; i <= _lim_; i++)
S[i << 1] = s[m - i + 1] - 'a';
init();
dp[0] = 1;
for (register int i = 1, _lim_ = m; i <= _lim_; i++) {
extend(S[i]);
for (int x = last; x; x = anc[x]) {
if (anc[x] != fail[x])
val[x] = val[fail[x]];
else
val[x] = 0;
int p = i - len[anc[x]] - diff[x];
val[x] = (val[x] + dp[p]) % P;
if ((~i & 1)) dp[i] = (dp[i] + val[x]) % P;
}
}
printf("%d\n", dp[m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
const int mod = inf + 7;
inline int _sum(int a, int b) { return a + b < mod ? a + b : a + b - mod; }
inline int _mul(int a, int b) { return (1ll * a * b) % mod; }
inline int _sub(int a, int b) { return a >= b ? a - b : a - b + mod; }
inline void _inc(int& x, int y) {
if ((x += y) >= mod) {
x -= mod;
}
}
inline void _dec(int& x, int y) {
if ((x -= y) < 0) {
x += mod;
}
}
inline int _binpow(int x, int pw) {
int res = 1;
int tmp = x;
while (pw > 0) {
if (pw & 1) {
res = _mul(res, tmp);
}
tmp = _mul(tmp, tmp);
pw >>= 1;
}
return res;
}
inline int _div(int a, int b) { return _mul(a, _binpow(b, mod - 2)); }
void read(string& s) { cin >> s; }
void gen(string& s) {
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int n = 2 * (rnd() % 3 + 1);
s.resize(n, '?');
for (int i = 0; i < n; i++) {
s[i] = rnd() % 5 == 0 ? 'a' : 'b';
}
}
string join_halfs(string s) {
int n = (int)s.size();
string t;
for (int i = 0; i < n / 2; i++) {
t.push_back(s[i]);
t.push_back(s[n - 1 - i]);
}
return t;
}
int slow(string s) {
s = join_halfs(s);
int n = (int)s.size();
s = "#" + s;
vector<int> dp(n + 1);
dp[0] = 1;
cout << s << "\n";
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
if ((i - j + 1) % 2) continue;
string hlp = s.substr(j, i - j + 1);
string rhlp = hlp;
reverse(rhlp.begin(), rhlp.end());
if (hlp == rhlp) {
_inc(dp[i], dp[j - 1]);
}
}
}
return dp[n];
}
const int N = 2e6 + 5;
struct Node {
map<int, int> nxt;
int link = -1;
int dp = 0;
int slink = -1;
int len = 0;
int diff = 0;
Node() = default;
};
Node t[N];
int sz, max_suff;
int fast(string s) {
{
sz = 0;
t[sz++] = Node();
t[sz++] = Node();
max_suff = 1;
t[0].link = 1;
t[1].link = 0;
t[0].len = -1;
t[1].len = 0;
}
int n = (int)s.size();
s = "#" + join_halfs(s);
vector<int> dp(n + 1);
dp[0] = 1;
max_suff = 1;
for (int i = 1; i <= n; i++) {
{
while (s[i] != s[i - t[max_suff].len - 1]) {
max_suff = t[max_suff].link;
}
if (!t[max_suff].nxt.count(s[i])) {
t[sz++] = Node();
t[sz - 1].len = t[max_suff].len + 2;
int next_max_suff = t[max_suff].link;
while (s[i] != s[i - t[next_max_suff].len - 1]) {
next_max_suff = t[next_max_suff].link;
}
t[sz - 1].link =
t[next_max_suff].nxt.count(s[i]) ? t[next_max_suff].nxt[s[i]] : 1;
t[sz - 1].diff = t[sz - 1].len - t[t[sz - 1].link].len;
if (t[sz - 1].diff == t[t[sz - 1].link].diff) {
t[sz - 1].slink = t[t[sz - 1].link].slink;
} else {
t[sz - 1].slink = t[sz - 1].link;
}
t[max_suff].nxt[s[i]] = sz - 1;
}
max_suff = t[max_suff].nxt[s[i]];
}
for (int x = max_suff; t[x].len > 0; x = t[x].slink) {
{
int j = i - t[t[x].slink].len - t[x].diff;
t[x].dp = dp[j];
}
if (t[x].diff == t[t[x].link].diff) {
_inc(t[x].dp, t[t[x].link].dp);
}
if (i % 2 == 0) {
_inc(dp[i], t[x].dp);
}
}
}
return dp[n];
}
void WORK() {
string s;
read(s);
cout << fast(s) << "\n";
}
void TEST() {
while (1) {
string s;
gen(s);
cout << "s = " << s << endl;
int sl = slow(s);
int fs = fast(s);
if (sl == fs) {
cout << "OK (" << fs << ")" << endl;
} else {
cout << "WA" << endl;
cout << "exp = " << sl << endl;
cout << "fnd = " << fs << endl;
break;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
WORK();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
const int ALP = 26;
struct PAM {
int next[maxn][ALP];
int fail[maxn];
int len[maxn];
int s[maxn];
int last;
int n;
int p;
int diff[maxn], anc[maxn];
int newnode(int l) {
for (int i = 0; i < ALP; i++) next[p][i] = 0;
len[p] = l;
return p++;
}
void init() {
p = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
s[n] = -1;
fail[0] = 1;
}
int get_fail(int x) {
while (s[n - len[x] - 1] != s[n]) x = fail[x];
return x;
}
void add(int c) {
c = c - 'a';
s[++n] = c;
int cur = get_fail(last);
if (!next[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = next[get_fail(fail[cur])][c];
next[cur][c] = now;
diff[now] = len[now] - len[fail[now]];
if (diff[now] == diff[fail[now]])
anc[now] = anc[fail[now]];
else
anc[now] = fail[now];
}
last = next[cur][c];
}
} pam;
char s[maxn], t[maxn];
long long f[maxn], g[maxn];
const long long mo = 1000000007;
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1);
pam.init();
int k = 0;
for (int i = 1; i <= len / 2; i++) t[++k] = s[i], t[++k] = s[len - i + 1];
memset(f, 0, sizeof(f));
f[0] = 1;
for (int i = 1; i <= k; i++) {
pam.add(t[i]);
int x = pam.last;
while (x > 0) {
g[x] = f[i - pam.len[pam.anc[x]] - pam.diff[x]];
if (pam.diff[x] == pam.diff[pam.fail[x]])
g[x] += g[pam.fail[x]], g[x] %= mo;
if (i % 2 == 0) {
f[i] += g[x];
f[i] %= mo;
}
x = pam.anc[x];
}
}
printf("%lld\n", f[k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gi() {
long long ret = 0;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
char c = ch == '-' ? getchar() : ch;
while (c >= '0' && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ch == '-' ? -ret : ret;
}
const int N = 2000000 + 10;
const int mo = 1e9 + 7;
int n, last, len[N], fail[N], slink[N], link[N], diff[N], allc;
char t[N], s[N];
int f[N], g[N];
map<int, int> tr[N];
int ins(int x) {
int p = last, c = s[x] - 'a';
while (p && s[x - len[p] - 1] != s[x]) p = fail[p];
if (s[x - len[p] - 1] != s[x]) return last = 0;
if (!tr[p][c]) {
int k = fail[p];
while (k && s[x - len[k] - 1] != s[x]) k = fail[k];
if (s[x - len[k] - 1] != s[x])
fail[++allc] = 0;
else
fail[++allc] = tr[k][c];
tr[p][c] = allc;
len[allc] = len[p] + 2;
diff[allc] = len[allc] - len[fail[allc]];
if (diff[allc] == diff[fail[allc]])
slink[allc] = slink[fail[allc]], g[allc] = g[fail[allc]];
else
slink[allc] = allc;
}
return last = tr[p][c];
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
int p = n;
for (int i = 1; i <= n / 2; i += 1) s[i * 2 - 1] = t[i], s[i * 2] = t[p--];
f[0] = 1;
for (int i = 1; i <= n; i += 1) {
for (int o = ins(i); o; o = fail[slink[o]]) {
if (i & 1) break;
g[o] = f[i - len[slink[o]]];
if (diff[o] == diff[fail[o]]) (g[o] += g[fail[o]]) %= mo;
(f[i] += g[o]) %= mo;
}
}
cout << f[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int alpha = 26;
typedef class TrieNode {
public:
int len, dif, g;
TrieNode *ch[alpha];
TrieNode *fail, *slink;
} TrieNode;
typedef class PalindromeTree {
public:
int len;
TrieNode *pool;
TrieNode *top;
TrieNode *odd, *even;
TrieNode *last;
char *str;
TrieNode *newnode(int len) {
top->len = len, top->dif = -1, top->g = 0;
memset(top->ch, 0, sizeof(top->ch));
top->fail = top->slink = NULL;
return top++;
}
PalindromeTree() {}
PalindromeTree(int n) {
pool = new TrieNode[(n + 5)];
str = new char[(n + 5)];
top = pool, len = 0;
odd = newnode(-1), even = newnode(0);
odd->fail = odd, even->fail = odd;
odd->dif = even->dif = -1, last = even, str[0] = 0;
}
TrieNode *extend(TrieNode *p) {
while (str[len - p->len - 1] != str[len]) p = p->fail;
return p;
}
void append(char x) {
str[++len] = x;
int c = x - 'a';
last = extend(last);
if (!last->ch[c]) {
TrieNode *p = newnode(last->len + 2);
p->fail = extend(last->fail)->ch[c];
if (!p->fail) p->fail = even;
last->ch[c] = p;
p->dif = p->len - p->fail->len;
if (p->dif == p->fail->dif)
p->slink = p->fail->slink;
else
p->slink = p->fail;
}
last = last->ch[c];
}
} PalindromeTree;
const int M = 1e9 + 7;
int n;
char bstr[1000005], str[1000005];
PalindromeTree pt;
int *f;
inline void init() {
gets(bstr + 1);
n = strlen(bstr + 1);
for (int i = 1; i <= n; i++) {
if (i & 1)
str[i] = bstr[(i + 1) >> 1];
else
str[i] = bstr[n - (i >> 1) + 1];
}
f = new int[(n + 1)];
memset(f, 0, sizeof(int) * (n + 1));
}
inline void solve() {
pt = PalindromeTree(n);
f[0] = 1;
for (int i = 1; i <= n; i++) {
pt.append(str[i]);
for (TrieNode *p = pt.last; p && p->len > 0; p = p->slink) {
p->g = f[i - p->slink->len - p->dif];
if (p->fail->dif == p->dif) p->g = (p->g + p->fail->g) % M;
if (!(i & 1)) f[i] = (f[i] + p->g) % M;
}
}
printf("%d", f[n]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000003, mod = 1e9 + 7;
char str[N], tmp[N];
int n, ch[N][26], fa[N], len[N], f[N], g[N], dif[N], anc[N], lst, cnt;
void qmo(int &x) { x += x >> 31 & mod; }
void insert(int c, int pos) {
int p = lst;
while (str[pos] != str[pos - len[p] - 1]) p = fa[p];
if (!ch[p][c]) {
int np = ++cnt, q = fa[p];
len[np] = len[p] + 2;
while (str[pos] != str[pos - len[q] - 1]) q = fa[q];
fa[np] = ch[q][c];
ch[p][c] = np;
dif[np] = len[np] - len[fa[np]];
anc[np] = dif[np] == dif[fa[np]] ? anc[fa[np]] : fa[np];
}
lst = ch[p][c];
}
int main() {
scanf("%s", tmp + 1);
n = strlen(tmp + 1);
if (n & 1) return puts("0"), 0;
for (int i = 1; i <= (n >> 1); ++i) {
str[i * 2 - 1] = tmp[i];
str[i * 2] = tmp[n + 1 - i];
}
f[0] = 1;
len[1] = -1;
fa[0] = fa[1] = lst = cnt = 1;
for (int i = 1; i <= n; ++i) {
insert(str[i] - 'a', i);
for (int j = lst; j; j = anc[j]) {
g[j] = f[i - len[anc[j]] - dif[j]];
if (anc[j] != fa[j]) qmo(g[j] += g[fa[j]] - mod);
if (!(i & 1)) qmo(f[i] += g[j] - mod);
}
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int CN = 26;
int nxt[MAXN][CN];
int fail[MAXN];
int cnt[MAXN];
int num[MAXN];
int len[MAXN];
int s[MAXN];
int diff[MAXN];
int slink[MAXN];
int sans[MAXN];
int last;
int n;
int p;
int newnode(int l) {
for (int i = 0; i < CN; ++i) nxt[p][i] = 0;
cnt[p] = 0;
num[p] = 0;
len[p] = l;
return p++;
}
void init() {
p = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
s[n] = -1;
fail[0] = 1;
}
int get_fail(int x) {
while (s[n - len[x] - 1] != s[n]) x = fail[x];
return x;
}
void add(int c) {
c -= 'a';
s[++n] = c;
int cur = get_fail(last);
if (!nxt[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = nxt[get_fail(fail[cur])][c];
nxt[cur][c] = now;
num[now] = num[fail[now]] + 1;
diff[now] = len[now] - len[fail[now]];
if (diff[now] == diff[fail[now]])
slink[now] = slink[fail[now]];
else
slink[now] = fail[now];
}
last = nxt[cur][c];
cnt[last]++;
}
void count() {
for (int i = p - 1; i >= 0; --i) cnt[fail[i]] += cnt[i];
}
char s1[MAXN];
char s2[MAXN];
const int N = 1000005, mo = 1e9 + 7;
int f[N];
int m;
int main() {
scanf("%s", s1 + 1);
int slen = strlen(s1 + 1);
for (int i = 1, j = slen; i <= j; i++, j--) {
s2[++m] = s1[i];
if (j != i) s2[++m] = s1[j];
}
s2[m + 1] = 0;
init();
f[0] = 1;
for (int i = 1; i <= m; i++) {
add(s2[i]);
for (int v = last; len[v] > 0; v = slink[v]) {
int pos = i - (len[slink[v]] + diff[v]);
sans[v] = f[pos];
if (diff[v] == diff[fail[v]]) sans[v] = (sans[v] + sans[fail[v]]) % mo;
f[i] = (f[i] + sans[v]) % mo;
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[m]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, f[1000005], g[1000005];
char S[1000005], T[1000005];
int rt0, rt1, ch[1000005][26];
int cnt = 1, lst, len[1000005], dif[1000005], lnk[1000005], slk[1000005];
void Extend(int p) {
int w = lst;
while (T[p - len[w] - 1] != T[p]) w = lnk[w];
if (!ch[w][T[p] - 'a']) {
int cur = ++cnt, k = lnk[w];
len[cur] = len[w] + 2;
while (T[p - len[k] - 1] != T[p]) k = lnk[k];
lnk[cur] = ch[k][T[p] - 'a'];
ch[w][T[p] - 'a'] = cur;
dif[cur] = len[cur] - len[lnk[cur]];
if (dif[cur] == dif[lnk[cur]])
slk[cur] = slk[lnk[cur]];
else
slk[cur] = lnk[cur];
}
lst = ch[w][T[p] - 'a'];
}
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
for (int i = 1; i <= n / 2; i++) T[2 * i - 1] = S[i];
for (int i = n; i > n / 2; i--) T[2 * (n - i + 1)] = S[i];
len[1] = -1;
lnk[0] = lnk[1] = 1;
f[0] = 1;
for (int i = 1; i <= n; i++) {
Extend(i);
for (int j = lst; j; j = slk[j]) {
g[j] = f[i - (len[slk[j]] + dif[j])];
if (dif[j] == dif[lnk[j]]) g[j] = (g[j] + g[lnk[j]]) % 1000000007;
if (!(i & 1)) f[i] = (f[i] + g[j]) % 1000000007;
}
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005, M = 1e9 + 7;
int len[N], fail[N], dp[N], ne[N][26], diff[N], pre[N], tot, last, f[N];
char s1[N], s[N];
inline int getfail(int x, int y) {
while (s1[y] != s1[y - len[x] - 1]) x = fail[x];
return x;
}
inline void insert(int x, int y) {
int now = getfail(last, y);
if (!ne[now][x]) {
tot++;
len[tot] = len[now] + 2;
fail[tot] = ne[getfail(fail[now], y)][x];
ne[now][x] = tot;
diff[tot] = len[tot] - len[fail[tot]];
if (diff[tot] == diff[fail[tot]])
pre[tot] = pre[fail[tot]];
else
pre[tot] = fail[tot];
}
last = ne[now][x];
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
tot = 1;
last = 0;
len[1] = -1;
fail[0] = pre[0] = 1;
for (int i = 1; i <= n; i++)
if (i & 1)
s1[i] = s[i / 2 + 1];
else
s1[i] = s[n - i / 2 + 1];
dp[0] = 1;
for (int i = 1; i <= n; i++) {
insert(s1[i] - 'a', i);
for (int j = last; j; j = pre[j]) {
f[j] = dp[i - len[pre[j]] - diff[j]];
if (pre[j] != fail[j]) (f[j] += f[fail[j]]) %= M;
if (!(i & 1)) (dp[i] += f[j]) %= M;
}
}
printf("%d\n", dp[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int n, las, tot, cnt;
int len[2000010], fail[2000010], ch[2000010][26], slink[2000010], diff[2000010],
f[2000010], g[2000010];
char s[2000010], str[2000010];
void init() { len[1] = -1, fail[0] = fail[1] = tot = 1; }
void insert(int i) {
int p = las, c = s[i] - 'a';
while (s[i - 1 - len[p]] != s[i]) p = fail[p];
if (ch[p][c]) {
las = ch[p][c];
return;
}
int x = fail[p], y = ++tot;
while (s[i - 1 - len[x]] != s[i]) x = fail[x];
fail[y] = ch[x][c], len[y] = len[p] + 2, ch[p][c] = las = y,
diff[y] = len[y] - len[fail[y]];
if (diff[y] == diff[fail[y]])
slink[y] = slink[fail[y]];
else
slink[y] = fail[y];
}
int main() {
init(), scanf("%s", str + 1), n = strlen(str + 1), f[0] = 1;
for (int i = 1; i <= 2 * n; i += 2) s[i] = str[++cnt];
for (int i = 2; i <= 2 * n; i += 2) s[i] = str[cnt--];
for (int i = 1; i <= n; ++i) {
insert(i);
for (int p = las; p; p = slink[p]) {
g[p] = f[i - len[slink[p]] - diff[p]];
if (slink[p] != fail[p]) g[p] = (g[p] + g[fail[p]]) % 1000000007;
if (!(i & 1)) f[i] = (f[i] + g[p]) % 1000000007;
}
}
printf("%d", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 1e6 + 5;
char s[MAXN];
char str[MAXN];
long long f[MAXN];
long long g[MAXN];
const int N = 26;
struct Palindromic_Tree {
int next[MAXN][N];
int fail[MAXN];
int cnt[MAXN];
int num[MAXN];
int len[MAXN];
int S[MAXN];
int last;
int n;
int p;
int dif[MAXN];
int id[MAXN];
int go[MAXN];
int newnode(int l) {
for (int i = 0; i < N; ++i) next[p][i] = 0;
cnt[p] = 0;
num[p] = 0;
len[p] = l;
return p++;
}
void init() {
p = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
S[n] = -1;
fail[0] = 1;
}
int get_fail(int x) {
while (S[n - len[x] - 1] != S[n]) x = fail[x];
return x;
}
void add(int c) {
S[++n] = c;
int cur = get_fail(last);
if (!next[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = next[get_fail(fail[cur])][c];
next[cur][c] = now;
num[now] = num[fail[now]] + 1;
dif[now] = len[now] - len[fail[now]];
go[now] = dif[now] == dif[fail[now]] ? go[fail[now]] : fail[now];
}
id[n] = last = next[cur][c];
cnt[last]++;
}
void solve() {
for (int i = 1; i <= n; i++) {
int idx = id[i];
int cnt = 0;
for (int j = idx; j; j = go[j]) {
cnt++;
g[j] = f[i - len[go[j]] - dif[j]];
if (dif[j] == dif[fail[j]]) g[j] = (g[j] + g[fail[j]]) % MOD;
if (i % 2 == 0) f[i] = (f[i] + g[j]) % MOD;
}
}
}
} PAM;
int main() {
PAM.init();
scanf("%s", s + 1);
int n = strlen(s + 1);
if (n & 1) return 0 * puts("0");
int cnt = 0;
for (int i = 1; i <= n / 2; i++) {
str[++cnt] = s[i];
str[++cnt] = s[n - i + 1];
}
for (int i = 1; i <= n; i++) PAM.add(str[i] - 'a');
f[0] = 1;
PAM.solve();
printf("%lld\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 1, maxl = 25, mod = (int)1e9 + 7;
int n, m, sta[maxl], dif[maxl], cnt[maxl], f[maxn], g[maxn];
char buf[maxn], str[maxn];
inline void mod_inc(int &x, int y) { (x += y) >= mod && (x -= mod); }
int main() {
scanf("%s", buf + 1);
n = strlen(buf + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n >> 1; ++i) {
str[(i << 1) - 1] = buf[i];
str[i << 1] = buf[n - i + 1];
}
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int tp = m, las = -maxn;
static int tsta[maxl], tdif[maxl], tcnt[maxl];
m = 0;
memcpy(tsta + 1, sta + 1, tp * sizeof(int));
memcpy(tdif + 1, dif + 1, tp * sizeof(int));
memcpy(tcnt + 1, cnt + 1, tp * sizeof(int));
for (int j = 1; j <= tp; ++j) {
if (str[tsta[j]] == str[i]) {
if (m && dif[m] == tsta[j] - 1 - las) {
++cnt[m];
} else {
sta[++m] = tsta[j] - 1;
dif[m] = sta[m] - las;
cnt[m] = 1;
}
las = tsta[j] - 1;
}
if (tcnt[j] > 1 && str[tsta[j] + tdif[j]] == str[i]) {
if (m && dif[m] == tsta[j] + tdif[j] - 1 - las) {
cnt[m] += tcnt[j] - 1;
} else {
sta[++m] = tsta[j] + tdif[j] - 1;
dif[m] = sta[m] - las;
cnt[m] = tcnt[j] - 1;
}
las = tsta[j] + tdif[j] * (tcnt[j] - 1) - 1;
}
}
if (str[i - 1] == str[i]) {
if (m && i - 2 - las == dif[m]) {
++cnt[m];
} else {
sta[++m] = i - 2;
dif[m] = sta[m] - las;
cnt[m] = 1;
}
las = i - 2;
}
if (m && i - 1 - las == dif[m]) {
++cnt[m];
} else {
sta[++m] = i - 1;
dif[m] = sta[m] - las;
cnt[m] = 1;
}
for (int j = 1; j <= m; ++j) {
int tsta = sta[j], tdif = dif[j], tcnt = cnt[j],
tend = tsta + (tcnt - 1) * tdif;
g[tend] = f[tend];
if (tcnt > 1) mod_inc(g[tend], g[tend - tdif]);
mod_inc(f[i], g[tend]);
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
char s[N], t[N], S[N];
int n, go[N][26], len[N], par[N], top, last;
int New(int L) {
len[++top] = L;
return top;
}
int diff[N], slink[N];
void extend(int n) {
int w = S[n], p = last;
while (S[n - len[p] - 1] != w) p = par[p];
if (!go[p][w - 'a']) {
int q = New(len[p] + 2), now = p;
do now = par[now];
while (S[n - len[now] - 1] != w);
par[q] = go[now][w - 'a'];
go[p][w - 'a'] = q;
diff[q] = len[q] - len[par[q]];
slink[q] = (diff[q] == diff[par[q]] ? slink[par[q]] : par[q]);
}
last = go[p][w - 'a'];
}
int ans[N], from[N], _ans[N], sum[N];
char kek[N];
int main() {
scanf("%s", kek + 1);
int n = strlen(kek + 1);
for (int i = 1; i <= n / 2; i++) s[i] = kek[i];
for (int i = 1; i <= n / 2; i++) t[i] = kek[n - i + 1];
n /= 2;
for (int i = 1; i <= n; i++) S[i * 2 - 1] = s[i], S[i * 2] = t[i];
par[0] = top = 1;
len[1] = -1;
n *= 2;
for (int i = 1; i <= n; i++) ans[i] = 0;
_ans[0] = 1;
ans[0] = 1;
for (int i = 1; i <= n; i++) {
extend(i);
for (int p = last; p; p = slink[p]) {
_ans[p] = i - (len[slink[p]] + diff[p]);
sum[p] = ans[_ans[p]];
int cur = p;
if (diff[par[cur]] == diff[cur]) {
sum[cur] += sum[par[cur]];
if (sum[cur] >= mod) sum[cur] -= mod;
}
if (!(i & 1)) {
ans[i] += sum[cur];
if (ans[i] >= mod) ans[i] -= mod;
}
}
}
cout << ans[n] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline void Add(int &a, int b) {
a += b;
a >= 1000000007 ? a -= 1000000007 : 1;
}
inline void Sub(int a, int b) {
a -= b;
a < 0 ? a += 1000000007 : 1;
}
inline int add(int a, int b) {
a += b;
return a >= 1000000007 ? a - 1000000007 : a;
}
const int Q = 1 << 20;
char ss[Q], s[Q];
struct dt {
int st, d, num;
int sm;
};
vector<dt> g, mem, u;
long long ID(int st, int d, int num) {
return 2000000000000LL * st + 1000005LL * d + num;
}
unordered_map<long long, int> rem;
int f[Q];
int G(int st, int d, int num) {
if (num == 1) return f[st - 1];
long long dd = ID(st, d, num);
int val = rem[dd];
if (val) return val - 1;
val = add(G(st, d, num - 1), f[st + (num - 1) * d - 1]);
rem[dd] = val + 1;
return val;
}
void Upd(dt h) { rem[ID(h.st, h.d, h.num)] = h.sm + 1; }
void Get(dt &h) { h.sm = G(h.st, h.d, h.num); }
int main() {
scanf("%s", ss + 1);
int nn = strlen(ss + 1), n = 0;
for (int i = 1, j = nn; i < j; i++, j--) s[++n] = ss[i], s[++n] = ss[j];
s[0] = '#', s[n + 1] = '&';
f[0] = 1;
for (int i = 1; i <= n; i++) {
mem.clear();
for (dt h : g)
if (s[i] == s[h.st - 1]) {
if (s[i] != s[h.st + h.d - 1])
mem.push_back((dt){h.st - 1, -1, 1, f[h.st - 2]});
else
--h.st, Get(h), mem.push_back(h);
} else {
if (h.num == 1) continue;
Sub(h.sm, f[h.st - 1]);
h.st += h.d, --h.num;
Upd(h);
if (s[i] == s[h.st - 1]) --h.st, Get(h), mem.push_back(h);
}
if (s[i] == s[i - 1]) mem.push_back((dt){i - 1, -1, 1, f[i - 2]});
mem.push_back((dt){i, -1, 1, f[i - 1]});
for (int j = 0; j < (int)mem.size() - 1; j++)
if (mem[j].num == 1) mem[j].d = mem[j + 1].st - mem[j].st;
u.clear();
for (int j = 0; j < (int)mem.size(); j++)
if (mem[j].num == 1)
u.push_back(mem[j]);
else {
dt h = mem[j];
int mr = h.st + (h.num - 1) * h.d;
if (h.d != mem[j + 1].st - mr) {
Sub(h.sm, f[mr - 1]);
--h.num;
Upd(h);
u.push_back(h);
u.push_back((dt){mr, mem[j + 1].st - mr, 1, f[mr - 1]});
} else
u.push_back(h);
}
g.clear();
int tp = -1;
for (int j = 0; j < (int)u.size(); j++)
if (tp < 0 || g[tp].d != u[j].d)
g.push_back(u[j]), ++tp;
else
Add(g[tp].sm, u[j].sm), g[tp].num += u[j].num, Upd(g[tp]);
if ((i & 1) ^ 1)
for (dt h : g) Add(f[i], h.sm);
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
char str[1000005], a[1000005];
int n, lst, ch[1000005][30], s[1000005], fail[1000005], len[1000005], tot, cnt,
f[1000005];
int slink[1000005], sum[1000005], diff[1000005], smallen[1000005];
int N(int x) { return len[++cnt] = x, cnt; }
void Clear() {
memset(ch, 0, sizeof(ch)), memset(fail, 0, sizeof(fail)), tot = cnt = 0;
N(0), N(-1), s[0] = -1, fail[1] = fail[2] = 2, lst = 1;
for (int i = 0; i < 26; i++) ch[1][i] = ch[2][i] = 1;
}
void Ins(int c) {
int p = lst;
s[++tot] = c;
while (s[tot - len[p] - 1] ^ c) p = fail[p];
if (ch[p][c] <= 1) {
int t = fail[p], x = N(len[p] + 2);
while (s[tot - len[t] - 1] ^ c) t = fail[t];
fail[x] = ch[t][c], ch[p][c] = x, diff[x] = len[x] - len[fail[x]];
if (diff[x] == diff[fail[x]])
slink[x] = slink[fail[x]], smallen[x] = smallen[fail[x]];
else
slink[x] = fail[x], smallen[x] = len[x];
}
lst = ch[p][c];
}
int main() {
scanf("%s", str + 1), Clear(), n = strlen(str + 1);
for (int i = 1, j = n, cnt = 1; cnt <= n; cnt++) {
if (cnt % 2 == 1)
a[cnt] = str[i++];
else
a[cnt] = str[j--];
}
f[0] = 1;
for (int i = 1; i <= n; i++) {
Ins(a[i] - 'a');
for (int p = lst; len[p] > 0; p = slink[p]) {
sum[p] = f[i - smallen[p]];
if (slink[p] != fail[p]) sum[p] = (sum[p] + sum[fail[p]]) % mod;
if (i % 2 == 0) f[i] = (f[i] + sum[p]) % mod;
}
}
cout << f[n];
return 0;
}
|
#include <bits/stdc++.h>
char s[2000005], ss[2000005];
int n, ans[2000005];
int read() {
char c = getchar();
int ans = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans;
}
void Write(int x) {
if (x < 10)
putchar(x ^ 48);
else
Write(x / 10), putchar((x % 10) ^ 48);
return;
}
int add(int x, int y) { return (x += y) >= 1000000007 ? x - 1000000007 : x; }
int sub(int x, int y) { return (x -= y) < 0 ? x + 1000000007 : x; }
namespace PAM {
int son[2000005][26], len[2000005], anc[2000005], diff[2000005], sum[2000005],
fail[2000005], last, cnt;
void init() {
len[1] = -1, len[0] = 0, fail[0] = 1, fail[1] = 0, last = cnt = 1;
return;
}
int get_fail(int x, int p) {
while (s[p - len[x] - 1] != s[p]) x = fail[x];
return x;
}
void Insert(int x, int p) {
int now = get_fail(last, p);
if (!son[now][x])
len[++cnt] = len[now] + 2, fail[cnt] = son[get_fail(fail[now], p)][x],
son[now][x] = cnt, diff[cnt] = len[cnt] - len[fail[cnt]],
anc[cnt] = (diff[cnt] == diff[fail[cnt]] ? anc[fail[cnt]] : fail[cnt]);
return (void)(last = son[now][x]);
}
} // namespace PAM
int main() {
PAM::init();
scanf("%s", ss + 1);
n = strlen(ss + 1);
for (register int i = 1; i <= n; i += 2) s[i] = ss[(i + 1) / 2];
std::reverse(ss + 1, ss + 1 + n);
for (register int i = 2; i <= n; i += 2) s[i] = ss[i / 2];
ans[0] = 1;
for (register int i = 1; i <= n; i++) {
PAM::Insert(s[i] - 'a', i);
for (register int j = PAM::last; j; j = PAM::anc[j]) {
PAM::sum[j] = ans[i - PAM::len[PAM::anc[j]] - PAM::diff[j]];
if (PAM::anc[j] != PAM::fail[j])
PAM::sum[j] = add(PAM::sum[j], PAM::sum[PAM::fail[j]]);
if (!(i & 1)) ans[i] = add(ans[i], PAM::sum[j]);
}
}
Write(ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LETTER = 26, MOD = 1000000007;
int add(int x, int y) { return x + y >= MOD ? x + y - MOD : x + y; }
struct PAMNode {
int fail, len, go[LETTER], slink, diff;
PAMNode(int f = 0, int l = 0) : fail(f), len(l), go{}, slink(0), diff(0) {}
};
struct PAM {
vector<PAMNode> a;
vector<int> s;
int last, n;
int dp[1000200], sum[1000020];
PAM() : a(0), s(1, -1), last(0), n(1) {
a.emplace_back(1, 0);
a.emplace_back(1, -1);
dp[0] = 1;
}
int getFail(int v) {
while (s[n - a[v].len - 2] != s[n - 1]) v = a[v].fail;
return v;
}
int insert(int x) {
s.push_back(x), n++;
last = getFail(last);
if (!a[last].go[x]) {
a.emplace_back(a[getFail(a[last].fail)].go[x], a[last].len + 2);
a.back().diff = a.back().len - a[a.back().fail].len;
a.back().slink = a.back().diff == a[a.back().fail].diff
? a[a.back().fail].slink
: a.back().fail;
a[last].go[x] = (int)a.size() - 1;
}
return last = a[last].go[x];
}
void trans(int i) {
for (int p = last; a[p].len > 0; p = a[p].slink) {
sum[p] = dp[i - a[a[p].slink].len - a[p].diff];
if (a[p].diff == a[a[p].fail].diff) sum[p] = add(sum[p], sum[a[p].fail]);
if (i % 2 == 0) dp[i] = add(dp[i], sum[p]);
}
}
} pam;
int main() {
string s;
deque<char> deq;
char ch = getchar();
while (isalpha(ch)) {
deq.push_back(ch);
ch = getchar();
}
int tot = 0;
while (!deq.empty()) {
if (++tot & 1)
s += deq.front(), deq.pop_front();
else
s += deq.back(), deq.pop_back();
}
for (int i = 0; i < (int)s.length(); ++i) {
pam.insert(s[i] - 'a');
pam.trans(i + 1);
}
printf("%d\n", pam.dp[pam.n - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string func(int c4, int c7) {
string res;
while (c4--) res += '4';
while (c7--) res += '7';
return res;
}
int main() {
string s;
while (cin >> s) {
int n = s.size();
if (n % 2 == 1) {
cout << string((n + 1) / 2, '4') << string((n + 1) / 2, '7') << endl;
continue;
}
string t = string(n / 2, '7') + string(n / 2, '4');
if (t < s) {
cout << string(n / 2 + 1, '4') << string(n / 2 + 1, '7') << endl;
continue;
}
int c4 = n / 2, c7 = n / 2;
string res;
for (int i = 0; i < n; ++i) {
if (c4 == 0 || c7 == 0) {
string s2 = s.substr(i);
if (s2 > func(c4, c7)) {
int k = res.find_last_of('4');
c4++;
c7 += res.size() - k - 2;
res = res.substr(0, k) + "7" + func(c4, c7);
} else {
res += func(c4, c7);
}
break;
}
if (s[i] == '4') {
res += '4';
c4--;
} else if (s[i] == '7') {
res += '7';
c7--;
} else if (s[i] < '4') {
res += func(c4, c7);
break;
} else if (s[i] < '7') {
res += '7';
c7--;
res += func(c4, c7);
break;
} else if (s[i] > '7') {
int k = res.find_last_of('4');
c4++;
c7 += res.size() - k - 2;
res = res.substr(0, k) + "7" + func(c4, c7);
break;
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
long long result = 200000000000;
void add(long long x, int d) {
if (x < result) {
if (d == 0 && x >= N) {
result = x;
} else {
add(x * 10 + 4, d + 1);
add(x * 10 + 7, d - 1);
}
}
}
int main() {
cin >> N;
add(4, 1);
add(7, -1);
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char num[1000010];
int dp[1000010];
int num4[1000010];
int num7[1000010];
int ps4 = 0;
bool is = 1;
int cao = 0;
int hehe = 0;
int main() {
gets(num);
int len = strlen(num);
for (int i = len; i >= 1; i--) num[i] = num[i - 1];
if (len % 2) {
len++;
len /= 2;
for (int i = 1; i <= len; i++) printf("%d", 4);
for (int i = 1; i <= len; i++) printf("%d", 7);
} else {
int max4 = len / 2;
int max7 = max4;
for (int i = 1; i <= len; i++) {
num4[i] = num4[i - 1];
num7[i] = num7[i - 1];
if (hehe) {
num7[i]++;
dp[i] = 7;
is = 0;
hehe = 0;
continue;
}
if (!is || num[i] < '4') {
if (num4[i] < max4) {
dp[i] = 4;
num4[i]++;
if (num7[i] < max7) ps4 = i;
} else {
dp[i] = 7;
num7[i]++;
}
is = 0;
} else {
if (num[i] == '4') {
if (num4[i] < max4) {
dp[i] = 4;
num4[i]++;
if (num7[i] < max7) ps4 = i;
} else {
dp[i] = 7;
num7[i]++;
is = 0;
}
} else if (num[i] < '7') {
if (num7[i] < max7) {
dp[i] = 7;
num7[i]++;
is = 0;
} else {
if (ps4 == 0) {
cao = 1;
break;
} else {
num4[ps4]--;
i = ps4 - 1;
hehe = 1;
}
}
} else if (num[i] == '7') {
if (num7[i] < max7) {
dp[i] = 7;
num7[i]++;
} else {
if (ps4 == 0) {
cao = 1;
break;
} else {
num4[ps4]--;
i = ps4 - 1;
hehe = 1;
}
}
} else {
if (ps4 == 0) {
cao = 1;
break;
} else {
num4[ps4]--;
i = ps4 - 1;
hehe = 1;
}
}
}
}
if (cao) {
len /= 2;
len++;
for (int i = 1; i <= len; i++) printf("4");
for (int i = 1; i <= len; i++) printf("7");
} else
for (int i = 1; i <= len; i++) printf("%d", dp[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 2e18;
const long long int N = 1e6;
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
long long int fact(long long int n) {
long long int ans = 1;
for (long long int i = 1; i <= n; i++) ans = (ans * i) % 1000000000;
return ans;
}
long long int exp(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n % 2 == 1) res = (res * x) % 1000000000;
x = (x * x) % 1000000000;
n = n / 2;
}
return res;
}
void null() {
long long int n;
cin >> n;
string s = to_string(n);
long long int m = s.size() % 2 ? s.size() + 1 : s.size();
vector<long long int> v;
string z = "";
for (int i = 0; i < m / 2; i++) z += '4';
for (int i = 0; i < m / 2; i++) z += '7';
do {
long long int ans = stoll(z);
v.push_back(ans);
} while (next_permutation(z.begin(), z.end()));
z += '4';
z += '7';
sort(z.begin(), z.end());
v.push_back(stoll(z));
cout << (*lower_bound(v.begin(), v.end(), n)) << '\n';
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(9);
cout << fixed;
long long int t = 1;
clock_t start, end;
start = clock();
while (t--) {
null();
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 1e6 + 20;
int n, l0, l;
char f[N];
char g[N];
void init() {
scanf("%s", &f);
n = strlen(f);
}
bool pd() {
for (int i = 0; i < n / 2; i++)
if (f[i] != '7') {
if (f[i] > '7') return false;
return true;
}
for (int i = n / 2; i < n; i++)
if (f[i] != '4') {
if (f[i] > '4') return false;
return true;
}
return true;
}
void work() {
if (n % 2 == 1) {
n++;
for (int i = 1; i <= n / 2; i++) printf("4");
for (int i = 1; i <= n / 2; i++) printf("7");
return;
}
if (!pd()) {
n += 2;
for (int i = 1; i <= n / 2; i++) printf("4");
for (int i = 1; i <= n / 2; i++) printf("7");
return;
}
bool sign = false;
int cnt = 0, pos = -1, p2;
for (int i = 0; i < n; i++) {
if (sign) {
f[i] = '4';
continue;
}
if (f[i] == '4') {
pos = i;
continue;
}
if (f[i] == '7') {
continue;
}
if (f[i] < '4') {
f[i] = '4';
sign = true;
continue;
}
if (f[i] < '7') {
f[i] = '7';
sign = true;
continue;
}
if (f[i] > '7') {
f[pos] = '7';
i = pos;
sign = true;
}
}
cnt = 0;
for (int i = 0; i < n; i++)
if (f[i] == '7') cnt++;
if (cnt > n / 2) {
cnt = 0;
f[n] = '4';
for (int i = 0; i <= n; i++) {
if (f[i] == '7')
cnt++;
else {
if (cnt >= n / 2) {
f[pos] = '7';
for (int j = pos + 1; j < n; j++) f[j] = '4';
break;
}
pos = i;
}
}
cnt = 0;
for (int i = 0; i < n; i++)
if (f[i] == '7') cnt++;
}
for (int i = n - 1; i >= 0; i--)
if (f[i] == '4') {
if (cnt >= n / 2) {
break;
}
cnt++;
f[i] = '7';
}
f[n] = '\0';
printf("%s\n", f);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int flag, n;
void f(int a, int b, long long c) {
if (flag || a < 0 || a > b) return;
if (a == 0 && b == 0 && c >= n) {
flag = 1;
cout << c << endl;
return;
}
f(a - 1, b - 1, c * 10 + 4);
f(a, b - 1, c * 10 + 7);
}
int main() {
cin >> n;
int l, t = n, m = 2;
while (t /= 10) m++;
for (l = m - m % 2, flag = 0; l <= m + m % 2; l += 2) f(l / 2, l, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
char txt[N];
int czworki[N], siodemki[N];
int main() {
scanf("%s", txt);
int n = strlen(txt);
if (n % 2 == 1) {
for (int i = (n - 1); i >= (0); --i) txt[i + 1] = txt[i];
txt[0] = '0';
n++;
txt[n] = 0;
}
int a = 0, b = 0;
for (int i = 0; i < (n); ++i) {
czworki[i] = a;
siodemki[i] = b;
if (txt[i] == '4') a++;
if (txt[i] == '7') b++;
}
if (a + b == n && a == b) {
puts(txt);
return 0;
}
for (int i = (n - 1); i >= (0); --i) {
a = czworki[i];
b = siodemki[i];
if (a + b != i || a > n / 2 || b > n / 2) continue;
int co = -1;
if (txt[i] < '4' && (a + 1) <= n / 2)
co = 4;
else if (txt[i] < '7' && (b + 1) <= n / 2)
co = 7;
if (co == -1) continue;
for (int j = 0; j < (i); ++j) putchar(txt[j]);
putchar('0' + co);
if (co == 4)
a++;
else
b++;
for (int j = 0; j < (n - (i + 1)); ++j) {
if (a + 1 <= n / 2)
putchar('4'), a++;
else
putchar('7');
}
puts("");
return 0;
}
for (int i = 0; i < (n / 2 + 1); ++i) putchar('4');
for (int i = 0; i < (n / 2 + 1); ++i) putchar('7');
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec;
void func(long long x, long long f, long long s) {
if (x > 1e10) return;
if (f == s) vec.push_back(x);
func(x * 10 + 4, f + 1, s);
func(x * 10 + 7, f, s + 1);
}
int main() {
func(0, 0, 0);
sort(vec.begin(), vec.end());
long long n;
cin >> n;
for (int i = 0;; i++) {
if (n <= vec[i]) {
cout << vec[i];
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653589793238462643383279502884;
int arr[8][8];
vector<long long int> v;
void solve(long long int x) {
if (x > 1e12) return;
v.push_back(x + 4), v.push_back(x + 7);
solve((x + 4) * 10);
solve((x + 7) * 10);
}
bool check(long long int x) {
int a4 = 0, a7 = 0;
while (x > 0) {
(x % 10 == 7) ? a7++ : a4++;
x /= 10;
}
return a7 == a4;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
solve(0);
sort(v.begin(), v.end());
vector<long long int> vec;
for (auto c : v)
if (check(c)) vec.push_back(c);
if (binary_search(vec.begin(), vec.end(), n))
cout << vec[(lower_bound(vec.begin(), vec.end(), n) - vec.begin())];
else
cout << vec[(upper_bound(vec.begin(), vec.end(), n) - vec.begin())];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:10240000000,10240000000")
char str[1000000];
char ans[1000000];
int n;
bool dfs(int pos, int num4, int num7, bool flag) {
if (pos == n) {
ans[n] = '\0';
return true;
} else {
if (flag) {
ans[pos] = '4';
if (num4 > 0) return dfs(pos + 1, num4 - 1, num7, flag);
ans[pos] = '7';
return dfs(pos + 1, num4, num7 - 1, flag);
} else {
if (str[pos] <= '4' && num4) {
ans[pos] = '4';
if (dfs(pos + 1, num4 - 1, num7, str[pos] < '4')) return true;
}
if (str[pos] <= '7' && num7) {
ans[pos] = '7';
if (dfs(pos + 1, num4, num7 - 1, str[pos] < '7')) return true;
}
}
}
return false;
}
void solved(int cas) {
scanf("%s", str);
n = strlen(str);
if (n & 1 || !dfs(0, n >> 1, n >> 1, false)) {
n = (n >> 1) + 1;
for (int i = 0; i < n; i++) printf("4");
for (int i = 0; i < n; i++) printf("7");
printf("\n");
} else
printf("%s\n", ans);
}
int main() {
int T = 1;
for (int nT = 1; nT <= T; ++nT) {
solved(nT);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long> s;
void solve(long long i) {
s.insert(i);
if (i >= 1e9) {
return;
}
solve(i * 10 + 4);
solve(i * 10 + 7);
}
bool can(long long t) {
int c = 0, c1 = 0;
while (t) {
if (t % 10 == 4)
c++;
else
c1++;
t /= 10;
}
if (c == c1)
return true;
else
return false;
}
int main() {
long long x;
cin >> x;
solve(0);
set<long long>::iterator y;
y = s.lower_bound(x);
long long z;
while (1) {
if (can(*y)) {
cout << *y;
return 0;
}
y = s.upper_bound(*y);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
queue<pair<long long, int> > q;
q.push(make_pair(4, 1));
q.push(make_pair(7, -1));
pair<long long, int> u;
while (!q.empty()) {
u = q.front();
q.pop();
if (u.first >= n && u.second == 0) {
cout << u.first << endl;
return 0;
}
q.push(make_pair(u.first * 10 + 4, u.second + 1));
q.push(make_pair(u.first * 10 + 7, u.second - 1));
}
return 0;
}
|
#include <bits/stdc++.h>
const int c = 100500;
char tmp[c];
int len;
int a[c];
int b[c];
int c4, c7;
bool w;
int main() {
gets(tmp);
len = strlen(tmp);
int i, j, k;
for (i = 0; i < len; ++i) a[i] = tmp[i] - '0';
if (len & 1) {
len++;
for (i = len - 1; i >= 1; --i) a[i] = a[i - 1];
a[0] = 0;
}
w = 0;
for (i = 0; i < len; ++i) {
if (w) {
if (c4 < len / 2)
b[i] = 4, ++c4;
else
b[i] = 7, ++c7;
} else {
if (a[i] < 4) {
if (c4 < len / 2)
b[i] = 4, ++c4;
else
b[i] = 7, ++c7;
w = 1;
} else if (a[i] == 4) {
if (c4 < len / 2)
b[i] = 4, ++c4;
else
b[i] = 7, ++c7, w = 1;
} else if (a[i] < 7) {
if (c7 < len / 2)
b[i] = 7, ++c7, w = 1;
else {
for (j = i - 1; j >= 0; --j)
if (b[j] == 7) break;
if (j < 0) break;
for (k = j - 1; k >= 0; --k)
if (b[k] == 4) break;
if (k < 0) break;
b[k] = 7, w = 1;
c4 = c7 = 0;
for (j = 0; j <= k; ++j)
if (b[j] == 4)
++c4;
else
++c7;
i = k;
}
} else if (a[i] == 7) {
if (c7 < len / 2)
b[i] = 7, ++c7;
else {
for (j = i - 1; j >= 0; --j)
if (b[j] == 7) break;
if (j < 0) break;
for (k = j - 1; k >= 0; --k)
if (b[k] == 4) break;
if (k < 0) break;
b[k] = 7, w = 1;
c4 = c7 = 0;
for (j = 0; j <= k; ++j)
if (b[j] == 4)
++c4;
else
++c7;
i = k;
}
} else {
if (c7 < len / 2) {
for (k = i - 1; k >= 0; --k)
if (b[k] == 4) break;
} else {
for (j = i - 1; j >= 0; --j)
if (b[j] == 7) break;
if (j < 0) break;
for (k = j - 1; k >= 0; --k)
if (b[k] == 4) break;
}
if (k < 0) break;
b[k] = 7, w = 1;
c4 = c7 = 0;
for (j = 0; j <= k; ++j)
if (b[j] == 4)
++c4;
else
++c7;
i = k;
}
}
}
if (i < len) {
len += 2;
for (i = 0; i < len / 2; ++i) b[i] = 4;
for (i = len / 2; i < len; ++i) b[i] = 7;
}
for (i = 0; i < len; ++i) printf("%d", b[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a;
string b;
int t;
int main() {
cin >> a;
t = a.size();
int x = t / 2;
while (x--) b += '7';
x = t / 2;
while (x--) b += '4';
if (t % 2) {
reverse(b.begin(), b.end());
cout << "4" << b << "7";
return 0;
}
int update = 0;
for (int i = 0; i < t; i++) {
if (a[i] > b[i]) {
update = 1;
break;
} else if (a[i] < b[i])
break;
}
if (update) {
reverse(b.begin(), b.end());
cout << "4" << b << "7";
return 0;
}
int xx = t / 2;
int yy = t / 2;
update = -1;
for (int i = 0; i < t; i++) {
if (a[i] == '4') {
xx--;
if (xx < 0) {
update = i;
break;
}
} else if (a[i] == '7') {
yy--;
if (yy < 0) {
update = i;
break;
}
} else {
if (a[i] > '7') {
update = i;
break;
} else if (a[i] > '4') {
if (yy) {
for (int y = 0; y < i; y++) cout << a[y];
yy--;
cout << "7";
while (xx--) cout << "4";
while (yy--) cout << "7";
return 0;
} else {
update = i;
break;
}
} else {
if (xx) {
for (int y = 0; y < i; y++) cout << a[y];
xx--;
cout << "4";
while (xx--) cout << "4";
while (yy--) cout << "7";
return 0;
}
}
}
}
if (update == -1) {
cout << a;
return 0;
}
int ch = 0;
int oo = 0;
for (int i = 0; i < update; i++) {
if (a[i] == '7') oo++;
if (a[i] == '4' && oo != t / 2) ch = i;
}
xx = t / 2;
yy = t / 2;
for (int i = 0; i < ch; i++) {
if (a[i] == '4')
xx--;
else
yy--;
cout << a[i];
}
yy--;
cout << "7";
while (xx--) cout << "4";
while (yy--) cout << "7";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100001;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u,
v, w, x, y, z;
string ss, st;
cin >> ss;
st = ss;
stringstream qq;
qq << st;
qq >> b;
long long int four = 0, seven = 0;
bool ans = false;
for (i = 0; i < ss.size(); i++) {
if (ss[i] == '4')
four++;
else if (ss[i] == '7')
seven++;
else {
ans = true;
break;
}
}
if (four == seven && four > 0 && seven > 0 && !ans)
cout << ss << endl;
else if (ans || four != seven) {
if (ss.size() % 2 != 0) {
d = ss.size() + 1;
e = d / 2;
for (i = 1; i <= e; i++) cout << "4";
for (i = 1; i <= e; i++) cout << "7";
cout << endl;
} else if (ss[0] > '7') {
d = ss.size();
e = (d / 2) + 1;
for (i = 1; i <= e; i++) cout << "4";
for (i = 1; i <= e; i++) cout << "7";
cout << endl;
} else if ((four == ss.size() || seven == ss.size())) {
d = ss.size() + 2;
e = d / 2;
for (i = 1; i <= e; i++) cout << "4";
for (i = 1; i <= e; i++) cout << "7";
cout << endl;
} else {
four = seven = 0;
for (i = 0; i < ss.size(); i++) {
if (ss[i] < '4')
ss[i] = '4';
else if (ss[i] > '4')
ss[i] = '7';
if (ss[i] == '4')
four++;
else
seven++;
}
d = ss.size() / 2;
if (four > seven) {
e = four - d;
c = 0;
for (i = ss.size() - 1; i >= 0; i--) {
if (ss[i] == '4') {
ss[i] = '7';
c++;
if (c == e) break;
}
}
} else if (seven > four) {
e = seven - d;
c = 0;
for (i = ss.size() - 1; i >= 0; i--) {
if (ss[i] == '7') {
ss[i] = '4';
c++;
if (e == c) break;
}
}
}
stringstream pp;
pp << ss;
pp >> d;
if (d > b) {
a = d;
a--;
t = 0;
for (i = 1; i <= MAX; i++) {
n = a;
four = seven = 0;
if (n > 0) {
bool ans2 = false;
while (n) {
e = n % 10;
n /= 10;
if (e == 4)
four++;
else if (e == 7)
seven++;
else {
ans2 = true;
break;
}
}
if (four == seven && !ans2 && four > 0 && seven > 0 && a > b) {
d = a;
} else if (a < b) {
t = 1;
}
} else
break;
if (t == 1) break;
a--;
}
cout << d << endl;
return 0;
} else if (d < b) {
for (i = d + 1;; i++) {
four = seven = 0;
a = i;
bool ans3 = false;
while (a) {
e = a % 10;
a /= 10;
if (e == 4)
four++;
else if (e == 7)
seven++;
else {
ans3 = true;
break;
}
}
if (four == seven && !ans3 && four > 0 && seven > 0) {
cout << i << endl;
return 0;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
char ans[100005];
int len;
bool dfs(int pos, int n4, int n7, bool tag) {
if (pos >= len) return true;
if (tag) {
for (int i = 0; i < n4; i++) ans[i + pos] = '4';
for (int i = 0; i < n7; i++) ans[i + pos + n4] = '7';
return true;
}
if (s[pos] <= '4' && n4) {
if (dfs(pos + 1, n4 - 1, n7, s[pos] < '4')) {
ans[pos] = '4';
return true;
}
}
if (s[pos] <= '7' && n7) {
if (dfs(pos + 1, n4, n7 - 1, s[pos] < '7')) {
ans[pos] = '7';
return true;
}
}
return false;
}
int main() {
while (cin >> s) {
len = strlen(s);
if (len % 2 == 1 || !dfs(0, len / 2, len / 2, 0)) {
len += 1 + (len % 2 == 0);
for (int i = 0; i < len / 2; i++) ans[i] = '4';
for (int i = len / 2; i < len; i++) ans[i] = '7';
}
ans[len] = '\0';
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[15];
int tot;
long long num[10000];
void dfs(long long n, int n4, int n7) {
if ((n4 + n7) % 2 == 0 && n4 == n7 && n4 > 0 && n7 > 0) {
num[++tot] = n;
}
if (n4 + n7 < 10) {
dfs(n * 10 + 4, n4 + 1, n7);
dfs(n * 10 + 7, n4, n7 + 1);
}
}
int main() {
scanf("%s", str);
tot = 0;
int n = strlen(str);
dfs(0, 0, 0);
sort(num + 1, num + tot + 1);
int temp = atoi(str);
for (int i = 1; i <= tot; i++) {
if (num[i] >= temp) {
cout << num[i] << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> ourLuckyNumbers;
long long n;
void genPossibleValues(long long value, int numberSevens, int numberFours) {
if (value > 10000000000LL) {
return;
}
if (numberFours == numberSevens) {
ourLuckyNumbers.push_back(value);
}
genPossibleValues(value * 10LL + 4, numberSevens, numberFours + 1);
genPossibleValues(value * 10LL + 7, numberSevens + 1, numberFours);
}
int main() {
cin >> n;
genPossibleValues(0, 0, 0);
sort(ourLuckyNumbers.begin(), ourLuckyNumbers.end());
int positionOfNumber =
lower_bound(ourLuckyNumbers.begin(), ourLuckyNumbers.end(), n) -
ourLuckyNumbers.begin();
cout << ourLuckyNumbers[positionOfNumber] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, n;
cin >> n;
long long arr[] = {
47, 74, 4477, 4747, 4774, 7447, 7474,
7744, 444777, 447477, 447747, 447774, 474477, 474747,
474774, 477447, 477474, 477744, 744477, 744747, 744774,
747447, 747474, 747744, 774447, 774474, 774744, 777444,
44447777, 44474777, 44477477, 44477747, 44477774, 44744777, 44747477,
44747747, 44747774, 44774477, 44774747, 44774774, 44777447, 44777474,
44777744, 47444777, 47447477, 47447747, 47447774, 47474477, 47474747,
47474774, 47477447, 47477474, 47477744, 47744477, 47744747, 47744774,
47747447, 47747474, 47747744, 47774447, 47774474, 47774744, 47777444,
74444777, 74447477, 74447747, 74447774, 74474477, 74474747, 74474774,
74477447, 74477474, 74477744, 74744477, 74744747, 74744774, 74747447,
74747474, 74747744, 74774447, 74774474, 74774744, 74777444, 77444477,
77444747, 77444774, 77447447, 77447474, 77447744, 77474447, 77474474,
77474744, 77477444, 77744447, 77744474, 77744744, 77747444, 77774444,
4444477777};
while (1) {
if (arr[i] >= n) {
cout << arr[i];
return 0;
}
i++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 5;
char ans[maxn];
char s[maxn];
int len;
bool dfs(int pos, int n4, int n7, int flag) {
int i;
if (pos >= len) return true;
if (flag) {
for (i = n4 - 1; i >= 0; i--) ans[i + pos] = '4';
for (i = n7 - 1; i >= 0; i--) ans[i + n4 + pos] = '7';
return true;
}
if (s[pos] <= '4' && n4) {
if (dfs(pos + 1, n4 - 1, n7, s[pos] < '4')) {
ans[pos] = '4';
return true;
}
}
if (s[pos] <= '7' && n7) {
if (dfs(pos + 1, n4, n7 - 1, s[pos] < '7')) {
ans[pos] = '7';
return true;
}
}
return false;
}
int main() {
int i, j;
int flag;
int n4, n7;
while (cin >> s) {
flag = 0;
len = strlen(s);
if (len % 2 == 1 || !dfs(0, len / 2, len / 2, 0)) {
if (len % 2 == 1)
len = len + 1;
else
len = len + 2;
for (i = 0; i < len; i++)
if (i < len / 2)
ans[i] = '4';
else
ans[i] = '7';
}
cout << ans << endl;
memset(s, 0, sizeof(s));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char second[1000010], res[1000010];
int n;
bool flag;
void sol(int p, int fst, int sed, bool e) {
if (p == n) {
flag = true;
res[n] = '\0';
return;
}
if (e) {
int i;
for (i = p; fst * 2 < n; i++, fst++) res[i] = '4';
for (; i < n; i++) res[i] = '7';
res[n] = '\0';
flag = true;
return;
} else {
if ('7' < second[p]) return;
if (fst * 2 < n && '4' >= second[p])
res[p] = '4', sol(p + 1, fst + 1, sed, '4' > second[p]);
if (flag) return;
if (sed * 2 < n && '7' >= second[p])
res[p] = '7', sol(p + 1, fst, sed + 1, '7' > second[p]);
}
}
int main() {
scanf("%s", second);
n = strlen(second);
if (n & 1) {
n = (n + 1) / 2;
for (int i = 0; i < n; i++) printf("4");
for (int i = 0; i < n; i++) printf("7");
printf("\n");
} else {
sol(0, 0, 0, 0);
if (flag)
printf("%s\n", res);
else {
n = (n + 2) / 2;
for (int i = 0; i < n; i++) printf("4");
for (int i = 0; i < n; i++) printf("7");
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool eq(double a, double b) { return fabs(a - b) < 1e-9; }
const long long int inf = 1e15;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
int n;
string str;
string sol(int n) {
string ans;
for (int i = (0); i < (n); i++) {
ans = ans + (i < n / 2 ? "4" : "7");
}
return ans;
}
void solve(int i, int c4, int c7) {
int j = i + 1;
for (int k = (j); k < (n); k++) {
str[k] = '4';
c4++;
}
for (int k = (n - 1); k >= (i + 1); k--) {
if (c4 > c7) {
str[k] = '7';
c4--;
c7++;
} else {
break;
}
}
cout << str << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> str;
n = str.length();
if (n & 1) {
cout << sol(n + 1) << endl;
} else {
int ind = -1, c4 = 0, c7 = 0;
for (int i = (0); i < (n); i++) {
if (str[i] > '7') {
if (ind == -1) {
cout << sol(n + 2) << endl;
return 0;
} else {
str[ind] = '7';
str[i] = '4';
c7++;
if (abs(c4 - c7) > n - i - 1) {
cout << sol(n + 2) << endl;
return 0;
} else {
solve(i, c4, c7);
return 0;
}
}
} else if (str[i] != '4' && str[i] != '7') {
if (str[i] < '4') {
str[i] = '4';
c4++;
} else {
str[i] = '7';
c7++;
}
if (abs(c4 - c7) > n - i - 1) {
cout << sol(n + 2) << endl;
return 0;
} else {
solve(i, c4, c7);
return 0;
}
} else {
if (str[i] == '4') {
ind = i;
c4++;
} else
c7++;
}
}
if (c4 > c7) {
for (int i = (ind); i >= (0); i--) {
if (c4 > c7) {
str[i] = '7';
c4--;
c7++;
} else
break;
}
cout << str << endl;
} else if (c7 > c4) {
int cc4 = 0, cc7 = 0;
for (int i = 0; i <= ind; i++) {
if (str[i] == '4')
cc4++;
else
cc7++;
}
c4 = cc4, c7 = cc7;
for (int i = (ind); i >= (0); i--) {
if (str[i] == '4') {
if (abs(c4 - c7 - 1) <= n - i - 1) {
str[i] = '7';
c4--;
c7++;
solve(i, c4, c7);
return 0;
}
c4--;
} else
c7--;
}
cout << sol(n + 2) << endl;
} else
cout << str << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
char str[N];
char ans[N];
int main() {
scanf("%s", str);
int len = strlen(str);
if (len % 2) {
len++;
for (int i = 0; i < len / 2; i++) str[i] = '4';
for (int i = len / 2; i < len; i++) str[i] = '7';
str[len] = 0;
cout << str << endl;
} else {
int pre4 = -1;
int num4 = len / 2, num7 = len / 2;
bool flag = false;
int i;
for (i = 0; i < len; i++) {
if (flag) {
if (num4 > 0)
ans[i] = '4', num4--;
else
ans[i] = '7', num7--;
} else {
if (str[i] > '4' && num7 > 0 || num4 == 0) {
num7--;
ans[i] = '7';
} else {
num4--;
ans[i] = '4';
if (ans[i] >= str[i]) pre4 = i;
}
if (ans[i] > str[i]) {
flag = true;
} else if (ans[i] < str[i]) {
if (pre4 != -1) {
flag = true;
int pre7 = i;
while (ans[pre7] != '7' && pre7 >= 0) pre7--;
while (pre7 > 0 && !(ans[pre7 - 1] == '4' && ans[pre7] == '7'))
pre7--;
if (pre7 == 0) {
flag = false;
break;
}
swap(ans[pre7 - 1], ans[pre7]);
int num44 = len / 2, num77 = len / 2;
for (int j = 0; j <= pre7; j++)
if (ans[j] == '4')
num44--;
else
num77--;
for (int j = pre7 + 1; j < len; j++)
if (num44 > 0)
ans[j] = '4', num44--;
else
ans[j] = '7';
break;
} else {
flag = false;
break;
}
}
}
}
if (!flag && i < len) {
len += 2;
for (int j = 0; j < len / 2; j++) ans[j] = '4';
for (int j = len / 2; j < len; j++) ans[j] = '7';
}
ans[len] = 0;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string n;
char ans[100005];
int four;
int seven;
bool vec;
bool danger;
void dfs(int x) {
if (vec == true) return;
if (four == seven && x == (int)n.length()) {
vec = true;
return;
}
if (x == (int)n.length()) return;
if (danger == true) {
if (n[x] > '7')
return;
else if (n[x] == '7') {
ans[x] = '7';
seven++;
dfs(x + 1);
if (vec == true) return;
seven--;
} else if (n[x] > '4') {
danger = false;
ans[x] = '7';
seven++;
dfs(x + 1);
if (vec == true) return;
seven--;
danger = true;
} else if (n[x] == '4') {
ans[x] = '4';
four++;
dfs(x + 1);
if (vec == true) return;
four--;
ans[x] = '7';
danger = false;
seven++;
dfs(x + 1);
if (vec == true) return;
seven--;
danger = true;
} else {
ans[x] = '4';
danger = false;
four++;
dfs(x + 1);
if (vec == true) return;
four--;
danger = true;
ans[x] = '7';
danger = false;
seven++;
dfs(x + 1);
if (vec == true) return;
danger = true;
seven--;
}
} else {
if ((seven - four + (int)n.length() - x) % 2 == 0 &&
(seven - four + (int)n.length() - x) >= 0 &&
(four + (int)n.length() - x - seven) % 2 == 0 &&
(four + (int)n.length() - x - seven) >= 0 &&
(seven + four + (int)n.length() - x) / 2 == (int)n.length() / 2) {
for (int ii = 0; ii < (seven - four + (int)n.length() - x) / 2; ii++) {
ans[x + ii] = '4';
}
for (int ii = 0; ii < (four + (int)n.length() - x - seven) / 2; ii++) {
ans[x + ii + (seven - four + (int)n.length() - x) / 2] = '7';
}
vec = true;
return;
} else {
return;
}
}
}
int main() {
cin >> n;
memset(ans, '\0', sizeof(ans));
four = 0;
seven = 0;
vec = false;
danger = false;
if ((int)n.length() % 2 == 0 && n[0] > '7') n += '1';
if ((int)n.length() % 2 == 1) {
for (int i = 0; i < ((int)n.length() + 1) / 2; i++) {
ans[i] = '4';
}
for (int i = 0; i < ((int)n.length() + 1) / 2; i++) {
ans[i + ((int)n.length() + 1) / 2] = '7';
}
puts(ans);
} else {
danger = true;
dfs(0);
if (vec == true)
puts(ans);
else {
n += '1';
for (int i = 0; i < ((int)n.length() + 1) / 2; i++) {
ans[i] = '4';
}
for (int i = 0; i < ((int)n.length() + 1) / 2; i++) {
ans[i + ((int)n.length() + 1) / 2] = '7';
}
puts(ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100];
int main() {
int N;
scanf("%d", &N);
sprintf(s, "%d", N);
int C = strlen(s);
if (C % 2) C++;
long long A;
long long ret = 1e12;
for (int i = 0; i < (1 << C); i++) {
string h;
int a = 0, b = 0;
for (int j = 0; j < C; j++) {
if ((bool)(i & (1 << j)))
h += '4', b++;
else
h += '7', a++;
}
sscanf(h.c_str(), "%I64d", &A);
if (a == b && A < ret && A >= N) {
ret = A;
}
}
C += 2;
for (int i = 0; i < (1 << C); i++) {
string h;
int a = 0, b = 0;
for (int j = 0; j < C; j++) {
if ((bool)(i & (1 << j)))
h += '4', b++;
else
h += '7', a++;
}
sscanf(h.c_str(), "%I64d", &A);
if (a == b && A < ret && A >= N) {
ret = A;
}
}
cout << ret;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[100010];
int len, cnt = 0;
char temp[100010];
void out(int len) {
for (int i = 0; i < len; i++) printf("4");
for (int i = 0; i < len; i++) printf("7");
puts("");
}
bool dfs(int p, int a, int b, int yes) {
if (p == 2 * len) {
temp[p] = 0;
return true;
}
if (a < len && (!yes || (yes && ch[p] <= '4'))) {
temp[p] = '4';
if (dfs(p + 1, a + 1, b, yes && ch[p] == '4')) return true;
}
if (b < len && (!yes || (yes && ch[p] <= '7'))) {
temp[p] = '7';
if (dfs(p + 1, a, b + 1, yes && ch[p] == '7')) return true;
}
return false;
}
int main() {
while (~scanf("%s", ch)) {
len = strlen(ch);
if (len & 1) {
len = (len + 1) / 2;
out(len);
continue;
}
len /= 2;
if (dfs(0, 0, 0, 1))
puts(temp);
else
out(len + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int k, i, j, n, x, sze;
cin >> n;
string s, t, r, ans, ch;
s = to_string(n);
sze = s.size();
r = s;
for (i = 1; i <= sze; i++) {
if (i <= (sze / 2)) {
t += '4';
ch += '7';
} else {
t += '7';
ch += '4';
}
}
if (sze % 2 != 0) {
sze++;
t = "";
for (i = 1; i <= sze; i++) {
if (i <= (sze / 2))
t += '4';
else
t += '7';
}
cout << t << endl;
return 0;
}
if (t >= s) {
cout << t << endl;
return 0;
} else {
next_permutation(t.begin(), t.end());
}
while (t < s && t < ch) {
if (t >= s) {
cout << t << endl;
return 0;
}
next_permutation(t.begin(), t.end());
}
if (t >= s) {
cout << t << endl;
return 0;
}
sze += 2;
t = "";
for (i = 1; i <= sze; i++) {
if (i <= (sze / 2))
t += '4';
else
t += '7';
}
cout << t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, ans;
long n, i, res;
long n4, n7, j;
bool ok, flag;
char ch;
string t, mp;
int main() {
cin >> s;
n = s.size();
if (s.size() % 2) {
for (i = 0; i <= (s.size() / 2); i++) cout << "4";
for (i = 0; i <= (s.size() / 2); i++) cout << "7";
return 0;
}
mp = string(n / 2, '7') + string(n / 2, '4');
if (mp < s) {
cout << string(n / 2 + 1, '4') << string(n / 2 + 1, '7') << endl;
return 0;
}
n4 = n / 2;
n7 = n / 2;
flag = false;
for (i = 0; i < n; i++) {
ok = false;
if (n4 > 0) {
if (flag || s[i] < '4')
ok = true;
else {
if (s[i] == '4') {
for (j = i + 1; j <= n; j++) {
if (j == n) {
ok = 1;
break;
}
if (j <= i + n7)
ch = '7';
else
ch = '4';
if (ch > s[j]) ok = 1;
if (ch != s[j]) break;
}
}
}
}
if (ok) {
t += '4';
n4--;
}
if (!ok) {
t += '7';
n7--;
}
if (t[i] > s[i]) flag = true;
}
cout << t << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void print(int n) {
for (int i = 0; i < n / 2; ++i) cout << 4;
for (int i = n / 2; i < n; ++i) cout << 7;
}
int main() {
string a;
cin >> a;
if (a.size() % 2)
print(a.size() + 1);
else {
string ans;
int i, cnt4 = 0, cnt7 = 0;
vector<int> p;
for (i = 0; a[i] == '4' || a[i] == '7'; ++i) {
ans.push_back(a[i]);
if (a[i] == '4')
p.push_back(i), cnt4++;
else
cnt7++;
}
if (i == a.size()) {
if (cnt4 == cnt7)
for (int j = 0; j < ans.size(); ++j) cout << ans[j];
else {
bool ps = false;
while (i > 0) {
i--;
if (a[i] == '4') {
cnt4--;
if (cnt4 > cnt7 + 1 && a.size() - (i + 1) >= cnt4 - (cnt7 + 1) &&
(a.size() - (i + 1)) % 2 == (cnt4 - (cnt7 + 1)) % 2) {
ps = true;
break;
}
if (cnt7 + 1 > cnt4 && a.size() - (i + 1) >= cnt7 + 1 - cnt4 &&
(a.size() - (i + 1)) % 2 == (cnt7 + 1 - cnt4) % 2) {
ps = true;
break;
}
if (cnt7 + 1 == cnt4 && (a.size() - (i + 1)) % 2 == 0) {
ps = true;
break;
}
} else
cnt7--;
}
if (ps) {
ans[i] = '7';
cnt7++;
i++;
for (; i < a.size(); ++i) ans[i] = '4', cnt4++, p.push_back(i);
while (!p.empty() && cnt4 != cnt7) {
ans[p[p.size() - 1]] = '7';
cnt7++, cnt4--;
p.pop_back();
}
for (int j = 0; j < ans.size(); ++j) cout << ans[j];
} else
print(a.size() + 2);
}
} else if (a[i] <= '4') {
for (; i < a.size(); ++i) ans.push_back('4'), cnt4++, p.push_back(i);
while (!p.empty() && cnt4 != cnt7) {
ans[p[p.size() - 1]] = '7';
cnt7++, cnt4--;
p.pop_back();
}
if (cnt4 == cnt7)
for (int j = 0; j < ans.size(); ++j) cout << ans[j];
else
print(a.size() + 2);
} else if (a[i] <= '7') {
ans.push_back('7'), cnt7++, i++;
for (; i < a.size(); ++i) ans.push_back('4'), cnt4++, p.push_back(i);
while (!p.empty() && cnt4 != cnt7) {
ans[p[p.size() - 1]] = '7';
cnt7++, cnt4--;
p.pop_back();
}
if (cnt4 == cnt7)
for (int j = 0; j < ans.size(); ++j) cout << ans[j];
else
print(a.size() + 2);
} else {
if (p.empty())
print(a.size() + 2);
else {
ans[p[p.size() - 1]] = '7';
cnt7++, cnt4--;
p.pop_back();
for (; i < a.size(); ++i) ans.push_back('4'), cnt4++, p.push_back(i);
while (!p.empty() && cnt4 != cnt7) {
ans[p[p.size() - 1]] = '7';
cnt7++, cnt4--;
p.pop_back();
}
if (cnt4 == cnt7)
for (int j = 0; j < ans.size(); ++j) cout << ans[j];
else
print(a.size() + 2);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<long long> lucky;
void solve(int i, int n, int number, int four, int seven) {
if (four < 0 || seven < 0) return;
if (i == n) {
lucky.push_back(number);
return;
}
for (int j = 0; j < 2; j++)
solve(i + 1, n, number * 10 + (j == 0 ? 4 : 7), j == 0 ? four - 1 : four,
j == 0 ? seven : seven - 1);
}
void init() {
for (int i = 2; i <= 8; i += 2) solve(0, i, 0, i / 2, i / 2);
lucky.push_back(4444477777);
}
int main() {
init();
cin >> N;
cout << *lower_bound(lucky.begin(), lucky.end(), N) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e12;
set<long long> s;
void generate_lucky(long long nr, int balance) {
if (nr > M) return;
if (balance == 0) s.insert(nr);
generate_lucky(10 * nr + 4, balance + 1);
generate_lucky(10 * nr + 7, balance - 1);
}
int main() {
std::ios::sync_with_stdio(false);
generate_lucky(4, 1);
generate_lucky(7, -1);
int n;
cin >> n;
long long res = *(s.lower_bound(n));
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void printopt(int p) {
for (int i = p / 2; i; i--) printf("4");
for (int i = p / 2; i; i--) printf("7");
}
char s[100000 + 2];
char s47[100000 + 2];
int n;
bool fopt(int i, int ddif47) {
if (abs(ddif47) > n - i) return 0;
int j = i;
for (; j < i + (n - i - ddif47) / 2; j++) s47[j] = '4';
for (; j < n; j++) s47[j] = '7';
return 1;
}
bool f(int i, int dif47) {
if (i == n) return dif47 == 0;
switch (s[i] - '0') {
case 0:
case 1:
case 2:
case 3:
if (fopt(i, dif47)) return 1;
break;
case 4:
s47[i] = '4';
if (f(i + 1, dif47 + 1)) return 1;
s47[i] = '7';
if (fopt(i + 1, dif47 - 1)) return 1;
break;
case 5:
case 6:
s47[i] = '7';
if (fopt(i + 1, dif47 - 1)) return 1;
break;
case 7:
s47[i] = '7';
if (f(i + 1, dif47 - 1)) return 1;
break;
case 8:
case 9:
break;
}
return 0;
}
int main() {
scanf("%s", s);
n = strlen(s);
if (n % 2)
printopt(n + 1);
else if (f(0, 0))
printf("%s", s47);
else
printopt(n + 2);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long a;
cin >> a;
queue<pair<long long, long long>> q;
q.push(make_pair(0, 0));
while (!q.empty()) {
long long d, c;
d = q.front().first;
c = q.front().second;
q.pop();
if (d >= a && c == 0) {
cout << d;
break;
}
q.push(make_pair(d * 10 + 4, c + 1));
q.push(make_pair(d * 10 + 7, c - 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int n;
bool v[100010];
char a[100010];
int t = 0;
void tle() {
while (1)
;
}
bool ff() {
for (int i = 0; i < t / 2; i++)
if (a[i] < '7') return 1;
for (int i = t / 2; i < t; i++)
if (a[i] > '4') return 0;
return 1;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = n - 1; i >= 0; i--)
if (s[i] > '7')
v[i] = 1;
else if (s[i] < '7')
v[i] = 0;
else if (v[i + 1])
v[i] = 1;
if (v[0]) {
for (int i = 0; i <= n; i++) a[t++] = '4';
} else {
bool F = 0;
for (int i = 0; i < n; i++)
if (F)
a[t++] = '4';
else if (s[i] < '4') {
a[t++] = '4';
F = 1;
} else if (s[i] == '4') {
if (v[i + 1])
a[t++] = '7', F = 1;
else
a[t++] = '4';
} else if (s[i] < '7') {
a[t++] = '7';
F = 1;
} else if (s[i] == '7') {
if (v[i + 1])
tle();
else
a[t++] = '7';
} else
tle();
}
if (t & 1) {
t++;
for (int i = 0; i < t / 2; i++) a[i] = '4';
for (int i = t / 2; i < t; i++) a[i] = '7';
printf("%s\n", a);
return 0;
}
if (!ff()) {
t++;
for (int i = 0; i < t; i++) a[i] = '4';
}
if (t & 1) {
t++;
for (int i = 0; i < t / 2; i++) a[i] = '4';
for (int i = t / 2; i < t; i++) a[i] = '7';
printf("%s\n", a);
return 0;
}
int z = 0;
for (int i = 0; i < t; i++)
if (a[i] == '4')
z++;
else
z--;
if (z == 0) {
printf("%s\n", a);
return 0;
}
for (int i = t - 1; i >= 0;) {
if (z == 0) break;
if (z > 0) {
if (a[i] == '4') a[i] = '7', z -= 2;
i--;
} else if (z < 0) {
if (a[i] == '7') {
int j = i;
while (a[j] == '7') a[j] = '4', z += 2, j--;
a[j] = '7', z -= 2;
if (z < 0) i = j;
if (z > 0) i = t;
} else
i--;
}
}
printf("%s\n", a);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int len;
char ans[100001], s[100001];
inline bool judge(int pos, int flag, int sev, int four) {
if (pos >= len) return 1;
if (flag) {
for (register int i = 0; i < four; ++i) ans[i + pos] = '4';
for (register int i = four + pos; i < len; ++i) ans[i] = '7';
return 1;
}
if (four && s[pos] <= '4' && judge(pos + 1, s[pos] < '4', sev, four - 1)) {
ans[pos] = '4';
return 1;
}
if (sev && s[pos] <= '7' && judge(pos + 1, s[pos] < '7', sev - 1, four)) {
ans[pos] = '7';
return 1;
}
return 0;
}
int main() {
scanf("%s", s);
len = strlen(s);
if (len & 1 || !judge(0, 0, len >> 1, len >> 1)) {
len += 1 + !(len & 1);
for (register int i = 0; (i << 1) < len; ++i) ans[i] = '4';
for (register int i = len >> 1; i < len; ++i) ans[i] = '7';
}
printf("%s\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::vector<long long int> v;
v = {47, 74, 4477, 4747, 4774, 7447, 7474,
7744, 444777, 447477, 447747, 447774, 474477, 474747,
474774, 477447, 477474, 477744, 744477, 744747, 744774,
747447, 747474, 747744, 774447, 774474, 774744, 777444,
44447777, 44474777, 44477477, 44477747, 44477774, 44744777, 44747477,
44747747, 44747774, 44774477, 44774747, 44774774, 44777447, 44777474,
44777744, 47444777, 47447477, 47447747, 47447774, 47474477, 47474747,
47474774, 47477447, 47477474, 47477744, 47744477, 47744747, 47744774,
47747447, 47747474, 47747744, 47774447, 47774474, 47774744, 47777444,
74444777, 74447477, 74447747, 74447774, 74474477, 74474747, 74474774,
74477447, 74477474, 74477744, 74744477, 74744747, 74744774, 74747447,
74747474, 74747744, 74774447, 74774474, 74774744, 74777444, 77444477,
77444747, 77444774, 77447447, 77447474, 77447744, 77474447, 77474474,
77474744, 77477444, 77744447, 77744474, 77744744, 77747444, 77774444,
4444477777};
long long int n;
cin >> n;
for (auto it = v.begin(); it != v.end(); it++) {
if (*it >= n) {
cout << *it << "\n";
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)2e9;
const double eps = 1e-9;
int main() {
std::ios_base::sync_with_stdio(false);
string str;
cin >> str;
int i, n = ((int)(str).size()), k = (n + 1) / 2, a4 = 0, a7 = 0, rem = 0;
string tmp = string(k, '7') + string(k, '4');
if ((n & 1) || (2 * k == n && tmp < str)) {
if (!(n & 1)) k++;
tmp = string(k, '4') + string(k, '7');
cout << tmp << endl;
return 0;
}
tmp = str;
int maxIdx = n;
for ((i) = (n - 1); (i) >= 0; (i)--) {
if (rem) {
rem = 0;
if (str[i] == '4')
str[i] = '7';
else if (str[i] == '7')
str[i] = '4', rem = 1;
}
if (str[i] != '4' && str[i] != '7') maxIdx = i + 1;
if (str[i] <= '4')
a4++, str[i] = '4';
else if (str[i] <= '7')
a7++, str[i] = '7';
else
rem++, a4++, str[i] = '4';
}
sort(str.begin() + maxIdx, str.end());
if (a7 < a4) {
for ((i) = (n - 1); (i) >= 0; (i)--) {
if (str[i] == '4') str[i] = '7', a7++, a4--;
if (a4 == a7) break;
}
} else if (a4 < a7) {
for ((i) = (n - 1); (i) >= 0; (i)--) {
if (str[i] == '7') str[i] = '4', a7--, a4++;
if (a4 == a7) {
bool flag = 1;
for (int j = i - 1; j >= 0; j--) {
if (str[j] == '7' && flag)
str[j] = '4', flag = 0;
else if (str[j] == '4' && !flag) {
str[j] = '7';
sort(str.begin() + j + 1, str.end());
break;
}
}
break;
}
}
}
cout << str << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> numbers{47, 74, 4477, 4747, 4774, 7447, 7474, 7744};
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
for (int k = j + 1; k < 6; k++) {
string s = "";
for (int l = 0; l < 6; l++) {
if ((l == i) || (l == j) || (l == k)) {
s = s + "4";
} else {
s = s + "7";
}
}
numbers.push_back(stoi(s));
}
}
}
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 6; j++) {
for (int k = j + 1; k < 7; k++) {
for (int l = k + 1; l < 8; l++) {
string s = "";
for (int m = 0; m < 8; m++) {
if ((m == i) || (m == j) || (m == k) || (m == l)) {
s = s + "4";
} else {
s = s + "7";
}
}
numbers.push_back(stoi(s));
}
}
}
}
numbers.push_back(4444477777);
int N;
cin >> N;
for (int i = 0; i < numbers.size(); i++) {
if ((numbers[i] < N) && (N < numbers[i + 1])) {
cout << numbers[i + 1];
return 0;
} else if (numbers[i] == N) {
cout << N;
return 0;
} else if (N < 47) {
cout << 47;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s4[100002], s7[100002];
int o4[100002], o7[100002];
void print(int n) {
string ans = "";
for (int i = 0; i < n / 2; i++) {
ans += '4';
}
for (int i = 0; i < n / 2; i++) {
ans += '7';
}
cout << ans << "\n";
}
int poss(string s) {
int n = s.size();
string te = "";
for (int i = 0; i < n / 2; i++) {
te += '7';
}
for (int i = 0; i < n / 2; i++) {
te += '4';
}
for (int i = 0; i < n; i++) {
if (te[i] > s[i]) {
return 1;
} else if (te[i] < s[i]) {
return 0;
}
}
return 1;
}
int main() {
string s;
cin >> s;
int n = s.size();
if (n % 2 != 0) {
print(n + 1);
return 0;
}
if (poss(s) == 0) {
print(n + 2);
return 0;
}
if (s[0] == '4') {
s4[0] = 1;
} else if (s[0] == '7') {
s7[0] = 1;
}
for (int i = 1; i < n; i++) {
if (s[i] == '4') {
s4[i] = s4[i - 1] + 1;
} else {
s4[i] = s4[i - 1];
}
if (s[i] == '7') {
s7[i] = s7[i - 1] + 1;
} else {
s7[i] = s7[i - 1];
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '4') {
o4[i] = o4[i + 1];
} else if (s[i] < '4') {
o4[i] = 1;
} else {
o4[i] = 0;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '7') {
o7[i] = o7[i + 1];
} else if (s[i] < '7') {
o7[i] = 1;
} else {
o7[i] = 0;
}
}
string ans = "";
int ok = 0, rem4, rem7;
rem4 = rem7 = n / 2;
for (int i = 0; i < n; i++) {
if (ok == 1) {
if (rem4 != 0) {
ans += '4';
rem4--;
} else if (rem7 != 0) {
ans += '7';
rem7--;
}
} else {
if (s[i] < '4') {
ok = 1;
ans += '4';
rem4--;
} else if (s[i] > '4' && s[i] < '7') {
ans += '7';
rem7--;
ok = 1;
} else if (s[i] == '7') {
ans += '7';
rem7--;
} else {
char ch = '7';
if (s7[i + rem7] - s7[i] == rem7) {
if (s4[n - 1] - s4[i + rem7] == rem4 - 1) {
ch = '4';
} else if (o4[i + rem7 + 1] == 1) {
ch = '4';
}
} else if (o7[i + 1] == 1) {
ch = '4';
}
if (ch == '7') {
rem7--;
ok = 1;
} else {
rem4--;
}
ans += ch;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int len = n.length();
string n_max(len, '?');
for (int i = 0; i < (len); i++) n_max[i] = (i < len / 2 ? '7' : '4');
if (len % 2 == 1 || (len % 2 == 0 && n > n_max)) {
cout << string(len / 2 + 1, '4') << string(len / 2 + 1, '7') << endl;
return 0;
}
bool big = false;
string ans(len, '?');
for (int i = 0; i < (len); i++) {
if (big || n[i] <= '4') {
ans[i] = '4';
if (n[i] < ans[i]) big = true;
} else if (n[i] <= '7') {
ans[i] = '7';
if (n[i] < ans[i]) big = true;
} else {
for (int j = i; j >= 0; j--) {
if (n[j] < '7') {
ans[j] = '7';
break;
}
ans[j] = '4';
}
big = true;
}
}
int cnt4 = count((ans).begin(), (ans).end(), '4'),
cnt7 = count((ans).begin(), (ans).end(), '7');
if (cnt4 < cnt7) {
int i, c = 0;
for (i = len - 1;; i--) {
if (ans[i] == '7') c++;
if (c > (cnt7 - cnt4) / 2 && ans[i] == '4' && ans[i + 1] == '7') break;
}
ans[i++] = '7';
c -= (cnt7 - cnt4) / 2 + 1;
fill(ans.begin() + i, ans.end() - c, '4');
fill(ans.end() - c, ans.end(), '7');
} else if (cnt4 > cnt7) {
for (int i = len - 1;; i--)
if (ans[i] == '4') {
if (cnt4 == cnt7) break;
ans[i] = '7';
cnt4--;
cnt7++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char num[100005], ans[100005];
int main() {
scanf("%s", num);
int a = 0, b = 0, n, c, pos, poss;
bool k = false, f = false;
int kk = 0;
n = strlen(num);
c = n / 2;
if (n % 2 == 0) {
for (int i = 0; i < n; i++) {
if (i < n / 2) {
if (num[i] > '7') {
f = true;
break;
}
if (num[i] < '7') break;
}
if (i >= n / 2) {
if (num[i] > '4') {
f = true;
break;
}
if (num[i] < '4') break;
}
}
if (f) {
n += 2;
goto en;
}
for (int i = 0; i < n; i++) {
if (kk == 1) {
ans[i] = '4';
if (!k) {
if (num[i] > ans[i]) {
ans[pos] = '7';
a = b = 0;
for (int i = 0; i < n; i++) {
if (i <= pos) {
if (ans[i] == '4')
b++;
else
a++;
} else {
if (b < c) {
b++;
ans[i] = '4';
} else
ans[i] = '7';
}
}
ans[n] = '\0';
printf("%s\n", ans);
return 0;
}
}
continue;
}
if (kk == -1) {
ans[i] = '7';
if (!k) {
if (num[i] > ans[i]) {
ans[pos] = '7';
ans[pos + 1] = '4';
} else if (num[i] < ans[i])
k = true;
}
continue;
}
if (!k) {
if (num[i] > '7') {
ans[pos] = '7';
if (pos + 1 < i) {
if (ans[pos + 1] == '4')
b--;
else
ans[pos + 1] = '4';
k = true;
ans[i] = '4';
b++;
if (b == c) {
kk = -1;
}
pos = i;
} else {
b--;
a++;
k = true;
ans[i] = '4';
b++;
if (b == c) {
kk = -1;
}
pos = i;
}
continue;
}
if (num[i] == '7') {
ans[i] = '7';
a++;
if (a == c) kk = 1;
poss = i;
continue;
}
if (num[i] > '4') {
ans[i] = '7';
k = true;
a++;
if (a == c) kk = 1;
poss = i;
continue;
}
ans[i] = '4';
if (num[i] < ans[i]) k = true;
b++;
if (b == c) {
kk = -1;
}
pos = i;
continue;
}
if (k) {
ans[i] = '4';
b++;
if (b == c) {
kk = -1;
pos = i;
}
}
}
ans[n] = '\0';
printf("%s\n", ans);
} else {
en:
c = (n + 1) / 2;
for (int i = 0; i < c; i++) {
printf("4");
}
for (int i = 0; i < c; i++) {
printf("7");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int dp[1000005];
int main() {
int a, b;
while (~scanf("%s", s)) {
int fl = 1;
int k = strlen(s);
if (k % 2 == 1) {
fl = 0;
for (int i = 0; i <= k / 2; i++) printf("4");
for (int i = 0; i <= k / 2; i++) printf("7");
} else {
if (s[0] > '7') {
fl = 0;
for (int i = 0; i <= k / 2; i++) printf("4");
for (int i = 0; i <= k / 2; i++) printf("7");
} else if (s[0] == '7') {
int flag = 0;
int t = 0;
while (s[t++] == '7') {
if (t == k / 2 && s[t] > '4') {
flag = 1;
break;
}
if (s[t] > '7') {
flag = 1;
}
if (s[t] < '7') break;
}
if (t == k / 2 && s[t] >= '4') {
for (int i = k / 2; i < k; i++)
if (s[i] > '4') {
flag = 1;
break;
}
}
if (flag) {
fl = 0;
for (int i = 0; i <= k / 2; i++) printf("4");
for (int i = 0; i <= k / 2; i++) printf("7");
}
}
if (fl == 1) {
a = 0;
b = 0;
for (int i = 0; i < k; i++) {
if (s[i] < '4') {
if (a < k / 2) {
dp[i] = 4;
a++;
} else {
dp[i] = 7;
b++;
}
fl = 0;
int x = 0;
int y = 0;
for (int j = 0; j <= i; j++) {
if (dp[j] == 4) x++;
if (dp[j] == 7) y++;
printf("%d", dp[j]);
}
for (int j = 0; j < k / 2 - x; j++) printf("4");
for (int j = 0; j < k / 2 - y; j++) printf("7");
break;
} else if (s[i] == '4') {
if (a < k / 2) {
dp[i] = 4;
a++;
} else {
dp[i] = 7;
b++;
fl = 0;
int x = 0;
int y = 0;
for (int j = 0; j <= i; j++) {
if (dp[j] == 4) x++;
if (dp[j] == 7) y++;
printf("%d", dp[j]);
}
for (int j = 0; j < k / 2 - x; j++) printf("4");
for (int j = 0; j < k / 2 - y; j++) printf("7");
break;
}
} else if (s[i] < '7') {
dp[i] = 7;
b++;
int t = i;
if (b > k / 2) {
dp[i] = 4;
a++;
while (1) {
t--;
if (dp[t] == 7) {
b--;
a++;
dp[t] = 4;
;
} else if (dp[t] == 4) {
if (b > k / 2) {
b--;
dp[t] = 4;
a++;
continue;
}
a--;
b++;
dp[t] = 7;
break;
}
}
}
fl = 0;
int x = 0;
int y = 0;
for (int j = 0; j <= t; j++) {
if (dp[j] == 4) x++;
if (dp[j] == 7) y++;
printf("%d", dp[j]);
}
for (int j = 0; j < k / 2 - x; j++) printf("4");
for (int j = 0; j < k / 2 - y; j++) printf("7");
break;
} else if (s[i] == '7') {
dp[i] = 7;
b++;
if (b > k / 2) {
b--;
dp[i] = 4;
a++;
int t = i;
while (1) {
t--;
if (dp[t] == 7) {
b--;
a++;
dp[t] = 4;
;
} else if (dp[t] == 4) {
a--;
b++;
dp[t] = 7;
if (b > k / 2) {
b--;
dp[t] = 4;
a++;
continue;
}
break;
}
}
fl = 0;
int x = 0;
int y = 0;
for (int j = 0; j <= t; j++) {
if (dp[j] == 4) x++;
if (dp[j] == 7) y++;
printf("%d", dp[j]);
}
for (int j = 0; j < k / 2 - x; j++) printf("4");
for (int j = 0; j < k / 2 - y; j++) printf("7");
break;
}
} else if (s[i] > '7') {
dp[i] = 4;
a++;
int t = i;
while (1) {
t--;
if (dp[t] == 7) {
b--;
a++;
dp[t] = 4;
;
} else if (dp[t] == 4) {
a--;
b++;
dp[t] = 7;
break;
}
}
fl = 0;
int x = 0;
int y = 0;
for (int j = 0; j <= t; j++) {
if (dp[j] == 4) x++;
if (dp[j] == 7) y++;
printf("%d", dp[j]);
}
for (int j = 0; j < k / 2 - x; j++) printf("4");
for (int j = 0; j < k / 2 - y; j++) printf("7");
break;
}
}
}
}
if (fl)
for (int j = 0; j < k; j++) {
printf("%d", dp[j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int len7, len4, cnt7[1000000], cnt4[1000000];
char second[10000000];
void print() {
for (int i = 0; i < len4; ++i) putchar('4');
for (int i = 0; i < len7; ++i) putchar('7');
exit(0);
}
int main() {
gets(second);
int len = strlen(second);
len7 = (len + 1) / 2;
len4 = (len + 1) / 2;
if (len % 2 == 1) print();
for (int i = len - 1; i >= 0; i--) {
if (second[i] == '7')
cnt7[i] = cnt7[i + 1] + 1;
else
cnt7[i] = 0;
if (second[i] == '4')
cnt4[i] = cnt4[i + 1] + 1;
else
cnt4[i] = 0;
}
for (int i = 0; i < len; ++i) {
if (second[i] < '4') {
for (int j = 0; j < i; ++j) putchar(second[j]);
print();
}
if (second[i] == '4') {
if (cnt7[i + 1] > len7) {
for (int j = 0; j < i; ++j) putchar(second[j]);
putchar('7');
len7--;
print();
} else if (cnt7[i + 1] == len7) {
int pos = i + 1 + cnt7[i + 1];
if (second[cnt4[pos] + pos] < '4')
;
else {
for (int j = 0; j < i; ++j) putchar(second[j]);
putchar('7');
len7--;
print();
}
} else if (second[i + 1 + cnt7[i + 1]] < '7')
;
else {
for (int j = 0; j < i; ++j) putchar(second[j]);
putchar('7');
len7--;
print();
}
len4--;
} else if (second[i] < '7') {
for (int j = 0; j < i; ++j) putchar(second[j]);
putchar('7');
len7--;
print();
} else if (second[i] == '7') {
if (cnt7[i] > len7) {
len4 = len / 2 + 1;
len7 = len / 2 + 1;
print();
} else if (cnt7[i] == len7) {
int pos = i + cnt7[i];
if (second[cnt4[pos] + pos] < '4')
;
else {
len4 = len / 2 + 1;
len7 = len / 2 + 1;
print();
}
} else if (second[i + cnt7[i]] < '7')
;
else {
len4 = len / 2 + 1;
len7 = len / 2 + 1;
print();
}
len7--;
} else {
len4 = len / 2 + 1;
len7 = len / 2 + 1;
print();
}
}
puts(second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void check_max(T& a, T b) {
if (a < b) a = b;
}
template <class T>
void check_min(T& a, T b) {
if (a > b) a = b;
}
const int MAXL = 100000 + 10;
char d[MAXL];
int l;
int main() {
scanf("%s", d);
l = strlen(d);
if (l % 2 == 1) {
l++;
for (int _t = l / 2, k = 0; k < _t; k++) putchar('4');
for (int _t = l / 2, k = 0; k < _t; k++) putchar('7');
putchar('\n');
return 0;
}
int cnt[10];
memset(cnt, 0, sizeof(cnt));
for (int _t = l, i = 0; i < _t; i++) cnt[d[i] - '0']++;
bool found = false;
int i = l;
for (; i >= 0; i--) {
if (cnt[4] + cnt[7] == i) {
int rest = l - cnt[4] - cnt[7];
if (rest == 0) {
if (cnt[4] == cnt[7]) {
for (int _t = i, k = 0; k < _t; k++) putchar(d[k]);
putchar('\n');
found = true;
break;
}
} else {
if (d[i] - '0' < 4) {
int a = cnt[4] + 1, b = cnt[7];
if (a <= l / 2 && b <= l / 2) {
for (int _t = i, k = 0; k < _t; k++) putchar(d[k]);
putchar('4');
for (int _t = l / 2 - a, k = 0; k < _t; k++) putchar('4');
for (int _t = l / 2 - b, k = 0; k < _t; k++) putchar('7');
putchar('\n');
found = true;
break;
}
}
if (d[i] - '0' < 7) {
int a = cnt[4], b = cnt[7] + 1;
if (a <= l / 2 && b <= l / 2) {
for (int _t = i, k = 0; k < _t; k++) putchar(d[k]);
putchar('7');
for (int _t = l / 2 - a, k = 0; k < _t; k++) putchar('4');
for (int _t = l / 2 - b, k = 0; k < _t; k++) putchar('7');
putchar('\n');
found = true;
break;
}
}
}
}
if (i > 0) cnt[d[i - 1] - '0']--;
}
if (!found) {
l += 2;
for (int _t = l / 2, k = 0; k < _t; k++) putchar('4');
for (int _t = l / 2, k = 0; k < _t; k++) putchar('7');
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 100005;
int len;
char num[inf], ans[inf];
bool dfs(int pos, int a, int b, int k) {
if (pos >= len) return 1;
if (k) {
int i;
for (i = 0; i < a; i++) {
ans[i + pos] = '4';
}
for (; i < len; i++) {
ans[i + pos] = '7';
}
return 1;
}
if (a && num[pos] <= '4') {
if (dfs(pos + 1, a - 1, b, num[pos] < '4')) {
ans[pos] = '4';
return 1;
}
}
if (b && num[pos] <= '7') {
if (dfs(pos + 1, a, b - 1, num[pos] < '7')) {
ans[pos] = '7';
return 1;
}
}
return 0;
}
int main(void) {
cin >> num;
len = strlen(num);
if (len & 1 || !dfs(0, len / 2, len / 2, 0)) {
len += 1 + (len % 2 == 0);
for (int i = 0; i < len / 2; i++) ans[i] = '4';
for (int i = len / 2; i < len; i++) ans[i] = '7';
}
ans[len] = 0;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[1100000];
int b[1100000];
int main() {
scanf("%s", a);
int l = strlen(a);
if (l & 1) {
l /= 2;
l++;
for (int i = 0; i < l; i++) printf("4");
for (int i = 0; i < l; i++) printf("7");
printf("\n");
return 0;
}
int p = -1;
int q = -1;
for (int i = 0; i < l; i++) {
if (a[i] < '7') p = i;
if (a[i] > '7') {
q = i;
break;
}
}
if (q == -1) p = 1e8;
if (q != -1 && p == -1) {
l++;
l += l & 1;
l /= 2;
for (int i = 0; i < l; i++) printf("4");
for (int i = 0; i < l; i++) printf("7");
printf("\n");
return 0;
}
for (int i = 0; i < l; i++) {
if (i < p) {
if (a[i] <= '4')
b[i] = 4;
else
b[i] = 7;
if (b[i] > a[i] - '0') p = i;
}
if (i == p) {
if (a[i] < '4')
b[i] = 4;
else
b[i] = 7;
}
if (i > p) {
b[i] = 4;
}
}
int n4 = 0;
int n7 = 0;
for (int i = 0; i < l; i++)
if (b[i] == 4)
n4++;
else
n7++;
p = l - 1;
while (p >= 0 && n4 < n7) {
while (p >= 0 && b[p] == 7) p--;
if (p >= 0) {
b[p] = 7;
n7++;
n4--;
for (int i = p + 1; i < l && b[i] == 7; i++) {
b[i] = 4;
n7--;
n4++;
}
}
}
if (n4 < n7) {
l++;
l += l & 1;
l /= 2;
for (int i = 0; i < l; i++) printf("4");
for (int i = 0; i < l; i++) printf("7");
printf("\n");
return 0;
} else if (n4 == n7) {
for (int i = 0; i < l; i++) printf("%d", b[i]);
printf("\n");
} else {
for (int i = l - 1; i >= 0; i--) {
if (b[i] == 4 && n4 > n7) {
b[i] = 7;
n4--;
n7++;
}
}
for (int i = 0; i < l; i++) printf("%d", b[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
vector<long long int> v;
string s;
long long int m = 47, k;
s = to_string(m);
stringstream geek(s);
geek >> k;
v.push_back(k);
while (s.size() <= 10) {
if (next_permutation(s.begin(), s.end())) {
stringstream geek(s);
geek >> k;
v.push_back(k);
} else {
s.resize(s.size() + 2);
for (int i = 0; i < s.size(); i++) {
if (i < s.size() / 2)
s[i] = '4';
else
s[i] = '7';
}
stringstream geek(s);
geek >> k;
v.push_back(k);
}
}
cin >> n;
vector<long long int>::iterator lower = lower_bound(v.begin(), v.end(), n);
cout << v[lower - v.begin()];
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, d;
bool check(long long x) {
string y = to_string(x);
long long z = 0, z1 = 0;
for (long long i = 0; i < y.size(); i++) {
if (y[i] != '4' && y[i] != '7')
return false;
else if (y[i] == '4')
z++;
else
z1++;
}
if (z == z1) return true;
return false;
}
int32_t main() {
cin >> n;
vector<long long> V;
V.push_back(47);
V.push_back(74);
V.push_back(4477);
V.push_back(4747);
V.push_back(4774);
V.push_back(7474);
V.push_back(7447);
V.push_back(7744);
string s = "777777";
for (long long i = 0; i < 4; i++) {
for (long long j = (i + 1); j < 5; j++) {
for (long long k = (j + 1); k < 6; k++) {
s[i] = '4';
s[j] = '4';
s[k] = '4';
long long z = stoi(s);
s[i] = '7';
s[j] = '7';
s[k] = '7';
V.push_back(z);
}
}
}
s = "77777777";
for (long long i = 0; i < 5; i++) {
for (long long j = (i + 1); j < 6; j++) {
for (long long k = (j + 1); k < 7; k++) {
for (long long l = (k + 1); l < 8; l++) {
s[i] = '4';
s[j] = '4';
s[k] = '4';
s[l] = '4';
long long z = stoi(s);
s[i] = '7';
s[j] = '7';
s[k] = '7';
s[l] = '7';
V.push_back(z);
}
}
}
}
V.push_back(4444477777);
sort(V.begin(), V.end());
long long st = 0;
long long end = V.size() - 1;
long long z = lower_bound(V.begin(), V.end(), n) - V.begin();
cout << V[z] << "\n";
for (long long i = 0; i < V.size(); i++) return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, s;
void dfs(long long x, long long s4, long long s7) {
if (n <= x && (x < s || s == 0) && s4 == s7) s = x;
if (x <= n * 100) {
dfs(x * 10 + 4, s4 + 1, s7);
dfs(x * 10 + 7, s4, s7 + 1);
}
}
int main() {
cin >> n;
dfs(0, 0, 0);
if (n <= 47) s = 47;
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int x, x2 = 1, e = 0, ans = 100000000000;
void mnum(int i, long long int t, int x4, int x7) {
if (i == e) {
if (t < ans && t >= x && x4 == x7) ans = t;
return;
}
long long int v = 1;
for (int z = 1; z <= i; z++) v *= 10;
mnum(i + 1, t + (v * 4), x4 + 1, x7);
mnum(i + 1, t + (v * 7), x4, x7 + 1);
}
int main() {
cin >> x;
x2 = x;
while (x2) {
x2 /= 10;
e++;
}
while (ans == 100000000000) {
mnum(0, 0, 0, 0);
e++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
bool isPrime(long long x) {
if (x == 1) return false;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
long long gcdByBit(long long a, long long b) {
if (!a || !b) return a | b;
unsigned shift = __builtin_ctz(a | b);
a >>= __builtin_ctzl(a);
do {
b >>= __builtin_ctzl(b);
if (a > b) {
swap(a, b);
}
b -= a;
} while (b);
return a << shift;
}
long long powerMod(long long n, long long p) {
long long res = 1;
while (p) {
if (p % 2 == 0) {
n = n * 1ll * n % 1000000007;
p /= 2;
} else {
res = res * 1ll * n % 1000000007;
p--;
}
}
return res;
}
long long powerMod2(long long b, long long p, long long m) {
if (p == 0) return 1;
return (b * powerMod2(b, p - 1, m) % m) % m;
}
long long fact(long long n) {
long long res = 1;
for (long long i = 1; i <= n; i++) {
res = res * 1ll * i % 1000000007;
}
return res;
}
long long nCr(long long n, long long r) {
return fact(n) * 1ll * powerMod(fact(r), 1000000007 - 2) % 1000000007 * 1ll *
powerMod(fact(n - r), 1000000007 - 2) % 1000000007;
}
pair<string, string> make(long long n) {
string small = "", lar = "";
for (long long i = 0; i < n; i++) {
small += '4';
lar += '7';
}
for (long long i = 0; i < n; i++) {
small += '7';
lar += '4';
}
return make_pair(small, lar);
}
void ans() {
string s;
cin >> s;
long long c1 = 0, c2 = 0;
bool f = 0;
for (long long i = 0; i < s.length(); i++) {
if (s[i] == '7')
c1++;
else if (s[i] == '4')
c2++;
else {
f = 1;
break;
}
}
if (!f && c1 == c2) {
cout << s << '\n';
return;
}
long long n = (long long)ceil((double)s.length() / 2.0);
pair<string, string> p = make(n);
if (s.length() % 2 != 0) {
cout << p.first << '\n';
return;
}
if (s > p.second) {
cout << make(n + 1).first;
return;
}
while (p.first < s) {
next_permutation(p.first.begin(), p.first.end());
}
cout << p.first << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc = 1;
while (tc--) {
ans();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T my_pow(T n, T p) {
if (p == 0) return 1;
T x = my_pow(n, p / 2);
x = (x * x);
if (p & 1) x = (x * n);
return x;
}
template <class T>
T big_mod(T n, T p, T m) {
if (p == 0) return (T)1;
T x = big_mod(n, p / 2, m);
x = (x * x) % m;
if (p & 1) x = (x * n) % m;
return x;
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
T multiplication(T n, T p, T m) {
if (p == 0) return (T)0;
T x = multiplication(n, p / 2, m);
x = (x + x) % m;
if (p & 1) x = (x + n) % m;
return x;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
template <class T>
T extract(string s, T ret) {
stringstream ss(s);
ss >> ret;
return ret;
}
template <class T>
string itos(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
long long stoi(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
const int mod = 1e9 + 7;
struct node {
long long u, v, w;
long long x, y, z;
} arr[100100];
bool com(node a, node b) { return a.x < b.x; }
long long a, b, n, m, res = 0, c = 0, t = 0, ans = 0, cc = 0, f = 0, ff = 0,
cnt = 0, cost = 0;
long long mn = (1e15), mx = -(1e15);
string s, ss, ch[100100];
long long ar[654321], ar1[654321];
vector<long long> v;
void call(long long a, long long c, long long cc) {
if (a > 10000000000LL) return;
if (c == cc) v.push_back(a);
call(a * 10 + 4, c + 1, cc);
call(a * 10 + 7, c, cc + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
call(0, 0, 0);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (__typeof(n + 10) i = 0; i < (n + 10); i++) {
if (v[i] >= n) {
cout << v[i];
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
int solve() {
string t;
cin >> t;
ll a = 0, flag = 1, r = 0, b = 0;
vector<int> data(t.size());
if (t.size() % 2 == 1) flag = 0;
vector<ll> s;
for (ll j = 0; j < t.size(); j++) {
if (t[j] - 0 == 52) {
data[j] = 4;
a++;
s.push_back(j);
} else if (t[j] - 0 == 55) {
data[j] = 7;
a--;
} else if (t[j] - 0 < 52) {
data[j] = 4;
r = 1;
b = j + 1;
break;
} else if (t[j] - 0 < 55) {
data[j] = 7;
r = 1;
b = j + 1;
break;
} else if (!s.empty()) {
r = 1;
b = s[s.size() - 1] + 1;
a--;
data[s[s.size() - 1]] = 7;
break;
} else
flag = 0;
}
if (r == 1) {
for (ll qw = b; qw < t.size(); qw++) {
data[qw] = 4;
}
a = 0;
for (ll qw = 0; qw < t.size(); qw++) {
if (data[qw] == 4)
a++;
else
a--;
}
}
if (flag == 1) {
if (a < 0 && s.empty())
flag = 0;
else if (a < 0 && !s.empty()) {
while (a < 0 && !s.empty()) {
data[s[s.size() - 1]] = 7;
for (ll qw = s[s.size() - 1] + 1; qw < t.size(); qw++) {
data[qw] = 4;
}
a = 0;
for (ll qw = 0; qw < t.size(); qw++) {
if (data[qw] == 4)
a++;
else
a--;
}
s.pop_back();
}
if (a < 0) flag = 0;
}
if (flag == 1) {
for (ll j = t.size() - 1; j > -1; j--) {
if (data[j] == 4 && a > 0) {
data[j] = 7;
a = a - 2;
}
}
for (ll j = 0; j < t.size(); j++) {
cout << data[j];
}
}
}
if (flag == 0) {
for (ll j = 0; j < 1 + (t.size() / 2); j++) cout << 4;
for (ll j = 0; j < 1 + (t.size() / 2); j++) cout << 7;
}
cout << endl;
return 0;
}
int main() {
for (int qwer = 0; qwer < 1; qwer++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100100;
char s[nmax];
char t[nmax];
int n;
void madeTemplate(int pos, int c4, int c7) {
if (pos < 0) {
while (true)
;
}
t[pos + c4 + c7] = 0;
while (c4) {
t[pos] = '4';
++pos;
--c4;
}
while (c7) {
t[pos] = '7';
++pos;
--c7;
}
}
void sevOver(int i, int c4, int c7) {
for (int j = i - 1; j >= 0; --j) {
if (t[j] == '7') {
++c7;
}
if (t[j] == '4') {
if (c7) {
t[j] = '7';
c4 = c7 = n / 2;
for (int k = 0; k <= j; ++k) {
if (t[k] == '4') --c4;
if (t[k] == '7') --c7;
}
madeTemplate(j + 1, c4, c7);
return;
}
}
}
}
void hcase() {
madeTemplate(0, n / 2, n / 2);
if (strcmp(s, t) <= 0) {
return;
}
reverse(t, t + n);
if (strcmp(s, t) > 0) {
n += 2;
madeTemplate(0, n / 2, n / 2);
return;
}
int c4 = n / 2;
int c7 = n / 2;
for (int i = 0; i < n; ++i) {
t[i] = s[i];
if (s[i] < '4') {
if (c4) {
t[i] = '4';
--c4;
} else {
t[i] = '7';
--c7;
}
madeTemplate(i + 1, c4, c7);
break;
}
if (s[i] == '4') {
if (c4) {
--c4;
continue;
} else {
t[i] = '7';
--c7;
madeTemplate(i + 1, c4, c7);
break;
}
}
if (s[i] < '7') {
t[i] = '7';
if (c7) {
--c7;
madeTemplate(i + 1, c4, c7);
} else {
sevOver(i, c4, c7);
}
break;
}
if (s[i] == '7') {
if (c7) {
--c7;
continue;
} else {
sevOver(i, c4, c7);
return;
}
}
if (s[i] > '7') {
sevOver(i, c4, c7);
return;
}
}
}
int main() {
gets(s);
n = (int)strlen(s);
if (n > nmax) {
while (true)
;
}
if (n & 1) {
madeTemplate(0, (n + 1) / 2, (n + 1) / 2);
} else {
hcase();
}
puts(t);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.