text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int bins(long long int arr[], long long int l, long long int r,
long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return bins(arr, l, mid - 1, x);
return bins(arr, mid + 1, r, x);
}
return -1;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
long long int n = s.size();
int p = 31;
long long int m = 1000000007;
vector<long long int> pro(n), h(n + 1, 0);
pro[0] = 1;
for (int i = 1; i < n; i++) {
pro[i] = (pro[i - 1] * p) % m;
}
for (int i = 0; i < n; i++) {
h[i + 1] = (h[i] + (s[i] - 'a' + 1) * pro[i]) % m;
}
long long int len = -1;
for (int l = n - 1; l >= 1; l--) {
long long int pre, cur, suf;
pre = (h[l] * pro[n - 1]) % m;
suf = (h[n] + m - h[n - l]) % m;
suf = (suf * pro[l - 1]) % m;
if (pre == suf) {
for (int i = 1; i <= n - l - 1; i++) {
cur = (h[i + l] + m - h[i]) % m;
cur = (cur * pro[n - i - 1]) % m;
if (cur == suf) {
len = l;
break;
}
}
}
if (len > 0) break;
}
if (len < 0)
cout << "Just a legend";
else {
cout << s.substr(0, len);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long n = s.length();
long long p[n];
p[0] = 0;
for (long long i = 1; i < n; i++) {
long long j = p[i - 1];
while (j > 0 && s[j] != s[i]) {
j = p[j - 1];
}
if (s[j] == s[i]) {
j++;
}
p[i] = j;
}
char s1[n];
for (long long i = n - 1; i >= 0; i--) {
s1[i] = s[n - 1 - i];
}
long long p1[n];
p1[0] = 0;
for (long long i = 1; i < n; i++) {
long long j = p1[i - 1];
while (j > 0 && s1[j] != s1[i]) {
j = p1[j - 1];
}
if (s1[j] == s1[i]) {
j++;
}
p1[i] = j;
}
long long op = 0, ans = p[n - 1];
for (long long i = 1; i < n - 1; i++) {
if (p[i] == p1[n - i + p[i] - 2]) {
ans = min(p[i], p1[n - i + p[i] - 2]);
if (ans > op) {
op = ans;
}
}
}
if (op == 0) {
cout << "Just a legend";
}
for (long long i = 0; i < op; i++) {
cout << s[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string s;
cin >> s;
long long n = s.length();
vector<long long> lps(n, 0);
for (long long i = 1; i < n; i++) {
long long j = lps[i - 1];
while (j > 0 and s[i] != s[j]) {
j = lps[j - 1];
}
if (s[i] == s[j]) j++;
lps[i] = j;
}
if (lps[n - 1] == 0)
cout << "Just a legend";
else {
for (long long i = 1; i < n - 1; i++) {
if (lps[i] == lps[n - 1]) {
cout << s.substr(0, lps[n - 1]);
exit(0);
}
}
if (lps[lps[n - 1] - 1] == 0)
cout << "Just a legend";
else
cout << s.substr(0, lps[lps[n - 1] - 1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> z;
int n;
void z_function(string s) {
z[0] = 0;
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
int len = 0;
vector<int> bit;
void update(int idx, int val) {
if (idx == 0) return;
while (idx <= n) {
bit[idx] += val;
idx += (idx & -idx);
}
}
int pref(int idx) {
int ans = 0;
while (idx > 0) {
ans += bit[idx];
idx -= (idx & -idx);
}
return ans;
}
int main() {
string s;
cin >> s;
n = s.size();
z.resize(n);
bit.resize(n + 1);
z_function(s);
for (int i = 1; i < n; i++) {
update(z[i], 1);
}
for (int i = n - 1; i > 1; i--) {
if (z[i] != (n - i)) continue;
if (pref(n) - pref(z[i] - 1) >= 2) {
len = max(len, z[i]);
}
}
if (!len)
cout << "Just a legend";
else
cout << s.substr(0, len);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> longestPrefix(1000001);
void computePrefix(string str) {
longestPrefix.push_back(0);
long long m = str.length();
for (long long i = 1, k = 0; i < m; i++) {
while (k > 0 && str[k] != str[i]) {
k = longestPrefix[k - 1];
}
if (str[k] == str[i]) {
longestPrefix[i] = ++k;
} else {
longestPrefix[i] = k;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
computePrefix(s);
long long found = 0;
long long len;
len = longestPrefix[s.length() - 1];
if (len != 0) {
for (long long j = 0; j < 2; j++) {
for (long long i = 1; i < s.length() - 1; i++) {
if (len == longestPrefix[i]) {
found = 1;
break;
}
}
if (!found) {
len = longestPrefix[len - 1];
if (len == 0) break;
} else
break;
}
}
if (!found || len == 0) {
cout << "Just a legend";
} else {
cout << s.substr(0, len);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int b[MAXN];
int ada[MAXN];
string p;
string lol = "Just a legend\n";
void kmp() {
int i = 0, j = -1, n = p.size();
b[0] = -1;
while (i < n) {
while (j >= 0 && p[i] != p[j]) j = b[j];
i++;
j++;
b[i] = j;
ada[j]++;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> p;
kmp();
if (b[p.size()] == 0)
cout << lol;
else if (ada[b[p.size()]] > 1)
cout << p.substr(0, b[p.size()]);
else if (b[b[p.size()]] == 0)
cout << lol;
else
cout << p.substr(0, b[b[p.size()]]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000500;
const int INF = 1000000000, mod = 1000000007;
const long long LLINF = 1000000000000000000ll;
char s[N];
int z[N];
int cnt[N];
int n;
void calcZ() {
int l = 0, r = 0;
for (int i = 1; i < n; ++i) {
if (i <= r) {
z[i] = min(z[i - l], r - i + 1);
}
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
z[i]++;
}
if (i + z[i] >= r) {
l = i;
r = i + z[i] - 1;
}
cnt[z[i]]++;
}
}
int main() {
scanf("%s", &s);
n = strlen(s);
calcZ();
int cur = 0;
for (int i = n; i >= 1; --i) {
cur += cnt[i];
if (cur >= 2 && z[n - i] == i) {
for (int j = 0; j < i; ++j) {
putchar(s[j]);
}
exit(0);
}
}
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<long long> longest_substring_ending_at_index_also_a_prefix(string s) {
long long n = s.size();
vector<long long> prefix(n, 0);
for (long long i = 1; i < n; i++) {
long long j = prefix[i - 1];
while (s[i] != s[j] && j > 0) {
j = prefix[j - 1];
}
if (s[i] == s[j]) j++;
prefix[i] = j;
}
return (prefix);
}
int32_t main() {
string s;
cin >> s;
long long n = s.size();
vector<long long> prefix = longest_substring_ending_at_index_also_a_prefix(s);
if (prefix[n - 1] == 0) {
cout << "Just a legend";
goto last;
} else {
for (long long i = 1; i <= n - 2; i++) {
if (prefix[i] == prefix[n - 1]) {
cout << s.substr(0, prefix[n - 1]);
goto last;
}
}
if (prefix[prefix[n - 1] - 1]) {
cout << s.substr(0, prefix[prefix[n - 1] - 1]);
goto last;
} else {
cout << "Just a legend";
goto last;
}
}
last:;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int Next[1000006] = {0}, Hash[1000006] = {0};
void kmp() {
int len = s.length() - 1;
for (int i = 2; i <= len; ++i) {
int k = Next[i - 1];
while (k && s[k + 1] != s[i]) k = Next[k];
if (s[k + 1] == s[i]) Next[i] = k + 1;
}
}
int main() {
cin >> s;
s = " " + s;
kmp();
int len = s.length() - 1;
for (int i = 2; i < len; ++i) Hash[Next[i]] = 1;
int x = Next[len];
while (!Hash[x] && x) x = Next[x];
if (!x)
cout << "Just a legend" << endl;
else {
for (int i = 1; i <= x; ++i) cout << s[i];
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long int p = 31, flag;
long long int hash_prefix[1000001];
long long int pw[1000000];
const long long int MOD = 1e9 + 9;
long long int pf, ppf, sf, tf, best = -1;
int main() {
cin >> s;
pw[0] = 1;
for (int i = 1; i < 1000000; i++) {
pw[i] = (pw[i - 1] % MOD * p) % MOD;
}
for (int i = 0; s[i]; i++) {
hash_prefix[i] = ((s[i] - 'a' + 1) * pw[i]) % MOD;
}
for (int i = 1; s[i]; i++) {
hash_prefix[i] += hash_prefix[i - 1];
hash_prefix[i] %= MOD;
}
for (int ln = s.length() - 1; ln > 0; ln--) {
pf = hash_prefix[ln - 1];
ppf = (pf * pw[s.length() - ln]) % MOD;
sf = hash_prefix[s.length() - 1] - hash_prefix[s.length() - ln - 1];
if (sf < 0) sf += MOD;
if (sf == ppf) {
flag = 0;
for (int i = 1; i + ln - 1 < s.length() - 1; i++) {
tf = hash_prefix[i + ln - 1] - hash_prefix[i - 1];
if (tf < 0) tf += MOD;
ppf = (pf * pw[i]) % MOD;
if (ppf == tf) flag = 1;
}
if (flag) {
best = ln;
break;
}
}
}
if (best == -1) {
cout << "Just a legend" << '\n';
} else {
for (int i = 0; i < best; i++) cout << s[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000002];
int len, fail[1000002];
bool occu[1000002];
int main() {
gets(s);
len = strlen(s);
int occ = 0, j = -1;
fail[0] = -1;
for (int i = 1; i < len; i++) {
while (j >= 0 && s[j + 1] != s[i]) j = fail[j];
if (s[j + 1] == s[i]) j++;
fail[i] = j;
}
memset(occu, 0, sizeof(occu));
for (int i = 1; i < len - 1; i++) occu[fail[i] + 1] = true;
j = fail[len - 1];
while (j >= 0 && !occu[j + 1]) j = fail[j];
if (j == -1)
printf("Just a legend\n");
else {
for (int i = 0; i <= j; i++) {
printf("%c", s[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, i, j, k, h, z[1000009], l, r, len, maxlen;
string s;
int main() {
cin >> s;
len = s.length();
l = r = -1;
for (i = 1; i < len; i++) {
if (i > r) {
l = r = i;
while (r < len && s[r] == s[r - l]) {
r++;
}
r--;
z[i] = r - l + 1;
} else {
if (r - i + 1 > z[i - l]) {
z[i] = z[i - l];
} else {
l = i;
while (r < len && s[r] == s[r - l]) {
r++;
}
r--;
z[i] = r - l + 1;
}
}
}
for (i = 0; i < len; i++) {
if (z[i] + i < len) {
maxlen = max(maxlen, z[i]);
} else {
maxlen = max(maxlen, z[i] - 1);
}
}
int ans = 0;
for (i = 1; i < len; i++) {
if (z[i] + i == len) {
if (maxlen >= z[i]) {
ans = z[i];
break;
}
}
}
if (ans != 0) {
for (i = 0; i < ans; i++) {
cout << s[i];
}
} else {
cout << "Just a legend";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e6 + 9;
const long long mod = 1e9 + 7;
const long long inf = (1ll << 60);
long long f[MX];
long long n;
string s;
void KMP() {
int i = 0, j = -1;
f[0] = -1;
while (i < n) {
while (j >= 0 && s[i] != s[j]) j = f[j];
i++;
j++;
f[i] = j;
}
}
int main() {
cin >> s;
n = s.size();
KMP();
if (f[n] == 0) {
puts("Just a legend");
return 0;
}
long long mx = f[n];
for (int i = 1; i < n - 1; i++) {
if (f[i] == mx) {
cout << s.substr(0, mx) << endl;
return 0;
}
}
long long x = f[mx];
if (x == 0) {
puts("Just a legend");
return 0;
}
cout << s.substr(0, x) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, p[1000005], ans, l, h[1000005], db[1000005], f;
char s[1000005];
void hhash(unsigned long long x) {
for (unsigned long long i = 1; i < l; i++) {
if (i + x - 1 >= l - 1) return;
unsigned long long sum = h[x - 1];
if (h[i + x - 1] - h[i - 1] * db[x] == sum) {
for (unsigned long long k = 0; k < x; k++) cout << s[k];
f = 1;
return;
}
}
}
void aaa() {
for (unsigned long long i = 1; i < l; i++) {
unsigned long long j = p[i - 1];
while (j > 0 && s[j] != s[i]) j = p[j - 1];
if (s[j] == s[i]) j++;
p[i] = j;
}
unsigned long long j = p[l - 1];
while (j > 0) {
hhash(j);
if (f == 1)
return;
else
j = p[j - 1];
}
}
signed main() {
cin >> s;
l = strlen(s);
db[0] = 1;
for (unsigned long long i = 1; i <= l; i++) db[i] = db[i - 1] * 27;
h[0] = s[0] - 'a' + 1;
for (unsigned long long i = 1; i < l; i++)
h[i] = h[i - 1] * 27 + s[i] - 'a' + 1;
aaa();
if (f == 0) cout << "Just a legend\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf1 = 0x3f3f3f3f;
const int inf2 = 0x7fffffff;
const long long INF = ((long long)1) << 61;
template <typename T>
using min_q = priority_queue<T, vector<T>, greater<T>>;
inline int read() {
char c = getchar();
int x = 0;
bool sgn = false;
while (c < '0' || c > '9') {
if (c == '-') {
sgn = true;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
return sgn ? -x : x;
}
const int maxn = 1e6 + 5;
int nex[maxn];
string s;
int l;
void getnex() {
int i = 0, j = -1;
nex[0] = -1;
while (i < l) {
if (j == -1 || s[i] == s[j])
nex[++i] = ++j;
else
j = nex[j];
}
}
bool kmp(int len) {
int j = 0;
for (int i = 1; i <= l - 2; i++) {
while (j && s[j] != s[i]) j = nex[j];
if (s[i] == s[j]) ++j;
if (j == len) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> s;
l = ((int)(s).size());
getnex();
for (int k = nex[l]; k; k = nex[k]) {
if (kmp(k)) {
for (int i = 0; i <= k - 1; i++) printf("%c", s[i]);
return 0;
}
}
printf("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
inline long long max(long long a, long long b) { return a > b ? a : b; }
inline long long min(long long a, long long b) { return a > b ? b : a; }
using namespace std;
const int maxn = 1e6 + 11;
const unsigned long long mod = 1e9 + 7;
unsigned long long p1[maxn], p2[maxn], h1[maxn], h2[maxn], ans,
base = 131, base2 = 31, a[maxn], top;
char str[maxn];
inline unsigned long long get(int l, int r, unsigned long long g[],
unsigned long long p[]) {
return (unsigned long long)g[r] - g[l - 1] * p[r - l + 1];
}
inline void fun(const int& len) {
unsigned long long head = 1, tail = len;
for (int i = 1; i <= len; i++)
if ((get(head, head + i - 1, h1, p1)) == get(tail - i + 1, tail, h1, p1) &&
(get(head, head + i - 1, h2, p2)) == get(tail - i + 1, tail, h2, p2))
a[++top] = i;
}
bool check(int x, int len) {
unsigned long long tar1 = get(1, x, h1, p1), tar2 = get(1, x, h2, p2);
for (int i = 2; i + x - 1 < len; i++)
if (tar1 == get(i, i + x - 1, h1, p1) && tar2 == get(i, i + x - 1, h2, p2))
return 1;
return 0;
}
int main() {
p2[0] = p1[0] = 1;
for (int i = 1; i < maxn; i++)
p1[i] = p1[i - 1] * base, p2[i] = p2[i - 1] * base2;
scanf("%s", str);
int len = strlen(str);
for (int i = 1; i <= len; i++) {
h1[i] = h1[i - 1] * base + (str[i - 1] - 'a' + 1);
h2[i] = h2[i - 1] * base2 + (str[i - 1] - 'a' + 1);
}
fun(len);
int l = 1, r = top, mid, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
if (check(a[mid], len))
l = mid + 1, ans = a[mid];
else
r = mid - 1;
}
if (ans == -1)
puts("Just a legend");
else {
for (int i = 0; i < ans; i++) printf("%c", str[i]);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
const long long INF = 1e18;
const int irand(int lo, int hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
const long long lrand(long long lo, long long hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
template <typename T>
T getnum() {
int sign = 1;
T ret = 0;
char c;
do {
c = getchar();
} while (c == ' ' || c == '\n');
if (c == '-')
sign = -1;
else
ret = c - '0';
while (1) {
c = getchar();
if (c < '0' || c > '9') break;
ret = 10 * ret + c - '0';
}
return sign * ret;
}
inline void ini(int& x) { x = getnum<int>(); }
inline void scani(int& x) { scanf("%d", &x); }
const int N = 1e6 + 5;
string str;
string str2;
int kmp[N];
int kmp2[N];
bool cek(string pat) {
kmp2[0] = -1;
for (int i = 0, j = -1; i < pat.size(); i++, j++) {
while ((j >= 0) && (pat[i] != pat[j])) j = kmp2[j];
kmp2[i + 1] = j + 1;
}
int found = -1;
for (int i = 0, j = 0; i < str2.size(); i++, j++) {
while ((j >= 0) && (str2[i] != pat[j])) j = kmp2[j];
if (j + 1 == pat.size()) {
found = i - j;
break;
}
}
return found != -1;
}
int main() {
cin >> str;
if (str.size() < 3) {
cout << "Just a legend" << '\n';
return 0;
}
str2 = str.substr(1, str.size() - 2);
kmp[0] = -1;
for (int i = 0, j = -1; i < str.size(); i++, j++) {
while ((j >= 0) && (str[i] != str[j])) j = kmp[j];
kmp[i + 1] = j + 1;
}
int ans = -1;
int now = kmp[str.size()];
while (now > 0) {
if (cek(str.substr(0, now))) {
ans = now;
break;
}
now = kmp[now];
}
if (ans == -1)
cout << "Just a legend" << '\n';
else
cout << str.substr(0, ans) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 1000010;
int N;
char A[NMax];
int pi[NMax];
bool viz[NMax];
void Make_Pi() {
int k = 0;
pi[1] = 0;
for (int i = 2; i <= N; ++i) {
while (k > 0 && A[k + 1] != A[i]) k = pi[k];
if (A[k + 1] == A[i]) ++k;
pi[i] = k;
if (i < N) viz[pi[i]] = true;
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> (A + 1);
N = strlen(A + 1);
Make_Pi();
bool found = false;
int p = pi[N];
int ans;
while (!found && p > 0)
if (viz[p]) {
found = true;
ans = p;
} else
p = pi[p];
if (found) {
A[p + 1] = 0;
cout << (A + 1) << "\n";
return 0;
}
cout << "Just a legend\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int Z[1000100];
void Z_Algo(string ch) {
memset(Z, 0, sizeof Z);
int pos, st, endd;
int l = ch.size();
Z[0] = l;
for (pos = 1, st = 0, endd = 0; pos < l; pos++) {
if (pos <= endd) Z[pos] = min(endd - pos + 1, Z[pos - st]);
while (pos + Z[pos] < l && ch[Z[pos]] == ch[pos + Z[pos]]) ++Z[pos];
if (pos + Z[pos] - 1 > endd) st = pos, endd = pos + Z[pos] - 1;
}
}
int ara[1000100];
int main() {
string ch;
cin >> ch;
int l = ch.size();
Z_Algo(ch);
memset(ara, 0, sizeof(ara));
int mx = 0;
for (int i = 1; i < l; i++) ara[Z[i]]++, mx = max(mx, Z[i]);
for (int i = mx - 1; i >= 0; i--) ara[i] += ara[i + 1];
int x = -1;
for (int i = 1; i < l; i++) {
if (Z[i] == l - i && ara[Z[i]] > 1 && Z[i] < l - 1) {
x = Z[i];
break;
}
}
if (x == -1)
printf("Just a legend\n");
else {
for (int i = 0; i < x; i++) cout << ch[i];
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
for (int tt = 0, _tt = (1); tt < _tt; ++tt) {
solve();
cout << '\n';
}
}
vector<int> string_z(string s) {
int n = s.length();
vector<int> z(n);
int l = 0, r = 0;
for (int i = (1), _i = (n); i < _i; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (s[i + z[i]] == s[z[i]] && (i + z[i] < n)) z[i]++;
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
void solve() {
string s;
cin >> s;
int n = s.length();
vector<int> z = string_z(s);
map<int, int> m;
for (int i = 0, _i = (n); i < _i; ++i) {
if (z[i] > 0) {
m[z[i]] = m[z[i]] + 1;
}
}
int found = 0, maxlen = 0;
for (int i = n - 1; i >= 1; i--) {
if (((m).find(i) != (m).end())) {
maxlen = max(maxlen, i);
if ((z[n - i] == i) && ((m[i] > 1) || (i < maxlen))) {
found = i;
break;
}
}
}
cout << (found ? s.substr(0, found) : "Just a legend");
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long inf = 1e18;
double eps = 1e-2;
ifstream in("input.txt");
ofstream out("output.txt");
int main() {
string s;
cin >> s;
int n = s.size();
vector<int> a(n);
a[0] = 0;
for (int i = 1; i < n; i++) {
int j = a[i - 1];
while (j > 0 && s[j] != s[i]) {
j = a[j - 1];
}
if (s[i] == s[j]) j++;
a[i] = j;
}
int val = a[n - 1];
while (val > 0) {
for (int i = val; i < n - 1; i++) {
if (a[i] >= val) {
cout << s.substr(0, val);
return 0;
}
}
val = a[val - 1];
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int _maxs = 1000011;
int slen, bord[_maxs], tong[_maxs], rans;
char s[_maxs];
int main() {
scanf("%s", s + 1);
slen = strlen(s + 1);
for (int i = 2, j = 0; i <= slen; ++i) {
while (j && s[j + 1] != s[i]) {
j = bord[j];
}
if (s[j + 1] == s[i]) {
++j;
}
bord[i] = j;
if (i != slen) {
tong[j] = 1;
}
}
for (int i = bord[slen]; i; i = bord[i]) {
if (tong[i]) {
for (int j = 1; j <= i; ++j) {
putchar(s[j]);
}
return 0;
}
}
printf("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 5332;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int pi[1000009];
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> s;
n = s.size();
pi[0] = 0;
for (int i = 1; i < n; ++i) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) ++j;
pi[i] = j;
}
int suf = pi[n - 1];
int j = suf;
while (j > 0) {
v.push_back(j);
j = pi[j - 1];
}
reverse(v.begin(), v.end());
int mid = 0;
for (int i = 1; i < n - 1; ++i) {
auto j = lower_bound(v.begin(), v.end(), pi[i]);
if (j == v.end()) continue;
if (*j == pi[i]) mid = max(mid, *j);
}
if (mid == 0) {
cout << "Just a legend\n";
return 0;
}
cout << s.substr(0, mid) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e6 + 10, mod = 2e9 + 63, base1 = 1e9 + 21,
base2 = 1e9 + 181;
char s[MAX_N];
long long pw1[MAX_N], pw2[MAX_N], slen;
void pw_calc() {
pw1[0] = pw2[0] = 1;
for (int i = 1; i < MAX_N; i++) {
pw1[i] = (pw1[i - 1] * base1) % mod;
pw2[i] = (pw2[i - 1] * base2) % mod;
}
}
struct Hash {
long long h1[MAX_N], h2[MAX_N];
void init() {
h1[0] = h2[0] = 0;
for (int i = 1; i <= slen; i++) {
h1[i] = (h1[i - 1] * base1 + s[i]) % mod;
h2[i] = (h2[i - 1] * base2 + s[i]) % mod;
}
}
inline long long hashVal(int l, int r) {
long long hsh1 = (h1[r] - h1[l - 1] * pw1[r - l + 1]) % mod;
if (hsh1 < 0) hsh1 += mod;
long long hsh2 = (h2[r] - h2[l - 1] * pw2[r - l + 1]) % mod;
if (hsh2 < 0) hsh2 += mod;
return (hsh1 << 32) | hsh2;
}
} fw;
long long subPre;
inline long long preExist(long long &l, long long &r) {
long long pre = fw.hashVal(1, r - l + 1), hsh = fw.hashVal(l, r);
return pre == hsh;
}
int main() {
scanf("%s", s + 1);
slen = strlen(s + 1);
pw_calc();
fw.init();
for (long long i = 2; i < slen; i++) {
long long lo = i, hi = slen - 1;
while (lo <= hi) {
long long mid = (lo + hi) >> 1;
if (preExist(i, mid)) {
subPre = max(subPre, mid - i + 1);
lo = mid + 1;
} else
hi = mid - 1;
}
}
long long start = -1;
for (long long i = 1; i <= slen; ++i) {
long long len = slen - i + 1;
if (len > subPre) continue;
long long pre = fw.hashVal(1, len), suf = fw.hashVal(i, slen);
if (pre == suf) {
start = i;
break;
}
}
if (start == -1)
printf("Just a legend");
else
for (long long i = start; i <= slen; i++) printf("%c", s[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> buildZ(const string& s) {
int n = (int)s.size();
;
vector<int> z(n);
int l = 0, r = 0;
for (int i = 1; i < n; i++) {
z[i] = max(0, min(z[i - l], r - i));
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] > r) {
r = i + z[i];
l = i;
}
}
return z;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
auto z = buildZ(s);
int n = (int)s.size();
;
vector<int> p;
for (int i = 0; i < (int)n; i++)
if (z[i] != 0) p.push_back(z[i]);
sort((p).begin(), (p).end());
int np = (int)p.size();
;
int len = 0;
for (int i = np - 2; i >= 0; i--) {
if (z[n - p[i]] == p[i]) len = max(len, p[i]);
}
if (!len)
cout << "Just a legend\n";
else {
for (int i = 0; i < (int)len; i++) cout << s[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double EPS = 1e-7;
const int MOD = 1e9 + 7;
const int INF = 2e9 + 7;
const long long INFL = 8e18L + 7;
bool debug = 0;
void run();
int main() {
string file_name = "";
if (file_name != "") {
freopen((file_name + ".in").c_str(), "r", stdin);
freopen((file_name + ".out").c_str(), "w", stdout);
}
run();
return 0;
}
const int N = 1e6 + 7;
int n;
const int AMN = 3;
const long long MODS[AMN] = {1000000003, 1000000007, 1000000009};
const long long PS[AMN] = {29, 31, 37};
long long KS[AMN][N];
long long HS[AMN][N];
vector<int> gethash(int i, int len) {
vector<int> ret(AMN);
for (int h = 0; h < AMN; h++)
ret[h] = (int)((HS[h][i + len - 1] - HS[h][i - 1] + MODS[h]) % MODS[h] *
KS[h][n - i] % MODS[h]);
return ret;
}
bool check(int len) {
vector<int> h1 = gethash(1, len);
vector<int> h2 = gethash(n - len + 1, len);
if (h1 == h2)
for (int i = 2; i <= n - len; i++)
if (gethash(i, len) == h1) return 1;
return 0;
}
void run() {
string s;
cin >> s;
n = s.length();
s = " " + s;
for (int h = 0; h < AMN; h++) KS[h][0] = 1;
for (int h = 0; h < AMN; h++)
for (int i = 1; i <= n; i++) KS[h][i] = (KS[h][i - 1] * PS[h]) % MODS[h];
for (int h = 0; h < AMN; h++)
for (int i = 1; i <= n; i++)
HS[h][i] = (HS[h][i - 1] + (s[i] - 'a' + 1) * KS[h][i]) % MODS[h];
for (int l = n; l > 0; l--)
if (check(l)) {
cout << s.substr(1, l) << endl;
return;
}
cout << "Just a legend" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
string nope = "Just a legend";
vector<int> ps(s.size());
for (int i = 1; i < s.size(); i++) {
int where = ps[i - 1];
while (s[where] != s[i]) {
if (where == 0) {
where = -1;
break;
}
where = ps[where - 1];
}
ps[i] = where + 1;
}
int ansLength = ps[s.size() - 1];
if (ansLength == 0) {
cout << nope;
return 0;
}
while (ansLength > 0) {
for (int i = 0; i < s.size() - 1; i++) {
if (ps[i] == ansLength) {
for (int j = 0; j < ps[i]; j++) cout << s[j];
return 0;
}
}
ansLength = ps[ansLength - 1];
}
cout << nope;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
vector<int> _Z(string s) {
int n = s.size();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
struct hey {
bool operator()(int a, int b) { return a >= b; }
};
int main() {
string s;
cin >> s;
vector<int> z = _Z(s);
int k = 0;
pair<int, int> chars[N];
set<int, hey> st;
for (int i = z.size() - 1, j = 1; i >= 1; i--, j++) {
auto Lower_Bound = st.upper_bound(z[i]);
if (Lower_Bound != st.end()) chars[k++] = {min(z[i], *Lower_Bound), i};
if (z[i] == j) st.insert(z[i]);
}
if (!k) {
printf("Just a legend");
return 0;
}
sort(chars, chars + k);
while (chars[k - 1].first--) {
cout << s[chars[k - 1].second++];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_length = 1e6 + 10;
string S;
int z[max_length];
int main() {
cin >> S;
for (int i = 1, l = 0, r = 0, cur_max_length = 0; i < (int)S.length(); ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < (int)S.length() && S[z[i]] == S[i + z[i]]) ++z[i];
if (i + z[i] == (int)S.length() && z[i] <= cur_max_length) {
for (int j = 0; j < z[i]; ++j) cout << S[j];
return 0;
}
cur_max_length = max(cur_max_length, z[i]);
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 1419;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int n, long long int p) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result % p * x % p) % p;
x = (x % p * x % p) % p;
n = n / 2;
}
return result % p;
}
void solve() {
string s;
cin >> s;
long long int n = s.length();
vector<long long int> v1(n), p(n, 1);
for (long long int i = 1; i <= n - 1; i++)
p[i] = (p[i - 1] * 31) % 1000000007;
for (long long int i = 0; i <= n - 1; i++)
v1[i] = (((long long int)s[i] - 'a' + 1) * p[i]) % 1000000007;
for (long long int i = 1; i <= n - 1; i++)
v1[i] = (v1[i - 1] + v1[i]) % 1000000007;
vector<long long int> v2, v3;
for (long long int i = 0; i <= n - 3; i++) {
long long int cur = (v1[i] * p[n - 1 - i]) % 1000000007;
long long int fin = (v1[n - 1] - v1[n - i - 2] + 1000000007) % 1000000007;
if (cur == fin) {
v2.push_back(i);
v3.push_back(v1[i]);
}
}
if (v2.size() == 0) {
cout << "Just a legend";
return;
}
reverse(v2.begin(), v2.end());
reverse(v3.begin(), v3.end());
vector<long long int> v4;
for (long long int i = 1; i <= n - 1; i++)
if (s[i] == s[0]) v4.push_back(i);
for (long long int i = 0; i <= v2.size() - 1; i++) {
for (long long int j = 0; j <= v4.size() - 1; j++) {
if (v4[j] + v2[i] < n - 1) {
long long int a1 =
(v1[v4[j] + v2[i]] - v1[v4[j] - 1] + 1000000007) % 1000000007;
long long int a2 = v3[i] * p[v4[j]] % 1000000007;
if (a1 == a2) {
for (long long int k = 0; k <= v2[i]; k++) cout << s[k];
return;
}
}
}
}
cout << "Just a legend";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int z[1000001];
void zAlgo() {
int L = 0, R = 0;
for (int i = 1; i < s.length(); i++) {
if (i > R) {
L = R = i;
while (R < s.length() && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < s.length() && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
void solution() {
cin >> s;
zAlgo();
int maxz = 0, res = 0;
for (int i = 1; i < s.length(); i++) {
int n = s.length();
if (z[i] == s.length() - i && maxz >= s.length() - i) {
res = s.length() - i;
break;
}
maxz = max(maxz, z[i]);
}
res ? cout << s.substr(0, res) : cout << "Just a legend";
}
int main() {
double beg = clock();
ios::sync_with_stdio(false);
solution();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool leq(int a1, int a2, int b1, int b2) {
return (a1 < b1 || a1 == b1 && a2 <= b2);
}
inline bool leq(int a1, int a2, int a3, int b1, int b2, int b3) {
return (a1 < b1 || a1 == b1 && leq(a2, a3, b2, b3));
}
static void radixPass(int* a, int* b, int* r, int n, int K) {
int* c = new int[K + 1];
for (int i = 0; i <= K; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[r[a[i]]]++;
for (int i = 0, sum = 0; i <= K; i++) {
int t = c[i];
c[i] = sum;
sum += t;
}
for (int i = 0; i < n; i++) b[c[r[a[i]]]++] = a[i];
delete[] c;
}
void suffixArray(int* s, int* SA, int n, int K) {
int n0 = (n + 2) / 3, n1 = (n + 1) / 3, n2 = n / 3, n02 = n0 + n2;
int* s12 = new int[n02 + 3];
s12[n02] = s12[n02 + 1] = s12[n02 + 2] = 0;
int* SA12 = new int[n02 + 3];
SA12[n02] = SA12[n02 + 1] = SA12[n02 + 2] = 0;
int* s0 = new int[n0];
int* SA0 = new int[n0];
for (int i = 0, j = 0; i < n + (n0 - n1); i++)
if (i % 3 != 0) s12[j++] = i;
radixPass(s12, SA12, s + 2, n02, K);
radixPass(SA12, s12, s + 1, n02, K);
radixPass(s12, SA12, s, n02, K);
int name = 0, c0 = -1, c1 = -1, c2 = -1;
for (int i = 0; i < n02; i++) {
if (s[SA12[i]] != c0 || s[SA12[i] + 1] != c1 || s[SA12[i] + 2] != c2) {
name++;
c0 = s[SA12[i]];
c1 = s[SA12[i] + 1];
c2 = s[SA12[i] + 2];
}
if (SA12[i] % 3 == 1) {
s12[SA12[i] / 3] = name;
} else {
s12[SA12[i] / 3 + n0] = name;
}
}
if (name < n02) {
suffixArray(s12, SA12, n02, name);
for (int i = 0; i < n02; i++) s12[SA12[i]] = i + 1;
} else
for (int i = 0; i < n02; i++) SA12[s12[i] - 1] = i;
for (int i = 0, j = 0; i < n02; i++)
if (SA12[i] < n0) s0[j++] = 3 * SA12[i];
radixPass(s0, SA0, s, n0, K);
for (int p = 0, t = n0 - n1, k = 0; k < n; k++) {
int i = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
int j = SA0[p];
if (SA12[t] < n0 ? leq(s[i], s12[SA12[t] + n0], s[j], s12[j / 3])
: leq(s[i], s[i + 1], s12[SA12[t] - n0 + 1], s[j],
s[j + 1], s12[j / 3 + n0])) {
SA[k] = i;
t++;
if (t == n02)
for (k++; p < n0; p++, k++) SA[k] = SA0[p];
} else {
SA[k] = j;
p++;
if (p == n0)
for (k++; t < n02; t++, k++)
SA[k] = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
}
}
delete[] s12;
delete[] SA12;
delete[] SA0;
delete[] s0;
}
vector<int> kasai(const string& s, const vector<int>& sa) {
int n = s.size(), k = 0;
vector<int> lcp(n, 0);
vector<int> rank(n, 0);
for (int i = 0; i < n; i++) rank[sa[i]] = i;
for (int i = 0; i < n; i++, k ? k-- : 0) {
if (rank[i] == n - 1) {
k = 0;
continue;
}
int j = sa[rank[i] + 1];
while (i + k < n && j + k < n && s[i + k] == s[j + k]) k++;
lcp[rank[i]] = k;
}
return lcp;
}
int Mini[1000 * 1000 + 5][20];
void precalcMin(vector<int>& lcp, int n) {
int len = 1;
int lg = 0;
for (int i = 0; i <= n - 1; i++) {
Mini[i][0] = lcp[i];
}
lg++;
len *= 2;
while (lg <= 19) {
for (int i = 0; i <= n - len; i++) {
Mini[i][lg] = min(Mini[i][lg - 1], Mini[i + len / 2][lg - 1]);
}
lg++;
len *= 2;
}
}
int getMin(int i, int j) {
int n = j - i + 1;
int lg = 0;
while (n > 1) {
lg++;
n /= 2;
}
int ans = min(Mini[i][lg], Mini[j + 1 - (1 << lg)][lg]);
return ans;
}
int sufind[1000 * 1000 + 5];
bool feasible(string& s, vector<int>& lcp, int len) {
int lastind = s.size() - len;
int lastSufInd = sufind[lastind];
if (lastSufInd > sufind[0])
return false;
else {
int moves = max(2, sufind[0] - lastSufInd);
int minlcp = getMin(lastSufInd, lastSufInd + moves - 1);
if (minlcp < len) return false;
return true;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
string s;
getline(cin, s);
int* s0 = new int[s.size() + 3];
int* sa = new int[s.size() + 3];
vector<int> sa_in(s.size() + 3, 0);
for (int i = 0; i < s.size(); i++) {
s0[i] = s[i];
}
s0[s.size()] = 0;
s0[s.size() + 1] = 0;
s0[s.size() + 2] = 0;
suffixArray(s0, sa, s.size(), 257);
for (int i = 0; i < s.size(); i++) {
sufind[sa[i]] = i;
}
for (int i = 0; i < s.size(); i++) {
sa_in[i] = sa[i];
}
vector<int> lcp = kasai(s, sa_in);
precalcMin(lcp, s.size());
int ans = 0;
if (s.size() >= 3) {
for (ans = s.size() - 2; ans > 0; ans--) {
if (feasible(s, lcp, ans)) break;
}
}
if (ans == 0) {
printf("Just a legend");
} else {
for (int i = 0; i < ans; i++) {
printf("%c", s[i]);
}
}
delete[] s0;
delete[] sa;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 10;
int pre[maxn];
int prefix(string s) {
int m = s.size();
pre[0] = -1, pre[1] = 0;
int i = 1, len = 0;
while (i < m) {
if (s[i] == s[len]) {
pre[i + 1] = ++len;
i++;
} else {
if (len > 0)
len = pre[len];
else {
pre[i + 1] = len;
i++;
}
}
}
return pre[m];
}
bool kmp_search(string p, int k) {
if (k > 0) {
int n = p.size();
for (int i = 1; i < n; i++)
if (pre[i] >= k) return true;
}
return false;
}
bool check(int k, string s) {
string hunt = s.substr(0, k);
return kmp_search(s, k);
}
int main() {
string s;
cin >> s;
string nw = s.substr(1, s.size() - 2);
int x = prefix(s);
bool tag = check(x, s);
if (tag) {
string ans = s.substr(0, x);
cout << ans;
return 0;
}
x = pre[x];
while (x != -1) {
tag = check(x, s);
if (tag && x > 0) {
for (int j = 0; j < x; j++) cout << s[j];
return 0;
}
x = pre[x];
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool SR(int &x) { return scanf("%d", &x) == 1; }
inline bool SR(long long &x) { return scanf("%lld", &x) == 1; }
inline bool SR(double &x) { return scanf("%lf", &x) == 1; }
inline bool SR(char *s) { return scanf("%s", s) == 1; }
inline bool RI() { return true; }
template <typename I, typename... T>
inline bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
inline void SP(const int x) { printf("%d", x); }
inline void SP(const long long x) { printf("%lld", x); }
inline void SP(const double x) { printf("%.16lf", x); }
inline void SP(const char *s) { printf("%s", s); }
inline void PL() { puts(""); }
template <typename I, typename... T>
inline void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
template <typename I>
void _DOING(const char *s, I &&x) {
cerr << s << " = " << x << endl;
}
template <typename I, typename... T>
void _DOING(const char *s, I &&x, T &&...tail) {
int c = 0;
while (*s != ',' || c != 0) {
if (*s == '(' || *s == '[' || *s == '{') c++;
if (*s == ')' || *s == ']' || *s == '}') c--;
cerr << *s++;
}
cerr << " = " << x << " , ";
_DOING(s + 1, tail...);
}
inline int RAND() {
static int x = 880301;
return (x = x * 0xdefaced + 1) & 0x7fffffff;
}
const int MAX_N = 1000000 + 10;
char s[MAX_N];
int dp[MAX_N];
int cnt[MAX_N];
inline void build_kmp(int n) {
int p = dp[0] = -1;
for (int i = 1; i <= int(n - 1); i++) {
while (p != -1 && s[p + 1] != s[i]) p = dp[p];
if (s[p + 1] == s[i]) p++;
dp[i] = p;
}
}
int main() {
RI(s);
int n = strlen(s);
build_kmp(n);
for (int i = 0; i < int(n - 1); i++)
if (dp[i] != -1) cnt[dp[i]]++;
int p = dp[n - 1];
while (~p) {
if (cnt[p]) {
for (int i = 0; i < int(p + 1); i++) putchar(s[i]);
PL();
return 0;
}
p = dp[p];
}
PL("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 1420;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 75377;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class first>
inline bool getbit(T a, first i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class first>
inline T setbit(T a, first i) {
T t = 1;
return (a | (t << i));
}
template <class T, class first>
inline T resetbit(T a, first i) {
T t = 1;
return (a & (~(t << i)));
}
template <class T, class first>
inline T togglebit(T a, first i) {
T t = 1;
return (a ^ (t << i));
}
template <typename T>
T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
T BIGMOD(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T Bigmod(T base, T power, T mod) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % mod;
base = (base * base) % mod;
power >>= 1;
}
return ret;
}
template <typename T>
T ModInverse(T number, T mod) {
return Bigmod(number, mod - 2, mod);
}
template <typename T>
T GCD(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T EUCLIDE(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
double DEG(double x) { return (180.0 * x) / ((2.0 * acos(0.0))); }
double RAD(double x) { return (x * (double)(2.0 * acos(0.0))) / (180.0); }
template <typename T>
T DIS(T x1, T y1, T x2, T y2) {
return sqrt((double)((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
long long isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
void P_ARR(int *ar, int a, int b) {
if (a > b) swap(a, b);
if (a <= b) cout << ar[a];
for (int i = a + 1; i <= b; i++) cout << " " << ar[i];
cout << endl;
}
const int MX = 1000007;
const int MOD = 1000000007;
const int inf = 1000000000;
int z[MX];
char s[MX];
int z_function() {
int len = strlen(s);
memset(z, 0, sizeof z);
z[0] = 0;
for (int i = 1, l = 0, r = 0; i < len; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < len && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
int mx = -1;
int id = -1;
for (int i = 1; i <= len - 1; i++) {
if (z[i] == len - i && z[i] <= mx) return i;
mx = max(mx, z[i]);
}
return -1;
}
int main() {
int tc, cas = 1;
gets(s);
int st = z_function();
if (st == -1)
return puts("Just a legend");
else
puts(s + st);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long fpow(int val, int p) {
if (p == 0) return 1;
if (p == 1) return val;
if (p % 2 == 0) {
unsigned long long half = fpow(val, p / 2);
return half * half;
} else {
unsigned long long half = fpow(val, p / 2);
return val * half * half;
}
}
char s[1001000];
unsigned long long hpmemo[1001000];
vector<int> eq;
int n;
int check(int mid) {
unsigned long long hp, hs;
int l = eq[mid];
unsigned long long inv = fpow(61, l - 1);
int flag = 0;
hs = 0;
hp = hpmemo[l - 1];
for (int i = 1; i <= l; i++) hs = hs * 61 + s[i] - 'a';
if (hs == hp) {
flag = 1;
}
for (int i = 2; i + l - 1 < n - 1; i++) {
hs = (hs - (s[i - 1] - 'a') * inv) * 61 + s[i + l - 1] - 'a';
if (hs == hp) {
flag = 1;
}
}
return flag;
}
int main(void) {
scanf("%s", s);
n = strlen(s);
unsigned long long hp = 0, hs = 0;
for (int i = 1; i <= n - 2; i++) {
hp = hp * 61 + s[i - 1] - 'a';
hs = hs + (s[n - i] - 'a') * fpow(61, i - 1);
if (hp == hs) {
eq.push_back(i);
}
hpmemo[i - 1] = hp;
}
int lo = 0, hi = eq.size() - 1;
if (hi == -1) {
printf("Just a legend\n");
return 0;
}
while (lo < hi) {
int mid = (lo + hi) / 2;
if (check(mid) == 0) {
hi = mid;
} else {
lo = mid + 1;
}
}
int found = check(lo);
if (found == 0 && lo == 0) {
printf("Just a legend\n");
} else if (found == 0) {
for (int i = 0; i < eq[lo - 1]; i++) printf("%c", s[i]);
printf("\n");
} else if (found == 1) {
for (int i = 0; i < eq[eq.size() - 1]; i++) printf("%c", s[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, f[maxn], k;
string s;
void imp() {
cout << "Just a legend\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
n = s.size();
f[0] = -1;
for (int i = 2; i <= n; i++) {
while (k > -1 && s[k] != s[i - 1]) k = f[k];
f[i] = ++k;
}
if (!k) imp();
int num = k;
k = 0;
for (int i = 2; i < n; i++) {
while (k > -1 && s[k] != s[i - 1]) k = f[k];
f[i] = ++k;
if (f[i] == num) {
cout << s.substr(0, num) << "\n";
return 0;
}
}
if (!f[f[n]]) imp();
cout << s.substr(0, f[f[n]]) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, ans = 0;
string s;
long long lps[10000000];
void computelps(string s) {
long long len = 0;
lps[0] = 0;
int i = 1;
long long M = s.length();
while (i < M) {
if (s[i] == s[len])
len++, lps[i] = len, i++;
else {
if (len != 0)
len = lps[len - 1];
else
lps[i] = 0, i++;
}
}
}
bool kmp(string txt, string pat) {
int i = 0;
int j = 0;
while (i < txt.length()) {
if (pat[j] == txt[i]) {
j++;
i++;
}
if (j == pat.length()) return true;
if (i < txt.length() && pat[j] != txt[i]) {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
string str = "Just a legend";
computelps(s);
n = s.length();
if (n < 3) return cout << str, 0;
string t = s;
t.pop_back();
t = t.substr(1);
if (lps[n - 1] == 0 or s.length() <= 2) return cout << str, 0;
for (long long k = lps[n - 1]; k > 0; k = lps[k - 1])
if (kmp(t, s.substr(0, k))) return cout << s.substr(0, k), 0;
cout << str;
}
|
#include <bits/stdc++.h>
using namespace std;
int z[2000001], m;
int main() {
string a;
cin >> a;
int l = 0, r = 0, ma = 0;
z[0] = a.size();
for (int i = 1; i < a.size(); i++) {
if (i > r) {
l = i;
r = i;
while (a[r] == a[r - l]) r++;
z[i] = r - l;
--r;
} else if (z[i - l] < r - i + 1) {
z[i] = z[i - l];
} else {
l = i;
while (a[r] == a[r - l]) r++;
z[i] = r - l;
--r;
}
if (z[i] + i == a.size()) {
if (z[i] > ma && z[i] <= m) {
ma = z[i];
}
}
m = max(m, z[i]);
}
if (ma) {
for (int i = 0; i < ma; i++) {
cout << a[i];
}
} else {
printf("Just a legend");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 123456;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e6 + 10;
const int def = 0x3f3f3f3f;
string a, b, c;
int nex[Max];
void getnex(int len) {
int k = -1, j = 0;
nex[j] = k;
while (j <= len) {
if (k == -1 || a[k] == a[j]) {
nex[++j] = ++k;
} else {
k = nex[k];
}
}
}
int kmp(int lenb, int lenc) {
int i = 0, j = 0;
while (i < lenb && j < lenc) {
if (j == -1 || b[i] == c[j]) {
i++;
j++;
} else
j = nex[j];
}
if (j == lenc) return 1;
return 0;
}
int main() {
int i, j, h;
int n, m;
cin >> a;
int len = a.length();
for (i = 1; i < len - 1; i++) b += a[i];
getnex(a.length());
int k = len;
if (len <= 2) {
printf("Just a legend");
return 0;
}
int flag = 0;
while (nex[k]) {
c.clear();
for (i = 0; i < nex[k]; i++) c += a[i];
if (kmp(len - 2, nex[k])) {
flag = 1;
break;
}
k = nex[k];
}
if (flag)
cout << c;
else
printf("Just a legend");
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int inp;
void sc(long long &x) {
scanf("%d", &inp);
x = inp;
}
void sc(long long &x, long long &y) {
scanf("%d", &inp);
x = inp;
scanf("%d", &inp);
y = inp;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
bool check(long long A) {
if (A < 9032) return 1;
return 0;
}
long long bslrg(long long L, long long R) {
long long mid, beg = L, en = R;
while (true) {
if (en - beg <= 20)
for (long long i = en; i >= beg; i--)
if (check(i)) return i;
mid = (beg + en + 1ll) / 2;
if (check(mid))
beg = mid;
else
en = mid - 1ll;
}
return -1;
}
long long bssml(long long L, long long R) {
long long mid, beg = L, en = R;
while (true) {
if (en - beg <= 20)
for (long long i = beg; i <= en; i++)
if (check(i)) return i;
mid = (beg + en + 1ll) / 2;
if (check(mid))
en = mid;
else
beg = mid + 1ll;
}
return -1;
}
void setbit(int &m, int ind, int val) {
if (val)
m = (m | (1 << ind));
else
m = (m & ~(1 << ind));
}
bool getbit(int m, int ind) {
int a = (1 << ind);
a = (a & m);
return a;
}
int cntbits(int m) {
int ret = 0;
while (m) {
ret += (m % 2);
m /= 2;
}
return ret;
}
bool smlltr(char c) {
if (c >= 'a' && c <= 'z') return 1;
return 0;
}
bool capltr(char c) {
if (c >= 'A' && c <= 'Z') return 1;
return 0;
}
const long long MOD = 1e9 + 7;
long long pow_mod(long long a, long long b) {
if (b == 0) return 1ll;
if (b % 2) return (a * pow_mod((a * a) % MOD, b / 2)) % MOD;
return pow_mod((a * a) % MOD, b / 2);
}
long long n, m, k, L, maxi, mini, Q, x, y, a[1000100], sol[1000100],
bit[1000100];
vector<int> res;
vector<int> computePrefix(string pat) {
int m = pat.length();
vector<int> longestPrefix(1000100);
for (int i = 1, k = 0; i < m; ++i) {
while (k > 0 && pat[k] != pat[i]) k = longestPrefix[k - 1];
if (pat[k] == pat[i])
longestPrefix[i] = ++k;
else
longestPrefix[i] = k;
}
return longestPrefix;
}
int main() {
string s;
cin >> s;
n = s.length();
vector<int> v = computePrefix(s);
if (v[n - 1] == 0) {
cout << "Just a legend";
return 0;
}
for (int i = 0; i <= n - 2; i++)
if (v[i] == v[n - 1]) {
for (int j = 0; j <= v[i] - 1; j++) cout << s[j];
return 0;
}
if (v[v[n - 1] - 1] == 0) {
cout << "Just a legend";
return 0;
}
for (int j = 0; j <= v[v[n - 1] - 1] - 1; j++) cout << s[j];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> findz(string s) {
int n = s.length();
vector<int> zarr(n, 0);
int l, r, k;
l = r = 0;
for (int i = 1; i < n; i++) {
if (i > r) {
l = r = i;
while (r < n && s[r - l] == s[r]) r++;
zarr[i] = r - l;
r--;
} else {
k = i - l;
if (i + zarr[k] - 1 < r) {
zarr[i] = zarr[k];
} else {
l = i;
while (r < n && s[r - l] == s[r]) r++;
zarr[i] = r - l;
r--;
}
}
}
return zarr;
}
int main() {
string s;
cin >> s;
int n = s.length();
vector<int> zpre = findz(s);
int max_so_far = 0;
for (int i = 0; i < n; i++) {
if (zpre[i] == n - i && max_so_far >= n - i) {
int id = n - i;
for (int j = 0; j < id; j++) printf("%c", s[j]);
return 0;
}
max_so_far = max(max_so_far, zpre[i]);
}
cout << "Just a legend" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 1e6 + 500;
int f[maxn];
int cnt[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
int k = -1;
f[0] = -1;
for (int i = 1; i < n; i++) {
while (s[k + 1] != s[i] && k >= 0) {
k = f[k];
}
if (s[k + 1] == s[i]) k++;
f[i] = k;
}
for (int i = 0; i < n; i++) {
cnt[f[i]]++;
}
k = f[n - 1];
if (k == -1) {
cout << "Just a legend";
return 0;
}
if (cnt[k] > 1) {
cout << s.substr(0, 1 + k);
return 0;
}
k = f[k];
if (k == -1) {
cout << "Just a legend";
return 0;
}
cout << s.substr(0, 1 + k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
string s;
int prefix[1000005];
bool occured[1000005];
int main() {
getline(cin, s);
int N = int((s).size());
int m = prefix[0] = 0;
for (int i = (1); i < (N); ++i) {
while (m > 0 && s[m] != s[i]) m = prefix[m - 1];
if (s[m] == s[i]) m++;
prefix[i] = m;
}
for (int i = (0); i < (N - 1); ++i) occured[prefix[i]] = true;
int pos = N;
while (pos > 0) {
pos = prefix[pos - 1];
if (occured[pos] && pos) {
for (int i = (0); i < (pos); ++i) printf("%c", s[i]);
return 0;
}
}
printf("Just a legend\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void getLPS(string s, int lps[]) {
int n = s.length();
for (int i = 1; i < n; i++) {
int indToConsider = i - 1;
while (true) {
indToConsider = lps[indToConsider];
if (s[i] == s[indToConsider]) {
lps[i] = indToConsider + 1;
break;
}
if (indToConsider == 0) break;
indToConsider--;
}
}
}
int Zfunc(string s, string pat) {
string newStr = pat + "$" + s;
int n = newStr.size();
int zfunc[n];
memset(zfunc, 0, sizeof(zfunc));
zfunc[0] = n;
int l = -1;
int r = -1;
int ind = 0;
for (int i = 1; i < n; i++) {
if (l == -1) {
if (newStr[i] == newStr[0]) {
l = i;
r = i;
for (int j = i + 1; j < n; j++) {
if (newStr[j] == newStr[j - i]) {
r = j;
} else {
break;
}
}
zfunc[i] = r - l + 1;
}
} else {
if (i > r) {
l = -1;
r = -1;
i--;
} else {
int k = i - l;
if (zfunc[k] >= r - i + 1) {
int j = r + 1;
while (r < n && newStr[j] == newStr[j - i]) {
r++;
j++;
}
l = i;
zfunc[i] = r - l + 1;
} else {
zfunc[i] = zfunc[k];
}
}
}
}
int mx = 0;
for (int i = 1; i < n; i++) {
mx = max(mx, zfunc[i]);
}
return mx;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
int lps[n];
memset(lps, 0, sizeof(lps));
getLPS(s, lps);
int pref = lps[n - 1];
if (pref == 0) {
cout << "Just a legend";
return 0;
}
string prefStr = "";
for (int i = 0; i < pref; i++) {
prefStr += s[i];
}
string substr = "";
for (int i = 1; i < n - 1; i++) {
substr += s[i];
}
int mx = Zfunc(substr, prefStr);
if (mx == 0) {
cout << "Just a legend";
return 0;
}
int yes = 1;
while (pref > mx) {
pref = lps[pref - 1];
}
if (pref == 0) {
cout << "Just a legend";
return 0;
}
for (int i = 0; i < pref; i++) {
cout << s[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 + 10;
int l[N];
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int n = ((int)(s).size());
l[0] = -1;
for (int i = (1); i <= (n); i++) {
l[i] = l[i - 1];
while (l[i] != -1 && s[i - 1] != s[l[i]]) l[i] = l[l[i]];
l[i]++;
}
if (l[n] == 0) {
cout << "Just a legend\n";
return 0;
}
for (int i = (0); i <= (n - 1); i++)
if (l[i] == l[n]) {
for (int j = (0); j <= (l[i] - 1); j++) cout << s[j];
cout << '\n';
return 0;
}
if (l[l[n]] == 0) {
cout << "Just a legend\n";
return 0;
}
for (int i = (0); i <= (n - 1); i++)
if (l[i] == l[l[n]]) {
for (int j = (0); j <= (l[l[n]] - 1); j++) cout << s[j];
cout << '\n';
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100000;
int f[MAXN];
char s[MAXN];
map<int, int> hsh;
int main() {
scanf("%s", s);
int n = strlen(s);
f[0] = f[1] = 0;
for (int i = 1; i < n; ++i) {
int j = f[i];
while (j && s[i] != s[j]) j = f[j];
f[i + 1] = s[i] == s[j] ? j + 1 : 0;
}
for (int i = 2; i < n; ++i)
if (f[i] != 0) hsh[f[i] - 1] = 1;
int x = n;
while (hsh[f[x] - 1] == 0 && x != 0) x = f[x];
if (x == 0)
printf("Just a legend");
else {
for (int i = 0; i < f[x]; ++i) printf("%c", s[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::string s;
std::cin >> s;
int n = s.length();
std::vector<int> prefix_fun(n, 0);
for (int i = 1; i < n; i++) {
int j = prefix_fun[i - 1];
while (j > 0 && s[i] != s[j]) {
j = prefix_fun[j - 1];
}
if (s[i] == s[j]) {
j++;
}
prefix_fun[i] = j;
}
if (prefix_fun[n - 1] == 0) {
std::cout << "Just a legend";
return 0;
}
for (int i = 1; i < n - 1; i++) {
if (prefix_fun[i] == prefix_fun[n - 1]) {
std::cout << s.substr(0, prefix_fun[i]);
return 0;
}
}
int j = prefix_fun[prefix_fun[n - 1] - 1];
if (j == 0) {
std::cout << "Just a legend";
return 0;
}
std::cout << s.substr(0, j);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 885544;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 1212121;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
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 (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> prime;
void sieve(long long int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (long long int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (long long int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
vector<long long int> merge(vector<long long int> v1,
vector<long long int> v2) {
vector<long long int> temp;
long long int i = 0, j = 0;
while (i < v1.size() && j < v2.size()) {
if (v1[i] < v2[j])
temp.push_back(v1[i]), i++;
else
temp.push_back(v2[j]), j++;
}
while (i < v1.size()) temp.push_back(v1[i]), i++;
while (j < v2.size()) temp.push_back(v2[j]), j++;
return temp;
}
long long int lps[1000005];
void kmplps(string st) {
long long int p = st.size();
lps[0] = 0;
long long int i = 1, l = 0;
while (i < p) {
if (st[i] == st[l]) {
l++;
lps[i] = l;
i++;
} else {
if (l != 0)
l = lps[l - 1];
else
lps[i] = 0, i++;
}
}
}
bool kmpsearch(string pat, string st) {
bool ms = 0;
long long int c = 0;
long long int a = pat.size(), b = st.size();
kmplps(pat);
long long int i = 0, j = 0;
while (i < b) {
if (pat[j] == st[i]) j++, i++;
if (j == a) {
c++;
if (i == b && c >= 3) ms = 1;
j = lps[j - 1];
} else if (i < b && pat[j] != st[i]) {
if (j != 0)
j = lps[j - 1];
else
i += 1;
}
}
if (c >= 3 && ms) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string st;
cin >> st;
long long int n = st.size();
kmplps(st);
long long int p = lps[n - 1];
while (p != 0) {
string s(st, 0, p);
if (kmpsearch(s, st)) {
cout << s << endl;
return 0;
}
p = lps[p - 1];
}
cout << "Just a legend" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
string a, b;
int z1[1000004], z2[100004], c[100005], ans;
void z1algo(string s, int n) {
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z1[i] = min(r - i + 1, z1[i - l]);
while (i + z1[i] < n && s[z1[i]] == s[i + z1[i]]) ++z1[i];
if (i + z1[i] - 1 > r) l = i, r = i + z1[i] - 1;
}
}
void z2algo(string s, int n) {
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z2[i] = min(r - i + 1, z2[i - l]);
while (i + z2[i] < n && s[z2[i]] == s[i + z2[i]]) ++z2[i];
if (i + z2[i] - 1 > r) l = i, r = i + z2[i] - 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> a;
z1algo(a, a.size());
int n = a.size();
int maxp = 0;
int len = 0;
for (int i = 1; i < n; i++) {
if (i + z1[i] == n && z1[i] <= maxp) {
len = z1[i];
break;
}
maxp = max(maxp, z1[i]);
}
if (!min(len, maxp)) {
cout << "Just a legend\n";
return 0;
}
for (int i = 0; i < min(len, maxp); i++) cout << a[i];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long double PI = 4 * atan((long double)1);
const long long INF = 1e18;
const long long NINF = -1e18;
long long get_hash(string s) {
long long N = 1000001;
long long base[N], A = 11, MD = 1110111110111;
base[0] = 1;
for (long long i = (1); i < (N); ++i) base[i] = (base[i - 1] * A) % MD;
long long hs = 0;
for (long long i = (0); i < (s.size()); ++i) {
hs += (s[i] * base[i]);
hs %= MD;
}
return hs;
}
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a *= a;
n /= 2;
}
return res;
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) long long idx,
__attribute__((unused)) long long LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, long long idx, long long LINE_NUM, Head H,
Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
long long fun(string a) {
long long n = a.size();
vector<long long> pi(n + 1);
pi[0] = 0;
for (long long i = (1); i < (a.size()); ++i) {
long long j = pi[i - 1];
while (j > 0 && a[i] != a[j]) j = pi[j - 1];
if (a[i] == a[j]) j++;
pi[i] = j;
}
long long u = pi[n - 1];
if (u == 0) return 0;
for (long long i = (0); i < (n - 1); ++i) {
if (pi[i] == u) return u;
}
long long v = pi[u - 1];
if (pi[u - 1] == 0) return 0;
return v;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string s;
cin >> s;
long long x = fun(s);
if (x <= 0) {
cout << "Just a legend";
return 0;
}
string a = s.substr(0, x);
cout << a;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
int Set(int N, int pos) { return (N | (1 << pos)); }
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return R;
}
const int N = 1e6;
int kmp[N + 5];
string str;
void genKMP() {
int m = str.length(), k;
kmp[0] = -1;
for (int i = 1; i <= m; i++) {
k = kmp[i - 1];
while (k >= 0) {
if (str[k] == str[i - 1])
break;
else
k = kmp[k];
}
kmp[i] = k + 1;
}
}
int main() {
cin >> str;
genKMP();
int len = str.size();
int found = 0;
string s;
if (kmp[len] != 0) {
for (int i = 1; i <= len - 1; i++) {
if (kmp[i] == kmp[len]) {
found = 1;
break;
}
}
if (!found) {
str = str.substr(len - kmp[len], kmp[len]);
len = str.size();
genKMP();
if (kmp[len] != 0) found = 1;
}
}
if (found) {
for (int i = 0; i < kmp[len]; i++) cout << str[i];
} else {
cout << "Just a legend";
}
}
|
#include <bits/stdc++.h>
char s[1000001];
int f[1000001], cnt[1000001];
int main() {
scanf("%s", s);
int n = strlen(s);
f[0] = f[1] = 0;
for (int i = 1; s[i]; i++) {
int j = f[i];
while (j && s[j] != s[i]) j = f[j];
f[i + 1] = s[j] == s[i] ? ++j : 0;
}
int nowLen = 0;
std::vector<int> cnt(n + 1, 1);
for (int i = n; i; i--) {
cnt[f[i]] += cnt[i];
}
int j = n;
while (j) {
if (cnt[f[j]] >= 3) {
nowLen = f[j];
break;
}
j = f[j];
}
if (nowLen > 0) {
s[nowLen] = 0;
printf("%s\n", s);
} else
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int z[N];
void computeZ(char s[]) {
int n = strlen(s), L = 0, R = 0;
for (int i = 1; i < n; i++) {
if (i > R) {
L = R = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
char s[N + 1];
int suffix[N + 1], size;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
computeZ(s);
int n = strlen(s), mx = 0;
int size = 0;
for (int i = 1; i < n; ++i)
if (z[i] == n - i) suffix[z[i]]++;
for (int i = 1; i < n; ++i) {
if (suffix[i])
suffix[i] = i;
else
suffix[i] = suffix[i - 1];
}
for (int i = 1; i < n; ++i) {
int len = z[i] - (z[i] == n - i);
mx = max(mx, suffix[len]);
}
if (mx == 0)
cout << "Just a legend" << endl;
else {
s[mx] = '\0';
cout << s << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr const long long MOD = 1e9 + 7;
string solve(const string &inp) {
string zstr = inp;
vector<int> z(zstr.length());
int limit = 0;
for (int i = 1, l = 0, r = 0; i < z.size(); ++i) {
auto prefix_candidate = z[i - l] < r - i + 1 ? z[i - l] : r - i + 1;
z[i] = 0 > prefix_candidate ? 0 : prefix_candidate;
while (z[i] + i < zstr.length() && zstr[z[i]] == zstr[z[i] + i])
l = i, r = z[i] + i, ++z[i];
if (z[i] + i == zstr.length()) {
limit = z[i] - 1 > limit ? z[i] - 1 : limit;
} else
limit = z[i] > limit ? z[i] : limit;
}
int ans = 0;
for (int i = 0; i < zstr.size(); ++i) {
if (z[i] + i == zstr.length() && z[i] <= limit)
ans = z[i] > ans ? z[i] : ans;
}
if (ans > 0) return inp.substr(0, ans);
return "Just a legend";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string inp;
cin >> inp;
cout << solve(inp) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
class cf126b {
public:
int p[N];
void solve(std::istream& in, std::ostream& out) {
string s;
in >> s;
int n = s.length();
kmp(s);
int x = 0, ans = p[n - 1];
for (int i = 1; i < n - 1; i++) x = max(x, p[i]);
if (ans == 0)
out << "Just a legend";
else {
while (ans) {
if (ans <= x) break;
ans = p[ans - 1];
}
if (!ans)
out << "Just a legend";
else
for (int i = 0; i < ans; i++) out << s[i];
}
}
void kmp(string s) {
int n = s.length();
memset(p, 0, sizeof(p));
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j && s[j] != s[i]) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cf126b solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long z[1000002], suf[1000002];
signed main() {
long long t = 1;
while (t--) {
string second;
cin >> second;
long long i, n = second.size();
long long l = 0, r = 0;
for (i = 1; i < n; i++) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n and second[z[i]] == second[i + z[i]]) z[i]++;
if (r < i + z[i] - 1) l = i, r = i + z[i] - 1;
}
long long mx = 0;
for (i = 1; i < n; i++) {
if (i + z[i] == n) {
suf[z[i]] = 1;
mx = max(mx, z[i] - 1);
} else
mx = max(mx, z[i]);
}
for (i = n - 2; i >= 1; i--) {
if (suf[i] and i <= mx) {
cout << second.substr(0, i);
return 0;
}
}
cout << "Just a legend";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int z[1000010], middle[1000010] = {0}, suffix[1000010] = {0}, ans = 0;
string s;
void calculate(int n) {
int L = 0, R = 0;
for (int i = 1; i < n; i++) {
if (i > R) {
L = R = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
int main() {
cin >> s;
int len = s.length();
calculate(len);
for (int i = 1; i < len; i++) {
middle[0]++;
if (i + z[i] < len)
middle[z[i] + 1]--;
else
middle[z[i]]--;
}
for (int i = 0; i < len; i++)
if (i + z[i] == len) suffix[z[i]]++;
for (int i = 1; i < len; i++) middle[i] += middle[i - 1];
for (int i = len - 1; i >= 0; i--)
if (suffix[i] && middle[i]) {
ans = i;
break;
}
if (ans)
for (int i = 0; i < ans; i++) cout << s[i];
else
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
mt19937 rng((int)chrono::steady_clock::now().time_since_epoch().count());
int uniform(int l, int r) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
template <int MOD>
struct str_hash {
static int P;
int n;
string second;
vector<long long> h, power;
str_hash(string s_) : n(s_.size()), second(s_), h(n), power(n) {
power[0] = 1;
for (int i = 1; i < n; i++) power[i] = power[i - 1] * P % MOD;
h[0] = second[0];
for (int i = 1; i < n; i++) h[i] = (h[i - 1] * P + second[i]) % MOD;
}
long long operator()(int i, int j) {
if (!i) return h[j];
return (h[j] - h[i - 1] * power[j - i + 1] % MOD + MOD) % MOD;
}
};
template <int MOD>
int str_hash<MOD>::P = uniform(137, MOD - 1);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string second;
cin >> second;
str_hash<1000000007> h(second);
int n = second.size();
long long melhor = 0;
for (int I = 1; I < n; I++) {
long long low = 0, high = n - I;
while (low + 1 < high) {
long long mid = (low + high) / 2;
if (h(0, mid - 1) == h(I, I + mid - 1)) {
low = mid;
} else {
high = mid;
}
melhor = max(melhor, low);
}
}
for (long long I = melhor; I > 0; I--) {
if (h(0, I - 1) != h(n - I, n - 1)) {
continue;
}
cout << second.substr(0, I) << '\n';
return 0;
}
cout << "Just a legend" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
vector<long long> prefix_function(string s) {
long long n = s.size();
vector<long long> pi(n);
for (long long i = 1; i < n; ++i) {
long long j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) ++j;
pi[i] = j;
}
return pi;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
vector<long long> p = prefix_function(s);
long long e = p[p.size() - 1];
if (e == 0)
cout << "Just a legend";
else {
bool k = 0;
for (long long i = 0; i < p.size() - 1; i++) {
if (p[i] == e) {
k = 1;
cout << s.substr(0, e);
break;
}
}
if (!k) {
e = p[e - 1];
if (e == 0)
cout << "Just a legend";
else
cout << s.substr(0, e);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
const int maxn = 1e6 + 10;
const ull p = 701, mod = 1e9 + 7;
string s;
int n;
ull h[maxn], po[maxn];
vector<int> v;
bool check(int x) {
for (int i = x; i < n - 1; i++)
if ((h[x - 1] * po[i - x + 1] % mod) == ((mod + h[i] - h[i - x]) % mod))
return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
n = s.size();
po[0] = 1;
for (int i = 1; i < maxn; i++) po[i] = (po[i - 1] * p) % mod;
h[0] = s[0] - 'a' + 1;
for (int i = 1; i < n; i++)
h[i] = (h[i - 1] + (((s[i] - 'a' + 1) * po[i]) % mod)) % mod;
for (int i = 1; i < n; i++)
if ((h[i - 1] * po[n - i] % mod) == ((mod + h[n - 1] - h[n - i - 1]) % mod))
v.push_back(i);
if (v.empty() || !check(v[0])) {
cout << "Just a legend\n";
return 0;
}
int l = 0, r = v.size();
while (l + 1 < r) {
int mid = (l + r) / 2;
if (check(v[mid]))
l = mid;
else
r = mid;
}
for (int i = 0; i < v[l]; i++) cout << s[i];
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> prefix_function(string s) {
int n = (int)s.length();
vector<int> pi(n);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
return pi;
}
int main() {
string s;
cin >> s;
int n = (int)s.length();
vector<int> p = prefix_function(s);
int k = p[n - 1];
if (k == 0)
cout << "Just a legend";
else {
bool found = false;
for (int i = 0; i < n - 1; i++)
if (p[i] == k) {
cout << s.substr(0, k);
found = true;
break;
}
if (!found) {
int l = p[k - 1];
if (l == 0)
cout << "Just a legend";
else {
cout << s.substr(0, l);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1001000];
int cnt[1001000], z[1001000];
int n;
void Z() {
z[0] = n;
int l = 0, r = 0;
for (int i = 1; i < n; i++) {
int ii = i - l;
int p = r + 1 - i;
if (i > r) {
int x = i;
while (x < n && s[x] == s[x - i]) x++;
z[i] = x - i;
if (x > i) {
l = i;
r = x - 1;
}
} else if (z[ii] >= p) {
int x = r + 1;
while (x < n && s[x] == s[x - i]) x++;
z[i] = x - i;
l = i;
r = x - 1;
} else
z[i] = z[ii];
}
}
int main() {
scanf("%s", s);
n = strlen(s);
Z();
for (int i = 1; i < n; i++) cnt[z[i]]++;
int sum = 0;
for (int i = n - 1; i > 0; i--) {
sum += cnt[i];
if (sum >= 2 && z[n - i] == i) {
for (int j = 0; j < i; j++) putchar(s[j]);
puts("");
return 0;
}
}
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e6 + 10;
const long long base = 1e9 + 7;
int N, ans;
long long power[maxN], H[maxN];
string S;
vector<int> F;
long long gethash(int x, int y) {
return (H[y] - H[x - 1] * power[y - x + 1] + base * base) % base;
}
bool check(int x) {
long long h = gethash(1, x);
for (int i = 2; i < N - x + 1; i++)
if (gethash(i, i + x - 1) == h) return 1;
return 0;
}
int main() {
cin >> S;
N = S.size();
power[0] = 1;
for (int i = 1; i <= N; i++) {
power[i] = power[i - 1] * 26 % base;
H[i] = (H[i - 1] * 26 + S[i - 1] - 'a') % base;
}
for (int i = 1; i <= N; i++) {
long long hpre = gethash(1, i), hsuf = gethash(N - i + 1, N);
if (hpre == hsuf) F.push_back(i);
}
ans = -1;
int l = 0, r = F.size() - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(F[mid]))
ans = F[mid], l = mid + 1;
else
r = mid - 1;
}
if (ans < 0) cout << "Just a legend";
for (int i = 0; i < ans; i++) cout << S[i];
}
|
#include <bits/stdc++.h>
using namespace std;
int z[1234567];
string s, a;
void z_cal(void) {
int n = s.size();
int l, r, k;
l = r = 0;
for (int i = 1; i <= n; i++) {
if (i > r) {
l = r = i;
while (r < n && s[r - l] == s[r]) r++;
z[i] = r - l;
r--;
} else {
k = i - l;
if (z[k] < r - i + 1)
z[i] = z[k];
else {
l = i;
while (r < n && s[r - l] == s[r]) r++;
z[i] = r - l;
r--;
}
}
}
}
int main() {
cin >> s;
z_cal();
int ans = -1;
int mx = 0;
for (int i = 1; i < s.size(); i++) {
if (z[i] == s.size() - i) {
if (mx >= z[i]) {
ans = i;
break;
}
}
mx = max(mx, z[i]);
}
if (ans == -1)
puts("Just a legend");
else
cout << s.substr(ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int base = 31;
const long long mod = 1e9 + 9;
long long hashs[1000001], p_pow[1000001];
int z[1000001];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = (int)s.size();
z[0] = 0;
int ans = 0;
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
if (i + z[i] < n)
ans = max(ans, z[i]);
else
ans = max(ans, z[i] - 1);
}
for (int i = 1; i < n; i++) {
if (i + z[i] == n && z[i] <= ans) {
for (int j = i; j < n; j++) cout << s[j] << "";
return 0;
}
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long N = 100001;
long long mod = 1000000007;
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long power(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long p, long long q) {
if (p % q == 0)
return q;
else {
return gcd(q, p % q);
}
}
long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long sub(long long a, long long b) {
return (((a - b) % mod) + mod) % mod;
}
vector<long long> kmp(string s) {
long long n = s.size();
vector<long long> ans(n);
long long len = 0;
for (long long i = 1; i < n; i++) {
while (len > 0 && s[len] != s[i]) len = ans[len - 1];
len += (s[i] == s[len]);
ans[i] = len;
}
return ans;
}
void solve() {
string s;
cin >> s;
vector<long long> ans = kmp(s);
if (ans.back() == 0) {
cout << "Just a legend" << '\n';
return;
}
for (long long i = 1; i < s.size() - 1; i++) {
if (ans[i] == ans.back()) {
cout << s.substr(0, ans[i]);
cout << '\n';
return;
}
}
if (ans[ans.back() - 1] == 0)
cout << "Just a legend";
else
cout << s.substr(0, ans[ans.back() - 1]);
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, lps[1000005];
bool possible[1000005];
char s[1000005];
void gen_lps() {
for (int i = 1; i < n; i++) {
int j = lps[i - 1];
while (j > 0 && s[j] != s[i]) j = lps[j - 1];
if (s[j] == s[i]) j++;
lps[i] = j;
}
}
int main() {
scanf("%s", s);
n = strlen(s);
gen_lps();
memset(possible, 0, sizeof(possible));
for (int i = 0; i < n - 1; i++) possible[lps[i]] = true;
int len = lps[n - 1];
while (len > 0 && !possible[len]) {
len = lps[len - 1];
}
if (len)
for (int i = 0; i < len; i++) printf("%c", s[i]);
else
printf("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
char s[1000010];
int next_[1000010], vis[1000010];
void getnext() {
int i = 0, j = -1;
int len = strlen(s);
next_[0] = -1;
while (i < len) {
if (j == -1 || s[i] == s[j])
next_[++i] = ++j;
else
j = next_[j];
}
}
int main() {
int i;
while (~scanf("%s", s)) {
int len = strlen(s);
getnext();
memset(vis, 0, sizeof(vis));
for (i = 1; i < len; i++) vis[next_[i]] = 1;
int j = len, flag = 0;
while (next_[j] > 0) {
if (vis[next_[j]]) {
for (i = 0; i < next_[j]; i++) printf("%c", s[i]);
printf("\n");
flag = 1;
break;
}
j = next_[j];
}
if (!flag) printf("Just a legend\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[z[i]] == s[z[i] + i]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
int max = 0;
int maxz = 0;
int maxi = 0;
for (int i = 1; i < n; ++i)
if (z[i] > maxz) maxz = z[i], maxi = i;
for (int i = 1; i <= maxz; ++i)
if (z[n - i] == i && z[n - i] > max && n - i != maxi) max = z[n - i];
if (max == 0)
cout << "Just a legend\n";
else {
for (int i = 0; i < max; ++i) cout << s[i];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int f[1000100];
int kid[1000100];
int main() {
cin >> s;
n = s.length();
int k = 0;
for (int i = 1; i < n; i++) {
while (k && s[i] != s[k]) k = f[k - 1];
if (s[i] == s[k]) k++;
f[i] = k;
kid[k]++;
}
if (f[n - 1] == 0)
cout << "Just a legend" << endl;
else if (kid[f[n - 1]] > 1)
cout << s.substr(0, f[n - 1]) << endl;
else if (f[f[n - 1] - 1] != 0)
cout << s.substr(0, f[f[n - 1] - 1]) << endl;
else
cout << "Just a legend" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> prefix_function(string s) {
long long int n = s.size();
vector<long long int> pi(n);
pi[0] = 0;
for (long long int i = 1; i < n; i++) {
long long int j = pi[i - 1];
while (j > 0 and s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
return pi;
}
void solve() {
string s;
cin >> s;
long long int n = s.size();
vector<long long int> pi(n);
pi = prefix_function(s);
long long int k = pi[n - 1];
if (k == 0) {
cout << "Just a legend\n";
return;
}
for (long long int i = 1; i < n - 1; i++) {
if (pi[i] == k) {
string ans = s.substr(0, k);
cout << ans << endl;
return;
}
}
k = pi[k - 1];
if (k == 0) {
cout << "Just a legend\n";
return;
}
string ans = s.substr(0, k);
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[1000005];
int z[1000005];
void zalgo(char s[], int n) {
int L, R, i, j, k;
L = R = 0;
for (i = 1; i < n; i++) {
if (i > R) {
L = R = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
int main() {
int n, i, max1 = -100000000, j;
scanf("%s", a);
n = strlen(a);
zalgo(a, n);
for (i = 1; i < n; i++) {
if (z[i] == n - i && max1 >= n - i) {
for (j = i; j < n; j++) cout << a[j];
break;
}
max1 = max(max1, z[i]);
}
if (i == n) cout << "Just a legend";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void MN(long long int &a, long long int b) {
if (a > b) a = b;
}
void MX(long long int &a, long long int b) {
if (a < b) a = b;
}
void MN(int &a, long long int b) {
if (a > b) a = b;
}
void MX(int &a, long long int b) {
if (a < b) a = b;
}
void MN(double &a, double b) {
if (a > b) a = b;
}
void MX(double &a, double b) {
if (a < b) a = b;
}
long long int sqdist(long long int p1x, long long int p1y, long long int p2x,
long long int p2y) {
return (p2x - p1x) * (p2x - p1x) + (p2y - p1y) * (p2y - p1y);
}
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a * (b / gcd(a, b));
}
int z[1000001];
char str[1000001];
int main() {
scanf("%s", str);
int n = strlen(str);
int l = -1, r = -1;
for (int i = 1; i < n; i++) {
if (i > r) {
l = r = i;
while (r < n && str[r] == str[r - l]) r++;
z[i] = r - l;
r--;
} else {
int k = i - l;
if (z[k] < r - i + 1) {
z[i] = z[k];
} else {
l = i;
while (r < n && str[r] == str[r - l]) r++;
z[i] = r - l;
r--;
}
}
}
int onnot = -1, res = -1;
for (int i = 0; i < n; i++) {
if (n - i != z[i]) {
if (z[i] > onnot) {
onnot = z[i];
}
} else {
if (onnot >= z[i]) {
res = z[i];
break;
} else {
if (z[i] > onnot) {
onnot = z[i];
}
}
}
}
if (res == -1)
printf("Just a legend\n");
else {
for (int i = 0; i < res; i++) printf("%c", str[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int prefix[s.length()];
int j = 0;
prefix[0] = 0;
for (int i = 1; i < s.length(); i++) {
if (s[i] == s[j]) {
prefix[i] = j + 1;
j++;
} else {
while (j != 0) {
j = prefix[j - 1];
if (s[i] == s[j]) {
j++;
prefix[i] = j;
break;
}
}
if (j == 0) prefix[i] = 0;
}
}
int hi = prefix[s.length() - 1];
int flag = 0;
for (int i = 0; i < s.length() - 1; i++) {
if (prefix[i] == hi) {
flag = 1;
break;
}
}
if (flag == 1 && hi != 0) {
cout << s.substr(s.length() - hi) << endl;
} else if (hi == 0)
cout << "Just a legend\n";
else {
if (prefix[hi - 1] == 0)
cout << "Just a legend\n";
else
cout << s.substr(s.length() - prefix[hi - 1]) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve(int testcase) {
string s;
cin >> s;
int n = ((int)s.size());
vector<int> p(n);
for (int i = (1); i <= (n - 1); i++) {
int j = p[i - 1];
while (j > 0 && s[j] != s[i]) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
if (p[n - 1] == 0) {
cout << "Just a legend";
return;
}
for (int i = (0); i <= (n - 2); i++) {
if (p[i] == p[n - 1]) {
cout << s.substr(0, p[n - 1]);
return;
}
}
if (p[p[n - 1] - 1] > 0) {
cout << s.substr(0, p[p[n - 1] - 1]);
return;
}
cout << "Just a legend";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(10);
clock_t b = clock();
int t = 1;
for (int tt = (1); tt <= (t); tt++) solve(tt);
clock_t e = clock();
cerr << (double(e - b) / CLOCKS_PER_SEC) << " sec";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1000100];
int zz[1000100], z[1000100];
int len;
void zfunction() {
int left = 0, right = 0;
len = strlen(str);
for (int i = 1; i < len; ++i) {
if (i > right) {
left = right = i;
while (right < len && str[right] == str[right - left]) {
right++;
}
right--;
zz[i] = right - left + 1;
} else {
int tmp = i - left;
if (zz[tmp] < right - i + 1) {
zz[i] = zz[tmp];
} else {
left = i;
while (right < len && str[right] == str[right - left]) {
right++;
}
right--;
zz[i] = right - left + 1;
}
}
}
}
int main() {
scanf("%s", str);
zfunction();
int ans = -1;
int maxm = 0;
for (int i = 1; i < len; ++i) {
if (i == len - zz[i] && zz[i] <= maxm) {
ans = i;
break;
}
maxm = max(maxm, zz[i]);
}
if (ans == -1)
printf("Just a legend\n");
else
printf("%s\n", &str[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string in;
while (cin >> in) {
int n = in.size();
int kmp[1000000 + 1];
kmp[0] = -1;
int j = -1, i = 0;
while (i < n) {
while (j >= 0 && in[i] != in[j]) j = kmp[j];
i++;
j++;
kmp[i] = j;
}
j = kmp[n];
int k = n;
bool solved = false;
while (j > 0 && !solved) {
for (int i = 1; i < n; i++)
if (kmp[i] == j) {
for (int u = 0; u < j; u++) cout << in[u];
cout << endl;
solved = true;
break;
}
j = kmp[j];
}
if (!solved) cout << "Just a legend" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 444666;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void build_z(int z[], string s) {
int L, R, n, k;
L = R = 0;
n = (int)(s.size());
for (int i = 1; i < n; i++) {
if (R < i) {
L = R = i;
while (R < n && s[R - L] == s[R]) {
R++;
}
z[i] = R - L;
R--;
} else {
k = i - L;
if (z[k] < (R - i + 1)) {
z[i] = z[k];
} else {
L = i;
while (R < n && s[R - L] == s[R]) {
R++;
}
z[i] = R - L;
R--;
}
}
}
}
int main() {
string s;
int n;
while (cin >> s) {
n = (int)(s.size());
int z[n];
build_z(z, s);
int maxz = 0, res = 0;
for (int i = 1; i < n; i++) {
if (z[i] == n - i && maxz >= n - i) {
res = n - i;
break;
}
maxz = max(maxz, z[i]);
}
if (res == 0)
cout << "Just a legend" << endl;
else
cout << s.substr(0, res) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace AC {
const long long N = 1e5 + 66;
long long BUGS = 1;
inline long long read() {
long long x = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
if (flag) return x;
return (~(x - 1));
}
inline void read(long long arr[], long long s, long long e) {
for (long long i = s; i <= e; ++i) arr[i] = read();
}
inline void write(long long x) {
if (x < 0) {
x = ~(x - 1);
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void print(long long x) {
write(x);
puts("");
}
inline void print(long long arr[], long long s, long long e) {
for (long long i = s; i <= e - 1; ++i) write(arr[i]), putchar(' ');
write(arr[e]);
puts("");
}
inline long long max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline long long min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline void debugNum(long long num, string ss) {
cout << "BUGS" << BUGS++ << " : " << ss << " : " << num << endl;
}
inline void debugArr(long long arr[], long long s, long long e, string ss) {
cout << "BUGS" << BUGS++ << " : " << ss << " : " << endl;
for (long long i = s; i <= e; ++i)
cout << "i : " << i << " val : " << arr[i] << endl;
}
inline void IO() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
} // namespace AC
using namespace AC;
namespace KMP {
const long long MAXN = 1e6 + 10;
const long long MAXM = 1e4 + 10;
long long prefix[MAXN], pp[MAXN];
vector<long long> ans;
inline void clearKMP() { ans.clear(); }
inline void getNext(long long lenP, long long* prefix, char* p) {
long long i = 0, k = -1;
prefix[0] = -1;
while (i < lenP) {
if (k == -1 || p[i] == p[k])
i++, k++, prefix[i] = k;
else
k = prefix[k];
}
}
inline void kmp(long long lenP, long long lenT, long long* prefix, char* p,
char* txt) {
getNext(lenP, prefix, p);
long long i = 0, j = 0;
while (i < lenT) {
if (j == -1 || txt[i] == p[j])
i++, j++;
else
j = prefix[j];
if (j >= lenP) ans.push_back(i - j + 1), j = prefix[j];
}
}
} // namespace KMP
using namespace KMP;
char ss[MAXN], p[MAXN];
int main() {
while (~scanf("%s", ss)) {
ans.clear();
long long lenss = strlen(ss);
getNext(lenss, prefix, ss);
long long cur = prefix[lenss];
bool ok = false;
while (cur > 0) {
long long lenp = 0;
for (long long i = 0; i < cur; ++i) {
p[lenp++] = ss[i];
}
p[lenp] = '\0';
ans.clear();
kmp(lenp, lenss, pp, p, ss);
if (ans.size() >= 3) {
ok = true;
printf("%s\n", p);
break;
} else
cur = prefix[cur];
}
if (ok == false) puts("Just a legend");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 5;
int dp[maxn];
char t[maxn];
bool ha[maxn];
void cal(char *s) {
int len = strlen(s);
memset(dp, -1, sizeof(dp));
for (int i = 1; i < len; ++i) {
int j = dp[i - 1];
while (j != -1 && s[j + 1] != s[i]) j = dp[j];
if (s[j + 1] == s[i]) dp[i] = j + 1;
}
}
int main() {
scanf("%s", t);
cal(t);
int n = strlen(t);
for (int i = 1; i < n - 1; ++i) {
ha[dp[i] + 1] = 1;
}
int x = n - 1;
while (x != -1 && !ha[dp[x] + 1]) x = dp[x];
if (x == -1 || dp[x] == -1) return puts("Just a legend"), 0;
for (int i = 0; i <= dp[x]; ++i) {
printf("%c", t[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1000005];
int n, z[1000005];
int main() {
scanf("%s", str);
n = strlen(str);
z[0] = n;
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (l && (i + z[i - l] < r))
z[i] = z[i - l];
else {
int j = min(l ? z[i - l] : 0, i > r ? 0 : r - i);
while (str[i + j] == str[j]) ++j;
z[i] = j, l = i, r = i + j;
}
}
int maxi = 0, ans = 0;
for (int i = (1); i < (n); ++i) {
if (z[i] == n - i && maxi >= n - i) {
ans = n - i;
break;
}
maxi = max(maxi, z[i]);
}
if (ans == 0)
printf("Just a legend\n");
else {
str[ans] = '\0';
printf("%s\n", str);
}
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
int main(int argc, const char* argv[]) {
string input;
cin >> input;
vector<int> table(input.size() + 1);
int i = 0;
int j = -1;
int max = 0;
table[i] = j;
while (i < input.size()) {
while (j >= 0 && input[i] != input[j]) j = table[j];
i++;
j++;
table[i] = j;
if (i < input.size()) {
max = std::max(max, table[i]);
}
}
table[0] = 0;
j = table[input.size()];
while (j > max) {
j = table[j];
}
if (0 == j) {
cout << "Just a legend" << endl;
} else {
cout << input.substr(0, j) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long int> pref;
long long phash[1000002], n;
vector<long long int> vv;
long long expo(long long base, long long exponent, long long mod) {
long long ans = 1;
while (exponent != 0) {
if ((exponent & 1) == 1) {
ans = ans * base;
ans = ans % mod;
}
base = base * base;
base %= mod;
exponent >>= 1;
}
return ans % mod;
}
bool check(long long m) {
long long len = vv[m];
for (long long i = 1; i + len - 1 < n - 1; i++) {
if ((phash[i + len - 1] -
(phash[i - 1] * expo(97, len, 1000000007)) % 1000000007 + 1000000007) %
1000000007 ==
phash[len - 1])
return 1;
}
return 0;
}
int main() {
long long i, j;
string s;
cin >> s;
n = (long long)s.length();
long long hash = 0;
for (i = 0; i < n; i++) {
hash = ((hash * 97) % 1000000007 + (s[i] - 'a' + 1)) % 1000000007;
phash[i] = hash;
if (i < n - 1) {
}
}
for (i = 1; i < n; i++) {
hash = (phash[n - 1] -
(phash[i - 1] * expo(97, n - i, 1000000007)) % 1000000007 +
1000000007) %
1000000007;
if (hash == phash[n - i - 1]) {
vv.push_back(n - i);
}
}
sort((vv).begin(), (vv).end());
long long lo = 0, hi = (long long)(vv.size()) - 1LL, mid;
while (lo < hi) {
mid = lo + (hi - lo + 1) / 2;
if (check(mid))
lo = mid;
else
hi = mid - 1;
}
if (lo >= 0 and lo < (long long)(vv.size()) and check(lo))
cout << s.substr(0, vv[lo]);
else
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 2e10;
ll bigmod(ll a, ll b) {
if (b == 0) return 1;
ll x = bigmod(a, b / 2);
x = x * x;
if (b & 1) x = a * x;
return x;
}
vector<ll> z;
void Z(string s) {
ll n = s.length();
z.resize(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min((ll)r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return;
}
void solve() {
string s;
ll cnt = 0, mx = 0;
cin >> s;
bool ok = 1;
if (s.size() < 3)
ok = 0;
else {
Z(s);
for (ll i = 0; i < s.size(); i++) {
if (z[i] + i == s.size() and mx >= z[i]) {
cnt = z[i];
break;
}
mx = max(mx, z[i]);
}
if (cnt == 0) ok = 0;
}
if (ok) {
for (ll i = 0; i < cnt; i++) cout << s[i];
} else
cout << "Just a legend";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e8 + 9, b = 1417;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int z[1000005], pre[1000005];
void zalgo(string str, int n) {
int l = 0, r = 0;
z[0] = n;
for (int i = 1; i < n; i++) {
if (i > r) {
int j = 0, k = i;
while (k < n && str[k] == str[j]) {
k++;
j++;
}
k--;
z[i] = j;
if (k > r) {
r = k;
l = i;
}
} else {
int k = i;
int k1 = k - l;
int b = r - k + 1;
if (z[k1] < b)
z[k] = z[k1];
else if (z[k1] > b)
z[k] = b;
else {
k = r + 1;
while (k < n && str[k] == str[b]) {
k++;
b++;
}
k--;
if (k > r) {
r = k;
l = i;
}
z[i] = b + r - k;
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string str;
cin >> str;
int final = 0;
int n = str.length();
zalgo(str, n);
pre[1] = z[1];
for (int i = 2; i < n; i++) {
pre[i] = max(pre[i - 1], z[i]);
}
for (int i = 1; i < n; i++) {
if (pre[i - 1] >= z[i] && (z[i] == n - i)) {
final = max(final, z[i]);
}
}
if (final == 0)
cout << "Just a legend\n";
else
cout << str.substr(0, final) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 101, N = 1000000;
const long long MOD1 = 1e9 + 7, MOD2 = 1e9 + 9;
long long h1[N], h2[N], p1[N], p2[N];
string s;
int n, tobs[N], cnt;
int get1(int i, int len) {
return (((h1[i + len - 1] - (i ? h1[i - 1] : 0) * p1[len]) % MOD1) + MOD1) %
MOD1;
}
int get2(int i, int len) {
return (((h2[i + len - 1] - (i ? h2[i - 1] : 0) * p2[len]) % MOD2) + MOD2) %
MOD2;
}
bool ok(int idx) {
int len = tobs[idx];
pair<int, int> val = {get1(0, len), get2(0, len)};
if (val != make_pair(get1(n - len, len), get2(n - len, len))) return 0;
for (int i = 1; i < n - 1; ++i) {
if (i + len >= n) break;
if (make_pair(get1(i, len), get2(i, len)) == val) return 1;
}
return 0;
}
int f(int lo, int hi) {
if (lo == hi) {
return lo;
}
int mid = (lo + hi) / 2 + 1;
if (ok(mid)) {
return f(mid, hi);
} else {
return f(lo, mid - 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.length();
p1[0] = p2[0] = 1;
for (int i = 1; i < n; ++i) {
p1[i] = p1[i - 1] * M;
p2[i] = p2[i - 1] * M;
p1[i] %= MOD1, p2[i] %= MOD2;
}
for (int i = 0; i < n; ++i) {
h1[i] = (i ? h1[i - 1] : 0) * M + s[i];
h2[i] = (i ? h2[i - 1] : 0) * M + s[i];
h1[i] %= MOD1, h2[i] %= MOD2;
}
tobs[0] = 0;
cnt = 1;
for (int i = 1; i < n; ++i) {
if (make_pair(get1(0, i), get2(0, i)) ==
make_pair(get1(n - i, i), get2(n - i, i))) {
tobs[cnt++] = i;
}
}
int ans = 0;
if (cnt) {
ans = f(0, cnt - 1);
}
if (ans == 0) {
cout << "Just a legend\n";
} else {
cout << s.substr(0, tobs[ans]) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> Zalgo(string s) {
int n = s.size();
vector<int> z(n);
z[0] = 0;
int l = 0, r = 0;
for (int i = 1; i < n; i++) {
if (i > r) {
l = r = i;
while (r < n && s[r - l] == s[r]) {
r++;
}
z[i] = r - l;
r--;
} else {
int k = i - l;
if (z[k] < r - i + 1) {
z[i] = z[k];
} else {
l = i;
while (r < n && s[r - l] == s[r]) {
r++;
}
z[i] = r - l;
r--;
}
}
}
return z;
}
int main() {
string s;
cin >> s;
int n = s.size();
vector<int> z = Zalgo(s);
int i;
int mx = 0;
int idx = n - 1;
vector<int> v;
for (i = n - 1; i >= 0; i--) {
if (i + z[i] == n) {
if (z[i] >= mx) {
mx = z[i];
idx = i;
v.push_back(mx);
}
}
}
if (idx < mx) {
mx = mx - idx;
cout << s.substr(0, mx);
} else {
string ans = "Just a legend";
reverse(v.begin(), v.end());
bool f = false;
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < n - v[i]; j++) {
if (z[j] >= v[i]) {
ans = s.substr(0, v[i]);
f = true;
}
}
if (f) {
break;
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 20;
char s[maxn];
int nxt[maxn], cnt[maxn];
void GetNextval(char* p, int nxt[]) {
int pLen = strlen(p);
nxt[0] = -1;
int k = -1;
int j = 0;
while (j != pLen) {
if (k == -1 || p[j] == p[k]) {
++j;
++k;
nxt[j] = k;
} else {
k = nxt[k];
}
}
}
int main() {
scanf("%s", s);
GetNextval(s, nxt);
int l = strlen(s);
for (int i = 1; i <= l; i++) {
cnt[nxt[i]]++;
;
}
if (cnt[nxt[l]] >= 2 && nxt[l] != 0) {
for (int i = 0; i < nxt[l]; i++) {
printf("%c", s[i]);
}
} else if (nxt[nxt[l]] != 0 && nxt[nxt[l]] != -1) {
for (int i = 0; i < nxt[nxt[l]]; i++) {
printf("%c", s[i]);
}
} else {
printf("Just a legend");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
char s[N];
int p[N], k;
void kmp() {
int n = strlen(s + 1);
for (int i = 2; i <= n; i++) {
while (k && s[k + 1] != s[i]) k = p[k];
if (s[k + 1] == s[i]) k++;
p[i] = k;
}
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%s", s + 1);
int n = strlen(s + 1);
kmp();
int x = 0, ans = p[n];
for (int i = 2; i < n; i++) x = max(x, p[i]);
while (ans) {
if (ans <= x)
break;
else
ans = p[ans];
}
if (!ans)
puts("Just a legend");
else
for (int i = 1; i <= ans; i++) printf("%c", s[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void next_function(char S[], int n, int next[]) {
next[0] = n;
int j = 0, k = 1;
while (1 + j < n && S[j] == S[1 + j]) j++;
next[1] = j;
for (int i = 2; i < n; ++i) {
int len = k + next[k] - 1;
int l = next[i - k];
if (l < len - i + 1)
next[i] = l;
else {
int j = max(0, len - i + 1);
while (S[i + j] == S[j] && i + j < n) j++;
next[i] = j;
k = i;
}
}
}
void extend_kmp(char S[], int n, char T[], int m, int next[], int lcp[]) {
next_function(T, m, next);
int j = 0, k = 0;
while (j < min(n, m) && T[j] == S[j]) ++j;
lcp[0] = j;
for (int i = 1; i < n; ++i) {
int len = k + lcp[k] - 1;
int l = next[i - k];
if (l < len - i + 1)
lcp[i] = l;
else {
int j = max(0, len - i + 1);
while (i + j < n && j < m && S[i + j] == T[j]) j++;
lcp[i] = j;
k = i;
}
}
}
char s[1000007];
int len, lcp[1000007];
int main() {
scanf("%s", s);
len = strlen(s);
next_function(s, len, lcp);
int x = 0;
for (int i = 1; i < len; ++i)
if (lcp[i] == len - i)
x = max(x, lcp[i] - 1);
else
x = max(x, lcp[i]);
int ans = 0;
for (int i = 1; i < len; ++i)
if (lcp[i] == len - i)
if (lcp[i] <= x) ans = max(ans, lcp[i]);
if (!ans)
cout << "Just a legend\n";
else
cout << string(s, 0, ans) << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.