text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool read(T& x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c) && (c != '-') && (c != EOF)) c = getchar();
if (c == EOF) return 0;
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
x *= f;
return 1;
}
template <typename T, typename... Args>
inline bool read(T& x, Args&... args) {
bool res = 1;
res &= read(x);
res &= read(args...);
return res;
}
const int M = 1000000007, INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int N = 1000010;
const double EPS = 1e-6;
inline bool isc(char c) { return (c >= 'a') && (c <= 'z'); }
inline int reads(char* s) {
int len = 0;
char c = getchar();
while (c != EOF && (!isc(c))) c = getchar();
if (c == EOF) return 0;
while (c != EOF && isc(c)) (*(++s)) = c, ++len, c = getchar();
(*(++s)) = '\0';
return len;
}
char s[N];
int n, nex[N], pos[N];
inline void init() {
n = reads(s);
int j = 0;
for (int i = (2), (ii) = (n); i <= (ii); ++i) {
while (j && (s[j + 1] != s[i])) j = nex[j];
if (s[j + 1] == s[i]) ++j;
++pos[j];
nex[i] = j;
}
}
inline void solve() {
int res = nex[n];
--pos[res];
while ((res) && (!pos[res])) res = nex[res];
if (res == 0) {
puts("Just a legend");
} else {
s[res + 1] = '\0';
printf("%s\n", s + 1);
}
}
signed main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ASS(bool b) {
if (!b) {
++*(int*)0;
}
}
#pragma comment(linker, "/STACK:106777216")
const int N = 1 << 20;
struct chash {
int a[N];
int p[N];
int hash(int pos, int k) const { return a[pos + k] - a[pos] * p[k]; }
void Init(char* s, int n, int h) {
a[0] = 0;
p[0] = 1;
for (int i = 0; i < (int)(n); i++) {
a[i + 1] = a[i] * h + s[i] - 'a' + 1;
p[i + 1] = p[i] * h;
}
}
};
chash h0, h1;
char s[N];
vector<int> toDel[N];
int main() {
scanf("%s", s);
int n = (int)strlen(s);
int H1 = 2999 + rand();
for (int i = 0; i < (int)(n); i++) H1 = H1 * 2999 + s[i] - 1;
H1 = (H1 & ((1 << 30) - 1)) | 1;
h0.Init(s, n, 3731);
h1.Init(s, n, H1);
set<int> st;
int BestLen = 0;
int BestPos = 0;
for (int i = 0; i < (int)(n); i++) {
if (i == n - 1 || i == 0) continue;
for (int j = 0; j < (int)(toDel[i].size()); j++) st.erase(toDel[i][j]);
int L = 0;
int R = n - i;
while (R - L > 1) {
int m = (L + R) >> 1;
if (h0.hash(i, m) == h0.hash(0, m) && h1.hash(i, m) == h1.hash(0, m))
L = m;
else
R = m;
}
if (L > 0) {
st.insert(i);
toDel[i + L].push_back(i);
}
L = 0;
R = i + 1;
while (R - L > 1) {
int m = (L + R) >> 1;
if (h0.hash(i - m + 1, m) == h0.hash(n - m, m) &&
h1.hash(i - m + 1, m) == h1.hash(n - m, m))
L = m;
else
R = m;
}
set<int>::iterator it = st.lower_bound(i - L + 1);
if (it != st.end()) {
int Len = i - (*it) + 1;
if (BestLen < Len) {
BestLen = Len;
BestPos = (*it);
}
}
}
if (BestLen == 0) {
printf("Just a legend\n");
} else {
s[BestPos + BestLen] = 0;
printf("%s\n", s + BestPos);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int z[1111111];
void pre() {
int l = 0, r = 0;
for (int i = 1; i < s.size(); i++) {
if (i >= r) {
while (i + z[i] < s.size()) {
if (s[z[i]] == s[z[i] + i])
z[i]++;
else
break;
}
if (l + z[i] - 1 > r) {
l = i, r = i + z[i] - 1;
}
} else {
int can = z[i - l];
if (i + can - 1 <= r) {
z[i] = can;
} else {
int cur;
for (cur = r; cur <= i + can && cur < s.size(); cur++) {
if (s[cur - l] != s[cur]) {
break;
}
}
z[i] = cur - i;
if (l + z[i] - 1 > r) {
l = i, r = i + z[i] - 1;
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> s;
pre();
int mx = 0;
for (int i = 0; i < s.size(); i++) {
if (z[i] > z[mx]) mx = i;
}
int ans = 0;
for (int i = 0; i < s.size(); i++) {
if (i == mx) continue;
if (z[i] == 0) continue;
if (z[s.size() - z[i]] == z[i]) {
ans = max(ans, z[i]);
}
}
if (ans)
cout << s.substr(0, ans) << endl;
else
cout << "Just a legend" << endl;
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void preFun(string str, vector<long long int>& pi) {
pi[0] = 0;
for (long long int i = 1; i < str.size() - 1; ++i) {
long long int j = pi[i - 1];
while (j > 0 && str[j] != str[i]) j = pi[j - 1];
if (str[j] == str[i]) j++;
pi[i] = j;
}
}
int main() {
string str;
cin >> str;
if (str.size() == 1) {
cout << "Just a legend";
return 0;
}
vector<long long int> pi(str.size());
preFun(str, pi);
long long int maxi = INT_MIN;
for (long long int i = 0; i < str.size() - 1; ++i) {
if (maxi < pi[i]) maxi = pi[i];
}
long long int ans = -1;
long long int j = pi[str.size() - 2];
while ((str[str.size() - 1] != str[j]) || (j + 1 > maxi)) {
if (j <= 0) break;
j = pi[j - 1];
}
if (str[j] == str[str.size() - 1]) j++;
ans = j;
if (ans == 0 || ans == -1 || ans > maxi) {
cout << "Just a legend";
} else
cout << str.substr(0, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long pi[1000005];
string p;
void kmp() {
long long now;
pi[0] = -1;
now = -1;
for (long long i = 1; i < p.size(); i++) {
while (now != -1 && p[i] != p[now + 1]) now = pi[now];
if (p[i] == p[now + 1])
pi[i] = ++now;
else
pi[i] = -1;
}
}
void solve() {
cin >> p;
kmp();
long long len = p.size();
long long maxi = pi[len - 1];
long long found = pi[maxi];
if (maxi == -1) found = -1;
for (long long i = 1; i < (len - 1); i++) {
if (pi[i] == maxi) found = maxi;
}
if (found == -1)
cout << "Just a legend" << endl;
else {
cout << p.substr(0, found + 1) << endl;
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
const char* INPUTFILE = NULL;
const char* OUTPUTFILE = NULL;
const char* ERROR_LOG__FILE = NULL;
const FILE* INPUT = (INPUTFILE ? freopen(INPUTFILE, "r", stdin) : stdin);
const FILE* OUTPUT = (OUTPUTFILE ? freopen(OUTPUTFILE, "w", stdout) : stdout);
const FILE* ERROR_LOG =
(ERROR_LOG__FILE ? freopen(ERROR_LOG__FILE, "w", stderr) : stderr);
inline double TIME() {
return (static_cast<double>(clock())) / (static_cast<double>(CLOCKS_PER_SEC));
}
using namespace std;
const int MAX_SIZE = (1 << 20);
string s;
int pref[MAX_SIZE], suff[MAX_SIZE], size;
class HashString {
public:
static const int p = 31;
unsigned long long pw[MAX_SIZE + 1], h[MAX_SIZE];
int size;
inline void build(const string& s) {
size = (int)s.size();
h[0] = s[0];
pw[0] = 1;
for (int i = 1; i < size; ++i) {
h[i] = h[i - 1] * p + s[i];
pw[i] = pw[i - 1] * p;
}
pw[size] = pw[size - 1];
}
inline unsigned long long get(const int& l, const int& r) const {
return (l ? h[r] - h[l - 1] * pw[r - l + 1] : h[r]);
}
inline bool eq(const int& l1, const int& r1, const int& l2,
const int& r2) const {
return get(l1, r1) == get(l2, r2);
}
} helper;
inline int find_pref(const int& id) {
int l, r, mid;
l = 1;
r = size - id - 1;
while (r - l > 1) {
mid = (l + r) >> 1;
if (helper.eq(id, id + mid - 1, 0, mid - 1)) {
l = mid;
} else {
r = mid;
}
}
if (helper.eq(id, id + r - 1, 0, r - 1)) {
return r;
} else if (helper.eq(id, id + l - 1, 0, l - 1)) {
return l;
} else {
return 0;
}
}
int ans;
inline void SolveOrDie() {
cin >> s;
helper.build(s);
size = (int)s.size();
for (int i = 1; i < size - 1; ++i) {
pref[i] = find_pref(i);
ans = max(ans, pref[i]);
}
for (int i = ans; i >= 1; --i) {
if (helper.eq(size - i, size - 1, 0, i - 1)) {
for (int j = 0; j < i; ++j) {
putchar(s[j]);
}
putchar('\n');
return;
}
}
puts("Just a legend");
}
int main(const int argc, const char** argv) {
assert(INPUT);
try {
SolveOrDie();
} catch (const std ::exception& e) {
cerr << e.what() << std ::endl;
exit(-1);
} catch (...) {
cerr << "Exception\n";
exit(-1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, k;
string s1, s2;
int F[1000010];
void kmp(string s) {
for (i = 1; i < s.size(); i++) {
while (s[i] != s[k] && k > 0) {
k = F[k - 1];
}
if (s[i] == s[k]) k++;
F[i] = k;
}
}
int main() {
cin >> s1;
n = s1.size();
kmp(s1);
if (F[n - 1] == 0) return cout << "Just a legend", 0;
for (int i = 0; i < n - 1; i++) {
if (F[i] == F[n - 1]) {
for (int j = 0; j < F[i]; j++) cout << s1[j];
return 0;
}
}
if (F[F[n - 1] - 1] == 0) return cout << "Just a legend", 0;
for (int j = 0; j < F[F[n - 1] - 1]; j++) cout << s1[j];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long INF = 1e18L;
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const long long nax = 1e6 + 5;
const long long prime = 31;
vector<long long> pi(nax), h(nax), p(nax);
string s;
void prf() {
long long n = (long long)s.size();
for (long long i = 1; i < n; i++) {
long long l = pi[i - 1];
while (l && s[i] != s[l]) {
l = pi[l - 1];
}
if (s[i] == s[l]) l++;
pi[i] = l;
}
}
void init() {
prf();
long long n = (long long)s.size();
p[0] = 1;
for (long long i = 1; i < n; i++) {
(p[i] = p[i - 1] * prime) %= mod;
}
for (long long i = 0; i < n; i++) {
(h[i + 1] = h[i] + (s[i] - 'a' + 1) * p[i] % mod) %= mod;
}
}
bool search(long long len) {
long long x = h[len], n = (long long)s.size(), cnt = 0;
for (long long i = 0; i + len - 1 < n; i++) {
long long cur = (h[i + len] - h[i] + mod) % mod;
if (cur == x * p[i] % mod) cnt++;
}
if (cnt >= 3) return true;
return false;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> s;
init();
long long n = (long long)s.size(), len;
len = pi[n - 1];
while (len) {
if (search(len)) {
break;
} else {
len = pi[len - 1];
}
}
if (len) {
cout << s.substr(0, len) << "\n";
} else {
cout << "Just a legend\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fail[1010000], c[1010000];
char pat[1010000];
void getnext() {
int i, k, n;
i = 0, k = -1;
n = strlen(pat);
fail[i] = -1;
while (i < n) {
if (k == -1 || pat[i] == pat[k]) {
++i;
++k;
fail[i] = k;
} else
k = fail[k];
}
}
int main() {
int i, j, n, k, ans;
while (scanf("%s", pat) != EOF) {
getnext();
n = strlen(pat);
for (i = 0; i <= n; i++) {
c[i] = 0;
}
for (i = n; i >= 0; i--) {
c[fail[i]] += c[i] + 1;
}
j = fail[n];
ans = -1;
while (j > 0) {
k = c[j];
if (k > 1) {
ans = j;
break;
} else
j = fail[j];
}
if (ans > 0) {
for (i = 0; i < ans; i++) {
printf("%c", pat[i]);
}
printf("\n");
} else
printf("Just a legend\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e9 + 7;
const int N = 1e6 + 100;
long long int n, k, f[N];
bool ex = 0;
string s, z;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
for (int i = 1; i < n; i++) {
while (k > 0 && s[k] != s[i]) k = f[k];
if (s[k] == s[i]) k++;
f[i + 1] = k;
}
if (f[n] != 0) {
for (long long int i = 0; i < f[n]; i++) z += s[i];
for (long long int i = 1; i < n - 1; i++) {
if (f[i] == f[n]) ex = 1;
}
if (ex)
cout << z;
else {
if (f[f[n]] == 0) {
cout << "Just a legend";
return 0;
}
z.clear();
for (long long int i = 0; i < f[f[n]]; i++) z += s[i];
cout << z;
}
} else
cout << "Just a legend";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 888883;
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>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
char s[1000006];
int p[1000006], n;
bool mark[1000006];
int main() {
cin >> s;
p[0] = 0;
n = 1;
for (int i = 1; s[i]; i++, n++) {
int j = p[i - 1];
while (j && s[j] != s[i]) j = p[j - 1];
if (s[j] == s[i]) j++;
p[i] = j;
if (i) mark[p[i - 1]] = 1;
}
for (int i = p[n - 1]; i; i = p[i - 1])
if (mark[i]) {
s[i] = '\0';
printf("%s\n", s);
return 0;
}
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
const int N = 10e6;
int first[N + 1];
void fail(string &s) {
int i = 0, j = 0;
first[0] = 0;
int n = s.size();
for (int i = 1; i < n; i++) {
if (s[i] == s[j]) {
first[i] = j + 1;
j++;
} else {
while (j != 0) {
j = first[j - 1];
if (s[j] == s[i]) {
first[i] = j + 1;
j++;
break;
}
}
if (j == 0) first[i] = 0;
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> s;
fail(s);
int n = s.size();
if (first[n - 1] == 0) {
cout << "Just a legend";
return 0;
}
if (2 * first[n - 1] > n) {
int x = 2 * first[n - 1] - n;
int y = first[n - 1] - x;
for (int i = y; x--; i++) cout << s[i];
} else {
int i;
for (i = 1; i < n - 1; i++)
if (first[i] == first[n - 1]) break;
if (i == n - 1) {
int x = first[first[n - 1] - 1];
if (x == 0)
cout << "Just a legend";
else
for (int i = 0; i < x; i++) cout << s[i];
} else {
for (int i = 0; i < first[n - 1]; i++) cout << s[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, sum, ans, z[1000005], p[1000005];
char s[1000005];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 2, l = 1, r = 1; i <= n; i++) {
if (i <= r && z[i - l + 1] <= r - i + 1)
z[i] = z[i - l + 1];
else
z[i] = max(0, r - i + 1);
while (i + z[i] <= n && s[z[i] + 1] == s[z[i] + i]) z[i]++;
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
if (i + z[i] - 1 >= n)
sum = max(z[i] - 1, sum);
else
sum = max(sum, z[i]);
}
for (int i = n; i >= 1; i--)
if (i + z[i] - 1 >= n && z[i] <= sum) ans = max(z[i], ans);
for (int i = 1; i <= ans; i++) printf("%c", s[i]);
if (!ans) printf("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int lps[1000000] = {0};
bool search(int l, int r) {
int start = 1, end = s.size() - 2;
int pos = l;
while (start <= end) {
if (s[start] == s[l]) {
start++;
l++;
if (l == r) return true;
} else {
if (l == 0)
start++;
else
l = lps[l - 1];
}
}
return false;
}
int main() {
cin >> s;
int n = s.size();
int i = 1, k = 0;
while (i < n) {
if (s[k] == s[i]) {
lps[i] = k + 1;
k = lps[i];
i++;
} else {
if (k == 0) {
lps[i] = 0;
i++;
} else
k = lps[k - 1];
}
}
int len = lps[n - 1];
while (len != 0) {
if (search(0, len)) {
break;
}
len = lps[len - 1];
}
if (len == 0) {
cout << "Just a legend" << endl;
return 0;
}
for (int i = 0; i < len; i++) cout << s[i];
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 1000010;
int N;
char A[NMax];
int pi[NMax];
int maxim;
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) maxim = max(maxim, pi[i]);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> (A + 1);
N = strlen(A + 1);
Make_Pi();
if (pi[N] <= maxim || pi[pi[N]] <= maxim) {
if (pi[N] <= maxim)
A[pi[N] + 1] = 0;
else
A[pi[pi[N]] + 1] = 0;
if (A[1])
cout << (A + 1) << "\n";
else
cout << "Just a legend\n";
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i1, i2, teq = 0, eq[1000050], l1, ans;
string s;
int main() {
cin >> s;
l1 = s.length();
s = ' ' + s;
for (i1 = 2; i1 <= l1; i1++) {
while (i2 >= 0) {
if (s[i1] == s[i2 + 1]) {
i2++;
eq[i1] = i2;
break;
} else {
i2 = eq[i2];
if (!i2) {
if (s[i1] == s[i2 + 1]) {
i2++;
eq[i1] = i2;
}
break;
}
}
}
}
ans = -1;
for (i1 = l1 - 1; i1 >= 1; i1--) {
if (eq[i1] == eq[l1]) {
ans = eq[l1];
}
}
if (ans == -1) {
ans = eq[eq[l1]];
}
if (ans) {
for (i1 = 1; i1 <= ans; i1++) {
cout << s[i1];
}
} else {
cout << "Just a legend";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000001];
int main() {
scanf("%s", s);
int n = strlen(s);
vector<int> z(n, 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;
}
int ans = -1, mx = 0;
for (int i = 1; i < n; ++i) {
if (i + z[i] < n)
mx = max(mx, z[i]);
else
mx = max(mx, z[i] - 1);
}
for (int i = 1; i < n; ++i) {
if (i + z[i] == n && mx >= z[i]) ans = max(ans, z[i]);
}
if (ans != -1) {
s[ans] = '\0';
printf("%s\n", s);
} else
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nn = 1100000;
int f[nn], L;
char S[nn];
int main() {
scanf("%s", S + 1);
L = strlen(S + 1);
while (f[2] < L - 1 && S[1 + f[2]] == S[2 + f[2]]) f[2]++;
int l = 2, r = l + f[2] - 1;
for (int i = 3; i <= (int)(L); ++i) {
if (i > r) {
l = i;
r = i - 1;
while (r < L && S[r + 1] == S[r + 1 - l + 1]) r++;
f[i] = r - l + 1;
} else {
if (i + f[i - l + 1] - 1 < r) {
f[i] = f[i - l + 1];
continue;
}
l = i;
while (r < L && S[r + 1] == S[r + 1 - l + 1]) r++;
f[i] = r - l + 1;
}
}
int mx = 0, x = 0;
for (int i = 2; i <= (int)(L); ++i) {
if (i + f[i] - 1 == L && i + mx > L) {
x = L - i + 1;
break;
}
mx = max(mx, f[i]);
}
if (x) {
for (int i = 1; i <= (int)(x); ++i) putchar(S[i]);
puts("");
} else
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fastPow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ret;
}
void printT(int n, string str) {
for (int i = int(0); i < int(n); i++) cout << str[i];
cout << endl;
}
int main() {
string str;
cin >> str;
if (str.length() < 3) {
cout << "Just a legend" << endl;
return 0;
}
long long c;
vector<long long> t(str.length());
t[0] = c = 0;
for (int i = int(1); i < int(str.length()); i++) {
while (c && str[c] != str[i]) c = t[c - 1];
c += str[c] == str[i] ? 1 : 0;
t[i] = c;
}
if (!t.back()) {
cout << "Just a legend" << endl;
return 0;
}
for (int i = int(0); i < int(str.length() - 1); i++) {
if (t[i] == t.back()) {
printT(t.back(), str);
return 0;
}
}
if (t[t.back() - 1] > 0) {
printT(t[t.back() - 1], str);
return 0;
}
cout << "Just a legend" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-16;
const int MOD = (int)1e9 + 9;
const long long INF = (int)1e9 + 10;
const int p = 31;
template <typename T>
vector<T> readVector0(int n) {
vector<T> res(n);
for (int i = 0; i < n; i++) cin >> res[i];
return res;
}
template <typename T>
vector<T> readVector1(int n) {
vector<T> res(n + 1);
for (int i = 1; i <= n; i++) cin >> res[i];
return res;
}
inline long long mod(long long first, long long m = MOD) {
if (first < 0) first += m;
return (first % m);
}
template <typename T>
bool sortBy2(const pair<T, T> &a, const pair<T, T> &b) {
return (a.second < b.second);
}
int n;
vector<long long> p_pow;
vector<long long> hp;
vector<long long> hs;
vector<int> pi;
long long binPow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = mod(res * a);
a = mod(a * a);
b >>= 1;
}
return res;
}
void getPrefHash(const string &s) {
p_pow = vector<long long>(n);
p_pow[0] = 1;
for (int i = 1; i < n; i++) p_pow[i] = (p_pow[i - 1] * p) % MOD;
hp = vector<long long>(n + 1, 0);
for (int i = 0; i < n; i++)
hp[i + 1] = (hp[i] + (s[i] - 'a' + 1) * p_pow[i]) % MOD;
}
bool checkHashes(int i, int j) {
if (mod(hp[i] * binPow(p, (j - 1))) == hs[j]) return true;
return false;
}
void prefixFunction(const string &s) {
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 main() {
string s;
cin >> s;
n = s.size();
pi = vector<int>(n, 0);
getPrefHash(s);
hs = vector<long long>(n + 1, 0);
for (int i = 1; i <= n; ++i) {
hs[i] = (hp[n] - hp[i - 1] + MOD) % MOD;
}
prefixFunction(s);
int m_l = 0;
for (int i = 0; i < n - 1; ++i) {
if (pi[i] > m_l && checkHashes(pi[i], n + 1 - pi[i])) {
m_l = pi[i];
}
}
if (m_l == 0) {
cout << "Just a legend";
return 0;
}
cout << s.substr(0, m_l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long n = s.length();
vector<long long> pi(n + 1);
pi.push_back(0);
long long j;
for (long long i = 1; i < n; i++) {
j = pi[i - 1];
while (j > 0 && s[j] != s[i]) {
j = pi[j - 1];
}
if (s[i] == s[j]) j++;
pi[i] = j;
}
if (pi[n - 1] == 0 || n == 1 || n == 2) {
cout << "Just a legend";
} else {
long long ans = 0, temp = 0;
for (long long i = 1; i < n - 1; i++) {
if (temp < pi[i]) temp = pi[i];
}
if (temp >= pi[n - 1]) {
ans = pi[n - 1];
} else {
ans = pi[pi[n - 1] - 1];
}
if (ans == 0)
cout << "Just a legend";
else {
for (long long i = 0; i < ans; i++) cout << s[i];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
A cvt(B x) {
stringstream ss;
ss << x;
A y;
ss >> y;
return y;
}
string s;
int n;
int cnt(int len, long long h) {
long long a = 0, p = 1;
for (int i = 0; i < (int)(len - 1); i++) p = (p * 31) % 1000000007;
int c = 0;
for (int i = 0; i < (int)(n); i++) {
if (i >= len) {
a = (a - p * (s[i - len] - 'a')) % 1000000007;
if (a < 0) a += 1000000007;
}
a = (a * 31 + (s[i] - 'a')) % 1000000007;
if (i >= len - 1 && a == h) c++;
}
return c;
}
int main() {
cin >> s;
n = s.size();
long long a = 0, b = 0, p = 1;
vector<pair<int, int> > sizes;
for (int i = (1); i <= (n - 1); i++) {
a = (a * 31 + (s[i - 1] - 'a')) % 1000000007;
b = (b + p * (s[n - i] - 'a')) % 1000000007;
p = (p * 31) % 1000000007;
if (a == b) sizes.push_back({i, a});
}
int lo = -1, hi = sizes.size();
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
auto [sz, h] = sizes[mid];
if (cnt(sz, h) >= 3)
lo = mid;
else
hi = mid;
}
if (lo == -1)
cout << "Just a legend" << endl;
else
cout << s.substr(0, sizes[lo].first) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int kmp[1000007];
vector<int> vec;
set<int> q;
int main() {
cin >> s;
int t = 0, pos = -1, x;
x = s.length();
kmp[0] = 0;
for (int i = 1; i < x; i++) {
while (t > 0 && s[i] != s[t]) {
t = kmp[t - 1];
}
if (s[i] == s[t]) t++;
kmp[i] = t;
}
if (!kmp[x - 1]) {
cout << "Just a legend";
return 0;
}
while (t > 0) {
vec.push_back(t);
t = kmp[t - 1];
}
sort(vec.begin(), vec.end());
for (int i = 0; i < x - 1; i++) q.insert(kmp[i]);
for (set<int>::reverse_iterator k = q.rbegin(); k != q.rend(); k++) {
if (binary_search(vec.begin(), vec.end(), *k)) {
pos = *k;
break;
}
}
if (pos == -1) {
cout << "Just a legend";
return 0;
}
for (int i = 0; i < pos; i++) cout << s[i];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 4445551;
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 long long MAX = 123456789;
const long long inf = 1234567890;
const double EPS = 1e-10;
const double PI = 2 * asin(1.0);
const long long mod = 1e9 + 7;
inline int cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
int z[1000010];
void z_algo(string s) {
int L = 0, R = 0;
for (int i = 1; i < ((int)s.size()); i++) {
if (i > R) {
L = R = i;
while (R < ((int)s.size()) && 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 < ((int)s.size()) && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
int main() {
string s;
cin >> s;
z_algo(s);
set<int> tamanhos;
for (int i = 0; i < ((int)s.size()); ++i) {
if (z[i] == ((int)s.size()) - i) tamanhos.insert(z[i]);
}
set<int>::reverse_iterator it = tamanhos.rbegin();
while (it != tamanhos.rend()) {
for (int i = 1; i < ((int)s.size()); ++i) {
if (z[i] == (*it)) {
if (i + (*it) != ((int)s.size())) {
cout << s.substr(0, (*it)) << endl;
return 0;
}
}
if (z[i] > (*it)) {
cout << s.substr(0, (*it)) << endl;
return 0;
}
}
it++;
}
cout << "Just a legend\n";
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
const int MAXN = 1000500;
int z[MAXN];
int n;
vector<int> zs;
int main() {
cin >> s;
n = s.size();
z[0] = 0;
int mxne = 0;
int i, j;
int l, r;
for (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[z[i] + i]) ++z[i];
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
if (i + z[i] < n)
mxne = max(mxne, z[i]);
else
mxne = max(mxne, z[i] - 1);
}
int mxl = 0;
int mxi;
for ((i) = (1); (i) < (n); ++(i))
if (i + z[i] == n && z[i] <= mxne) {
for ((j) = (i); (j) < (n); ++(j)) printf("%c", s[j]);
puts("");
return 0;
}
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double PI = 3.14159265358979323846;
const long long modo = 998244353;
const long long inf = 1e16;
const long long ms = (1e6) + 5;
char ar[ms];
int tt[ms] = {0};
set<int> ss;
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
string s;
cin >> s;
int n = s.length();
int i;
int pr = 0;
for (i = 1; i < n; i++) {
while (pr > 0 && s[pr] != s[i]) {
pr = tt[pr - 1];
}
if (s[i] == s[pr]) {
pr++;
}
tt[i] = pr;
}
ss.insert(0);
for (i = 1; i < (n - 1); i++) {
ss.insert(tt[i]);
}
pr = tt[n - 1];
while (!ss.count(pr)) {
pr = tt[pr - 1];
}
if (!pr) {
cout << "Just a legend";
return 0;
}
for (i = 0; i < pr; i++) cout << s[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 1000010;
int N;
char A[NMax];
int pi[NMax];
int maxim;
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) maxim = max(maxim, pi[i]);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> (A + 1);
N = strlen(A + 1);
Make_Pi();
if (pi[N] <= maxim || pi[pi[N]] <= maxim) {
if (pi[N] <= maxim)
A[pi[N] + 1] = 0;
else
A[pi[pi[N]] + 1] = 0;
if (A[1])
cout << (A + 1) << "\n";
else
cout << "Just a legend\n";
return 0;
}
cout << "Just a legend\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int xx[4] = {0, 0, 1, -1};
int yy[4] = {-1, 1, 0, 0};
clock_t time_p = clock();
void Time() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
vector<long long> z_algo(string s) {
vector<long long> z(s.size(), 0);
long long l = 0, r = 0, n = s.size();
for (int i = 1; i < s.size(); i++) {
if (i > r) {
l = i;
r = i;
while (r < n && s[r - l] == s[r]) {
r++;
}
r--;
z[i] = r - l + 1;
} else {
long long j = i - l;
if (z[j] < r - i + 1) {
z[i] = z[j];
} else {
l = i;
while (r < n && s[r - l] == s[r]) {
r++;
}
r--;
z[i] = r - l + 1;
}
}
}
return z;
}
void solve() {
string s;
cin >> s;
vector<long long> vec = z_algo(s);
map<long long, long long> mp;
long long res = 0, maxx = 0, n = s.size();
for (int i = 0; i < s.size(); i++) {
if (n - i == vec[i] && maxx >= vec[i]) {
res = max(res, vec[i]);
}
maxx = max(maxx, vec[i]);
}
if (res == 0) cout << "Just a legend";
for (int i = 0; i < res; i++) {
cout << s[i];
}
cout << endl;
}
int main() {
long long t = 1;
while (t--) {
solve();
}
Time();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long P = 29;
const int N = 1e6 + 5;
string s;
int n;
long long hsh[N], inv[N];
vector<int> L;
long long bpow(long long a, long long b) {
long long ans = 1LL;
while (b) {
if (b & 1) ans = ans * a;
a *= a;
if (ans >= MOD) ans %= MOD;
if (a >= MOD) a %= MOD;
b >>= 1LL;
}
return ans;
}
long long GetHash(int fi, int se) {
if (!fi) return hsh[se];
return (hsh[se] - hsh[fi - 1] + MOD) % MOD * inv[fi] % MOD;
}
void print(int i, int j) {
for (int k = i; k <= j; k++) cout << s[k];
}
bool solve(int mid, long long h1) {
for (int i = 1; i + mid - 1 < n - 1; i++) {
if (GetHash(i, i + mid - 1) == h1) {
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.length();
long long p = 1LL;
for (int i = 1; i < n; i++) {
p *= P;
if (p >= MOD) p %= MOD;
}
inv[n - 1] = bpow(p, MOD - 2);
for (int i = n - 2; i >= 0; i--) {
inv[i] = inv[i + 1] * P % MOD;
if (inv[i] >= MOD) inv[i] %= MOD;
}
p = P;
hsh[0] = s[0] - 'a' + 1;
for (int i = 1; i < n; i++) {
hsh[i] = (hsh[i - 1] + p * (s[i] - 'a' + 1)) % MOD;
p *= P;
if (p >= MOD) p %= MOD;
}
long long h1, h2;
for (int len = 0; len < n - 1; len++) {
h1 = GetHash(0, len);
h2 = GetHash(n - 1 - len, n - 1);
if (h1 == h2) {
L.push_back(len + 1);
}
}
if (L.size() == 0) {
cout << "Just a legend";
return 0;
}
int le = 0;
int ri = L.size() - 1;
int ans = -1;
while (le <= ri) {
int mid = (le + ri) >> 1;
if (solve(L[mid], GetHash(0, L[mid] - 1))) {
ans = L[mid];
le = mid + 1;
} else {
ri = mid - 1;
}
}
if (ans != -1) {
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 double pi = 3.141592653589793238460;
const long long mod = 1000000007;
const long long maxi = 200005;
const long long INF = INT_MAX;
const string no = "NO\n", yes = "YES\n";
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long x, unsigned long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
void mysol() {
long long i = 0, j = 0, n, mx = 0, l = 0, r = 0;
string s;
cin >> s;
n = s.length();
vector<long long> Z(n, 0);
for (i = 1; 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;
}
}
set<long long> sol;
for (i = 0; i < n; i++) {
if (i + Z[i] == n) {
sol.insert(Z[i]);
}
}
for (i = 1; i < n; i++) {
long long temp;
if (i + Z[i] == n) {
temp = Z[i] - 1;
} else {
temp = Z[i];
}
auto it = sol.upper_bound(temp);
if (it == sol.begin()) {
continue;
} else {
it--;
temp = *it;
}
if (temp != 0 && temp > mx) {
mx = temp;
j = i;
}
}
if (mx == 0)
cout << "Just a legend\n";
else
cout << s.substr(j, mx);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
mysol();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e6) + 1;
char s[N];
int n;
vector<int> p;
bool check(int num) {
for (int i = 1; i < n - 1; ++i) {
if (p[i] == num) {
return true;
}
}
return false;
}
int main(int argc, char *argv[]) {
scanf("%s", s);
n = int(strlen(s));
p.resize(n);
p[0] = 0;
for (int i = 1; i < n; ++i) {
int j = p[i - 1];
while (j && s[i] != s[j]) {
j = p[j - 1];
}
if (s[i] == s[j]) {
++j;
}
p[i] = j;
}
int ans;
for (ans = p.back(); ans;) {
if (check(ans)) {
break;
}
ans = p[ans - 1];
}
if (ans) {
for (int i = 0; i < ans; ++i) {
printf("%c", s[i]);
}
} else {
printf("Just a legend");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using tint = long long;
using vi = vector<int>;
using pi = pair<int, int>;
void setIO(string name = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const int INF = 1e9;
const ld PI = acos((ld)-1);
vector<int> z(string &second) {
int n = second.size();
vi 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 && second[z[i]] == second[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int main() {
setIO();
string second;
cin >> second;
vi v = z(second);
int maxi = 0, ret = 0;
for (int i = int(0); i < int((int)(second).size()); i++) {
if (v[i] + i == (int)(second).size() && maxi >= v[i]) {
ret = v[i];
break;
}
maxi = max(maxi, v[i]);
}
if (ret == 0)
cout << "Just a legend" << endl;
else
cout << second.substr(0, ret) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modOfNegative(long long x, long long m) {
long long xVal = ((llabs(x / m) + 1) * m) * (-1);
return llabs(x - xVal);
}
long long pow2(long long a, long long b, long long MOD2) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD2) x %= MOD2;
}
y = (y * y);
if (y > MOD2) y %= MOD2;
b /= 2;
}
return x;
}
long long modInverse(long long a, long long m) { return pow2(a, m - 2, m); }
char sArr[1000006];
string storeS[2];
long long storeHash[2];
vector<long long> vecHash[2];
const long long base = 29;
const long long hashMod = 1009010791;
long long modInvCal[1000006];
void genModInv() {
long long x = modInverse(base, hashMod);
modInvCal[1] = x;
modInvCal[0] = 1;
for (int i = 2; i < 1000006; i++) {
modInvCal[i] = (modInvCal[i - 1] * x) % hashMod;
}
}
long long basePow[1000006];
void genPow() {
basePow[0] = 1;
for (int i = 1; i < 1000006; i++) {
basePow[i] = (basePow[i - 1] * base) % hashMod;
}
}
long long hashing(int ith, int len) {
long long hashVal = 0;
for (int i = 0; i < len; i++) {
long long x = sArr[i] - 97 + 1;
hashVal *= base;
hashVal %= hashMod;
hashVal += x;
hashVal %= hashMod;
vecHash[ith].push_back(hashVal);
}
return hashVal;
}
long long getHashStartingAt(int iPos, long long mainHash, int len,
int ithString) {
if (iPos == 0) return mainHash;
if (iPos == len) return 0;
long long curHash = mainHash;
curHash =
curHash - (vecHash[ithString][iPos - 1] * basePow[len - iPos]) % hashMod;
if (curHash < 0)
curHash = modOfNegative(curHash, hashMod);
else
curHash %= hashMod;
return curHash;
}
long long getHashOfSubString(int i, int j, long long mainHash, int len,
int ithString) {
long long curHash = getHashStartingAt(i, mainHash, len, ithString);
curHash = curHash - getHashStartingAt(j + 1, mainHash, len, ithString);
if (curHash < 0)
curHash = modOfNegative(curHash, hashMod);
else
curHash %= hashMod;
curHash = (curHash * modInvCal[len - 1 - j]) % hashMod;
curHash %= hashMod;
return curHash;
}
string str;
vector<int> v;
int pi[1000006];
void KMP() {
int it = 0;
pi[0] = 0;
int len = str.length();
for (int i = 1; i < len; i++) {
if (str[it] == str[i]) {
it++;
pi[i] = it;
} else if (it) {
it = pi[it - 1];
i--;
} else
pi[i] = 0;
}
for (int i = len - 2; i > 0; i--) v.push_back(pi[i]);
}
int main() {
genModInv();
genPow();
cin >> str;
KMP();
int len = str.length();
for (int i = 0; i < len; i++) sArr[i] = str[i];
storeS[0] = str;
storeHash[0] = hashing(0, len);
sort(v.begin(), v.end());
bool paisi = false;
for (int i = v.size() - 1; i >= 0; i--) {
int id = v[i];
if (id == 0) continue;
if (i != 0 && id == v[i - 1]) continue;
int st = 0;
int ed = id - 1;
long long hashP = getHashOfSubString(st, ed, storeHash[0], len, 0);
st = len - id;
ed = len - 1;
long long hashS = getHashOfSubString(st, ed, storeHash[0], len, 0);
if (hashP == hashS) {
for (int i = 0; i < id; i++) cout << str[i];
cout << "\n";
paisi = true;
break;
}
}
if (!paisi)
cout << "Just a legend"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length();
vector<int> vi(len);
for (int i = 1; i < len; i++) {
int j = vi[i - 1];
while (j > 0 && s[i] != s[j]) {
j = vi[j - 1];
}
if (s[i] == s[j]) {
++j;
}
vi[i] = j;
}
if (vi[len - 1] == 0) {
cout << "Just a legend" << endl;
return 0;
}
for (int i = 1; i < len - 1; ++i) {
if (vi[i] == vi[len - 1]) {
for (int j = len - vi[len - 1]; j < len; ++j) {
cout << s[j];
}
cout << endl;
return 0;
}
}
if (vi[vi[len - 1] - 1] == 0) {
cout << "Just a legend" << endl;
return 0;
} else {
for (int i = vi[len - 1] - vi[vi[len - 1] - 1]; i < vi[len - 1]; ++i) {
cout << s[i];
}
cout << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string text, pattern;
int sizeText, sizePattern;
int prefix[1000006];
vector<int> results;
bool f[1000006];
void generatePrefix() {
prefix[0] = 0;
for (int i = 0, j = 2; j < sizePattern; j++) {
while (i > 0 && pattern[i + 1] != pattern[j]) i = prefix[i];
if (pattern[i + 1] == pattern[j]) i = i + 1;
prefix[j] = i;
}
for (int i = 2; i < pattern.size() - 1; i++) f[prefix[i]] = 1;
int vv = prefix[pattern.size() - 1];
while (vv) {
if (f[vv]) {
cout << pattern.substr(1, vv) << endl;
exit(0);
}
vv = prefix[vv];
}
cout << "Just a legend" << endl;
exit(0);
}
void matchingCheck() {
int i = 1, j = 1, k = 1;
while (i < sizeText) {
while (j < sizePattern && text[i] == pattern[j]) i++, j++;
if (j == sizePattern) results.push_back(k);
if (prefix[j - 1] > 0)
k = i - prefix[j - 1];
else {
if (i == k) i++;
k = i;
}
if (j > 1) j = prefix[j - 1] + 1;
}
}
int main() {
cin >> pattern;
pattern = "0" + pattern;
sizePattern = pattern.size();
generatePrefix();
matchingCheck();
cout << "PREFIX" << endl;
for (int i = 0; i < pattern.size(); i++) cout << prefix[i] << ' ';
cout << endl;
cout << "RESULTS " << endl;
for (int i = 0; i < results.size(); i++) cout << results[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char S[1000001];
int Z[1000001], m;
int R[1000001], nr;
int st, dr, mij, okay;
void calculZ(int m, char S[], int Z[]) {
int L, R, k, kp, beta;
Z[1] = 0;
L = R = 1;
for (k = 2; k <= m; k++)
if (S[k] != S[1])
Z[k] = 0;
else if (k > R) {
Z[k] = 1;
while (S[k + Z[k]] == S[1 + Z[k]]) Z[k]++;
L = k;
R = k + Z[k] - 1;
} else {
kp = k - (L - 1);
beta = R - (k - 1);
Z[k] = min(Z[kp], beta);
while (S[k + Z[k]] == S[1 + Z[k]]) Z[k]++;
if (k + Z[k] - 1 > R) {
L = k;
R = k + Z[k] - 1;
}
}
}
int main() {
cin >> S + 1;
m = strlen(S + 1);
calculZ(m, S, Z);
nr = 0;
for (int k = m; k >= 2; k--)
if (Z[k] == m - (k - 1)) R[++nr] = Z[k];
if (nr == 0) {
cout << "Just a legend";
return 0;
}
st = 1;
dr = nr;
while (st < dr) {
mij = (st + dr + 1) / 2;
okay = 0;
for (int i = 2; i <= m - R[mij]; i++)
if (Z[i] >= R[mij]) {
okay = 1;
break;
}
if (okay == 1)
st = mij;
else
dr = mij - 1;
}
okay = 0;
for (int i = 2; i <= m - R[st]; i++)
if (Z[i] >= R[st]) {
okay = 1;
break;
}
if (okay == 1)
for (int i = 1; i <= R[st]; i++) cout << S[i];
else
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 123458;
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 h, n, i, l, m, w, z, f, k;
int d[1000010];
char a[1000010];
int main() {
ios_base::sync_with_stdio(false);
cin >> a, l = strlen(a);
if (l <= 2) {
cout << "Just a legend";
return 0;
}
while (m < 2) {
if (!m)
k = 1;
else
k = l - h, h = 0;
while (true) {
if (k == l) break;
if (a[h] == a[k])
d[k] = ++h, k++;
else
!h ? k++ : h = d[h - 1];
}
if (!m) {
for (h = 0, i = 1; i < l - 1; i++) h = max(h, d[i]);
d[l - 1] = 0;
}
m++;
}
if (!d[l - 1])
cout << "Just a legend";
else {
a[d[l - 1]] = '\0';
cout << a;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
using namespace std;
double __begin;
template <typename T1, typename T2, typename T3>
struct triple {
T1 a;
T2 b;
T3 c;
triple(){};
triple(T1 _a, T2 _b, T3 _c) : a(_a), b(_b), c(_c) {}
};
template <typename T1, typename T2, typename T3>
bool operator<(const triple<T1, T2, T3> &t1, const triple<T1, T2, T3> &t2) {
if (t1.a != t2.a)
return t1.a < t2.a;
else
return t1.b < t2.b;
}
template <typename T1, typename T2, typename T3>
inline std::ostream &operator<<(std::ostream &os, const triple<T1, T2, T3> &t) {
return os << "(" << t.a << ", " << t.b << ", " << t.c << ")";
}
inline int bits_count(int v) {
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline int bits_count(long long v) {
int t = v >> 32;
int p = (v & ((1LL << 32) - 1));
return bits_count(t) + bits_count(p);
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
inline int sign(int x) { return (x >> 31) | (-x >> 31); }
inline bool ispow2(int x) { return (x != 0 && (x & (x - 1)) == 0); }
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
bool first = true;
os << "[";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::set<T> &v) {
bool first = true;
os << "[";
for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::map<T1, T2> &v) {
bool first = true;
os << "[";
for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T, typename T2>
void printarray(T a[], T2 sz, T2 beg = 0) {
for (T2 i = beg; i < sz; i++) cout << a[i] << " ";
cout << endl;
}
inline long long binpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
inline long long gcd(long long a, long long b) {
long long t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline int gcd(int a, int b) {
int t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline long long lcm(int a, int b) { return a / gcd(a, b) * (long long)b; }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long gcd(long long a, long long b, long long c) {
return gcd(gcd(a, b), c);
}
inline int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
inline long long lcm(long long a, long long b, long long c) {
return lcm(lcm(a, b), c);
}
inline long long lcm(int a, int b, int c) {
return lcm(lcm(a, b), (long long)c);
}
inline long long max(long long a, long long b) { return (a > b) ? a : b; }
inline int max(int a, int b) { return (a > b) ? a : b; }
inline double max(double a, double b) { return (a > b) ? a : b; }
inline long long max(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline int max(int a, int b, int c) { return max(a, max(b, c)); }
inline double max(double a, double b, double c) { return max(a, max(b, c)); }
inline long long min(long long a, long long b) { return (a < b) ? a : b; }
inline int min(int a, int b) { return (a < b) ? a : b; }
inline double min(double a, double b) { return (a < b) ? a : b; }
inline long long min(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline int min(int a, int b, int c) { return min(a, min(b, c)); }
inline double min(double a, double b, double c) { return min(a, min(b, c)); }
template <class T>
inline void getar(T a, int n, int m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
inline void getar(int *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d", a + ii);
}
}
inline void getar(pair<int, int> *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d%d", &a[ii].first, &a[ii].second);
}
}
inline void getar(long long *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%I64d", a + ii);
}
}
int a[1000010];
char s[1000100];
int main() {
cin >> s;
a[0] = 0;
int i;
int max = 0;
for (i = 1; s[i]; ++i) {
if (a[i - 1] > max) max = a[i - 1];
int k = a[i - 1];
while (k > 0 && s[i] != s[k]) {
k = a[k - 1];
}
if (s[i] == s[k]) ++k;
a[i] = k;
}
if (max == 0) {
cout << "Just a legend" << endl;
return 0;
}
for (i = 1; s[i]; ++i) {
int k = a[i - 1];
while (s[i] == s[k] && k == max || k > 0 && s[i] != s[k]) {
k = a[k - 1];
}
if (s[i] == s[k]) ++k;
a[i] = k;
}
if (a[i - 1] == 0) {
cout << "Just a legend" << endl;
} else {
s[a[i - 1]] = 0;
cout << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000009];
int p[1000009];
int n;
void compute_prefix_function() {
char _s[1000009];
for (int i = 1; i <= n; i++) _s[i] = s[i - 1];
int q = 0;
p[1] = 0;
for (int i = 2; i <= n; i++) {
while (q && _s[q + 1] != _s[i]) q = p[q];
if (_s[q + 1] == _s[i]) q++;
p[i] = q;
}
for (int i = 0; i < n; i++) p[i] = p[i + 1];
p[n] = 0;
}
int main() {
scanf("%s", s);
n = strlen(s);
compute_prefix_function();
if (n < 3) {
printf("Just a legend");
return 0;
}
int mx = *max_element(p + 1, p + n - 1);
int q = p[n - 1];
while (mx < q && q) {
q = p[q - 1];
}
if (min(q, mx) == 0)
printf("Just a legend");
else {
for (int i = 0; i < min(q, mx); i++) printf("%c", s[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
long long int power(long long int a, long long int b) {
long long int x = 1;
long long int y = a;
while (b > 0) {
if (b & 1) {
x = x * y;
x %= 100000000;
}
y = y * y;
y %= 100000000;
b /= 2;
}
return x;
}
long long int inver(long long int a) { return power(a, 100000000 - 2); }
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int gcd(int a, int b) {
while (b != 0) {
int temp = a;
a = b;
b = temp % a;
}
return a;
}
char a[1000010];
int main() {
scanf("%s", a);
int n = strlen(a);
int pre[n];
int i, k;
pre[0] = k = -1;
for (i = 1; i < n; i++) {
while (k >= 0 && a[k + 1] != a[i]) k = pre[k];
pre[i] = k;
if (a[i] == a[k + 1]) pre[i] = ++k;
}
set<int> s;
for (int i = 0; i < n - 1; i++) {
s.insert(pre[i]);
}
int res = pre[n - 1];
while (res >= 0) {
if (s.find(res) != s.end()) break;
res = pre[res];
}
if (res < 0) {
cout << "Just a legend" << endl;
} else {
a[res + 1] = '\0';
cout << a << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 31;
vector<long long> p_pow;
vector<long long> h;
long long get_h(int i1, int len) {
long long h1 = h[i1 + len - 1];
if (i1) h1 -= h[i1 - 1];
return h1;
}
string s;
bool check(int n) {
if (get_h(0, n) * p_pow[s.length() - 1 - n] != get_h(s.length() - n, n))
return false;
for (int i = 1; i < s.length() - n; i++)
if (get_h(i, n) == get_h(0, n) * p_pow[i - 1]) return true;
return false;
}
int main() {
cin >> s;
p_pow.resize(s.length() + 1);
h.resize(s.length());
p_pow[0] = p;
for (int i = 1; i < s.length(); i++) p_pow[i] = p * p_pow[i - 1];
for (int i = 0; i < s.length(); i++) {
h[i] = (s[i] - 'a' + 1) * p_pow[i];
if (i) h[i] += h[i - 1];
}
for (int i = s.length() - 2; i > 0; i--) {
if (check(i)) {
string res = "";
for (int j = 0; j < i; j++) res += s[j];
cout << res;
return 0;
}
}
cout << "Just a legend";
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 31;
const int m = 1e9 + 9;
long long p_pow[1000009];
void preprocess() {
p_pow[0] = 1;
for (int i = 1; i < 1000009; i++) p_pow[i] = (p_pow[i - 1] * p) % m;
}
long long get_hash(string const& s) {
long long hash = 0;
for (int i = 0; i < s.size(); i++)
hash = (hash + (s[i] - 'a' + 1) * p_pow[i]) % m;
return hash;
}
vector<long long> get_prefix_hash(string const& s) {
int siz = s.size();
vector<long long> h(siz + 1, 0);
for (int i = 0; i < siz; i++)
h[i + 1] = (h[i] + (s[i] - 'a' + 1) * p_pow[i]) % m;
return h;
}
long long get_sub(int start, int len, const vector<long long>& h) {
return (h[start + len] - h[start] + m) % m;
}
bool compare(int start1, int start2, int len, const vector<long long>& h) {
if (start1 > start2) swap(start1, start2);
return get_sub(start1, len, h) * p_pow[start2 - start1] % m ==
get_sub(start2, len, h);
}
void solve() {
preprocess();
string s;
cin >> s;
int n = s.size();
vector<int> sizs;
vector<long long> pres = get_prefix_hash(s);
for (int i = 1; i <= n - 2; i++) {
if (compare(0, n - i, i, pres)) sizs.push_back(i);
}
int l = 0;
int r = sizs.size();
while (l < r) {
int mm = (l + r) / 2;
int len = sizs[mm];
int ok = 0;
for (int i = 1; i + len - 1 < n - 1; i++)
if (compare(i, 0, len, pres)) ok = 1;
if (ok)
l = mm + 1;
else
r = mm;
}
l--;
if (l >= 0)
cout << s.substr(0, sizs[l]) << endl;
else
cout << "Just a legend" << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void DBG() { cout << "]" << endl; }
string to_string(string strin) { return strin; }
string to_string(vector<int>& vec) {
string t = "";
for (int i = (0), _c = (vec.size() - 1); i <= _c; ++i)
t += to_string(vec[i]) + (i ^ (vec.size() - 1) ? " " : "");
return t;
}
template <class H, class... T>
void DBG(H h, T... t) {
cout << to_string(h);
if (sizeof...(t)) cout << ", ";
DBG(t...);
}
template <class T>
bool umin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
vector<int> makeZ(const string& s) {
int n = ((int)((s).size()));
vector<int> z(n, 0);
z[0] = 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[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
void test_case() {
string s;
cin >> s;
vector<int> z = makeZ(s);
int n = ((int)((s).size()));
int ans = 0, ma = 0;
for (int i = (1), _c = (n - 1); i <= _c; ++i) {
if (z[i] == n - i && ma >= z[i]) {
ans = z[i];
break;
}
umax(ma, z[i]);
}
if (ans == 0)
cout << "Just a legend"
<< "\n";
else
cout << s.substr(0, ans) << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto time = clock();
int test = 1;
while (test--) {
test_case();
}
cerr << "[It took " << fixed << setprecision(3)
<< double(clock() - time) / CLOCKS_PER_SEC << "s]"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long OO = 1e18;
const int mx = 3333;
const int md = 1000000007;
int n, m, k, x, y, q, t;
string s;
int z[1000055];
void zfunc() {
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[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] - 1 > r) r = i + z[i] - 1, l = i;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
zfunc();
x = 0;
for (int i = 1; i < n; i++) {
if (z[i] + i == n) {
if (x >= z[i]) {
cout << s.substr(0, z[i]);
return 0;
} else
x = max(x, z[i] - 1);
} else
x = max(x, z[i]);
}
cout << "Just a legend";
cout << "\n\n\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string st;
int z[1000010], len;
char a[1000010];
void z_alg() {
z[0] = len;
for (int i = 1, j = 1, k; i < len; i = k) {
if (j < i) j = i;
while (j < len && a[j] == a[j - i]) j++;
z[i] = j - i;
k = i + 1;
while (k + z[k - i] < j) z[k] = z[k - i], k++;
}
}
int main() {
cin >> a;
len = strlen(a);
z_alg();
for (int i = 1; i < len; i++)
if (i + z[i] == len)
for (int j = 1; j < i; j++)
if (z[j] >= z[i]) {
cout << (a + i) << endl;
return 0;
}
puts("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<ll>;
using VB = vector<bool>;
using VD = vector<long double>;
using VC = vector<char>;
using VS = vector<string>;
using VPII = vector<pair<ll, ll> >;
using V2I = vector<VI>;
using V3I = vector<V2I>;
const ll mod{(ll)1e9 + 7};
const ll mod2{(ll)1e9 + 9};
const long double pi = 2 * acos(0.0);
const ll INF{(ll)1e14};
void godSpeed();
ll power(ll x, ll y, ll m = LLONG_MAX) {
ll ans = 1LL;
while (y) {
if (y & 1) ans = (ans * x) % m;
y /= 2;
x = (x * x) % m;
}
return ans;
}
ll modInverse(ll a, ll m) { return power(a, m - 2, m); }
const ll p{47LL};
ll hash_fn(string &s, ll m) {
ll hash_val{};
ll power{1LL};
for (char c : s) {
hash_val = (hash_val + (c - 'a' + 1) * power) % m;
power = power * p % m;
}
return hash_val;
}
ll inv1[(ll)1e6 + 5], inv2[(ll)1e6 + 5];
void preCalc(ll n) {
ll total1{1LL};
ll total2{1LL};
for (ll i{0}; i < n; ++i) {
inv1[i] = modInverse(total1, mod);
inv2[i] = modInverse(total2, mod2);
total1 = total1 * p % mod;
total2 = total2 * p % mod2;
}
}
void solve() {
string s;
cin >> s;
preCalc((ll)s.size());
VPII preSum;
ll hash_val1{}, hash_val2{}, pow1{1LL}, pow2{1LL};
for (char c : s) {
hash_val1 = (hash_val1 + (c - 'a' + 1) * pow1) % mod;
hash_val2 = (hash_val2 + (c - 'a' + 1) * pow2) % mod2;
pow1 = pow1 * p % mod;
pow2 = pow2 * p % mod2;
preSum.push_back({hash_val1, hash_val2});
}
VI vec;
for (ll i{0}; i < (ll)s.size() - 1; ++i) {
ll tem1{(preSum[(ll)s.size() - 1].first - preSum[i].first + mod) % mod},
tem2{(preSum[(ll)s.size() - 1].second - preSum[i].second + mod2) %
mod2};
tem1 = tem1 * inv1[i + 1] % mod;
tem2 = tem2 * inv2[i + 1] % mod2;
pair<ll, ll> pr{tem1, tem2};
if (preSum[(ll)s.size() - 2 - i] == pr)
vec.push_back({(ll)s.size() - i - 1});
}
sort(vec.begin(), vec.end());
ll st{}, en{(ll)vec.size() - 1};
while (st <= en) {
ll mid{(st + en) / 2}, len{vec[mid]};
auto pr{preSum[len - 1]};
bool find{};
for (ll i{1}; i < (ll)s.size() - len; i++) {
pair<ll, ll> val{};
val.first = (preSum[i + len - 1].first - preSum[i - 1].first + mod) % mod;
val.second =
(preSum[i + len - 1].second - preSum[i - 1].second + mod2) % mod2;
val.first = val.first * inv1[i] % mod;
val.second = val.second * inv2[i] % mod2;
if (pr == val) {
find = 1;
break;
}
}
if (find)
st = mid + 1;
else
en = mid - 1;
}
if (en < 0)
cout << "Just a legend";
else
cout << s.substr(0, vec[en]);
}
int32_t main() {
godSpeed();
solve();
}
void godSpeed() {
ios::sync_with_stdio(0);
cin.tie(0);
}
|
#include <bits/stdc++.h>
using namespace std;
int z[(int)1e6 + 3];
string z_algo(string s) {
int x = 0, y = 0;
int T = 0, M = (int)1e6 + 3;
for (int i = 1; i < s.size(); i++) {
z[i] = max(0, min(z[i - x], y - i + 1));
while (i + z[i] < s.size() && s[z[i]] == s[i + z[i]]) {
x = i, y = i + z[i];
z[i]++;
}
}
int maxz = 0, res = 0, n = s.size();
int ans = 0;
for (int i = 0; i < n; i++) {
if (i + z[i] == n && maxz >= z[i]) {
ans = max(ans, z[i]);
}
maxz = max(maxz, z[i]);
}
string t;
for (int i = 0; i < ans; i++) t.push_back(s[i]);
if (!ans) return "Just a legend";
return t;
}
int main() {
int t, tc = 0;
string s, ans;
cin >> s;
ans = z_algo(s);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const INF = 2147483647, R_INF = 9223372036854775807, MOD = 1e9 + 7;
const int N = 1e6 + 1;
int max_border[N];
void prefix(string str) {
max_border[0] = -1;
for (int i = (1); i < (str.size()); i++) {
max_border[i] = max_border[i - 1];
while (~max_border[i] && str[i] != str[max_border[i] + 1])
max_border[i] = max_border[max_border[i]];
if (str[i] == str[max_border[i] + 1]) max_border[i]++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string str;
cin >> str;
prefix(str);
int maxi1 = -1, maxi2 = max_border[str.size() - 1];
for (int i = (1); i < (str.size() - 1); i++)
maxi1 = max(maxi1, max_border[i]);
if (maxi1 >= maxi2)
maxi1 = maxi2;
else {
while (maxi1 < maxi2) {
maxi2 = max_border[maxi2];
}
}
maxi1 = maxi2;
if (maxi1 == -1) return cout << "Just a legend", 0;
for (int i = (0); i < (maxi1 + 1); i++) {
cout << str[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long base = 196613, maxn = 1e6 + 9, mod = 1e9 + 7;
string s;
long long n, b[maxn], h[maxn], l1, r1;
void build() {
b[0] = 1;
h[0] = s[0];
for (int i = 1; i < n; i++) {
h[i] = ((h[i - 1] * base) % mod + s[i]) % mod;
}
for (int i = 1; i < maxn; i++) b[i] = (b[i - 1] * base) % mod;
}
long long gethash(int l, int r) {
if (l - 1 >= 0)
return (mod + h[r] - (h[l - 1] * b[r - l + 1]) % mod) % mod;
else
return (h[r] + mod) % mod;
}
bool ch(long long a) {
for (int i = 1; i < n - a; i++)
if (gethash(i, i + a - 1) == gethash(0, a - 1)) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = (int)s.size();
build();
for (int mid = n - 1; mid >= 1; mid--) {
if (gethash(0, mid - 1) == gethash(n - mid, n - 1) && ch(mid)) {
for (int j = 0; j < mid; j++) cout << s[j];
return 0;
}
}
cout << "Just a legend";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
const long long p = 31;
string s;
long long pref[1000005];
long long inv[1000005];
long long suff[1000005];
long long cal[1000005];
long long pw(long long a, long long b) {
if (b == 0)
return 1;
else if (b == 1)
return a % mod;
else {
long long x = pw(a, b / 2);
if (b % 2 == 0)
return (x * x) % mod;
else
return x * x % mod * a % mod;
}
}
long long subs(long long l, long long r) {
return (pref[r] - (l == 0 ? 0 : pref[l - 1]) + mod) % mod * inv[l] % mod;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
long long n = s.size();
for (long long i = 0; i < 1000005; ++i) {
if (i == 0)
cal[i] = 1;
else
cal[i] = (cal[i - 1] * p) % mod;
inv[i] = pw(cal[i], mod - 2);
}
for (long long i = 0; i < n; ++i) {
if (i == 0)
pref[i] = (s[i] - 'a' + 1) % mod;
else
pref[i] = (pref[i - 1] + (s[i] - 'a' + 1) * cal[i]) % mod;
}
for (long long j = n - 1; ~j; --j) {
suff[n - j - 1] = subs(j, n - 1);
}
vector<pair<long long, long long> > v;
for (long long i = 0; i < n - 1; ++i) {
if (pref[i] == suff[i]) v.push_back(pair<long long, long long>(pref[i], i));
}
if (v.empty()) {
cout << "Just a legend";
return 0;
}
long long ll = 0, mid, ans = -1;
long long rr = (long long)v.size() - 1;
bool ok = false, ex = false;
pair<long long, long long> tmp;
while (ll < rr) {
mid = (rr + ll + 1) / 2;
ok = false;
tmp = v[mid];
for (long long i = 1; i + tmp.second < n - 1; ++i) {
if (subs(i, i + tmp.second) == tmp.first) {
ll = mid;
ok = true;
ex = true;
break;
}
}
if (ok) {
ll = mid;
} else
rr = mid - 1;
}
if (!ex) {
for (long long i = 1; i + v[ll].second < n - 1; ++i) {
if (subs(i, i + v[ll].second) == v[ll].first) {
ex = true;
break;
}
}
}
if (ex) {
for (long long i = 0; i <= v[ll].second; ++i) cout << s[i];
} else
cout << "Just a legend";
}
|
#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;
}
inline void solve() {
string s;
cin >> s;
vector<int> lps(s.length(), 0);
int i = 1, len = 0, n = s.length();
while (i < n) {
if (s[i] == s[len]) {
++len;
lps[i] = len;
++i;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
++i;
}
}
}
if (!lps[n - 1]) {
cout << "Just a legend";
return;
}
int q = n - 1;
unordered_map<long long int, long long int> mp;
for (int i = 0; i < n - 1; i++) mp[lps[i]]++;
int p = 1;
while (1) {
p = lps[q];
if (!p) break;
if (mp[p]) {
for (int i = 0; i < p; i++) cout << s[i];
return;
}
q = lps[q - 1];
}
cout << "Just a legend";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long p = 29;
unsigned long long mod = 1000000009;
unsigned long long h[1000009];
unsigned long long power[1000009];
unsigned long long hash_range(int l, int r) {
int len = r - l + 1;
unsigned long long x = power[len] * h[r + 1];
x %= mod;
return (h[l] - x + mod) % mod;
}
int main() {
string s;
cin >> s;
int n = s.size();
power[0] = 1;
for (int i = 1; i < n; i++) power[i] = (power[i - 1] * p) % mod;
h[n - 1] = s[n - 1] - 'a';
for (int i = n - 2; i >= 0; i--) {
h[i] = (h[i + 1] * p) % mod;
h[i] = (h[i] + s[i] - 'a') % mod;
}
vector<int> ss;
ss.reserve(n);
for (int i = 0; i + 1 < n; i++) {
unsigned long long lh = hash_range(0, i);
unsigned long long rh = hash_range(n - 1 - i, n - 1);
if (lh == rh) ss.push_back(i + 1);
}
int ans = 0;
for (auto it = ss.rbegin(); !ans && it != ss.rend(); it++) {
int len = *it;
unsigned long long hh = hash_range(0, len - 1);
for (int i = 1; i + len - 1 < n - 1; i++) {
unsigned long long xx = hash_range(i, i + len - 1);
if (xx == hh) {
ans = len;
break;
}
}
}
if (ans)
cout << s.substr(0, ans) << '\n';
else
cout << "Just a legend\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T const &t, V const &...v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
vector<int> prefixFunction(string s) {
int n = s.size();
vector<int> p(n);
p[0] = 0;
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
return p;
}
bool check(string s, int len) {
long long int hash = 0, mod = 1000000007, keyHash = 0;
long long int pow = 1;
for (int i = 0; i < len - 1; i++) {
pow = (pow * 26) % mod;
}
for (int i = 0; i < len; i++) {
keyHash = ((keyHash * 26) % mod + s[i] - 'a') % mod;
}
for (int i = 1; i <= len; i++) {
hash = ((hash * 26) % mod + s[i] - 'a') % mod;
}
if (hash == keyHash) return true;
for (int i = len + 1; i < s.size() - 1; i++) {
hash = ((hash - (pow * (s[i - len] - 'a')) % mod) + mod) % mod;
hash = ((hash * 26) % mod + s[i] - 'a') % mod;
;
if (hash == keyHash) return true;
}
return false;
}
int main() {
string s, imp = "Just a legend";
cin >> s;
int n = s.size();
vector<int> p = prefixFunction(s);
;
int len = p[n - 1];
if (len == 0) {
cout << imp << endl;
} else {
if (len <= s.size() - 2 && check(s, len)) {
cout << s.substr(0, len) << endl;
} else {
len = p[len - 1];
if (len <= 0) {
cout << imp << endl;
} else {
;
if (check(s, len)) {
cout << s.substr(0, len) << endl;
} else {
cout << imp << endl;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-16;
const int MOD = (int)1e9 + 9;
const long long INF = (int)1e9 + 10;
const int NHASH = 2;
template <typename T>
vector<T> readVector0(int n) {
vector<T> res(n);
for (int i = 0; i < n; i++) cin >> res[i];
return res;
}
template <typename T>
vector<T> readVector1(int n) {
vector<T> res(n + 1);
for (int i = 1; i <= n; i++) cin >> res[i];
return res;
}
inline long long mod(long long first, long long m = MOD) {
if (first < 0) first += m;
return (first % m);
}
template <typename T>
bool sortBy2(const pair<T, T> &a, const pair<T, T> &b) {
return (a.second < b.second);
}
int n;
vector<long long> p_pow[NHASH];
int p[NHASH];
vector<long long> hp[NHASH];
vector<long long> hs[NHASH];
vector<int> pi;
string s;
long long binPow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = mod(res * a);
a = mod(a * a);
b >>= 1;
}
return res;
}
void getPrefHash(const string &s) {
for (int k = 0; k < NHASH; k++) {
p_pow[k] = vector<long long>(n);
p_pow[k][0] = 1;
for (int i = 1; i < n; i++) p_pow[k][i] = (p_pow[k][i - 1] * p[k]) % MOD;
hp[k] = vector<long long>(n + 1, 0);
for (int i = 0; i < n; i++)
hp[k][i + 1] = (hp[k][i] + (s[i] - 'a' + 1) * p_pow[k][i]) % MOD;
}
}
bool checkHashes(const string &s, int i, int j) {
for (int k = 0; k < NHASH; k++) {
if (mod(hp[k][i] * binPow(p[k], (j - 1))) != hs[k][j]) return false;
}
return true;
}
void prefixFunction(const string &s) {
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 main() {
auto seed = chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count();
mt19937 mt(seed);
for (int k = 0; k < NHASH; k++) {
p[k] = uniform_int_distribution<int>(31, 100000)(mt);
}
cin >> s;
n = s.size();
pi = vector<int>(n, 0);
getPrefHash(s);
for (int k = 0; k < NHASH; k++) {
hs[k] = vector<long long>(n + 1, 0);
for (int i = 1; i <= n; ++i)
hs[k][i] = (hp[k][n] - hp[k][i - 1] + MOD) % MOD;
}
prefixFunction(s);
int m_l = 0;
for (int i = 0; i < n - 1; ++i) {
if (pi[i] > m_l && checkHashes(s, pi[i], n + 1 - pi[i])) {
m_l = pi[i];
}
}
if (m_l == 0) {
cout << "Just a legend";
return 0;
}
cout << s.substr(0, m_l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int n = 1e6 + 10;
string s;
int arr[n];
void build() {
for (int i = 1; i < s.size(); i++) {
int j = arr[i - 1];
while (j > 0 && s[i] != s[j]) j = arr[j - 1];
if (s[i] == s[j]) j++;
arr[i] = j;
}
}
int main() {
cin >> s;
memset(arr, 0, sizeof(arr));
build();
int val = arr[s.size() - 1];
int res = -1;
bool ok = false;
for (int i = 1; i < s.size() - 1; i++) {
if (arr[i] == val && val != 0) {
ok = true;
res = arr[i];
break;
}
}
if (!ok && arr[arr[s.size() - 1] - 1] != 0) {
ok = true;
res = arr[arr[s.size() - 1] - 1];
}
if (!ok || res == 0 || res == -1)
cout << "Just a legend";
else
cout << s.substr(0, res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void no() {
cout << "Just a legend\n";
exit(0);
}
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 = s.size();
if (n < 3) no();
vector<int> pi = prefix_function(s);
if (pi[n - 1] == 0) no();
bool gd = false;
for (int i = 0; i < n - 1; ++i) {
if (pi[i] == pi[n - 1]) gd = true;
}
string ans;
if (gd) {
ans = s.substr(0, pi[n - 1]);
} else {
if (pi[pi[n - 1] - 1] == 0) no();
ans = s.substr(0, pi[pi[n - 1] - 1]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
const int p = 31, m = 1e9 + 9;
bool poss(int n, long long hash, int len, vector<long long>& power,
vector<long long>& h_s) {
for (int i = 1; i + len - 1 < n - 1; ++i) {
long long cur = (h_s[i + len] - h_s[i] + m) % m;
cur = cur * power[n - i - 1] % m;
if (cur == hash) return true;
}
return false;
}
void solve(int n) {
vector<long long> power(n), h_s(n + 1, 0);
power[0] = 1;
for (int i = 1; i < n; ++i) power[i] = power[i - 1] * p % m;
for (int i = 0; i < n; ++i)
h_s[i + 1] = (h_s[i] + (s[i] - 'a' + 1) * power[i]) % m;
long long pre, suf;
vector<pair<int, long long>> q;
for (int i = 0; i < n; ++i) {
pre = h_s[i + 1] % m;
suf = (h_s[n] - h_s[n - i - 1] + m) % m;
pre = pre * power[n - 1] % m;
suf = suf * power[i] % m;
if (pre == suf) q.push_back({i + 1, suf});
}
int beg = 0, end = q.size() - 1, mid, ans = -1;
while (beg <= end) {
mid = (beg + end) >> 1;
auto it = poss(n, q[mid].second, q[mid].first, power, h_s);
if (it) {
beg = mid + 1;
ans = q[mid].first;
} else
end = mid - 1;
}
if (ans == -1) {
printf("Just a legend\n");
return;
}
s[ans] = '\0';
printf("%s\n", s);
return;
}
int main() {
scanf("%s", s);
int n = strlen(s);
solve(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long cl(long double a) {
if (a > (long long)a) {
return (long long)a + 1;
} else {
return (long long)a;
}
}
long long flr(long double a) { return (long long)a; }
const long long M = 2e6 + 100;
vector<long long> st(4 * M + 1);
long long a[M];
void update(long long v, long long tl, long long tr, long long pos,
long long change) {
if (tl == tr) {
st[v] += change;
return;
}
long long tm = (tl + tr) / 2;
if (pos <= tm)
update(2 * v, tl, tm, pos, change);
else
update(2 * v + 1, tm + 1, tr, pos, change);
st[v] = st[2 * v] + st[2 * v + 1];
}
long long query(long long v, long long tl, long long tr, long long l,
long long r) {
if (tl > r || tr < l) return 0;
if (tl >= l && tr <= r) return st[v];
long long tm = (tl + tr) / 2;
return query(2 * v, tl, tm, l, r) + query(2 * v + 1, tm + 1, tr, l, r);
}
vector<long long> z_function(string &s) {
long long n = (long long)s.size();
vector<long long> z(2 * n + 1);
for (long long 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;
}
void solve() {
string s;
cin >> s;
vector<long long> zs = z_function(s);
long long ans = 0;
long long n = s.length();
vector<long long> z = z_function(s);
for (long long i = 1; i < n; i++) {
update(1, 0, n, z[i], 1);
}
for (long long i = n - 1; i > 1; i--) {
if (z[i] != n - i) continue;
long long p1 = query(1, 0, n, 0, n);
long long p2 = query(1, 0, n, 0, z[i] - 1);
if (p1 - p2 >= 2) {
ans = max(ans, z[i]);
}
update(1, 0, n, z[i], -1);
}
if (!ans) {
cout << "Just a legend"
<< "\n";
return;
}
cout << s.substr(0, ans) << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> ma;
vector<long long int> cases;
string s;
bool find(long long int len) {
long long int val = ma[len];
long long int a = 0;
long long int m = 1e9 + 9;
long long int p = 31, n = s.size(), i;
long long int p_pow = 1;
for (i = 1; i <= len && i < n - 1; ++i) {
a *= p;
a += (s[i] - 'a' + 1);
a %= m;
p_pow *= p;
p_pow %= m;
}
if (a == val) return true;
for (i = len + 1; i < n - 1; ++i) {
a *= p;
a = ((a - p_pow * (s[i - len] - 'a' + 1) + s[i] - 'a' + 1) % m + m) % m;
if (a == val) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, m, n, i, f = 0, j, ans = 0;
cin >> s;
n = s.length();
long long int suff = 0;
long long int pre = 0;
long long int p_pow = 1;
long long int p = 31;
m = 1e9 + 9;
for (i = 0; i < n - 1; ++i) {
suff *= p;
suff += (s[i] - 'a' + 1);
suff %= m;
pre += p_pow * (s[n - i - 1] - 'a' + 1);
p_pow *= p;
p_pow %= m;
pre %= m;
if (suff == pre) {
f = 1;
ma[i + 1] = suff;
cases.push_back(i + 1);
}
}
if (f == 0) {
cout << "Just a legend";
return 0;
}
if (!find(cases[0])) {
cout << "Just a legend";
return 0;
}
long long int k = cases.size();
if (find(cases[k - 1])) {
for (i = 0; i < cases[k - 1]; ++i) {
cout << s[i];
}
return 0;
}
long long int l = 0;
long long int r = k - 1;
long long int mid;
while (l <= r) {
mid = l + (r - l) / 2;
if (find(cases[mid])) {
ans = cases[mid];
l = mid + 1;
} else
r = mid - 1;
}
for (i = 0; i < ans; ++i) cout << s[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
vector<int> pi;
void pref_fun() {
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[j] != s[i]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
}
int main() {
cin >> s;
n = s.size();
pi.resize(n);
pref_fun();
int ans = pi.back();
if (ans == 0) {
cout << "Just a legend";
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (ans == pi[i]) {
cnt++;
}
}
if (cnt > 1) {
for (int i = 0; i < ans; i++) {
cout << s[i];
}
return 0;
} else {
ans = pi[pi[n - 1] - 1];
if (ans == 0) {
cout << "Just a legend";
return 0;
} else {
for (int i = 0; i < ans; i++) {
cout << s[i];
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.length();
vector<int> pi(n, 0);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[j] != s[i]) j = pi[j - 1];
if (s[j] == s[i]) j++;
pi[i] = j;
}
vector<int> sub(n + 1, 0);
for (int i = 0; i < n; i++) sub[pi[i]]++;
for (int i = n; i > 0; i--) sub[pi[i - 1]] += sub[i];
int j = n, ch = 0;
while (j > 0) {
j = pi[j - 1];
if (sub[j] > 1 && j) {
ch = 1;
break;
}
}
if (ch)
cout << s.substr(0, j);
else
cout << "Just a legend\n";
cout << "\n";
}
|
#include <bits/stdc++.h>
#pragma 03
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
vector<long long> h, p;
long long m = 1e9 + 9, po = 31;
signed main() {
if (fopen(""
".INP",
"r")) {
freopen(
""
".INP",
"r", stdin);
freopen(
""
".OUT",
"w", stdout);
};
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
string s;
cin >> s;
long long n = s.length();
h.resize(n, 0);
p.resize(n, 1);
long long val = 1;
long long now = 0;
for (long long i = 0; i < n; ++i) {
p[i] = val;
h[i] = (now + (s[i] - 'a' + 1) * p[i]) % m;
now = h[i];
val = (val * po) % m;
}
for (long long i = n - 2; i >= 0; --i) {
if ((h[n - 1] + m - h[n - i - 2]) % m == (h[i] * p[n - i - 1]) % m) {
for (long long l = 1; l < n - i - 1; ++l) {
if ((h[i] * p[l]) % m == (h[l + i] + m - h[l - 1]) % m) {
cout << s.substr(0, i + 1);
return 0;
}
}
}
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int p[1000010], a[1000010], n, S = 0;
inline int hh(int x, int y) { return a[y] - a[x - 1] * p[y - x + 1]; }
int ff(int x) {
int L = 1, R = n - x;
while (L <= R) {
int M = (L + R) / 2;
if (hh(1, M) == hh(x, x + M - 1))
L = M + 1;
else
R = M - 1;
}
return R;
}
int main() {
cin >> s;
n = s.size();
p[0] = 1;
for (int i = 1; i < n + 5; i++) p[i] = p[i - 1] * 1000000007;
for (int i = 1; i <= n; i++) a[i] = a[i - 1] * 1000000007 + s[i - 1];
for (int i = 2; i <= n; i++) S = max(S, ff(i));
for (int i = S; i >= 1; i--)
if (hh(1, i) == hh(n - i + 1, n)) {
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 MN = 1e6 + 44;
const int mod = 1e9 + 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;
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
int n;
int m;
int p[1000000];
int main() {
string s;
cin >> s;
n = ((int)(s).size());
p[0] = 0;
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j])
p[i] = j + 1;
else
p[i] = 0;
}
int imax = 0;
for (int i = 1; i < n - 1; i++) {
if (p[i] > p[imax]) imax = i;
}
int q = p[n - 1];
while (q > p[imax]) {
q = p[q - 1];
}
if (q == 0)
cout << "Just a legend" << endl;
else {
for (int i = 0; i < (q); i++) cout << s[i];
cerr << endl;
}
return 0;
}
|
#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_function(int *z, char *s) {
int len = strlen(s);
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;
int z[MX];
char s[MX];
memset(z, 0, sizeof z);
gets(s);
int st = z_function(z, s);
if (st == -1)
return puts("Just a legend");
else
puts(s + st);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 444555;
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 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();
int k = pi[N];
while (k > 0 && !viz[k]) k = pi[k];
if (k == 0)
cout << "Just a legend\n";
else {
A[k + 1] = 0;
cout << (A + 1) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long double PI = acos(-1.0);
const int INF = 1e9;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
const long long BIGINF = 1e18;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(-1000000000, 1000000000);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
vector<int> p(s.size(), 0);
int l = 0, r = 0;
p[0] = 0;
for (int i = 1; i < s.size(); ++i) {
p[i] = p[i - 1];
while (p[i] > 0 && s[p[i]] != s[i]) p[i] = p[p[i] - 1];
if (s[p[i]] == s[i]) p[i]++;
}
if (!p.back()) {
cout << "Just a legend" << '\n';
return 0;
}
int k = p.back();
while (k > 0) {
for (int i = 0; i < int(s.size()) - 1; ++i) {
if (p[i] == k) {
for (int j = 0; j < k; ++j) {
cout << s[j];
}
cout << '\n';
return 0;
}
}
k = p[k - 1];
}
cout << "Just a legend" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int len;
char ch;
char T[1000010];
int nexxt[1000010];
int find_t(int le) {
int i = 1, j = 0;
while (i < len - 1 && j <= le) {
if (j == -1 || T[i] == T[j]) {
i++;
j++;
} else
j = nexxt[j];
}
if (j == le + 1) return 1;
return 0;
}
int bo(int le) {
int y = len;
while (nexxt[y] >= le + 1) {
if (nexxt[y] == le + 1)
return 1;
else
y = nexxt[y];
}
return 0;
}
int main() {
int i, j;
len = 0;
while ((ch = getchar()) != '\n') {
T[len] = ch;
len++;
}
T[len] = '4';
nexxt[0] = -1;
nexxt[1] = 0;
for (i = 2; i <= len; i++) {
j = i - 1;
while (nexxt[j] != -1 && T[nexxt[j]] != T[i - 1]) {
j = nexxt[j];
}
nexxt[i] = nexxt[j] + 1;
}
for (i = len - 2; i >= 0; i--) {
if (i == -1) break;
if (bo(i) && find_t(i)) break;
}
if (i == -1)
printf("Just a legend");
else {
for (j = 0; j <= i; j++) {
printf("%c", T[j]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 982451653;
const long long P = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string str;
cin >> str;
long long a = 0, b = 0, n = str.size();
long long curP = 1;
vector<pair<long long, long long>> w;
for (long long i = 0; i < n - 2; ++i) {
a += curP * str[i];
curP *= P;
curP %= MOD;
a %= MOD;
b = b * P + str[n - 1 - i];
b %= MOD;
if (a == b) {
w.push_back(make_pair(i + 1, b));
}
}
long long start = -1, end = w.size();
for (long long i = 0; i < 25; ++i) {
long long cur = (start + end) / 2;
if (cur >= w.size()) {
end = cur;
continue;
}
long long hash = 0;
long long pow = 1;
long long j;
for (j = n - 1 - w[cur].first; j < n - 1; ++j) {
hash += (str[j] * pow) % MOD;
hash %= MOD;
if (j == n - 2) {
break;
}
pow *= P;
pow %= MOD;
}
if (hash == w[cur].second) {
start = cur;
continue;
}
for (j = n - 2 - w[cur].first; j > 0; j--) {
hash =
(hash + MOD * str[j + w[cur].first] - pow * str[j + w[cur].first]) %
MOD;
hash = (hash * P + str[j]) % MOD;
if (hash == w[cur].second) {
start = cur;
break;
}
}
if (start == cur) {
continue;
}
end = cur;
}
if (start == -1) {
cout << "Just a legend";
} else {
cout << str.substr(0, w[start].first);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long infinity = 1000000000000000000;
bool do_debug = false;
void gen_z(vector<int>& z, string s, int len) {
int l = 0, r = 0;
for (int i = 1; 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 (z[i] + i - 1 > r) {
l = i;
r = z[i] + i - 1;
}
}
}
void solve() {
string s;
cin >> s;
int len = s.length();
vector<int> z(len, 0);
multiset<int> sett;
vector<int> cv(len, 0);
gen_z(z, s, len);
for (int i = 1; i < len - 1; i++) {
int contr = z[i];
if (i + contr - 1 == len - 1) {
contr--;
}
if (contr) {
sett.insert(contr);
}
cv[i] = contr;
}
int ans_i = -1, ans_l = 0;
for (int i = len - 1; i >= 1; i--) {
if (cv[i]) {
sett.erase(sett.find(cv[i]));
}
if (!sett.size()) {
break;
}
if (*sett.rbegin() >= z[i] && i + z[i] - 1 == len - 1) {
if (z[i] > ans_l) {
ans_l = z[i];
ans_i = i;
}
}
}
if (ans_i != -1) {
for (int i = ans_i; i < ans_i + ans_l; i++) {
cout << s[i];
}
cout << "\n";
} else {
cout << "Just a legend";
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q = 1;
while (q-- > 0) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long exp(long long a, long long p) {
long long result = 1;
if (p == 0) return 1;
if (p == 1) return a;
while (p) {
if (p & 1) result *= a;
p >>= 1;
a *= a;
}
return result;
}
struct RH {
vector<long long> rh;
RH(string &s) {
int N = s.length();
rh.resize(N + 1, 0);
rh[N] = 0;
rh[N - 1] = s[N - 1];
for (int i = N - 2; i >= 0; i--) {
rh[i] = s[i] + rh[i + 1] * 33;
}
}
long long getHash(int i, int len) {
return rh[i] - rh[i + len] * exp(33, len);
}
};
int main() {
string s;
cin >> s;
RH rh = RH(s);
int len = s.length();
int l = len;
bool flag = false;
long long h;
while (!flag) {
h = rh.getHash(0, l);
if (h == rh.getHash(len - l, l)) {
for (int i = 1; i < len - l; i++) {
if (h == rh.getHash(i, l)) {
flag = true;
break;
}
}
if (!flag) l--;
} else {
l--;
}
if (l == 0) {
cout << "Just a legend" << endl;
return 0;
}
}
cout << s.substr(0, l) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ZAlgo(string s) {
int n = s.size();
vector<int> z(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--;
}
}
}
return z;
}
int main() {
string s;
cin >> s;
int n = s.size(), mx = 0;
vector<int> z = ZAlgo(s);
for (int i = 0; i < s.size(); i++) {
if (z[i] == n - i && mx >= z[i]) {
cout << s.substr(i, n - i);
return 0;
}
mx = max(mx, z[i]);
}
cout << "Just a legend";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> z_function_naive(string s) {
int n = (int)s.size();
vector<int> zf(n);
for (int i = 1; i < n; i++) {
while (zf[i] < n - i && s[zf[i]] == s[i + zf[i]]) {
zf[i]++;
}
}
return zf;
}
vector<int> z_function(string s) {
int n = (int)s.length();
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;
}
int main() {
string s;
cin >> s;
vector<int> ans = z_function(s);
int n = (int)s.size();
int prev = 0;
for (int i = 0; i < n; i++) {
if (ans[i] == n - i) {
if (prev >= ans[i]) {
cout << s.substr(0, ans[i]) << '\n';
return 0;
}
}
prev = max(prev, ans[i]);
}
cout << "Just a legend" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, l, r, i, m, mm;
string s;
cin >> s;
n = s.size();
m = 0;
mm = 0;
vector<long int> z(n);
vector<long int> a(n, 0);
l = 0;
r = 0;
for (i = 1; 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) {
r = i + z[i] - 1;
l = i;
}
}
for (i = 1; i < n; i++) {
a[z[i]]++;
}
for (i = 0; i < n; i++) {
if (a[i] > 0) {
m = i;
mm = a[i];
}
}
l = 0;
for (i = 1; i < n; i++) {
if (i + z[i] == n) {
if (m > z[i] || (m == z[i] && mm >= 2)) {
l = z[i];
break;
}
}
}
if (l == 0) {
cout << "Just a legend" << endl;
} else {
for (i = 0; i < l; i++) {
cout << s[i];
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 10;
const int M = 1000000007;
const double eps = 1e-9;
const double PI = acos(-1);
const int oo = 1000000000;
int n, z[N], l, r;
char s[N];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 1; i < n; ++i) {
if (i > r) {
l = r = i;
while (r < n && s[r] == s[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 && s[r] == s[r - l]) ++r;
z[i] = r - l;
--r;
}
}
}
int ans = 0, mx = 0;
for (int i = 1; i < n; ++i) {
if (z[i] == n - i && mx >= n - i) {
ans = n - i;
break;
}
mx = max(mx, z[i]);
}
if (!ans)
puts("Just a legend");
else {
s[ans] = 0;
printf("%s\n", s);
}
return 0;
}
|
#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;
int lps[1000005];
void computeLPSArray(string pat) {
int M = pat.size();
int len = 0;
int i;
lps[0] = 0;
i = 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
string a;
int main() {
cin >> a;
computeLPSArray(a);
int n = a.size();
if (lps[n - 1] == 0) {
printf("Just a legend");
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (lps[i] == lps[n - 1]) {
cout << a.substr(0, lps[n - 1]);
return 0;
}
}
lps[n - 1] = lps[lps[n - 1] - 1];
if (lps[n - 1] == 0) {
printf("Just a legend");
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (lps[i] == lps[n - 1]) {
cout << a.substr(0, lps[n - 1]);
return 0;
}
}
printf("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> z_func(const string &s) {
vector<int> z(s.size());
int l = 0, r = 0;
for (int _n(s.size()), k(1); k < _n; k++) {
if (k <= r) z[k] = min(z[k - l], r - k + 1);
while (k + z[k] < s.size() && s[k + z[k]] == s[z[k]]) ++z[k];
if (k + z[k] - 1 > r) l = k, r = k + z[k] - 1;
}
return z;
}
int main() {
string s;
cin >> s;
const int N = s.size();
if (N <= 2) {
cout << "Just a legend" << endl;
return 0;
}
{
set<char> ch((s).begin(), (s).end());
if (ch.size() == 1) {
cout << s.substr(0, N - 2) << endl;
;
return 0;
}
}
vector<int> z = z_func(s);
int mx = 0;
for (int _n(N), i(1); i < _n; i++) mx = max(mx, min(z[i], N - 1 - i));
int ans = -1;
for (int _n(N), i(N - mx); i < _n; i++)
if (i + z[i] == N) {
ans = z[i];
break;
}
if (ans == -1) {
cout << "Just a legend" << endl;
return 0;
}
cout << s.substr(0, ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vll = vector<long long>;
using vii = vector<pair<int, int>>;
int main() {
string s;
cin >> s;
int n = s.length();
vi p(n);
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 && s[j] != s[i]) j = p[j - 1];
if (s[j] == s[i]) ++j;
p[i] = j;
}
int ans = 0;
if (p[n - 1] > 0) {
for (int i = 0; i < n - 1; i++) {
if (p[i] == p[n - 1]) {
ans = p[i];
break;
}
}
if (ans == 0) ans = p[p[n - 1] - 1];
}
if (ans == 0)
cout << "Just a legend" << endl;
else
cout << s.substr(0, ans) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int z[1000000];
void zAlgorithm(const string &s) {
int n = s.length();
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() {
string s;
cin >> s;
int n = s.length();
zAlgorithm(s);
int maxz = 0, ans = 0;
for (int i = 1; i < n && !ans; ++i)
if (z[i] == n - i && z[i] <= maxz)
ans = z[i];
else
maxz = max(maxz, z[i]);
if (ans)
cout << s.substr(0, ans) << endl;
else
cout << "Just a legend" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> fail(const string &s) {
vector<int> f{0, 0};
int u = 0;
for (int i = 1; i < s.length(); i++) {
while (u && s[i] != s[u]) u = f[u];
if (s[i] == s[u]) ++u;
f.push_back(u);
}
return f;
}
void solve() {
string s;
cin >> s;
int n = s.length();
vector<int> v = fail(s);
if (v[n] == 0)
cout << "Just a legend";
else {
int f = 0;
for (int i = 1; i < n; i++) {
if (v[i] == v[n]) f = 1;
}
if (f) {
for (int i = 0; i < v[n]; i++) cout << s[i];
} else {
if (v[v[n]] == 0)
cout << "Just a legend";
else {
int tmp = v[v[n]];
for (int i = 0; i < tmp; i++) cout << s[i];
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
namespace StrAlgo {
vector<int> Kmp(string s) {
int n = (int(s.size()));
vector<int> ans(n + 1);
for (int i = 2; i <= n; i++) {
ans[i] = ans[i - 1];
while (ans[i] > 0 && s[ans[i]] != s[i - 1]) ans[i] = ans[ans[i]];
ans[i] += s[ans[i]] == s[i - 1];
}
return ans;
}
vector<int> Z(string s) {
int n = (int(s.size()));
vector<int> ans(n + 1);
int L = -1, R = -1;
for (int i = 2; i <= n; i++) {
if (i < R)
ans[i] = min(ans[i - L], R - i);
else
L = i, R = i;
while (i + ans[i] <= n && s[i + ans[i] - 1] == s[ans[i] - 1]) ans[i]++;
if (i + ans[i] > R) L = i, R = i + ans[i];
}
return ans;
}
}; // namespace StrAlgo
void print(string s, int len) {
if (len == 0)
cout << "Just a legend\n";
else
cout << s.substr((int(s.size())) - len) << "\n";
exit(0);
}
int cnt[maxn];
int main() {
ios_base::sync_with_stdio(0), cin.tie(), cout.tie();
string s;
cin >> s;
vector<int> kmp = StrAlgo::Kmp(s);
for (int x : kmp) cnt[x]++;
if (cnt[kmp.back()] > 1) print(s, kmp.back());
print(s, kmp[kmp.back()]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 12345;
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;
constexpr const long long MOD = 1e9 + 7;
string solve(const string &inp) {
string zstr = inp;
vector<int> z(zstr.length());
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];
}
int limit = 0;
for (int i = 0; i < zstr.size(); ++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;
int n, m;
inline int Read() {
int y = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
y = y * 10 + (c - '0'), c = getchar();
}
return y * f;
}
inline void read(int &x) { x = Read(); }
char a[1000005], b[1000005];
int nxt[1000005];
void work() {
cin >> a + 1;
int n = strlen(a + 1);
int j = 0;
nxt[1] = 0;
for (int i = 1; i <= n; i++) {
if (i == 1) continue;
while (j > 0 && (a[j + 1] != a[i])) {
j = nxt[j];
}
if (a[i] == a[j + 1]) ++j;
nxt[i] = j;
}
int Max = 0;
for (int i = 1; i <= n - 1; i++) Max = max(Max, nxt[i]);
int Ans = nxt[n];
if (!Ans || !Max) {
cout << "Just a legend";
} else {
int j = nxt[n];
while (j > Max) j = nxt[j];
if (!j) {
cout << "Just a legend";
return;
}
for (int i = 1; i <= j; i++) cout << a[i];
}
}
int main() {
int T = 1;
while (T--) {
work();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i1, i, j, k = -4, l, m, n, p, cnt = 0, x;
string s;
cin >> s;
n = s.size();
string s1 = "", s2 = "", t = "";
string last = "";
string ans = "";
string temp;
long long int maxi = 0;
long long int len = 0;
long long int lps[n];
lps[0] = 0;
i = 1;
while (i < n) {
if (s[i] == s[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len == 0) {
lps[i] = 0;
i++;
} else {
len = lps[len - 1];
}
}
}
x = n - 1;
while (lps[x] > 0) {
k = -4;
if (lps[x] == 0) {
cout << "Just a legend";
goto last;
}
for (i = 1; i < n - 1; i++) {
if (lps[i] == lps[x]) {
k = i;
break;
}
}
if (k >= 0) {
for (i = k - lps[x] + 1; i <= k; i++) {
cout << s[i];
}
goto last;
}
x = lps[x] - 1;
}
cout << "Just a legend";
last:;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> prefix_function(const string &s) {
int n = 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() {
int n, i, j, k, t;
string s1, s2;
string s;
cin >> s;
long long len = s.length();
vector<int> pi = prefix_function(s);
long long a = pi[len - 1];
if (a == 0) {
cout << "Just a legend" << endl;
return 0;
}
for (i = 0; i < len - 1; i++) {
if (pi[i] == a) {
cout << s.substr(0, a) << endl;
return 0;
}
}
long long b = pi[a - 1];
if (b == 0) {
cout << "Just a legend" << endl;
return 0;
} else {
cout << s.substr(0, b) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int mod = 1000000007;
const double pi = 4 * atan(1);
const int inf = 2000000000;
const long long linf = (long long)1e18;
const int pr = 37;
const int maxn = 1000001;
const int maxn_big = 1000001;
string s;
vector<int> v;
unsigned long long h[maxn], p[maxn];
unsigned long long get_hash(int l, int r) {
int len = (r - l) + 1;
if (!l) return h[r];
return h[r] - h[l - 1] * p[len];
}
bool check(int pf) {
unsigned long long pref_hash = get_hash(0, pf);
bool has_ans = 0;
for (int i = 1; i < ((int)(s.size())) - 1; ++i) {
int r = i + pf;
if (r >= ((int)(s.size())) - 1) break;
if (get_hash(i, r) == pref_hash) {
has_ans = 1;
break;
}
}
return has_ans;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
srand(time(NULL));
cin >> s;
h[0] = s[0];
p[0] = 1;
for (int i = 1; i < ((int)(s.size())); ++i) {
h[i] = h[i - 1] * pr + s[i];
p[i] = p[i - 1] * pr;
}
for (int i = 0; i < ((int)(s.size())); ++i) {
int l = ((int)(s.size())) - 1 - i;
if (get_hash(0, i) == get_hash(l, ((int)(s.size())) - 1)) v.push_back(i);
}
if (!((int)(v.size()))) {
cout << "Just a legend";
return 0;
}
int l = -1, r = ((int)(v.size()));
bool has = 0;
while (r - l > 1) {
int mid = (r + l) / 2;
if (check(v[mid])) {
l = mid;
has = 1;
} else {
r = mid;
}
}
if (!has) {
cout << "Just a legend";
return 0;
}
string res = "";
for (int i = 0; i <= v[l]; ++i) res += s[i];
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e6 + 3;
int n, za[N], p;
char a[N];
int main() {
scanf("%s", a + 1), n = strlen(a + 1);
za[1] = n;
for (int i = 2, j = 0; i <= n; i++) {
if (j + za[j] > i) za[i] = std::min(j + za[j] - i, za[i - j + 1]);
for (; i + za[i] <= n && a[1 + za[i]] == a[i + za[i]]; ++za[i])
;
if (i + za[i] > j + za[j]) j = i;
if (!p && i + za[i] - 1 == n) p = i;
}
for (int i = 2; i <= n; i++) {
if (i < p && za[i] >= za[p]) return 0 * printf("%s\n", a + p);
if (i > p && i + za[i] - 1 == n) return 0 * printf("%s\n", a + i);
}
return 0 * puts("Just a legend");
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
int n;
int z[1000010];
string s;
int suff[1000010];
char scelta[1000010];
int best;
int w;
void zeta() {
int l = 0, r = 0;
for (int i = 1; i < n; i++) {
if (i > r) {
l = i;
r = i;
while (r < n and 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 and s[r - l] == s[r]) r++;
z[i] = r - l;
r--;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> s;
n = s.size();
zeta();
suff[n - 1] = -1;
for (int i = n - 1; i > 0; i--) {
if (z[i] == n - i)
suff[i] = i;
else if (i < n - 1)
suff[i] = suff[i + 1];
}
for (int i = 1; i < n - 1; i++) {
if (z[i] == 0) continue;
if (z[i] < n - i) {
if (suff[n - z[i]] != -1 and z[i] > best) {
w = suff[n - z[i]];
best = n - suff[n - z[i]];
}
} else {
if (suff[i + 1] != -1 and z[i] - 1 > best) {
w = suff[n - z[i] + 1];
best = n - suff[n - z[i] + 1];
}
}
}
if (best > 0)
for (int i = w; i < n; i++) cout << s[i];
else
cout << "Just a legend";
}
|
#include <bits/stdc++.h>
char str[1000040];
int len, next[1000040], hash[1000040];
void GetNext() {
int i = 0, j = -1;
next[i] = -1;
while (i < len) {
if (j == -1 || str[i] == str[j])
i++, j++, next[i] = j;
else
j = next[j];
}
for (i = 1; i < len; ++i) hash[next[i]]++;
}
int main() {
int i, j, k, flag;
while (scanf("%s", str) != EOF) {
len = strlen(str);
memset(hash, 0, sizeof(hash));
GetNext();
flag = 0, i = len;
while (next[i] != 0) {
if (hash[next[i]]) {
for (j = 0; j < next[i]; ++j) printf("%c", str[j]);
flag = 1;
break;
}
i = next[i];
}
if (flag == 0) printf("Just a legend");
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
string s;
cin >> s;
long long n = s.length();
vector<long long> p(n, 0);
for (long long i = 1; i < n; i++) {
long long j = p[i - 1];
while (j > 0 && s[i] != s[j]) {
j = p[j - 1];
}
if (s[i] == s[j]) {
j++;
}
p[i] = j;
}
if (p[n - 1] == 0) {
cout << "Just a legend";
return 0;
}
for (long long i = 1; i < n - 1; i++) {
if (p[i] == p[n - 1]) {
for (long long j = 0; j < p[i]; j++) {
cout << s[j];
}
return 0;
}
}
if (p[p[n - 1] - 1] == 0) {
cout << "Just a legend";
return 0;
}
long long x = p[p[n - 1] - 1];
for (long long i = 0; i < x; i++) {
cout << s[i];
}
}
|
#include <bits/stdc++.h>
const long long int N = 1000 * 1000, P = 709;
char s[N + 1];
unsigned int l, m = 0, h[N + 1] = {0}, p[N + 1] = {1};
int main() {
gets(s);
for (l = 0; s[l]; ++l) {
p[l + 1] = p[l] * P;
h[l + 1] = h[l] * P + s[l];
}
for (int k = l - 2; k > 0 && !m; --k)
if (h[k] == h[l] - p[k] * h[l - k])
for (int i = k + 1; i < l; ++i)
if (h[k] == h[i] - p[k] * h[i - k]) m = k;
s[m] = '\0';
puts(m ? s : "Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
#pragma Ofast
using namespace std;
long long base = 311;
long long mod = 1000000007;
long long n, z, ans = -1;
long long Hash[1111111], POW[1111111];
long long gethash(int i, int j) {
return (Hash[j] - Hash[i - 1] * POW[j - i + 1] + mod * mod) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
string s;
cin >> s;
n = s.length();
POW[0] = 1;
Hash[0] = s[0] - 'a' + 1;
for (long long i = 1; i < n; i++) {
POW[i] = POW[i - 1] * base % mod;
Hash[i] = (Hash[i - 1] * base + s[i] - 'a' + 1) % mod;
}
for (int k = 0; k < n - 2; k++) {
int x = gethash(0, k);
int y = gethash(n - 1 - k, n - 1);
if (x != y) continue;
for (int i = 1; i + k < n - 1; i++) {
z = gethash(i, i + k);
if (x == z) {
ans = k;
break;
}
}
}
if (ans == -1)
cout << "Just a legend";
else
for (int i = 0; i <= ans; i++) cout << s[i];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 128483;
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);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.