text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
int ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
int add(int x, int y) { return x + y > 998244353 ? x + y - 998244353 : x + y; }
int sub(int x, int y) { return x - y < 0 ? x - y + 998244353 : x - y; }
vector<int> a[1000005];
vector<int> sum[1000005];
vector<int> res[1000005], r[1000005];
char s[1000005];
int n, m;
int get(int x1, int y1, int x2, int y2) {
return sum[x2][y2] + sum[x1 - 1][y1 - 1] - sum[x1 - 1][y2] - sum[x2][y1 - 1];
}
bool judge(int mid) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) res[i][j] = r[i][j] = 0;
}
mid = mid + mid + 1;
for (int i = 1; i + mid - 1 <= n; i++) {
for (int j = 1; j + mid - 1 <= m; j++) {
int re = get(i, j, i + mid - 1, j + mid - 1);
if (re != mid * mid) continue;
res[i + mid / 2][j + mid / 2] = 1;
r[i][j]++, r[i + mid][j]--, r[i][j + mid]--, r[i + mid][j + mid]++;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
r[i][j] += r[i - 1][j] + r[i][j - 1] - r[i - 1][j - 1];
if (a[i][j] == 1 && r[i][j] == 0) return false;
}
}
return true;
}
signed main() {
cin >> n >> m;
for (int i = 0; i <= m; i++) a[0].push_back(0);
for (int i = 0; i <= m; i++) sum[0].push_back(0);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
a[i].push_back(0);
for (int j = 1; j <= m; j++) a[i].push_back(s[j] == 'X');
}
for (int i = 1; i <= n; i++) {
sum[i].push_back(0);
for (int j = 1; j <= m; j++) {
sum[i].push_back(sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] +
a[i][j]);
}
}
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= m + 1; j++) res[i].push_back(0), r[i].push_back(0);
}
int l = 0, r = n * m, ans;
while (l <= r) {
int mid = (l + r) / 2;
if (judge(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
judge(ans);
cout << ans << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", res[i][j] == 1 ? 'X' : '.');
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const int NN = (int)4e6 + 5;
int q[NN];
vector<string> grid;
int n, m;
vector<vector<int> > dist_from_fire;
vector<vector<int> > dist;
int beg, fin;
inline void add(int v) { q[fin++] = v; }
inline int pop() { return q[beg++]; }
void bfs(vector<vector<int> >& dist) {
while (beg < fin) {
int x = pop();
int y = pop();
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++)
if (dx || dy) {
int n_x = x + dx;
int n_y = y + dy;
if (grid[n_x][n_y] == 'X' && dist[n_x][n_y] == INF) {
dist[n_x][n_y] = dist[x][y] + 1;
add(n_x);
add(n_y);
}
}
}
}
}
void bfs_fire(vector<vector<int> >& dist) {
while (beg < fin) {
int x = pop();
int y = pop();
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++)
if (dx || dy) {
int n_x = x + dx;
int n_y = y + dy;
if (0 <= n_x && n_x < n && 0 <= n_y && n_y < m &&
dist[n_x][n_y] == INF) {
dist[n_x][n_y] = dist[x][y] + 1;
add(n_x);
add(n_y);
}
}
}
}
}
bool can(int T) {
beg = 0, fin = 0;
dist.clear();
dist.resize(n, vector<int>(m, INF));
for (int i = 1; i < n - 1; i++) {
for (int j = 1; j < m - 1; j++) {
if (grid[i][j] == 'X' && dist_from_fire[i][j] >= T)
add(i), add(j), dist[i][j] = 0;
}
}
bfs_fire(dist);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == 'X' && dist[i][j] > T) return false;
if (grid[i][j] == '.' && dist[i][j] <= T) return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
m += 2;
n += 2;
grid.resize(n, string(m, '.'));
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < m - 2; j++) cin >> grid[i + 1][j + 1];
}
dist_from_fire.clear();
dist_from_fire.resize(n, vector<int>(m, INF));
beg = 0, fin = 0;
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++) {
if (grid[x][y] == 'X') {
bool ok = false;
for (int dx = -1; dx <= 1 && !ok; dx++) {
for (int dy = -1; dy <= 1 && !ok; dy++)
if (dx || dy) {
int n_x = x + dx;
int n_y = y + dy;
if (grid[n_x][n_y] == '.') ok = true;
}
}
if (ok == true) {
add(x);
add(y);
dist_from_fire[x][y] = 0;
}
}
}
bfs(dist_from_fire);
int T = -1;
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
if (grid[x][y] == 'X') T = max(T, dist_from_fire[x][y]);
}
}
int lo = 0, hi = T + 1;
while (lo < hi) {
T = (lo + hi + 1) >> 1;
if (can(T) == false) {
hi = T - 1;
} else
lo = T;
}
T = lo;
cout << T << endl;
for (int i = 1; i < n - 1; i++) {
for (int j = 1; j < m - 1; j++) {
if (grid[i][j] == 'X' && dist_from_fire[i][j] >= T)
cout << 'X';
else
cout << '.';
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
template <class T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_heap = priority_queue<T>;
const int mod = 998244353;
const int inf = 0x3fffffff;
const int N = 2 * 1e5 + 10;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct PairHash {
template <typename T1, typename T2>
std::size_t operator()(const pair<T1, T2> &p) const {
return hash<T1>()(p.first) ^ hash<T2>()(p.second);
}
};
int n, m;
const int d[][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
void calc_ng(vector<char *> &ng, const vector<char *> &g, int T,
const vector<vector<int>> &sum) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ng[i][j] = '.';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int zi = i - T * 2;
int zj = j - T * 2;
if (zi < 0 || zj < 0) continue;
int s = sum[i][j] - (zi - 1 >= 0 ? sum[zi - 1][j] : 0) -
(zj - 1 >= 0 ? sum[i][zj - 1] : 0) +
(zi - 1 >= 0 && zj - 1 >= 0 ? sum[zi - 1][zj - 1] : 0);
if (s == (2 * T + 1) * (2 * T + 1)) ng[i - T][j - T] = 'X';
}
}
}
bool verify_ng(vector<char *> &ng, const vector<char *> &g, int T) {
queue<pair<int, int>> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ng[i][j] == 'X') q.push(pair<int, int>(i, j));
}
}
for (int t = 0; t < T; t++) {
vector<pair<int, int>> n_e;
while (!q.empty()) {
pair<int, int> head = q.front();
q.pop();
for (int k = 0; k < 8; k++) {
int nx = head.first + d[k][0];
int ny = head.second + d[k][1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) return false;
if (ng[nx][ny] != '.') continue;
ng[nx][ny] = 'X';
if (g[nx][ny] == '.') return false;
n_e.push_back(pair<int, int>(nx, ny));
}
}
for (auto &p : n_e) q.push(p);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ng[i][j] != g[i][j]) return false;
}
}
return true;
}
bool okay(int T, const vector<char *> &g, vector<char *> &ng,
const vector<vector<int>> &sum) {
calc_ng(ng, g, T, sum);
return verify_ng(ng, g, T);
}
void solve(int ncase) {
scanf("%d%d", &n, &m);
vector<char *> g(n);
for (int i = 0; i < n; i++) {
g[i] = new char[m + 1];
}
for (int i = 0; i < n; i++) {
scanf("%s", g[i]);
g[i][m] = 0;
}
int ans = max(n, m);
int T = (ans + 1) / 2 - 1;
if (T == 0) {
printf("%d\n", 0);
for (int i = 0; i < n; i++) printf("%s\n", g[i]);
return;
}
vector<vector<int>> col_sum(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
col_sum[i][j] = (j > 0 ? col_sum[i][j - 1] : 0) + (g[i][j] == 'X');
}
}
vector<vector<int>> sum(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum[i][j] = (i > 0 ? sum[i - 1][j] : 0) + col_sum[i][j];
}
}
vector<char *> ng(n);
for (int i = 0; i < n; i++) {
ng[i] = new char[m + 1];
for (int j = 0; j < m; j++) {
ng[i][j] = '.';
}
ng[i][m] = 0;
}
int l = 0, r = T + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (okay(mid, g, ng, sum))
l = mid;
else
r = mid;
}
printf("%d\n", l);
calc_ng(ng, g, l, sum);
for (int i = 0; i < n; i++) printf("%s\n", ng[i]);
}
void solve_all_cases() {
int T = 1;
int ncase = 0;
while (T--) {
solve(++ncase);
}
}
int main() {
cout << std::fixed;
cout << setprecision(9);
solve_all_cases();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 1;
int linha[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
int coluna[] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
int n, m;
unordered_map<int, char> tab[maxn];
unordered_map<int, int> soma[maxn];
unordered_map<int, char> res[maxn];
unordered_map<int, bool> mark[maxn];
int get(int xa, int ya, int xb, int yb) {
return (soma[xb][yb] - soma[xb][ya - 1] - soma[xa - 1][yb] +
soma[xa - 1][ya - 1]);
}
void bfs(vector<pair<int, int>> &V, int k) {
queue<pair<pair<int, int>, int>> fila;
for (auto pp : V) fila.push({pp, 0});
while (!fila.empty()) {
int x = fila.front().first.first, y = fila.front().first.second;
int d = fila.front().second;
fila.pop();
if (d == k) continue;
for (int i = 0; i < 9; i++) {
int a = x + linha[i], b = y + coluna[i];
if (a < 1 || a > n || b < 1 || b > m || mark[a][b]) continue;
mark[a][b] = 1;
fila.push({{a, b}, d + 1});
}
}
}
bool ok(int k) {
vector<pair<int, int>> V;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) mark[i][j] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) res[i][j] = '.';
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i - k < 1 || j - k < 1 || i + k > n || j + k > m) continue;
if (get(i - k, j - k, i + k, j + k) == (2 * k + 1) * (2 * k + 1)) {
mark[i][j] = 1;
V.push_back({i, j});
res[i][j] = 'X';
}
}
}
bfs(V, k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (tab[i][j] == 'X' && !mark[i][j]) return false;
return true;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> tab[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
soma[i][j] = soma[i - 1][j] + soma[i][j - 1] - soma[i - 1][j - 1] +
(tab[i][j] == 'X');
int ini = 0, fim = 1000001, ans = 0;
while (ini <= fim) {
int mid = (ini + fim) >> 1;
if (ok(mid))
ans = mid, ini = mid + 1;
else
fim = mid - 1;
}
cout << ans << "\n";
ok(ans);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << res[i][j];
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n, m;
vector<string> gr;
struct Pt {
int i, j;
Pt(int _i, int _j) : i(_i), j(_j) {}
};
bool isValid(Pt p) { return 0 <= p.i && p.i < n && 0 <= p.j && p.j < m; }
vector<Pt> dirs = {Pt(-1, 0), Pt(1, 0), Pt(0, -1), Pt(0, 1),
Pt(1, 1), Pt(1, -1), Pt(-1, 1), Pt(-1, -1)};
vector<Pt> getNei(Pt p) {
vector<Pt> ans;
for (auto pd : dirs) {
Pt p2(p.i + pd.i, p.j + pd.j);
if (isValid(p2)) ans.push_back(p2);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
gr.resize(n);
for (auto& s : gr) cin >> s;
vector<vector<int>> dist(n, vector<int>(m, MOD));
queue<Pt> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (gr[i][j] == '.') {
dist[i][j] = 0;
q.push(Pt(i, j));
}
}
}
while (q.size()) {
auto cur = q.front();
q.pop();
for (auto p : getNei(cur)) {
if (dist[p.i][p.j] == MOD) {
dist[p.i][p.j] = dist[cur.i][cur.j] + 1;
q.push(p);
}
}
}
for (int i = 0; i < n; i++) {
if (gr[i][0] == 'X' && dist[i][0] > 1) {
dist[i][0] = 1;
q.push(Pt(i, 0));
}
if (gr[i][m - 1] == 'X' && dist[i][m - 1] > 1) {
dist[i][m - 1] = 1;
q.push(Pt(i, m - 1));
}
}
for (int j = 0; j < m; j++) {
if (gr[0][j] == 'X' && dist[0][j] > 1) {
dist[0][j] = 1;
q.push(Pt(0, j));
}
if (gr[n - 1][j] == 'X' && dist[n - 1][j] > 1) {
dist[n - 1][j] = 1;
q.push(Pt(n - 1, j));
}
}
while (q.size()) {
auto cur = q.front();
q.pop();
for (auto p : getNei(cur)) {
if (dist[p.i][p.j] > dist[cur.i][cur.j] + 1) {
dist[p.i][p.j] = dist[cur.i][cur.j] + 1;
q.push(p);
}
}
}
int r = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
r = max(r, dist[i][j]);
}
}
int l = 0;
while (l < r) {
int mid = (l + r) / 2;
vector<vector<int>> d2(n, vector<int>(m, MOD));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dist[i][j] >= mid + 1) {
q.push(Pt(i, j));
d2[i][j] = 0;
}
}
}
while (q.size()) {
auto cur = q.front();
q.pop();
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
if (!i && !j) continue;
Pt p(cur.i + i, cur.j + j);
if (isValid(p) && d2[p.i][p.j] == MOD) {
d2[p.i][p.j] = d2[cur.i][cur.j] + 1;
q.push(p);
}
}
}
}
bool works = 1;
for (int i = 0; i < n && works; i++) {
for (int j = 0; j < m && works; j++) {
if (gr[i][j] == 'X' && d2[i][j] > mid ||
gr[i][j] == '.' && d2[i][j] <= mid)
works = 0;
}
}
if (works)
l = mid + 1;
else
r = mid;
}
cout << l - 1 << '\n';
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << (dist[i][j] >= l ? 'X' : '.');
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int get(vector<vector<int> > &p, int l, int i, int j) { return 0; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
char s[n][m];
int x[] = {1, 1, 1, 0, 0, -1, -1, -1};
int y[] = {1, -1, 0, 1, -1, -1, 0, 1};
int a[n + 2][m + 2], b[n + 2][m + 2];
int pref[n + 2][m + 2];
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) {
a[i][j] = 0;
b[i][j] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> s[i][j];
for (int j = 0; j < m; j++)
if (s[i][j] == '.')
a[i + 1][j + 1] = 0;
else
a[i + 1][j + 1] = 1;
}
int dp[n + 2][m + 2], dp1[n + 2][m + 2], dp2[n + 2][m + 2], dp3[n + 2][m + 2],
dp4[n + 2][m + 2];
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) {
dp[i][j] = 0;
dp1[i][j] = 0;
dp2[i][j] = 0;
dp3[i][j] = 0;
dp4[i][j] = 0;
pref[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] == 1)
dp1[i][j] = min(min(dp1[i - 1][j] + 1, dp1[i][j - 1] + 1),
dp1[i - 1][j - 1] + 1);
for (int i = n; i > 0; i--)
for (int j = m; j > 0; j--)
if (a[i][j] == 1)
dp2[i][j] = min(min(dp2[i + 1][j] + 1, dp2[i][j + 1] + 1),
dp2[i + 1][j + 1] + 1);
for (int i = 1; i <= n; i++)
for (int j = m; j > 0; j--)
if (a[i][j] == 1)
dp3[i][j] = min(min(dp3[i - 1][j] + 1, dp3[i][j + 1] + 1),
dp3[i - 1][j + 1] + 1);
for (int i = n; i > 0; i--)
for (int j = 1; j <= m; j++)
if (a[i][j] == 1)
dp4[i][j] = min(min(dp4[i + 1][j] + 1, dp4[i][j - 1] + 1),
dp4[i + 1][j - 1] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
dp[i][j] = min(dp1[i][j], min(dp2[i][j], min(dp3[i][j], dp4[i][j])));
int l = 0, r = (min(n, m) - 1) / 2, mid;
while (l < r) {
mid = (l + r + 1) / 2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[i][j] > mid)
b[i][j] = 1;
else
b[i][j] = 0;
pref[i][j] = 0;
}
}
int o = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (b[i][j] == 1) pref[i][j] = 1;
pref[i][j] += pref[i][j - 1];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) pref[i][j] += pref[i - 1][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int k1 = 1, k2 = 1, k3 = 1, k4 = 1;
if (a[i][j] == 1)
if (pref[i][j] - pref[max(0, i - mid - 1)][j] -
pref[i][max(0, j - mid - 1)] +
pref[max(0, i - mid - 1)][max(0, j - mid - 1)] ==
0)
k1 = 0;
if (a[i][j] == 1)
if (pref[i][min(m, j + mid)] -
pref[max(0, i - mid - 1)][min(m, j + mid)] - pref[i][j - 1] +
pref[max(0, i - mid - 1)][j - 1] ==
0)
k2 = 0;
if (a[i][j] == 1)
if (pref[min(n, i + mid)][j] - pref[i - 1][j] -
pref[min(n, i + mid)][max(0, j - mid - 1)] +
pref[i - 1][max(0, j - mid - 1)] ==
0)
k3 = 0;
if (a[i][j] == 1)
if (pref[min(n, i + mid)][min(m, j + mid)] -
pref[i - 1][min(m, j + mid)] - pref[min(n, i + mid)][j - 1] +
pref[i - 1][j - 1] ==
0)
k4 = 0;
if (a[i][j] == 0)
if (pref[i][j] - pref[max(0, i - mid - 1)][j] -
pref[i][max(0, j - mid - 1)] +
pref[max(0, i - mid - 1)][max(0, j - mid - 1)] >
0)
o = 0;
if (a[i][j] == 0)
if (pref[i][min(m, j + mid)] -
pref[max(0, i - mid - 1)][min(m, j + mid)] - pref[i][j - 1] +
pref[max(0, i - mid - 1)][j - 1] >
0)
o = 0;
if (a[i][j] == 0)
if (pref[min(n, i + mid)][j] - pref[i - 1][j] -
pref[min(n, i + mid)][max(0, j - mid - 1)] +
pref[i - 1][max(0, j - mid - 1)] >
0)
o = 0;
if (a[i][j] == 0)
if (pref[min(n, i + mid)][min(m, j + mid)] -
pref[i - 1][min(m, j + mid)] - pref[min(n, i + mid)][j - 1] +
pref[i - 1][j - 1] >
0)
o = 0;
if (k1 + k2 + k3 + k4 == 0) o = 0;
}
if (o == 1)
l = mid;
else
r = mid - 1;
}
cout << l << "\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (dp[i][j] > l)
cout << 'X';
else
cout << '.';
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int pre[10000001];
int s[10000001];
int ans[10000001];
int tot[10000001];
int n, m;
int Find(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m) return -1;
return x * m + y;
}
int Query(int x, int y, int a[]) {
if (Find(x, y) == -1)
return 0;
else
return a[Find(x, y)];
}
bool Check(int x) {
x = x * 2 + 1;
memset(ans, 0, sizeof(ans));
memset(tot, 0, sizeof(tot));
for (int i = 0; x + i - 1 < n; i++)
for (int j = 0; x + j - 1 < m; j++) {
int now = Query(i + x - 1, j + x - 1, pre) + Query(i - 1, j - 1, pre) -
Query(i + x - 1, j - 1, pre) - Query(i - 1, j + x - 1, pre);
if (now == x * x) ans[Find(i, j)] = 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
tot[Find(i, j)] = ans[Find(i, j)] + Query(i - 1, j, tot) +
Query(i, j - 1, tot) - Query(i - 1, j - 1, tot);
for (int i = 0; i < n; i++)
for (int j = 0; j <= m; j++)
if (s[Find(i, j)]) {
int t = tot[Find(i, j)] - Query(i - x, j, tot) - Query(i, j - x, tot) +
Query(i - x, j - x, tot);
if (t == 0) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == 'X')
s[Find(i, j)] = 1;
else
s[Find(i, j)] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
pre[Find(i, j)] = Query(i - 1, j, pre) + Query(i, j - 1, pre) -
Query(i - 1, j - 1, pre) + s[Find(i, j)];
int an = 0, l = 0, r = min(n, m);
while (r >= l) {
int m = (l + r) / 2;
if (Check(m)) {
l = m + 1;
an = m;
} else
r = m - 1;
}
Check(an);
cout << an << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (i - an >= 0 && j - an >= 0 && ans[Find(i - an, j - an)])
cout << 'X';
else
cout << '.';
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 11;
char a[N];
int s[N];
int n, m;
int t[N];
int num(int l, int r) {
if (l < 1 || r < 1) return 0;
return (l - 1) * m + r;
}
int sum(int l1, int r1, int l2, int r2) {
l1 = max(l1, 1);
r1 = max(r1, 1);
return s[num(l2, r2)] - s[num(l1 - 1, r2)] - s[num(l2, r1 - 1)] +
s[num(l1 - 1, r1 - 1)];
}
int sum2(int l1, int r1, int l2, int r2) {
l1 = max(l1, 1);
r1 = max(r1, 1);
return t[num(l2, r2)] - t[num(l1 - 1, r2)] - t[num(l2, r1 - 1)] +
t[num(l1 - 1, r1 - 1)];
}
bool good(int l1, int r1, int l2, int r2) {
if (l1 < 1 || r1 < 1 || l2 > n || r2 > m) return false;
int c = sum(l1, r1, l2, r2);
if (c == (l2 - l1 + 1) * (r2 - r1 + 1)) return true;
return false;
}
bool good(int x) {
x *= 2;
x++;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int c = 0;
if (good(i, j, i + x - 1, j + x - 1)) c = 1;
t[num(i, j)] =
t[num(i - 1, j)] + t[num(i, j - 1)] - t[num(i - 1, j - 1)] + c;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[num(i, j)] == 1) {
if (sum2(i - x + 1, j - x + 1, i, j) == 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == 'X') a[num(i, j)] = 1;
s[num(i, j)] = s[num(i - 1, j)] + s[num(i, j - 1)] -
s[num(i - 1, j - 1)] + a[num(i, j)];
}
int l = 0, r = min(n, m);
while (r - l > 1) {
int mid = (l + r) / 2;
if (good(mid))
l = mid;
else
r = mid;
}
int x = 0;
if (good(r))
x = r;
else
x = l;
cout << x << "\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (good(i - x, j - x, i + x, j + x))
cout << "X";
else
cout << ".";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<string> a;
vector<vector<long long>> pr;
vector<pair<long long, long long>> nxt{{1, 0}, {1, 1}, {1, -1}, {-1, 0},
{-1, 1}, {-1, -1}, {0, -1}, {0, 1}};
bool check(long long time) {
queue<pair<long long, long long>> q;
vector<vector<long long>> mn(n, vector<long long>(m, 1e9));
long long k = (time + time + 1);
k = k * k;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (i - time < 0 || j - time < 0 || i + time >= n || j + time >= m)
continue;
if (pr[i + time + 1][j + time + 1] + pr[i - time][j - time] -
pr[i + time + 1][j - time] - pr[i - time][j + time + 1] !=
k)
continue;
else {
q.push({i, j});
mn[i][j] = 0;
}
}
}
while (!q.empty()) {
auto first = q.front();
q.pop();
for (auto j : nxt) {
if (first.first + j.first >= n || first.first + j.first < 0 ||
first.second + j.second >= m || first.second + j.second < 0)
continue;
if (mn[first.first + j.first][first.second + j.second] != 1e9) continue;
mn[first.first + j.first][first.second + j.second] =
mn[first.first][first.second] + 1;
q.push({first.first + j.first, first.second + j.second});
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if ((a[i][j] == '.' && mn[i][j] <= time) ||
(a[i][j] == 'X' && mn[i][j] > time))
return false;
}
}
return true;
}
int32_t main() {
cin.tie(NULL);
cout.tie(NULL);
ios::sync_with_stdio(false);
cin >> n >> m;
a.resize(n);
for (long long i = 0; i < n; i++) cin >> a[i];
pr.resize(n + 1, vector<long long>(m + 1, 0));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
pr[i + 1][j + 1] =
pr[i + 1][j] + pr[i][j + 1] - pr[i][j] + (a[i][j] == 'X' ? 1 : 0);
}
}
long long l = 0, r = min(n, m) + 1, mid;
while (r - l > 1) {
mid = (r + l) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
long long time = l;
cout << time << '\n';
long long k = (time + time + 1);
k = k * k;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (i - time < 0 || j - time < 0 || i + time >= n || j + time >= m) {
cout << '.';
continue;
}
if (pr[i + time + 1][j + time + 1] + pr[i - time][j - time] -
pr[i + time + 1][j - time] - pr[i - time][j + time + 1] !=
k)
cout << '.';
else
cout << 'X';
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vll = vector<long long>;
using vpi = vector<pair<int, int>>;
using pii = pair<int, int>;
const char nl = '\n';
string to_string(char c) { return string(1, c); }
string to_string(const char* s) { return (string)s; }
string to_string(string s) { return s; }
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(vector<bool> v) {
string res = "{";
for (int i = 0; i < ((int)v.size()); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = 0; i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class A, class B>
string to_string(pair<A, B> p);
template <class T>
string to_string(T& v) {
bool fst = 1;
string res = "{";
for (const auto& x : v) {
if (!fst) res += ", ";
fst = 0;
res += to_string(x);
}
res += "}";
return res;
}
template <class A, class B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<string> mp(n);
for (int i = 0; i < n; i++) {
cin >> mp[i];
}
vector<vector<int>> pre(n + 1, vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
pre[i + 1][j + 1] =
pre[i + 1][j] + pre[i][j + 1] - pre[i][j] + (mp[i][j] == 'X');
}
}
auto query = [&](int r0, int c0, int r1, int c1) -> int {
if (r0 > r1) swap(r0, r1);
if (c0 > c1) swap(c0, c1);
return pre[r1][c1] - pre[r1][c0 - 1] - pre[r0 - 1][c1] +
pre[r0 - 1][c0 - 1];
};
auto ok = [&](int T) -> bool {
vector<vector<int>> dist(n, vector<int>(m, 2e9));
queue<array<int, 2>> q;
for (int i = 0; i < n - T + 1; i++) {
for (int j = 0; j < m - T + 1; j++) {
int count = query(i + 1, j + 1, i + T, j + T);
if (count == T * T) {
dist[i + (T - 1) / 2][j + (T - 1) / 2] = 0;
q.push({i + (T - 1) / 2, j + (T - 1) / 2});
}
}
}
const int D[8][2] = {{1, 0}, {0, -1}, {-1, 0}, {0, 1},
{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};
while (!q.empty()) {
auto [i, j] = q.front();
q.pop();
for (int k = 0; k < 8; k++) {
int u = i + D[k][0];
int v = j + D[k][1];
if (u >= 0 && u < n && v >= 0 && v < m && dist[i][j] + 1 < dist[u][v]) {
dist[u][v] = dist[i][j] + 1;
q.push({u, v});
}
}
}
for (int i = 0; i < n; i++) {
0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
bool has = dist[i][j] <= (T - 1) / 2;
if ((!has && mp[i][j] == 'X') || (has && mp[i][j] == '.')) {
return false;
}
}
}
return true;
};
int low = 0, high = min(n, m) / 2;
while (low < high) {
int mid = low + (high - low + 1) / 2;
bool res = ok(2 * mid + 1);
0;
if (res) {
low = mid;
} else {
high = mid - 1;
}
}
int T = low * 2 + 1;
cout << ((T - 1) / 2) << nl;
vector<string> source(n, string(m, '.'));
for (int i = 0; i < n - T + 1; i++) {
for (int j = 0; j < m - T + 1; j++) {
int count = query(i + 1, j + 1, i + T, j + T);
if (count == T * T) {
source[i + (T - 1) / 2][j + (T - 1) / 2] = 'X';
}
}
}
for (int i = 0; i < n; i++) {
cout << source[i] << nl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
const int N = 2005;
int n, m;
vector<vector<char>> a;
vector<vector<int>> c, u;
bool check2(int i, int j, int i1, int j2) {
if (i < 1 || j < 1 || i1 < 1 || j2 < 1) return 0;
if (i > n || j > m || i1 > n || j2 > m) return 0;
return c[i1][j2] - c[i - 1][j2] - c[i1][j - 1] + c[i - 1][j - 1] ==
(i1 - i + 1) * (j2 - j + 1);
}
bool check(int vl) {
for (int i = 0; i < n + 2; ++i) {
for (int j = 0; j < m + 2; ++j) {
u[i][j] = 0;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'X' && check2(i - vl, j - vl, i + vl, j + vl)) {
++u[i - vl][j - vl];
--u[i - vl][j + vl + 1];
--u[i + vl + 1][j - vl];
++u[i + vl + 1][j + vl + 1];
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
u[i][j] += u[i - 1][j] + u[i][j - 1] - u[i - 1][j - 1];
if (a[i][j] == 'X' && u[i][j] == 0) {
return 0;
}
if (a[i][j] == '.' && u[i][j] != 0) {
abort();
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
a.resize(n + 2, vector<char>(m + 2, 0));
c.resize(n + 2, vector<int>(m + 2, 0));
u.resize(n + 2, vector<int>(m + 2, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
c[i][j] = c[i - 1][j] + c[i][j - 1] - c[i - 1][j - 1] + (a[i][j] == 'X');
}
}
int l = 0, r = max(n, m), mid;
while (r - l > 1) {
mid = (l + r) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << '\n';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'X' && check2(i - l, j - l, i + l, j + l)) {
cout << 'X';
} else {
cout << '.';
}
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace star {
const int maxn = 1e6 + 5;
int n, m;
vector<int> sum[maxn], tot[maxn];
vector<bool> ans[maxn];
char ch[maxn];
bool check(int x) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
tot[i][j] = 0;
}
}
for (int i = x + 1; i <= n - x; i++) {
for (int j = x + 1; j <= m - x; j++) {
if (sum[i + x][j + x] - sum[i - x - 1][j + x] - sum[i + x][j - x - 1] +
sum[i - x - 1][j - x - 1] ==
(2 * x + 1) * (2 * x + 1)) {
tot[i + x + 1][j + x + 1] += 1;
tot[i - x][j + x + 1] += -1;
tot[i + x + 1][j - x] += -1;
tot[i - x][j - x] += 1;
}
}
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (tot[i][j] += tot[i - 1][j] + tot[i][j - 1] - tot[i - 1][j - 1]) {
cnt++;
}
}
}
return cnt == sum[n][m];
}
void work() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= m + 1; j++) {
sum[i].push_back(0);
tot[i].push_back(0);
ans[i].push_back(false);
}
}
char c = getchar();
for (int i = 1; i <= n; i++) {
while (c != '.' and c != 'X') c = getchar();
for (int j = 1; j <= m; j++)
sum[i][j] =
(c == 'X') + sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1],
c = getchar();
}
int mid, l = 0, r = (min(n, m) - 1) / 2, res;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
res = mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", res);
for (int i = res + 1; i <= n - res; i++) {
for (int j = res + 1; j <= m - res; j++) {
if (sum[i + res][j + res] - sum[i - res - 1][j + res] -
sum[i + res][j - res - 1] + sum[i - res - 1][j - res - 1] ==
(2 * res + 1) * (2 * res + 1)) {
ans[i][j] = true;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
putchar((ans[i][j] ? 'X' : '.'));
}
puts(" ");
}
}
} // namespace star
int main() {
star::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 239;
vector<int> dx = {0, 0, 1, -1, 1, 1, -1, -1};
vector<int> dy = {-1, 1, 0, 0, 1, -1, 1, -1};
int n, m;
vector<vector<int>> a;
vector<vector<int>> ps;
vector<vector<int>> cand;
vector<vector<int>> d;
int gt(int i, int j) {
if (i == -1 || j == -1) {
return 0;
} else {
return ps[i][j];
}
}
void init() {
ps.resize(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ps[i][j] = a[i][j] + gt(i, j - 1) + gt(i - 1, j) - gt(i - 1, j - 1);
}
}
}
int sm(int i, int j, int m) {
return gt(i + m - 1, j + m - 1) - gt(i - 1, j + m - 1) -
gt(i + m - 1, j - 1) + gt(i - 1, j - 1);
}
bool bfs(int x) {
queue<pair<int, int>> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (cand[i][j]) {
d[i][j] = 0;
q.push({i, j});
}
}
}
while (!q.empty()) {
int i, j;
tie(i, j) = q.front();
q.pop();
for (int k = 0; k < 8; k++) {
int ni = i + dx[k];
int nj = j + dy[k];
if (ni >= 0 && ni < n && nj >= 0 && nj < m && d[ni][nj] > d[i][j] + 1) {
d[ni][nj] = d[i][j] + 1;
q.push({ni, nj});
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] && d[i][j] > x) {
return false;
}
}
}
return true;
}
bool can(int x) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cand[i][j] = 0;
d[i][j] = INF;
}
}
int len = 2 * x + 1;
for (int i = 0; i + len <= n; i++) {
for (int j = 0; j + len <= m; j++) {
if (sm(i, j, len) == len * len) {
cand[i + len / 2][j + len / 2] = 1;
}
}
}
return bfs(x);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
a.resize(n, vector<int>(m));
cand.resize(n, vector<int>(m, 0));
d.resize(n, vector<int>(m, INF));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[i][j] = (c == 'X');
}
}
init();
int l = 0;
int r = 507;
while (r - l > 1) {
int x = (r + l) >> 1;
if (can(x)) {
l = x;
} else {
r = x;
}
}
assert(can(l));
cout << l << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (cand[i][j])
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
int fx[4] = {0, 1, 0, -1};
int fy[4] = {1, 0, -1, 0};
const long long M = 2e5 + 10, M2 = 1e6 + 10, oo = 1e9 + 7;
const long long MC = (1 << 22) + 5;
vector<string> vs, setfire;
int n, m;
void getpre(int id, vector<vector<int> > &pre) {
pre = vector<vector<int> >(n + 2, vector<int>(m + 2, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (id == 0 && vs[i][j] == 'X') pre[i][j]++;
if (id == 1 && setfire[i][j] == 'X') pre[i][j]++;
if (i > 0) pre[i][j] += pre[i - 1][j];
if (j > 0) pre[i][j] += pre[i][j - 1];
if (i > 0 && j > 0) pre[i][j] -= pre[i - 1][j - 1];
}
}
}
int getsum(int lx, int ly, int rx, int ry, vector<vector<int> > &pre) {
if (lx < 0 || lx >= n || ly < 0 || ly >= m || rx < 0 || rx >= n || ry < 0 ||
ry >= m)
return 0;
int ret = pre[rx][ry];
if (lx > 0) ret -= pre[lx - 1][ry];
if (ly > 0) ret -= pre[rx][ly - 1];
if (lx > 0 && ly > 0) ret += pre[lx - 1][ly - 1];
return ret;
}
int iscenter(int x, int y, int t, vector<vector<int> > &pre) {
int lx = x - t, ly = y - t, rx = x + t, ry = y + t;
if (getsum(lx, ly, rx, ry, pre) == (2 * t + 1) * (2 * t + 1)) return 1;
return 0;
}
int iscell(int x, int y, int t, vector<vector<int> > &cenpre) {
if (vs[x][y] == '.') return 1;
int lx = max(0, x - t), ly = max(0, y - t), rx = min(n - 1, x + t),
ry = min(m - 1, y + t);
int ret = getsum(lx, ly, rx, ry, cenpre);
return (ret > 0);
}
void precomp() {}
void solve() {
cin >> n >> m;
vector<vector<int> > pre, cenpre;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
vs.push_back(s);
}
getpre(0, pre);
setfire = vector<string>(n + 2, string(m + 2, '.'));
auto can = [&](int tm) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (iscenter(i, j, tm, pre)) {
setfire[i][j] = 'X';
} else
setfire[i][j] = '.';
}
}
getpre(1, cenpre);
int ret = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ret &= (iscell(i, j, tm, cenpre));
}
}
return ret;
};
int lo = 0, hi = min(n, m);
while (lo < hi) {
int mid = (lo + hi) / 2;
if (can(mid))
lo = mid + 1;
else
hi = mid;
}
cout << lo - 1 << '\n';
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (iscenter(i, j, lo - 1, pre))
cout << "X";
else
cout << ".";
}
cout << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
precomp();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000005;
char p[maxn];
int a[maxn], b[maxn], c[maxn];
int n, m;
int ad(int i, int j) { return (i - 1) * m + j; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", p + ad(i, 1));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (p[ad(i, j)] == '.')
a[ad(i, j)] = 0;
else if (i == 1 || j == 1)
a[ad(i, j)] = 1;
else
a[ad(i, j)] =
min(a[ad(i - 1, j - 1)], min(a[ad(i - 1, j)], a[ad(i, j - 1)])) + 1;
}
int l = 0, r = 1000000;
int mid, x;
while (r > l + 1) {
mid = (l + r) >> 1;
x = 2 * mid + 1;
bool flag = true;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[ad(i, j)] >= x)
c[ad(i, j)] = x;
else
c[ad(i, j)] = 0;
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--) {
if (i > 1) c[ad(i - 1, j)] = max(c[ad(i - 1, j)], c[ad(i, j)] - 1);
if (j > 1) c[ad(i, j - 1)] = max(c[ad(i, j - 1)], c[ad(i, j)] - 1);
if (i > 1 && j > 1)
c[ad(i - 1, j - 1)] = max(c[ad(i - 1, j - 1)], c[ad(i, j)] - 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[ad(i, j)] == 0) continue;
if (c[ad(i, j)] == 0) flag = false;
}
if (flag)
l = mid;
else
r = mid;
}
printf("%d\n", l);
x = 2 * l + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) b[ad(i, j)] = '.';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[ad(i, j)] >= x) b[ad(i - l, j - l)] = 'X';
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", b[ad(i, j)]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long N = 1234567891, M = 31;
long long n, m, t, k, f, mi = 2e9, x, y, z, ma, x3, x2, y2, l, r, i, j, ans, vv;
char c[1010000];
string s;
vector<long long> v, v2, v3;
vector<long long> a[1100000], b[1100000], d, d2, dp[1100000];
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%s", c);
s = c;
a[i].push_back(0);
for (j = 1; j <= m; j++) {
a[i].push_back((s[j - 1] == 'X'));
}
}
for (i = 0; i <= n + 1; i++)
for (j = 0; j <= m + 1; j++) {
b[i].push_back(0);
dp[i].push_back(0);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
b[i][j] = a[i][j] + b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];
}
}
long long l = 0, r = min((n - 1) / 2, (m - 1) / 2) + 1;
while (r - l > 1) {
int t2 = (l + r) / 2;
int t = t2 * 2 + 1;
for (i = 0; i <= n + 1; i++) {
for (j = 0; j <= m + 1; j++) {
dp[i][j] = 0;
}
}
for (i = t; i <= n; i++) {
for (j = t; j <= m; j++) {
if (b[i][j] - b[i - t][j] - b[i][j - t] + b[i - t][j - t] == t * t) {
dp[i - t + 1][j - t + 1]++;
dp[i - t + 1][j + 1]--;
dp[i + 1][j - t + 1]--;
dp[i + 1][j + 1]++;
}
}
}
f = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
dp[i][j] = dp[i][j] + dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1];
if (dp[i][j] && !a[i][j]) f = 1;
if (!dp[i][j] && a[i][j]) f = 1;
}
}
if (!f)
l = t2;
else
r = t2;
}
cout << l << endl;
t = l * 2 + 1;
for (i = 0; i <= n + 1; i++) {
for (j = 0; j <= m + 1; j++) {
dp[i][j] = 0;
}
}
for (i = t; i <= n; i++) {
for (j = t; j <= m; j++) {
if (b[i][j] - b[i - t][j] - b[i][j - t] + b[i - t][j - t] == t * t) {
dp[i - l][j - l] = 1;
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (dp[i][j])
printf("X");
else
printf(".");
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline const T read1() {
T m = 0;
char k = getchar();
while (('0' > k || k > '9') && (k != '-')) k = getchar();
const bool f = (k == '-' ? 1 : 0);
if (f) k = getchar();
while ('0' <= k && k <= '9')
m = (m << 3) + (m << 1) + (k ^ 48), k = getchar();
return f ? -m : m;
}
int s, m, **a, t;
char **str;
bool **vis, **h;
queue<pair<int, int> > q;
bool judge(int n) {
while (!q.empty()) q.pop();
int len = n << 1 | 1, op = 0;
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= m; ++j) vis[i][j] = h[i][j];
for (int i = 1; i <= s - len + 1; ++i)
for (int j = 1; j <= m - len + 1; ++j)
if (!(a[i + len - 1][j + len - 1] - a[i - 1][j + len - 1] -
a[i + len - 1][j - 1] + a[i - 1][j - 1]))
q.push(make_pair(i + n, j + n)), ++op, vis[i + n][j + n] = 1;
for (int i = 1; i <= n; ++i) {
int k = q.size();
while (k--) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int tx = -1; tx <= 1; ++tx)
for (int ty = -1; ty <= 1; ++ty)
if (x + tx && x + tx <= s && y + ty && y + ty <= m &&
!vis[x + tx][y + ty]) {
vis[x + tx][y + ty] = 1;
q.push(make_pair(x + tx, y + ty));
++op;
}
}
}
return op == t;
}
int main() {
s = read1<int>(), m = read1<int>();
str = new char *[s + 5];
a = new int *[s + 5];
vis = new bool *[s + 5];
h = new bool *[s + 5];
a[0] = new int[m + 5]();
vis[0] = new bool[m + 5]();
h[0] = new bool[m + 5]();
for (int i = 1; i <= s; ++i) {
str[i] = new char[m + 5];
vis[i] = new bool[m + 5]();
h[i] = new bool[m + 5]();
a[i] = new int[m + 5]();
scanf("%s", str[i] + 1);
for (int j = 1; j <= m; ++j)
a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1] +
(h[i][j] = str[i][j] == '.'),
t += str[i][j] == 'X';
}
int l = 1, r = min(s, m) - 1 >> 1, ans = 0, mid;
while (l <= r) judge(mid = l + r >> 1) ? ans = mid, l = mid + 1 : r = mid - 1;
printf("%d\n", ans);
for (int i = 1; i <= s; ++i)
for (int j = 1; j <= m; ++j) vis[i][j] = 0;
int len = ans << 1 | 1;
for (int i = 1; i <= s - len + 1; ++i)
for (int j = 1; j <= m - len + 1; ++j)
if (!(a[i + len - 1][j + len - 1] - a[i - 1][j + len - 1] -
a[i + len - 1][j - 1] + a[i - 1][j - 1]))
vis[i + ans][j + ans] = 1;
for (int i = 1; i <= s; ++i, putchar('\n'))
for (int j = 1; j <= m; ++j) putchar(vis[i][j] ? 'X' : '.');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int>> ans;
bool check(int d, vector<vector<int>> a, string *s) {
int ps[n + 2][m + 2];
ans.clear();
memset(ps, 0, sizeof ps);
for (int i = 1; i + d <= n + 1; i++)
for (int j = 1; j + d <= m + 1; j++)
if (a[i][j] - a[i + d][j] - a[i][j + d] + a[i + d][j + d] == d * d) {
ans.push_back({i + d / 2, j + d / 2});
ps[i][j]++;
ps[i][j + d]--;
ps[i + d][j]--;
ps[i + d][j + d]++;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
ps[i][j] += ps[i][j - 1] + ps[i - 1][j] - ps[i - 1][j - 1];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (ps[i + 1][j + 1] == 0 && s[i][j] == 'X') return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
vector<vector<int>> a(n + 2, vector<int>(m + 2, 0));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) a[i + 1][j + 1] = s[i][j] == 'X';
for (int i = n; i > 0; i--)
for (int j = m; j > 0; j--)
a[i][j] += a[i][j + 1] + a[i + 1][j] - a[i + 1][j + 1];
int l = 0, r = 500;
while (r - l > 1) {
int mid = l + r >> 1;
check(mid * 2 + 1, a, s) ? l = mid : r = mid;
}
cout << l << endl;
check(l * 2 + 1, a, s);
bool c[n][m];
memset(c, 0, sizeof c);
for (auto [x, y] : ans) c[x - 1][y - 1] = 1;
for (int i = 0; i < n; i++, cout << '\n')
for (int j = 0; j < m; j++) cout << (c[i][j] ? 'X' : '.');
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
long long n, m, ans, cnt, tot;
vector<vector<char> > ch(N), out(N);
vector<vector<long long> > sum(N);
bool check(long long mid) {
long long cnt[n + 2][m + 2];
memset(cnt, 0, sizeof(cnt));
for (long long i = 2 * mid + 1; i <= n; i++) {
for (long long j = 2 * mid + 1; j <= m; j++) {
if (ch[i][j] == 'X' &&
(sum[i][j] + sum[i - 2 * mid - 1][j - 2 * mid - 1] -
sum[i][j - 2 * mid - 1] - sum[i - 2 * mid - 1][j]) ==
(2 * mid + 1) * (2 * mid + 1))
cnt[i + 1][j + 1]++, cnt[i - 2 * mid][j - 2 * mid]++,
cnt[i + 1][j - 2 * mid]--, cnt[i - 2 * mid][j + 1]--;
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cnt[i][j] = cnt[i - 1][j] + cnt[i][j - 1] - cnt[i - 1][j - 1] + cnt[i][j];
if ((cnt[i][j] > 0 && ch[i][j] == '.') ||
(cnt[i][j] <= 0 && ch[i][j] == 'X'))
return 0;
}
}
return 1;
}
void solve() {
cin >> n >> m;
for (long long i = 0; i <= n + 1; i++) {
ch[i].resize(m + 2);
out[i].resize(m + 2);
sum[i].resize(m + 2);
for (long long j = 1; j <= m && i <= n && i; j++)
out[i][j] = '.', cin >> ch[i][j];
}
for (long long j = 1; j <= m; j++) {
cnt = 0;
for (long long i = 1; i <= n; i++) {
if (ch[i][j] == 'X') cnt++;
sum[i][j] = sum[i][j - 1] + cnt;
}
}
long long s = 1, e = min(n / 2, m / 2);
while (s <= e) {
long long mid = (s + e) / 2;
if (check(mid)) {
s = mid + 1;
ans = mid;
} else
e = mid - 1;
}
cout << ans << '\n';
cnt = (2 * ans + 1) * (2 * ans + 1);
for (long long i = 2 * ans + 1; i <= n; i++) {
for (long long j = 2 * ans + 1; j <= m; j++) {
if (ch[i][j] == 'X' &&
(sum[i][j] + sum[i - 2 * ans - 1][j - 2 * ans - 1] -
sum[i][j - 2 * ans - 1] - sum[i - 2 * ans - 1][j]) == cnt)
out[i - ans][j - ans] = 'X';
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cout << out[i][j];
}
cout << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
clock_t start, end;
start = clock();
cout << fixed << setprecision(8);
while (t--) {
solve();
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<char> > a;
vector<vector<int> > pref, val, dp;
int n, m;
inline int get_sum(int lx, int ly, int rx, int ry) {
if (lx <= 0 || ly <= 0 || rx > n || ry > m) return 0;
return (pref[rx][ry] - pref[rx][ly - 1] - pref[lx - 1][ry] +
pref[lx - 1][ly - 1]) == (rx - lx + 1) * (ry - ly + 1);
}
inline void add(int lx, int ly, int rx, int ry) {
val[lx][ly]++;
val[lx][ry + 1]--;
val[rx + 1][ly]--;
val[rx + 1][ry + 1]++;
}
inline int oks(int x) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) val[i][j] = 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (get_sum(i - x, j - x, i + x, j + x)) {
add(i - x, j - x, i + x, j + x);
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + val[i][j];
assert(dp[i][j] >= 0);
if (a[i][j] == 'X' && dp[i][j] == 0) return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i <= n + 1; ++i) {
a.emplace_back();
pref.emplace_back();
val.emplace_back();
dp.emplace_back();
for (int j = 0; j <= m + 1; ++j) {
a.back().push_back('a');
pref.back().push_back(0);
val.back().push_back(0);
dp.back().push_back(0);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) cin >> a[i][j];
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
pref[i][j] = pref[i - 1][j] + pref[i][j - 1] - pref[i - 1][j - 1];
if (a[i][j] == 'X') pref[i][j]++;
}
}
int lef = -1, righ = max(n, m) + 1;
while (righ - lef > 1) {
int mid = (righ + lef) / 2;
if (oks(mid))
lef = mid;
else
righ = mid;
}
cout << lef << '\n';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (get_sum(i - lef, j - lef, i + lef, j + lef))
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int total_num = 0;
int* pool;
int** grid;
int* prefix_sum_pool;
int** prefix_sum;
int* prefix2_pool;
int** prefix2;
int get_sum(int minR, int minC, int maxR, int maxC) {
return prefix_sum[maxR][maxC] - (minR == 0 ? 0 : prefix_sum[minR - 1][maxC]) -
(minC == 0 ? 0 : prefix_sum[maxR][minC - 1]) +
(minR == 0 || minC == 0 ? 0 : prefix_sum[minR - 1][minC - 1]);
}
bool works(int time) {
int len = 2 * time + 1;
for (int i = 0; i < n * m; i++) {
prefix2_pool[i] = 0;
}
prefix_sum[0][0] = grid[0][0];
for (int i = 1; i < m; i++) {
prefix_sum[0][i] = prefix_sum[0][i - 1] + grid[0][i];
}
for (int i = 1; i < n; i++) {
prefix_sum[i][0] = prefix_sum[i - 1][0] + grid[i][0];
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
prefix_sum[i][j] = prefix_sum[i - 1][j] + prefix_sum[i][j - 1] -
prefix_sum[i - 1][j - 1] + grid[i][j];
}
}
vector<pair<int, int>> centers;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int minR = i - time;
int minC = j - time;
int maxR = i + time;
int maxC = j + time;
if (minR < 0 || minC < 0 || maxR >= n || maxC >= m) continue;
int sum = get_sum(minR, minC, maxR, maxC);
if (sum == len * len) {
centers.push_back({i, j});
for (int i = minR; i <= maxR; i++) {
prefix2[i][minC] += 1;
if (maxC + 1 < m) prefix2[i][maxC + 1] -= 1;
}
}
}
}
int count = 0;
for (int i = 0; i < n; i++) {
int running_sum = 0;
for (int j = 0; j < m; j++) {
running_sum += prefix2[i][j];
if (running_sum > 0) count++;
}
}
return count == total_num;
}
void gen_config(int time) {
bool* thing = new bool[n * m];
bool** thing2 = new bool*[n];
for (int i = 0; i < n; i++) {
thing2[i] = thing + i * m;
}
for (int i = 0; i < n * m; i++) {
thing[i] = false;
}
int len = 2 * time + 1;
for (int i = 0; i < n * m; i++) {
prefix2_pool[i] = 0;
}
prefix_sum[0][0] = grid[0][0];
for (int i = 1; i < m; i++) {
prefix_sum[0][i] = prefix_sum[0][i - 1] + grid[0][i];
}
for (int i = 1; i < n; i++) {
prefix_sum[i][0] = prefix_sum[i - 1][0] + grid[i][0];
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
prefix_sum[i][j] = prefix_sum[i - 1][j] + prefix_sum[i][j - 1] -
prefix_sum[i - 1][j - 1] + grid[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int minR = i - time;
int minC = j - time;
int maxR = i + time;
int maxC = j + time;
if (minR < 0 || minC < 0 || maxR >= n || maxC >= m) continue;
int sum = get_sum(minR, minC, maxR, maxC);
if (sum == len * len) {
thing2[i][j] = true;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << (thing2[i][j] ? 'X' : '.');
}
cout << '\n';
}
delete[] thing;
delete[] thing2;
}
int main() {
cin >> n >> m;
pool = new int[n * m];
prefix_sum_pool = new int[n * m];
prefix2_pool = new int[n * m];
for (int i = 0; i < n * m; i++) {
pool[i] = 0;
prefix_sum_pool[i] = 0;
prefix2_pool[i] = 0;
}
grid = new int*[n];
prefix_sum = new int*[n];
prefix2 = new int*[n];
for (int i = 0; i < n; i++) {
grid[i] = pool + i * m;
prefix_sum[i] = prefix_sum_pool + i * m;
prefix2[i] = prefix2_pool + i * m;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c = 0;
cin >> c;
grid[i][j] = c == 'X';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
total_num += grid[i][j];
}
}
int low = 0;
int high = min(n / 2, m / 2) + 1;
int last_worked = 0;
while (low < high) {
int mid = (low + high) / 2;
if (works(mid)) {
last_worked = mid;
low = mid + 1;
} else {
high = mid;
}
}
cout << last_worked << endl;
gen_config(last_worked);
delete[] pool;
delete[] grid;
delete[] prefix_sum;
delete[] prefix_sum_pool;
delete[] prefix2_pool;
delete[] prefix2;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DX[] = {-1, -1, 0, +1, +1, +1, 0, -1};
const int DY[] = {0, +1, +1, +1, 0, -1, -1, -1};
const int INF = 1e9;
int n, m;
vector<vector<bool> > f;
vector<pair<int, int> > fired;
vector<vector<int> > pref;
vector<pair<int, int> > ans;
int get_sum(int x1, int y1, int x2, int y2) {
return pref[x2][y2] + pref[x1 - 1][y1 - 1] - pref[x1 - 1][y2] -
pref[x2][y1 - 1];
}
bool check(int i, int j, int mid) {
int x1 = i - mid;
int y1 = j - mid;
int x2 = i + mid;
int y2 = j + mid;
return x1 >= 0 && x1 < n && y1 >= 0 && y1 < m && x2 >= 0 && x2 < n &&
y2 >= 0 && y2 < m &&
(get_sum(x1 + 1, y1 + 1, x2 + 1, y2 + 1) ==
(x2 - x1 + 1) * (y2 - y1 + 1));
}
bool ch(int mid) {
queue<pair<int, int> > q;
vector<pair<int, int> > lists;
vector<vector<int> > d(n, vector<int>(m, INF));
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
if (check(i, j, mid)) {
q.push({i, j});
lists.push_back({i, j});
d[i][j] = 0;
}
}
}
while (!q.empty()) {
int x, y;
tie(x, y) = q.front();
q.pop();
for (int i = 0; i < 8; i++) {
int v = x + DX[i];
int u = y + DY[i];
if (v >= 0 && v < n && u >= 0 && u < m) {
if (d[x][y] + 1 < d[v][u]) {
d[v][u] = d[x][y] + 1;
q.push({v, u});
}
}
}
}
for (auto elem : fired) {
if (d[elem.first][elem.second] > mid) {
return false;
}
}
ans = lists;
return true;
}
void precalc() {
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
pref[i + 1][j + 1] =
pref[i + 1][j] + pref[i][j + 1] - pref[i][j] + f[i][j];
}
}
}
void solve() {
precalc();
int l = -1;
int r = min(n, m) + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (ch(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << "\n";
vector<vector<int> > answer(n, vector<int>(m, 0));
for (auto elem : ans) {
answer[elem.first][elem.second] = 1;
}
for (auto& elem : answer) {
for (auto& elem2 : elem) {
if (elem2) {
cout << 'X';
} else {
cout << '.';
}
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m;
f.resize(n, vector<bool>(m, false));
pref.resize(n + 1, vector<int>(m + 1, 0));
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
char tmp;
cin >> tmp;
if (tmp == 'X') {
f[i][j] = 1;
fired.push_back({i, j});
}
}
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e6 + 100;
ll n;
ll m;
ll **arr() {
ll **res = new ll *[n + 2];
for (ll i = 0; i < n + 2; ++i) {
res[i] = new ll[m + 2];
fill_n(res[i], m + 2, 0);
}
return res;
}
ll **inp;
ll **ans;
void pref(ll **a) {
for (ll i = 1; i <= n + 1; ++i) {
for (ll j = 1; j <= m + 1; ++j) {
a[i][j] += a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
}
}
}
ll sum(ll **a, ll il, ll ir, ll jl, ll jr) {
il = max(il, 1ll);
ir = min(ir, n);
jl = max(jl, 1ll);
jr = min(jr, m);
--il;
--jl;
return a[ir][jr] - a[ir][jl] - a[il][jr] + a[il][jl];
}
ll sq(ll first) { return first * first; }
bool check(ll t) {
for (ll i = 1; i <= n; ++i) {
for (ll j = 1; j <= m; ++j) {
ans[i][j] = sum(inp, i - t, i + t, j - t, j + t) == sq(2 * t + 1);
}
}
pref(ans);
for (ll i = 1; i <= n; ++i) {
for (ll j = 1; j <= m; ++j) {
if (sum(inp, i, i, j, j) && sum(ans, i - t, i + t, j - t, j + t) == 0) {
return false;
}
}
}
return true;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
inp = arr();
ans = arr();
for (ll i = 1; i <= n; ++i) {
string s;
cin >> s;
for (ll j = 1; j <= m; ++j) {
inp[i][j] = s[j - 1] == 'X';
}
}
pref(inp);
ll lef = 0, rig = N;
while (rig - lef > 1) {
ll mid = (lef + rig) / 2;
if (check(mid)) {
lef = mid;
} else {
rig = mid;
}
}
assert(check(lef));
cout << lef << "\n";
for (ll i = 1; i <= n; ++i) {
for (ll j = 1; j <= m; ++j) {
cout << ".X"[sum(ans, i, i, j, j)];
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dir[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {1, 0},
{1, -1}, {1, 1}, {0, 1}, {0, -1}};
int n, m;
vector<vector<int> > grid, dist, visited;
string s[1000010];
bool check(int x, int y) {
if (x >= 1 && y >= 1 && x <= n && y <= m && s[x][y] == 'X') return true;
return false;
}
int getsumi(int i, int j, int a, int b) {
return grid[a][b] - grid[i - 1][b] - grid[a][j - 1] + grid[i - 1][j - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
int tot = 0;
for (int i = 1; i <= n; i++) {
cin >> s[i];
s[i] = "?" + s[i];
}
vector<int> temp(m + 1);
for (int i = 0; i <= n; i++) {
grid.push_back(temp);
visited.push_back(temp);
dist.push_back(temp);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
grid[i][j] += grid[i][j - 1] + grid[i - 1][j] - grid[i - 1][j - 1];
if (s[i][j] == 'X') {
tot++;
grid[i][j] += 1;
}
}
}
int low = 1, high = min(n, m);
while (low < high) {
int mid = (low + high) / 2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) visited[i][j] = 0, dist[i][j] = 0;
vector<pair<int, int> > sources;
for (int i = 1; i + 2 * mid <= n; i++) {
for (int j = 1; j + 2 * mid <= m; j++) {
if (getsumi(i, j, i + 2 * mid, j + 2 * mid) ==
1LL * (2 * mid + 1) * (2 * mid + 1)) {
sources.push_back(make_pair(i + mid, j + mid));
}
}
}
queue<pair<int, int> > pq;
for (auto val : sources) {
pq.push(val);
visited[val.first][val.second] = 1;
}
int ans = 0;
while (pq.size()) {
pair<int, int> ft = pq.front();
ans++;
pq.pop();
int x = ft.first;
int y = ft.second;
if (dist[x][y] == mid) continue;
for (int i = 0; i < 8; i++) {
int p = x + dir[i][0];
int q = y + dir[i][1];
if (check(p, q)) {
if (!visited[p][q]) {
dist[p][q] = dist[x][y] + 1;
visited[p][q] = 1;
pq.push({p, q});
}
}
}
}
if (ans < tot)
high = mid;
else
low = mid + 1;
}
int ans = low - 1;
cout << ans << '\n';
vector<pair<int, int> > sources;
for (int i = 1; i + 2 * ans <= n; i++) {
for (int j = 1; j + 2 * ans <= m; j++) {
if (getsumi(i, j, i + 2 * ans, j + 2 * ans) ==
1LL * (2 * ans + 1) * (2 * ans + 1)) {
sources.push_back(make_pair(i + ans, j + ans));
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
s[i][j] = '.';
}
}
for (int i = 0; i < sources.size(); i++) {
s[sources[i].first][sources[i].second] = 'X';
}
for (int i = 1; i <= n; i++) {
cout << s[i].substr(1, m) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
int a[n][m];
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j < m; ++j) {
if (s[j] == 'X') {
a[i][j] = 1;
} else {
a[i][j] = 0;
}
}
}
int x[] = {1, -1, -1, 1, 0, 1, 0, -1};
int y[] = {-1, 1, -1, 1, 1, 0, -1, 0};
int pref[n + 1][m + 1];
for (int k = 0; k < n + 1; ++k) {
pref[k][0] = 0;
}
for (int l = 0; l < m + 1; ++l) {
pref[0][l] = 0;
}
for (int i = 1; i < n + 1; ++i) {
for (int j = 1; j < m + 1; ++j) {
pref[i][j] = a[i - 1][j - 1] + pref[i][j - 1] + pref[i - 1][j] -
pref[i - 1][j - 1];
}
}
int l = 0;
int r = min(n, m) + 1;
while (l + 1 != r) {
int mid = (l + r) / 2;
int d = mid * 2 + 1;
int t[n][m];
int dist[n][m];
bool used[n][m];
for (int k = 0; k < n; ++k) {
for (int i = 0; i < m; ++i) {
t[k][i] = 0;
dist[k][i] = 1e9;
used[k][i] = false;
}
}
for (int i = 0; i <= n - d; ++i) {
for (int j = 0; j <= m - d; ++j) {
int sum =
pref[i + d][j + d] - pref[i + d][j] - pref[i][j + d] + pref[i][j];
if (sum == d * d) {
t[i + mid][j + mid] = 1;
}
}
}
queue<pair<int, int>> q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (t[i][j] == 1) {
q.push({i, j});
used[i][j] = true;
dist[i][j] = 0;
}
}
}
while (q.size() != 0) {
int xx = (q.front()).first;
int yy = q.front().second;
q.pop();
for (int i = 0; i < 8; ++i) {
int xxx = xx + x[i];
int yyy = yy + y[i];
if (xxx >= 0 && xxx < n && yyy >= 0 && yyy < m && !used[xxx][yyy]) {
dist[xxx][yyy] = dist[xx][yy] + 1;
used[xxx][yyy] = true;
q.push({xxx, yyy});
}
}
}
bool good = true;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 1) {
if (dist[i][j] > mid) {
good = false;
}
}
}
}
if (good)
l = mid;
else
r = mid;
}
cout << l << "\n";
int mid = l;
int d = mid * 2 + 1;
int t[n][m];
int used[n][m];
int add[n][m];
for (int k = 0; k < n; ++k) {
for (int i = 0; i < m; ++i) {
t[k][i] = 0;
used[k][i] = 0;
}
}
for (int i = 0; i <= n - d; ++i) {
for (int j = 0; j <= m - d; ++j) {
int sum =
pref[i + d][j + d] - pref[i + d][j] - pref[i][j + d] + pref[i][j];
if (sum == d * d) {
used[i][j] += 1;
used[i + d - 1][j + d - 1] -= 1;
add[i + d - 1][j + d - 1] += 1;
t[i + mid][j + mid] = 1;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (t[i][j] == 1) {
cout << "X";
} else {
cout << ".";
}
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<long long int> v[1000010];
vector<long long int> cum[1000010];
vector<long long int> amid[1000010];
void build() {
cum[0][0] = v[0][0];
for (int i = 1; i < m; i++) cum[0][i] = cum[0][i - 1] + v[0][i];
for (int i = 1; i < n; i++) cum[i][0] = cum[i - 1][0] + v[i][0];
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
cum[i][j] = cum[i - 1][j] + cum[i][j - 1] - cum[i - 1][j - 1] + v[i][j];
}
}
return;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << cum[i][j] << " ";
}
cout << '\n';
}
}
long long int get(int sx, int sy, long long int c) {
int ex = sx + 2 * c, ey = sy + 2 * c;
long long int ret = cum[ex][ey];
if (sx) ret -= cum[sx - 1][ey];
if (sy) ret -= cum[ex][sy - 1];
if (sx && sy) ret += cum[sx - 1][sy - 1];
return ret;
}
int dx[] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[] = {0, 1, -1, 1, -1, 0, 1, -1};
bool in(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
bool ok(int c) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
amid[i][j] = -1;
}
}
queue<pair<long long int, long long int> > q;
long long int s = (2 * c + 1) * (2 * c + 1);
for (int i = 0; i + 2 * c + 1 <= n; i++) {
for (int j = 0; j + 2 * c + 1 <= m; j++) {
long long int x = get(i, j, c);
if (x == s) {
amid[i + c][j + c] = 0;
q.push({i + c, j + c});
}
}
}
while (!q.empty()) {
pair<long long int, long long int> cur = q.front();
q.pop();
if (amid[cur.first][cur.second] == c) continue;
for (int i = 0; i < 8; i++) {
int nx = cur.first + dx[i];
int ny = cur.second + dy[i];
if (in(nx, ny) && amid[nx][ny] == -1) {
amid[nx][ny] = amid[cur.first][cur.second] + 1;
q.push({nx, ny});
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j] == 1 && amid[i][j] == -1) return 0;
if (v[i][j] == 0 && amid[i][j] != -1) return 0;
}
}
return 1;
}
int main() {
cin >> n >> m;
int mn = 1000000;
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < m; j++) {
char c;
amid[i].push_back(0);
cum[i].push_back(0);
scanf(" %c", &c);
int x = 0;
if (c == 'X') x = 1;
v[i].push_back(x);
if (x == 1)
cnt++;
else {
if (cnt) mn = min(mn, cnt);
cnt = 0;
}
}
if (cnt) mn = min(mn, cnt);
}
for (int j = 0; j < m; j++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (v[i][j] == 1)
cnt++;
else {
if (cnt) mn = min(mn, cnt);
cnt = 0;
}
}
if (cnt) mn = min(mn, cnt);
}
build();
int st = 0, en = 1000000;
while (st + 1 < en) {
int md = (st + en) / 2;
if (ok(md))
st = md;
else
en = md;
}
cout << st << '\n';
ok(st);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (amid[i][j] == 0)
cout << "X";
else
cout << ".";
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
void comp_z(vector<long> &z) {
long n = z.size();
z[0] = n;
long L = -1, R = -1;
for (int i = 1; i < n; i++) {
if (R < i) {
L = R = i;
while (R < n && s[R] == s[R - L]) R++;
z[i] = R - L;
R--;
} else {
long 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 main(void) {
cin >> s;
int n = s.length();
vector<long> z(n, 0);
comp_z(z);
long mx = 0, res = 0;
long i;
for (i = 1; i < n; i++) {
if (z[i] == (n - i) && mx >= (n - i)) {
res = n - i;
break;
}
mx = max(mx, z[i]);
}
if (res)
cout << s.substr(0, res);
else
cout << "Just a legend";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hash[26] = {0};
string s;
cin >> s;
int n = s.length();
if (n == 1) {
cout << "Just a legend\n";
return 0;
}
if (n >= 3) {
for (int i = 0; i < n; i++) {
hash[(int)s[i] - 'a']++;
}
int ct = 0;
for (int i = 0; i < 26; i++) {
if (hash[i] > 0) ct++;
}
if (ct == 1) {
for (int i = 0; i < n - 2; i++) cout << s[i];
cout << "\n";
return 0;
}
}
int z[1000006];
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--;
}
}
}
set<pair<int, int> > st;
int steps = 0;
for (int i = n - 1; i >= 0; i--) {
steps++;
if (steps == z[i]) {
st.insert(pair<int, int>(z[i], i));
}
}
set<pair<int, int> >::reverse_iterator it;
int start = -1, len = 0;
for (it = st.rbegin(); it != st.rend(); it++) {
if (len < it->first)
for (int i = 0; i < it->second; i++) {
if (z[i] >= it->first) {
start = i;
len = it->first;
}
}
}
if (start == -1) {
cout << "Just a legend\n";
return 0;
}
for (int i = start; i < start + len; i++) cout << s[i];
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e6 + 10;
string s;
int z[maxN];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> s;
int l, r;
l = r = 0;
for (int i = 1; i < s.size(); ++i) {
if (i > r) {
l = r = i;
while (r < s.size() && s[r - l] == s[r]) ++r;
z[i] = r - l;
--r;
} else {
int k = i - l;
z[i] = min(z[k], r - i + 1);
if (z[i] >= r - i + 1) {
l = i;
while (r < s.size() && s[r - l] == s[r]) ++r;
z[i] = r - l;
--r;
}
}
}
int ans, mx;
ans = -1, mx = 0;
for (int i = 1; i < s.size(); ++i) {
if (i + z[i] == s.size() && z[i] <= mx) {
ans = z[i];
break;
}
mx = max(mx, z[i]);
}
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;
int lim = 1000000;
int mod = 1000000000 + 7;
int inf = 1000000000;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
const string t = "Just a legend";
int n = (int)s.length();
vector<int> pi(n);
pi[0] = 0;
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) {
j = pi[j - 1];
}
if (s[i] == s[j]) {
j++;
}
pi[i] = j;
}
if (pi[n - 1] == 0) {
cout << t;
} else {
int p = 0;
for (int i = 1; i < n - 1; i++) {
if (pi[i] == pi[n - 1]) {
p = 1;
break;
}
}
if (p) {
for (int i = 0; i < pi[n - 1]; i++) {
cout << s[i];
}
} else {
if (pi[pi[n - 1] - 1] == 0) {
cout << t;
} else {
int p1 = 0;
for (int i = 1; i < n - 1; i++) {
if (pi[i] == pi[pi[n - 1] - 1]) {
p1 = 1;
break;
}
}
if (p1) {
for (int i = 0; i < pi[pi[n - 1] - 1]; i++) {
cout << s[i];
}
} else {
cout << t;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
vector<int> prefix(n);
for (int i = 1, k = 0; i < n; i++) {
while (k > 0 && s[k] != s[i]) k = prefix[k - 1];
if (s[i] == s[k])
prefix[i] = ++k;
else
prefix[i] = k;
}
int j = n, l;
while (1) {
l = j - 1;
j = prefix[l];
if (j == 0) break;
for (int i = 0; i < (int)(n - 1); i++)
if (prefix[i] >= j) {
cout << s.substr(n - j) << endl;
return 0;
}
}
cout << "Just a legend\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000023;
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans = (ans * a);
b /= 2;
a = (a * a);
}
return ans;
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first > b.first)
return 1;
else if (a.first == b.first)
return (a.second < b.second);
else
return 0;
}
long long int hash1[N];
long long int p_pow[N];
string str;
long long int n;
void cal_pow() {
long long int p = 31;
for (long long int i = 0; i < N; i++) {
if (i != 0)
p_pow[i] = (p_pow[i - 1] * p) % 1000000007;
else
p_pow[i] = 1;
}
}
void calc() {
hash1[0] = str[0] - 'a' + 1;
for (long long int i = 1; i <= str.size() - 1; i++) {
hash1[i] = (hash1[i - 1] + (p_pow[i] * (str[i] - 'a' + 1)) % 1000000007) %
1000000007;
}
}
long long int check(long long int val, long long int len) {
for (long long int i = 1; i < n - len; i++) {
long long int temp =
(p_pow[n - 1 - i] * (hash1[i + len - 1] - hash1[i - 1] + 1000000007) %
1000000007) %
1000000007;
if (temp == val) return 1;
}
return 0;
}
void solve() {
cin >> str;
cal_pow();
calc();
vector<pair<long long int, long long int>> v;
n = str.size();
for (long long int i = 0; i < n - 1; i++) {
long long int f = (p_pow[n - 1] * hash1[i]) % 1000000007;
long long int s =
(p_pow[i] * (hash1[n - 1] - hash1[n - i - 2] + 1000000007) %
1000000007) %
1000000007;
if (f == s) v.push_back({i + 1, f});
}
if (!v.size()) {
cout << "Just a legend" << endl;
return;
}
sort((v).begin(), (v).end());
v.push_back({n + 3, 1});
long long int l = 0, r = v.size() - 1;
if (!check(v[0].second, v[0].first)) {
cout << "Just a legend" << endl;
return;
}
while ((l + 1) < r) {
long long int mid = (l + r) / 2;
if (check(v[mid].second, v[mid].first))
l = mid;
else
r = mid;
}
long long int idx = 0, len = v[l].first;
while (len--) {
cout << str[idx];
idx++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int Test;
Test = 1;
long long int t = 0;
while (t++ < Test) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int n = s.length();
int i, j, l = 0, r = 0;
vector<int> z(n, 0);
for (i = 1; i < n; i++) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (z[i] + i < n && s[z[i]] == s[z[i] + i]) z[i]++;
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
int mx[n], ans = -1;
mx[0] = z[0];
for (i = 1; i < n; i++) mx[i] = max(mx[i - 1], z[i]);
for (i = n - 1; i > 0; i--) {
if (i + z[i] == n && mx[i - 1] >= z[i]) ans = i;
}
if (ans == -1)
cout << "Just a legend\n";
else {
for (int j = ans; j < n; j++) cout << s[j];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxstrlen = 1e6;
unsigned long long mod[] = {(int)1e9 + 7, (int)1e9 + 9};
class RH {
static vector<unsigned long long> x[2];
vector<unsigned long long> h[2];
string str;
int n;
unsigned long long hash(int a, int start, int len) {
unsigned long long ans = 0, end = start + len;
ans += h[a][start] - h[a][end] * x[a][len] % mod[a] + mod[a];
return ans % mod[a];
}
public:
RH() {}
RH(const string &str) {
this->str = str;
n = str.size();
if (x[0].empty())
for (int a = 0; a < (int)2; ++a) {
x[a].assign(maxstrlen + 1, 1);
for (int i = 0; i < (int)maxstrlen; ++i)
x[a][i + 1] = x[a][i] * 127 % mod[a];
}
for (int a = 0; a < (int)2; ++a) {
h[a].assign(n + 1, 0);
for (int i = n - 1; i >= 0; --i)
h[a][i] = (h[a][i + 1] * 127 + str[i]) % mod[a];
}
}
unsigned long long hash(int start, int len) {
return hash(0, start, len) << 32 | hash(1, start, len);
}
};
vector<unsigned long long> RH::x[2];
int main() {
string Texto;
cin >> Texto;
int Indice = -1;
RH RoHa(Texto);
for (int i = 0; i < Texto.size() - 1; ++i) {
if (RoHa.hash(0, i + 1) == RoHa.hash(Texto.size() - 1 - i, i + 1)) {
for (int j = 1; j + i < Texto.size() - 1; ++j) {
if (RoHa.hash(0, i + 1) == RoHa.hash(j, i + 1)) {
Indice = i;
break;
}
}
}
}
if (Indice == -1) {
cout << "Just a legend" << endl;
} else {
cout << Texto.substr(0, Indice + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int T[1000010];
void preprocess(const string &Needle) {
T[0] = -1;
int i = 0, j = -1;
while (i < Needle.size()) {
while (j >= 0 && Needle[i] != Needle[j]) j = T[j];
j++;
i++;
T[i] = j;
}
}
int F[1000010];
void Find(const string &Hay, const string &Needle) {
preprocess(Needle);
int i = 0, j = 0;
while (i < Hay.size()) {
while (j >= 0 && Needle[j] != Hay[i]) j = T[j];
i++, j++;
}
while (j >= 0) {
F[i - j] = j;
j = T[j];
}
}
int ok(const string &Hay, const string &Needle) {
preprocess(Needle);
int i = 1, j = 0;
int ma = 0;
while (i < Hay.size()) {
while (j >= 0 && Needle[j] != Hay[i]) j = T[j];
i++, j++;
if (i == Hay.size()) break;
ma = max(j, ma);
}
return ma;
}
int main() {
string A = "fixprefixsuffix";
cin >> A;
Find(A, A);
int ma = ok(A, A);
int ans = 0;
for (int i = 0; i < A.size() && ans == 0; ++i)
if (F[i] <= ma) ans = F[i];
if (ans == 0)
cout << "Just a legend" << endl;
else
cout << A.substr(0, ans) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> prefix_function(string s) {
int n = (int)s.length();
vector<int> pi(n);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
return pi;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int f = 0;
vector<int> v;
v = prefix_function(s);
if (v[s.length() - 1] == 0) {
cout << "Just a legend";
return 0;
}
for (int i = v[s.length() - 1]; i < s.length() - 1; i++) {
if (v[i] == v[s.length() - 1]) {
f = 1;
break;
}
}
if (f == 1) {
for (int i = 0; i < v[s.length() - 1]; i++) cout << s[i];
return 0;
}
if (v[v[s.length() - 1] - 1] > 0) {
for (int i = 0; i < v[v[s.length() - 1] - 1]; i++) cout << s[i];
return 0;
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const double PI = 3.141592653589793;
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct rollingHash {
int base, curN;
bool suffixOn;
string *myString;
vector<long long> precBase;
vector<long long> hash[2];
explicit rollingHash(string *x, int curBase = 31, bool enableSuffix = 0,
bool precomputeBase = 1) {
myString = x;
curN = myString->length();
base = curBase;
suffixOn = enableSuffix;
hash[0].resize(curN);
if (enableSuffix) hash[1].resize(myString->length());
precBase.resize(curN);
makeHash();
}
void makeHash() {
if (curN == 0) return;
precBase[0] = 1;
for (int i = 1; i < curN; i++) precBase[i] = (precBase[i - 1] * base) % MOD;
for (int i = 0; i < curN; i++) {
int curlet = (*myString)[i] - 'a';
hash[0][i] = (curlet * precBase[curN - i - 1]) % MOD;
if (i) hash[0][i] = (hash[0][i] + hash[0][i - 1]) % MOD;
if (suffixOn) {
hash[1][i] = (curlet * precBase[i]) % MOD;
if (i) hash[1][i] = (hash[1][i] + hash[1][i - 1]) % MOD;
}
}
return;
}
inline long long getHash(int a, int b) {
bool isSuffix = a > b;
if (a > b) swap(a, b);
return (hash[isSuffix][b] - (a - 1 >= 0 ? hash[isSuffix][a - 1] : 0) +
MOD) %
MOD;
}
bool isSame(pair<int, int> a, pair<int, int> b) {
if (abs(a.first - a.second) != abs(b.first - b.second)) return 0;
long long valA = getHash(a.first, a.second);
long long valB = getHash(b.first, b.second);
if (a.first <= a.second)
a = {curN - a.second - 1, curN - a.first - 1};
else
swap(a.first, a.second);
if (b.first <= b.second)
b = {curN - b.second - 1, curN - b.first - 1};
else
swap(b.first, b.second);
if (a.first > b.first) {
swap(a, b);
swap(valA, valB);
}
valA = (valA * precBase[b.first - a.first]) % MOD;
return valA == valB;
}
bool isSame(pair<int, int> a, string &s, long long sHash) {
int sLen = s.length();
sLen--;
if (abs(a.first - a.second) != sLen) return 0;
long long valA = getHash(a.first, a.second);
if (a.first <= a.second)
a = {curN - a.second - 1, curN - a.first - 1};
else
swap(a.first, a.second);
sHash = (sHash * precBase[a.first]) % MOD;
return valA == sHash;
}
bool isPalindrome(int a, int b) {
if (a == b) return 1;
return isSame({a, b}, {b, a});
}
};
long long getSingleHash(string &s, long long base = 31) {
long long ret = 0;
for (int i = 0; i < s.length(); i++) {
ret = (ret * base);
ret = (ret + (s[i] - 'a')) % MOD;
}
return ret;
}
int main() {
fasterios();
string s;
cin >> s;
rollingHash hash1(&s, 31, 0, 1);
rollingHash hash2(&s, 37, 0, 1);
rollingHash hash3(&s, 41, 0, 1);
int n = s.length();
n--;
for (int i = n - 2; i >= 0; i--) {
pair<int, int> a = {0, i};
pair<int, int> b = {n - i, n};
if (hash1.isSame(a, b) && hash2.isSame(a, b) && hash3.isSame(a, b)) {
for (int j = 1;; j++) {
int kanan = j + i;
if (kanan == n) break;
if (hash1.isSame(a, {j, kanan}) && hash2.isSame(a, {j, kanan}) &&
hash3.isSame(a, {j, kanan})) {
for (int k = 0; k <= i; k++) cout << s[k];
cout << '\n';
return 0;
}
}
}
}
cout << "Just a legend" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = s.length();
vector<long long> lps(n, 0);
for (long long i = 1; i < n; i++) {
long long j = lps[i - 1];
while (j > 0 && s[i] != s[j]) {
j = lps[j - 1];
}
if (s[i] == s[j]) {
j++;
}
lps[i] = j;
}
if (lps[n - 1] == 0) {
cout << "Just a legend";
return 0;
}
long long yes = 0;
for (long long i = 0; i < n - 1; i++) {
if (lps[i] == lps[n - 1]) {
cout << s.substr(0, lps[i]);
return 0;
}
}
long long z = lps[lps[n - 1] - 1];
if (z > 0) {
cout << s.substr(0, z);
return 0;
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int P[1000001], pr[1000001];
int i, j, c;
int main() {
getline(cin, s);
if (int((s).size()) <= 2) {
cout << "Just a legend" << endl;
return 0;
}
pr[0] = 0;
P[0] = 0;
for (i = 1; i <= int((s).size()) - 1; i++) {
j = pr[i - 1];
while (j > 0 && s[i] != s[j]) j = pr[j - 1];
if (s[i] == s[j]) j++;
pr[i] = j;
P[i] = max(P[i - 1], pr[i]);
}
j = pr[int((s).size()) - 1];
while (j > 0) {
if (P[int((s).size()) - 2] >= j) {
for (c = 0; c <= j - 1; c++) cout << s[c];
cout << endl;
return 0;
}
j = pr[j - 1];
}
cout << "Just a legend" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int kmp[1000007];
int i = 0;
void doit(string b) {
kmp[0] = 0;
int lth = b.length();
for (int j = 1; j < (lth); j++) {
while (b[j] != b[i] && i > 0) {
i = kmp[i - 1];
}
if (b[j] == b[i]) {
i++;
} else {
i = 0;
if (b[j] == b[0]) {
i++;
}
}
kmp[j] = i;
}
}
int main() {
string a;
cin >> a;
doit(a);
vector<int> check;
int x, y;
x = kmp[a.length() - 1];
check.push_back(x);
while (x > 0) {
y = kmp[x - 1];
check.push_back(y);
x = y;
}
for (int j = 0; j < check.size(); j++) {
x = check[j];
if (x > 0) {
for (int i = 1; i < (a.length() - 1); i++) {
if (kmp[i] == x) {
cout << a.substr(0, x);
return 0;
break;
}
}
}
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int N = 1000010;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int nxt[2][N];
void preKMP(char x[], int m, int kmpNext[]) {
int i = 1, j = kmpNext[1] = 0;
while (i <= m) {
while (0 != j && x[i + 1] != x[j + 1]) j = kmpNext[j];
if (x[j + 1] == x[i + 1]) ++j;
kmpNext[i + 1] = j;
++i;
}
}
int main() {
char s[N] = {0};
scanf("%s", s + 1);
int len = strlen(s + 1);
preKMP(s, len, nxt[0]);
reverse(s + 1, s + 1 + len);
preKMP(s, len, nxt[1]);
reverse(s + 1, s + 1 + len);
int pos = 0, mx = 0;
for (int i = 1; i <= len; i++)
if (nxt[0][i] == nxt[1][len - i + nxt[0][i]])
if (nxt[0][i] > mx) pos = i, mx = nxt[0][i];
if (pos == 0) {
cout << "Just a legend" << endl;
} else {
for (int i = pos - mx + 1; i <= pos; i++) {
printf("%c", s[i]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char save[1000010];
int pre[1000010];
char tmp[1000010];
int tpre[1000010];
void gpre(char *s, int *p) {
int i, j;
int len = strlen(s);
p[0] = -1;
j = -1;
for (i = 0; i < len && j < len;) {
if (j == -1 || s[i] == s[j]) {
p[++i] = ++j;
} else {
j = p[j];
}
}
}
int find(char *s, char *x, int *p) {
int i, j;
i = j = 0;
int len = strlen(x);
int length = strlen(s);
while (i < length && j < len) {
if (j == -1 || s[i] == x[j]) {
i++;
j++;
} else {
j = p[j];
}
}
if (j == len) {
return i - len;
}
return -1;
}
int main() {
while (scanf("%s", save) != EOF) {
gpre(save, pre);
int len = strlen(save);
if (len == 0) {
printf("Just a legend\n");
break;
}
int e = pre[len];
int res = -1;
while (e) {
sprintf(tmp, "%s", save + len - e);
gpre(tmp, tpre);
int tres = find(save + 1, tmp, tpre);
if (tres + 1 + e < len) {
res = tres + 1;
break;
}
e = pre[e];
}
if (res != -1) {
printf("%s\n", save + len - e);
} else {
printf("Just a legend\n");
}
}
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);
for (int i = 0; i <= len; i++) z[i] = 0;
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];
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 MAX = 1000005;
char s[MAX];
int z[MAX];
void zfun(int n) {
int l = 0, r = 0;
for (int i = 1; i < n; ++i) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> s;
n = strlen(s);
zfun(n);
int tmp = -1;
for (int i = 1; i < n; ++i) {
if (z[i] <= tmp && z[i] == n - i) {
for (int j = i; j < i + z[i]; ++j) cout << s[j];
return 0;
}
tmp = max(tmp, z[i]);
}
cout << "Just a legend" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
int nxt[maxn], len;
char s[maxn];
set<int> ss;
void kmp() {
nxt[0] = 0;
nxt[1] = 0;
for (int i = 1; i < len; ++i) {
int k = nxt[i];
while (k && s[k] != s[i]) k = nxt[k];
if (s[k] == s[i])
nxt[i + 1] = k + 1;
else
nxt[i + 1] = 0;
}
}
int main() {
scanf("%s", &s);
len = strlen(s);
kmp();
for (int i = 0; i < len; ++i) {
ss.insert(nxt[i]);
}
int tem = nxt[len];
while (tem) {
if (ss.count(tem)) {
for (int i = 0; i < tem; ++i) {
printf("%c", s[i]);
}
return 0;
} else {
tem = nxt[tem];
}
}
printf("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mult(long long int a, long long int b) {
return ((a * b) % 1000000007);
}
long long int pow_m(long long int a, long long int p) {
if (p == 0) {
return 1;
} else if (p == 1) {
return a;
}
long long int temp = pow_m(a, p / 2);
if (p % 2 == 0) {
return mult(temp, temp);
} else {
return mult(mult(temp, temp), a);
}
}
long long int inv(long long int a) {
if (a == 0) {
return 0;
}
return pow_m(a, 1000000007 - 2);
}
long long int nChooseK(long long int n, long long int k) {
if (k == 0) {
return 1;
}
long long int answer = 1;
for (int i = 0; i < k; ++i) {
answer = mult(answer, n - i);
}
for (int i = 2; i <= k; ++i) {
answer = mult(answer, inv(i));
}
return answer;
}
long long int nChooseK(long long int n, long long int k,
vector<long long int>& pre_mult,
vector<long long int>& pre_div) {
if (k == 0) {
return 1;
}
long long int answer = 1;
answer = mult(answer, pre_mult[n]);
answer = mult(answer, pre_div[n - k]);
answer = mult(answer, pre_div[k]);
return answer;
}
vector<long long int> coordinate_compression(vector<long long int>& input) {
vector<long long int> b = input;
sort(b.begin(), b.end());
map<long long int, long long int> mp;
for (long long int i = 0; i < b.size(); ++i) {
if (mp.find(b[i]) == mp.end()) {
mp[b[i]] = i;
}
}
vector<long long int> answer = input;
long long int index = 0;
while (index < b.size()) {
answer[index] = mp[answer[index]];
}
return answer;
}
map<long long int, long long int> get_coordinate_compression_map(
vector<long long int>& input) {
vector<long long int> b = input;
sort(b.begin(), b.end());
map<long long int, long long int> mp;
for (long long int i = 0; i < b.size(); ++i) {
if (mp.find(b[i]) == mp.end()) {
mp[b[i]] = i;
}
}
return mp;
}
int64_t my_pow(int64_t base, int64_t height) {
if (height == 0) {
return 1;
}
if (height % 2 == 0) {
int64_t temp = my_pow(base, height / 2);
return (temp * temp) % 1000000007;
} else {
int64_t temp = my_pow(base, height / 2);
return ((temp * temp) % 1000000007) * base % 1000000007;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
vector<int> dp(s.size(), 0);
int n = s.size();
int i = 1;
int length = 0;
while (i < n) {
if (s[i] == s[length]) {
dp[i] = length + 1;
i++;
length++;
} else {
if (length == 0) {
dp[i] = 0;
i++;
} else {
length = dp[length - 1];
}
}
}
if (dp[n - 1] == 0) {
cout << "Just a legend\n";
return 0;
}
string temp = s.substr(0, dp[n - 1]);
if (temp.size() + 2 <= s.size()) {
int64_t temp_hash = 0;
for (int j = 0; j < temp.size(); ++j) {
temp_hash = (temp_hash * 26 + (temp[j] - 'a')) % 1000000007;
}
int64_t current_hash = 0;
for (int i = 1; i < temp.size() + 1; ++i) {
current_hash = (current_hash * 26 + (s[i] - 'a')) % 1000000007;
}
if (current_hash == temp_hash) {
cout << temp << "\n";
return 0;
}
for (int i = temp.size() + 1; i < n - 1; ++i) {
current_hash = (current_hash + 1000000007 -
((s[i - temp.size()] - 'a') *
my_pow(26, temp.size() - 1) % 1000000007)) %
1000000007;
current_hash = (current_hash * 26 + (s[i] - 'a')) % 1000000007;
if (current_hash == temp_hash &&
s.substr(i - temp.size() + 1, temp.size()) == temp) {
cout << temp << "\n";
return 0;
}
}
}
if (dp[dp[n - 1] - 1] == 0) {
cout << "Just a legend\n";
return 0;
} else {
cout << s.substr(0, dp[dp[n - 1] - 1]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int i = 1, j = 0;
int lps[n];
lps[0] = 0;
while (i < n) {
if (s[i] == s[j]) {
j++;
lps[i] = j;
i++;
} else {
if (j != 0)
j = lps[j - 1];
else {
lps[i] = 0;
i++;
}
}
}
if (lps[n - 1] == 0) {
cout << "Just a legend" << endl;
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (lps[i] == lps[n - 1]) {
cout << s.substr(0, lps[n - 1]) << endl;
return 0;
}
}
if (lps[lps[n - 1] - 1] == 0)
cout << "Just a legend" << endl;
else
cout << s.substr(0, lps[lps[n - 1] - 1]) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 8883;
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 MAXN = 1000007;
int Z[MAXN];
int cnt[MAXN];
int suff[MAXN];
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int L = 0, R = 0;
int n = s.size();
Z[0] = n;
for (int i = 1; i < n; i++) {
if (i > R) {
L = i;
R = i;
} else {
int k = i - L;
if (Z[k] < R - i + 1) {
Z[i] = Z[k];
continue;
} else {
L = i;
}
}
while (R < n && s[R - L] == s[R]) R++;
Z[i] = R - L;
R--;
}
for (int i = 1; i < n; i++) {
cnt[Z[i]]++;
}
for (int i = n - 1; i >= 0; i--) {
suff[i] = suff[i + 1] + cnt[i];
}
for (int i = 1; i < n; i++) {
if (Z[i] + i == n && suff[Z[i]] >= 2) {
for (int j = i; j < n; j++) {
cout << s[j];
}
cout << '\n';
return 0;
}
}
cout << "Just a legend\n";
}
|
#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 + 1], R - i);
else
L = i, R = i;
while (i + ans[i] <= n && s[i - 1 + ans[i]] == s[ans[i]]) 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 main() {
ios_base::sync_with_stdio(0), cin.tie(), cout.tie();
string s;
cin >> s;
int n = (int(s.size()));
vector<int> z = StrAlgo::Z(s);
int ln = 0;
for (int i = 2; i <= n; i++) {
ln = max(ln, z[i] - (i + z[i] == n + 1));
}
for (int i = 2; i <= n; i++) {
if (i + z[i] == n + 1 && z[i] <= ln)
return cout << s.substr(i - 1) << endl, 0;
}
return cout << "Just a legend\n", 0;
}
|
#include <bits/stdc++.h>
const double eps = 1e-7, PI = 3.1415926;
const int N = 2e5 + 10;
using namespace std;
int n, q, m, k, x, y, a[N], mx = -1, mn = 1e9, sum;
char c[N];
string s, s1, s2;
map<int, int> mp;
vector<int> vec;
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() {
cin >> s;
vec = z_function(s);
int lo = 0;
vector<int> op;
op = vec;
sort(op.begin(), op.end(), greater<int>());
for (int i = 0; i < op.size(); i++) {
if (i)
mp[op[i]] = mp[op[i - 1]] + 1;
else
mp[op[i]] = 1;
}
for (int i = vec.size() - 1; i >= 0; i--) {
if (vec[i] && mp[vec[i]] >= 2 && i + vec[i] == vec.size()) lo = vec[i];
}
if (lo) {
for (int i = 0; i < lo; i++) cout << s[i];
} else {
cout << "Just a legend";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
const unsigned long long seed = 131;
unsigned long long Hash[MAX], P[MAX];
char s[MAX];
int n;
unsigned long long get(int l, int r) {
return Hash[r] - Hash[l - 1] * P[r - l + 1];
}
int b[MAX], tot;
bool ok(int x) {
unsigned long long tar = get(1, x);
for (int l = 2; l + x - 1 < n; l++) {
int r = l + x - 1;
if (tar == get(l, r)) return 1;
}
return 0;
}
int main() {
cin >> s + 1;
n = strlen(s + 1);
P[0] = 1;
for (int i = 1; i <= n; i++) P[i] = P[i - 1] * seed;
for (int i = 1; i <= n; i++) {
Hash[i] = Hash[i - 1] * seed + s[i] - 'a' + 1;
}
for (int i = 1; i <= n; i++) {
if (get(1, i) == get(n - i + 1, n)) b[++tot] = i;
}
int l = 1, r = tot, ans = -1, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (ok(b[mid]))
l = mid + 1, ans = b[mid];
else
r = mid - 1;
}
if (ans == -1) {
printf("Just a legend\n");
return 0;
}
for (int i = 1; i <= ans; i++) printf("%c", s[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
const int MAXN = 1e6 + 5;
const int mod = 1e9 + 7;
using namespace std;
int oc[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string a;
cin >> a;
vector<int> f((int)a.size());
int border = 0;
f[0] = 0;
for (int i = 1; i < (int)a.size(); i++) {
while (a[border] != a[i] && border > 0) border = f[border - 1];
if (a[border] == a[i]) border++;
f[i] = border;
oc[border]++;
}
if (border && border != (int)a.size() && oc[border] > 1)
cout << a.substr(0, border);
else if (border && f[border - 1] != 0)
cout << a.substr(0, f[border - 1]);
else
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
char a[N];
int p[N], n, sxl;
int main() {
cin >> a + 1;
n = strlen(a + 1);
p[1] = 0;
for (int i = 2, j = 0; i <= n; i++) {
while (j && a[i] != a[j + 1]) j = p[j];
if (a[i] == a[j + 1]) j++;
p[i] = j;
if (i != n) sxl = max(sxl, p[i]);
}
int x = p[n];
if (x == 0) {
cout << "Just a legend";
} else {
while (x > sxl) x = p[x];
if (x == 0) {
cout << "Just a legend";
return 0;
}
for (int i = 2; i < n; i++)
if (x == p[i]) {
for (int j = i - p[i] + 1; j <= i; j++) cout << a[j];
cout << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char text[1000005];
int nxt[1000005];
bool visit[1000005];
void prepare() {
int i = 0, j = -1, len = strlen(text);
nxt[0] = -1;
while (i < len) {
if (j == -1 || text[i] == text[j]) {
i++;
j++;
nxt[i] = j;
} else {
j = nxt[j];
}
}
}
void work() {
prepare();
int len = strlen(text);
for (int i = 0; i < len; i++) {
visit[nxt[i]] = 1;
}
int pos = len;
bool flag = 0;
while (nxt[pos] > 0) {
if (visit[nxt[pos]]) {
flag = 1;
for (int i = 0; i < nxt[pos]; i++) cout << text[i];
cout << '\n';
break;
} else {
pos = nxt[pos];
}
}
if (!flag) cout << "Just a legend\n";
}
int main() {
ios::sync_with_stdio(false);
cin >> text;
work();
}
|
#include <bits/stdc++.h>
using namespace std;
long long p = 31;
vector<long long> inv_p_powers;
long long power(long long a, long long b) {
if (b == 0) return 1;
long long temp = power(a, b / 2);
temp = temp * temp % 1000000007;
if (b % 2 == 1) {
temp = temp * a % 1000000007;
}
return temp;
}
long long find_hash(vector<long long> &prefix_hash, int i, int j) {
if (i == 0) return prefix_hash[j];
long long sub_s_hash =
(prefix_hash[j] - prefix_hash[i - 1] + 1000000007) % 1000000007;
sub_s_hash = sub_s_hash * inv_p_powers[i] % 1000000007;
return sub_s_hash;
}
bool check(string t, int l, vector<long long> &prefix_hash) {
int start = 1;
int end = start + l - 1;
int maxi = prefix_hash.size() - 1;
while (1) {
if (end >= maxi) break;
long long sub_s_hash = find_hash(prefix_hash, start, end);
if (sub_s_hash == prefix_hash[l - 1]) return true;
start++;
end = start + l - 1;
}
return false;
}
int main() {
int i;
long long p_pow = 1;
for (i = 1; i <= 1000010; i++) {
inv_p_powers.push_back(power(p_pow, 1000000007 - 2));
;
p_pow = p_pow * p % 1000000007;
}
string t;
cin >> t;
int len = t.length();
vector<long long> prefix_hash;
vector<long long> suffix_hash;
long long hash = 0;
p_pow = 1;
for (i = 0; i <= len - 1; i++) {
hash = (hash + p_pow * ((long long)(t[i] - 'a' + 1))) % 1000000007;
prefix_hash.push_back(hash);
;
p_pow = p_pow * p % 1000000007;
}
for (i = 0; i <= len - 1; i++) {
suffix_hash.push_back(find_hash(prefix_hash, len - 1 - i, len - 1));
;
}
vector<int> ans_len;
for (i = 0; i <= len - 1; i++) {
if (prefix_hash[i] == suffix_hash[i]) {
ans_len.push_back(i + 1);
;
}
}
int high = ans_len.size() - 1;
int low = 0;
while (low < high) {
int mid = (low + high + 1) / 2;
if (check(t, ans_len[mid], prefix_hash)) {
low = mid;
} else {
high = mid - 1;
}
}
if (check(t, ans_len[low], prefix_hash)) {
cout << t.substr(0, ans_len[low]);
} else
cout << "Just a legend";
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 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, MOD - 1)(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 int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 1418;
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;
string a;
bool kmp(string s) {
vector<int> v;
v.resize(s.size());
v[0] = 0;
for (int i = 1, j = 0; i < s.size(); ++i) {
if (s[i] == s[j]) {
v[i] = j + 1;
++j;
} else {
if (j == 0)
;
else {
j = v[j - 1];
--i;
}
}
}
string str = s.substr(0, v[v.size() - 1]);
v.resize(str.size());
v[0] = 0;
for (int i = 1, j = 0; i < str.size(); ++i) {
if (str[i] == str[j]) {
v[i] = j + 1;
++j;
} else {
if (j == 0)
;
else {
j = v[j - 1];
--i;
}
}
}
if (str.size() == 0) return false;
int k = 0;
int ans = 0;
for (int i = 0; i < a.size(); ++i) {
if (a[i] == str[k]) {
++k;
if (k == str.size()) {
++ans;
if (k > 0) k = v[k - 1];
}
} else {
if (k > 0) {
k = v[k - 1];
--i;
}
}
}
if (ans > 2) {
cout << str;
return true;
}
return kmp(str);
}
int main() {
cin >> a;
if (!kmp(a)) cout << "Just a legend";
}
|
#include <bits/stdc++.h>
using namespace std;
void task() {
string str;
cin >> str;
int l = 0;
int r = 0;
vector<int> z(str.length(), 0);
for (int i = 1; i < str.length(); i++) {
if (r > i) {
z[i] = min(z[i - l], r - i);
}
while (i + z[i] < str.length() && str[z[i]] == str[i + z[i]]) {
z[i]++;
}
if (i + z[i] > r) {
l = i;
r = i + z[i];
}
}
int maxlen = -1;
int ans = -1;
for (int i = 0; i < str.length() && ans == -1; i++) {
if (z[i] != 0) {
if (i + z[i] == str.length() && maxlen >= z[i]) {
ans = z[i];
} else {
maxlen = max(z[i], maxlen);
}
}
}
if (ans == -1) {
cout << "Just a legend" << endl;
}
for (int i = str.length() - ans; i < str.length(); i++) {
cout << str[i];
}
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
task();
return 0;
}
|
#include <bits/stdc++.h>
char in[1100000];
unsigned long long hs, st[1100000], ed[1100000];
unsigned long long pw[1100000];
int main() {
int i, j, k, l, m, n, ok, res;
while (scanf("%s", in) == 1) {
n = strlen(in);
res = 0;
pw[0] = 1;
for (i = 0; i < n + 1; i++) pw[i + 1] = pw[i] * 10007;
st[0] = ed[0] = 0;
for (i = 0; i < n; i++) st[i + 1] = st[i] * 10007 + in[i];
for (i = 0; i < n; i++) ed[i + 1] = ed[i] + in[n - 1 - i] * pw[i];
for (k = n - 1; k; k--)
if (st[k] == ed[k]) {
ok = 0;
hs = 0;
for (i = 0; i < k; i++) hs = hs * 10007 + in[i];
for (i = k; i < n - 1; i++) {
hs = hs * 10007 + in[i] - in[i - k] * pw[k];
if (hs == st[k]) ok = 1;
}
if (ok) {
res = k;
break;
}
}
if (res > 0) {
for (i = 0; i < res; i++) putchar(in[i]);
puts("");
} else {
puts("Just a legend");
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const int inf = 0x3f3f3f3f;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long power(long long a, long long b, long long m = 1000000007) {
long long answer = 1;
while (b) {
if (b & 1) answer = (answer * a) % m;
b /= 2;
a = (a * a) % m;
}
return answer;
}
using namespace std;
vector<int> z_function(string second) {
int n = (int)second.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 && 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 pi[1000000 + 5];
void kmpPreprocess(string &P) {
int i = 0, j = -1, m = P.size();
pi[0] = -1;
while (i < m) {
while (j >= 0 and P[i] != P[j]) j = pi[j];
i++, j++;
pi[i] = j;
}
}
int main() {
string p;
cin >> p;
vector<int> z;
z = z_function(p);
kmpPreprocess(p);
int mx = 0;
string h = "";
int n = p.length();
bool flag = true;
if (pi[n] == 0) {
cout << "Just a legend\n";
return 0;
}
for (int i = 0; i < n; i++) {
if (pi[n] == pi[i]) {
for (int j = 0; j < pi[i]; j++) cout << p[j];
return 0;
}
}
if (pi[pi[n]] == 0) {
cout << "Just a legend\n";
return 0;
}
for (int i = 0; i < pi[pi[n]]; i++) cout << p[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1000000;
string s;
vector<int> pi;
int main() {
getline(cin, s);
int n = s.size();
s.insert(s.begin(), 0);
pi.push_back(0);
pi.push_back(0);
for (int i = 2, k = 0; i <= n; ++i) {
while (k > 0 && s[i] != s[k + 1]) k = pi[k];
pi.push_back(k += int(s[i] == s[k + 1]));
}
int p = pi[n];
bool b = false;
while (p) {
int i;
for (i = p + 1; i < n; ++i)
if (pi[i] == p) break;
if (i < n) {
cout << s.substr(1, p);
b = true;
break;
} else
p = pi[p];
}
if (!b) cout << "Just a legend\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000007;
string s;
int pi[MAX];
char p[MAX], p2[MAX], T;
void compute_prefix_function(int m) {
int k = pi[0] = -1;
for (int i = 1; i < m; i++) {
while (k >= 0 && s[i] != s[k + 1]) k = pi[k];
if (s[i] == s[k + 1]) k++;
pi[i] = k;
}
}
int main() {
cin >> s;
compute_prefix_function(s.size());
int ans = pi[s.size() - 1];
if (ans == -1) {
cout << "Just a legend\n";
return 0;
}
for (int i = 1; i < s.size() - 1; i++) {
if (ans == pi[i]) {
cout << s.substr(0, ans + 1) << '\n';
return 0;
}
}
ans = pi[ans];
if (ans == -1)
cout << "Just a legend\n";
else
cout << s.substr(0, ans + 1) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000007;
int phi[N];
void build(string& s) {
phi[0] = 0;
for (int i = 1; i < s.size(); i++) {
int j = phi[i - 1];
while (j and s[i] != s[j]) j = phi[j - 1];
if (s[i] == s[j])
phi[i] = j + 1;
else
phi[i] = 0;
}
}
int main() {
string s;
cin >> s;
build(s);
int bestmid = 0;
for (int i = 1; i < s.size() - 1; i++) bestmid = max(bestmid, phi[i]);
int j = phi[s.size() - 1];
while (j > bestmid) j = phi[j - 1];
if (!j)
cout << "Just a legend\n";
else
cout << s.substr(0, j) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000008];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
a[0] = 0;
int i = 1, l = 0, n = s.length();
while (i < n) {
if (s[i] == s[l]) {
l++;
a[i] = l;
i++;
} else {
if (l != 0) {
l = a[l - 1];
} else {
a[i] = 0;
i++;
}
}
}
if (a[n - 1] == 0) {
cout << "Just a legend\n";
return 0;
}
for (int i = 1; i <= n - 2; i++) {
if (a[i] == a[n - 1]) {
for (int i = 0; i < a[n - 1]; i++) {
cout << s[i];
}
return 0;
}
}
if (a[a[n - 1] - 1] == 0) {
cout << "Just a legend\n";
return 0;
}
for (int i = 1; i <= n - 2; i++) {
if (a[i] == a[a[n - 1] - 1]) {
for (int i = 0; i < a[a[n - 1] - 1]; i++) {
cout << s[i];
}
return 0;
}
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000005;
int main() {
char s[MAX_N];
scanf("%s", s);
int n = strlen(s);
vector<int> z(n + 1);
int l = 0, r = 0;
z[0] = 0;
for (int i = 1; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (z[i] + i < n && s[z[i] + i] == s[z[i]]) ++z[i];
if (i + z[i] - 1 > r) r = i + z[i] - 1, l = i;
}
set<int> substr;
vector<char> good_pr(n + 1, 0);
for (int i = 1; i < n; ++i) {
if (i + z[i] >= n) {
good_pr[z[i]] = 1;
substr.insert(z[i] - 1);
} else {
substr.insert(z[i]);
}
}
int res = 0;
for (int i = 1; i <= n; ++i) {
if (good_pr[i] && substr.lower_bound(i) != substr.end()) res = max(res, i);
}
if (res == 0) {
printf("Just a legend");
} else {
for (int i = 0; i < res; ++i) printf("%c", s[i]);
}
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[MX];
char s[MX];
int z_function() {
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;
gets(s);
int st = z_function();
if (st == -1)
return puts("Just a legend");
else
puts(s + st);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 8113;
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 maxsz = 1e6 + 10;
char s[maxsz];
const long long p1 = 1e9 + 321;
const long long base = 1013;
long long pws1[maxsz];
long long preff[maxsz];
void build(long long len) {
pws1[0] = 1;
preff[0] = 0;
for (int i = 1; i <= len; i++) {
pws1[i] = (pws1[i - 1] * base) % p1;
preff[i] = (preff[i - 1] * base + (s[i - 1] - 'a' + 1)) % p1;
}
}
long long getKey(long long l, long long r) {
long long len = r - l + 1;
long long res = (preff[l + len] - preff[l] * pws1[len]) % p1;
if (res < 0) res += p1;
return res;
}
bool isSame(long long len, long long len_str) {
long long num1 = getKey(0, len - 1);
long long inv_l = len_str - len;
long long num2 = getKey(inv_l, len_str - 1);
if (num1 == num2) return true;
return false;
}
vector<long long> nums;
bool find_str(long long hash_num, long long len, long long len_str) {
for (int L = 1; L + len < len_str; L++) {
long long R = L + len - 1;
long long num1 = getKey(L, R);
if (num1 == hash_num) return true;
}
return false;
}
int main() {
scanf("%s", s);
long long len = strlen(s);
build(len);
for (int r = 1; r < len - 1; r++) {
if (isSame(r, len)) nums.push_back(r);
}
long long lo = 0, hi = nums.size();
long long p = -1;
while (lo < hi) {
long long mi = (lo + hi) / 2;
long long tst = nums[mi];
long long prf = getKey(0, tst - 1);
if (find_str(prf, tst, len))
lo = mi + 1, p = max(tst, p);
else
hi = mi;
}
if (p != -1)
for (int i = 0; i < p; i++) cout << s[i];
else
cout << "Just a legend";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
char s[N];
int n, z[N];
map<int, int> cnt;
void Z_function() {
int L = 0, R = 0;
z[1] = n;
for (int i = 2; i <= n; i++) {
if (i > R) {
L = R = i;
while (R <= n && s[R] == s[R - L + 1]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L + 1;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R <= n && s[R] == s[R - L + 1]) R++;
z[i] = R - L;
R--;
}
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
Z_function();
for (int i = 1; i <= n; i++) cnt[z[i]]++;
for (int i = n; i >= 1; i--) cnt[i] += cnt[i + 1];
int ans = -1;
for (int i = n; i >= 2; i--) {
if (z[i] == n - i + 1 && cnt[z[i]] >= 3) ans = i;
}
if (ans == -1)
puts("Just a legend");
else {
for (int i = ans; i <= n; i++) printf("%c", s[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int p[1000001];
map<int, bool> used;
int main() {
cin >> s;
for (int i = 1; i < s.size(); ++i) {
int j = p[i - 1];
while (j > 0 && s[j] != s[i]) j = p[j - 1];
if (s[i] == s[j]) ++j;
p[i] = j;
if (i != s.size() - 1) used[p[i]] = true;
}
int j = p[s.size() - 1];
while (j > 0) {
if (used[j]) {
for (int i = 0; i < j; ++i) cout << s[i];
return 0;
}
j = p[j - 1];
}
cout << "Just a legend" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
template <typename T>
void __RI(T &x) {
int ch = getchar(), neg = 1;
x = 0;
for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = getchar())
;
if (ch == EOF) return;
if (ch == '-') neg = -1, ch = getchar();
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
x *= neg;
}
void R(int &x) { __RI(x); }
void R(int64_t &x) { __RI(x); }
template <typename T1, typename T2>
void R(std::pair<T1, T2> &x) {
R(x.first);
R(x.second);
}
template <typename T>
void R(std::vector<T> &x) {
for (auto &i : x) {
R(i);
}
}
template <typename T>
void R(T &x) {
std::cin >> x;
}
template <typename T, typename... Args>
void R(T &x, Args &...args) {
R(x), R(args...);
}
template <typename T>
void RA(T *arr, int l, int r) {
arr += l;
int p = r - l + 1;
while (p--) R(*arr++);
}
char space = ' ';
template <typename T>
void __WI(T x) {
if (x == 0) putchar('0');
if (x < 0) putchar('-'), x = -x;
char ch[64];
int pos = 0;
while (x) ch[pos++] = x % 10 + 48, x /= 10;
while (pos) putchar(ch[--pos]);
}
void W() {}
void W(const int &x) { __WI(x); }
void W(const int64_t &x) { __WI(x); }
void W(const double &x) { printf("%lf", static_cast<double>(x)); }
void W(const char &x) { putchar(x); }
void W(const std::string &x) { printf("%s", x.c_str()); }
template <typename T1, typename T2>
void W(const std::pair<T1, T2> &x) {
W(x.first);
W(space);
W(x.second);
}
template <typename T>
void W(const std::vector<T> &x) {
for (auto it = x.cbegin(); it != x.cend(); it++) {
W(*it);
W(space);
}
W('\n');
}
template <typename T>
void W(const T &x) {
std::cout << x;
}
template <typename T, typename... Args>
void W(const T &x, const Args &...args) {
W(x), W(space), W(args...);
}
template <typename... Args>
void WL(const Args &...args) {
W(args...), W('\n');
}
template <typename T>
void WA(T *arr, int l, int r, char sp = ' ') {
arr += l;
int p = r - l;
while (p--) W(*arr++), W(sp);
W(*arr);
}
template <typename T>
void WAL(T *arr, int l, int r) {
arr += l;
int p = r - l;
while (p--) W(*arr++);
WL(*arr);
}
}; // namespace IO
char t[1000010];
int nxt[1000010], vis[1000010];
int len;
void getnxt() {
nxt[0] = -1;
int i = 0, j = -1;
while (i < len) {
if (j == -1 || t[i] == t[j])
i++, j++, nxt[i] = j;
else
j = nxt[j];
}
for (int i = 0; i < len; i++) vis[nxt[i]]++;
}
int main() {
IO::R(t);
len = strlen(t);
getnxt();
int j = len;
bool ok = 0;
while (nxt[j] != 0) {
if (vis[nxt[j]]) {
IO::WAL(t, 0, nxt[j] - 1);
ok = 1;
break;
}
j = nxt[j];
}
if (ok == 0) IO::WL("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
char str[1000005];
int z[1000005];
int len, answer;
void CalcZArrayN2() {
for (int i = 1; i < len; i++) {
while ((i + z[i] < len) && (str[i + z[i]] == str[z[i]])) {
z[i]++;
}
}
}
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
void CalcZArrayLinear() {
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) && (str[i + z[i]] == str[z[i]])) {
z[i]++;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
}
void ReadData() {
memset(str, 0, sizeof(char) * 1000005);
memset(z, 0, sizeof(int) * 1000005);
scanf("%s\n", &str);
}
void Solve() {
len = strlen(str);
answer = -1;
if (len < 3) return;
CalcZArrayLinear();
int maxz = 0;
for (int i = 1; i < len; i++) {
if (z[i] == len - i && maxz >= len - i) {
answer = len - i;
break;
}
maxz = max(maxz, z[i]);
}
}
void WriteData() {
if (answer == -1) {
printf("Just a legend");
} else {
for (int i = 0; i < answer; i++) {
printf("%c", str[i]);
}
}
printf("\n");
}
int main() {
int QWE;
QWE = 1;
for (int T = 0; T < QWE; T++) {
ReadData();
Solve();
WriteData();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const double eps = 1e-12;
const long long MOD = 1e9 + 7;
const double PI = acos(-1.0);
const long long INF = 1e18;
vector<long long> z_function(string &s) {
long long n = (long long)s.length();
vector<long long> z(n);
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;
long long n = s.length();
if (n == 1) {
cout << "Just a legend\n";
return;
}
vector<long long> z = z_function(s);
map<long long, pair<long long, long long>, greater<long long>> m;
for (long long i = 1; i < n; i++) {
pair<long long, long long> p = {m[z[i]].first + 1, i};
m[z[i]] = p;
}
long long take = 0;
for (auto x : m) {
take += x.second.first;
if (take >= 2) {
if (z[x.second.second] + x.second.second == n) {
cout << s.substr(0, x.first) << "\n";
return;
}
}
}
cout << "Just a legend\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#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());
set<int, greater<int>> suffix;
int limit = 0;
for (int i = 1, l = 0, r = 0; i < z.size(); ++i) {
auto prefix_candidate = z[i - l] < r - i + 1 ? z[i - l] : r - i + 1;
z[i] = 0 > prefix_candidate ? 0 : prefix_candidate;
while (z[i] + i < zstr.length() && zstr[z[i]] == zstr[z[i] + i])
l = i, r = z[i] + i, ++z[i];
if (z[i] + i == zstr.length()) {
suffix.insert(z[i]);
limit = z[i] - 1 > limit ? z[i] - 1 : limit;
} else
limit = z[i] > limit ? z[i] : limit;
}
auto it = suffix.begin();
for (; it != suffix.end() && (*it > limit); ++it)
;
if (it != suffix.end() && *it > 0) return inp.substr(0, *it);
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>
const long long ary = 1e6 + 5;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
using namespace std;
string second;
long long z[ary], c[ary], mx;
void zf() {
long long l = 1, r = 1;
for (int i = 1; i < (long long)second.size(); i++) {
z[i] = max(0ll, min(z[i - l], r - i + 1));
c[z[i]]++;
while (i + z[i] < (long long)second.size() &&
second[z[i]] == second[i + z[i]]) {
z[i]++;
c[z[i]]++;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> second;
zf();
for (int i = 0; i < (long long)second.size(); i++) {
if (i + z[i] == (long long)second.size()) {
if (c[z[i]] > 1) {
for (int j = i; j < i + z[i]; j++) {
cout << second[j];
}
return 0;
}
}
}
cout << "Just a legend";
}
|
#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 gcdExtended(ll a, ll b, ll &x, ll &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
ll x1, y1;
ll d = gcdExtended(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
ll modInverse(ll a, ll m = mod) {
ll x, y;
ll d = gcdExtended(a, m, x, y);
if (d != 1) {
return -1;
}
return (x % m + m) % mod;
}
const ll p{31LL};
ll pwr1[(ll)1e6 + 5];
ll pow1[(ll)1e6 + 5];
void preCalc(ll n, ll mod) {
ll total{1LL};
for (ll i{0}; i < n; ++i) {
pow1[i] = total;
pwr1[i] = modInverse(total, mod);
total = total * p % mod;
}
}
void solve() {
string s;
cin >> s;
ll n{(ll)s.size()};
preCalc(n, mod);
ll preSum[(ll)1e6 + 5];
ll hash_val1{};
for (ll i{0}; i < n; ++i) {
hash_val1 = (hash_val1 + (s[i] - 'a' + 1) * pow1[i]) % mod;
preSum[i] = hash_val1;
}
VI vec;
for (ll i{0}; i < n - 1; ++i) {
ll tem1{(preSum[n - 1] - preSum[i] + mod) % mod};
tem1 = tem1 * pwr1[i + 1] % mod;
ll pr{tem1};
if (preSum[n - 2 - i] == pr) vec.push_back({n - 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 < n - len; i++) {
ll val{};
val = (preSum[i + len - 1] - preSum[i - 1] + mod) % mod;
val = val * pwr1[i] % mod;
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;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 7771;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 12388;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 12387;
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 N = 1e6 + 6;
int p[N];
void kmp(string s) {
int n = s.length();
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;
}
}
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
kmp(s);
int n = s.length();
if (p[n - 1] == 0)
cout << "Just a legend";
else {
int x = 0, ans = p[n - 1];
for (int i = 1; i < n - 1; i++) x = max(x, p[i]);
while (ans != 0) {
if (ans <= x)
break;
else
ans = p[ans - 1];
}
if (ans == 0)
cout << "Just a legend";
else {
for (int i = 0; i < ans; i++) cout << s[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int N = s.length();
int i = 1, j = 0;
int lps[1000001];
lps[0] = 0;
while (i < N) {
if (s[i] == s[j]) {
lps[i] = j + 1;
i++, j++;
} else {
if (j != 0)
j = lps[j - 1];
else
lps[i++] = 0;
}
}
if (lps[N - 1] == 0) {
cout << "Just a legend" << endl;
return 0;
} else {
for (int i = 1; i < N - 1; i++) {
if (lps[i] == lps[N - 1]) {
for (int j = 0; j < lps[i]; j++) cout << s[j];
cout << endl;
return 0;
}
}
}
if (lps[lps[N - 1] - 1] == 0) {
cout << "Just a legend" << endl;
return 0;
} else {
for (int j = 0; j < lps[lps[N - 1] - 1]; j++) cout << s[j];
cout << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod1 = 1e9 + 7;
long long mod2 = 998244353;
long long mul(long long x, long long y) {
return (1ll * (x % mod1) * (y % mod1));
}
long long power(long long x, long long y) {
long long z = 1;
while (y > 0) {
if (y % 2) z = mul(z, x);
x = mul(x, x);
y /= 2;
}
return z;
}
long long gcd(long long a, long long b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long pref[(long long)1e7];
string sol(const string& s) {
string a = s;
long long c = 0;
for (int i = 1; i < (int)a.size(); i++) {
while (c != 0 && a[c] != a[i]) c = pref[c - 1];
if (a[c] == a[i]) c++;
pref[i] = c;
}
return s.substr(0, c);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
string t = sol(s);
long long n = s.size(), m = t.size();
long long f = 1;
if (m == 0) {
cout << "Just a legend" << endl;
} else {
for (long long i = 1; i < n - 1; i++) {
if (pref[i] == m) {
f = 0;
cout << t << endl;
break;
}
}
string st = s.substr(0, pref[m - 1]);
if (f) {
if (st.size() == 0 || m == 0) {
cout << "Just a legend" << endl;
} else {
cout << st << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
auto speedup = []() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return nullptr;
}();
static const auto io_sync_off = []() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
return 0;
}();
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>
#pragma GCC optimize(3)
using namespace std;
const int maxn = 1000005;
int nxt[maxn];
char a[maxn], b[maxn];
int main() {
scanf("%s", a + 1);
int n = strlen(a + 1);
int m = n;
for (register int i = 1; i <= n; i++) {
b[i] = a[i];
}
for (register int i = 2, j; i <= n; i++) {
j = nxt[i - 1];
while (j && a[i] != a[j + 1]) {
j = nxt[j];
}
if (a[i] == a[j + 1]) {
j++;
}
nxt[i] = j;
}
if (!nxt[n]) {
printf("Just a legend");
return 0;
}
while (1) {
n = nxt[n];
if (n == 0) {
break;
}
for (int i = nxt[n]; i <= m - 1; i++) {
if (nxt[i] == n) {
for (register int k = 1; k <= n; k++) {
printf("%c", b[k]);
}
return 0;
}
}
}
printf("Just a legend");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 1000000 + 10;
int fail[nax];
int main() {
std::ios::sync_with_stdio(0);
string s;
cin >> s;
int len = s.length();
fail[0] = 0;
int i = 1, j = 0;
while (i < len) {
if (s[j] != s[i]) {
if (j == 0)
fail[i] = 0, i++;
else
j = fail[j - 1];
} else {
fail[i] = j + 1;
i++, j++;
}
}
int last = fail[len - 1];
int slast = fail[last - 1];
int flag = 0;
if (last == 0) flag = 1;
int mainflag = 0;
for (int i = 0; i < len - 1; i++) {
if (fail[i] == last) mainflag = 1;
}
if (mainflag == 1 && flag == 0) {
cout << s.substr(0, last) << endl;
return 0;
}
if (slast == 0) flag = 1;
mainflag = 1;
if (mainflag == 1 && flag == 0) {
cout << s.substr(0, slast) << endl;
return 0;
}
cout << "Just a legend";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
inline void imp() {
printf("Just a legend\n");
exit(0);
}
string s;
int n;
long long H[1 << 20];
long long PP[1 << 20];
inline long long getHash(int l, int r) {
long long res = H[r];
if (l) res -= H[l - 1] * PP[r - l + 1];
return res;
}
inline int check(int l) {
long long PH = getHash(0, l - 1);
for (int i = 1; i + l < n; ++i) {
long long curHash = getHash(i, i + l - 1);
if (curHash == PH) return 1;
}
return 0;
}
int main() {
cin >> s;
n = (int)s.length();
if (n < 3) imp();
H[0] = (long long)s[0];
for (int i = 1; i < n; ++i) H[i] = H[i - 1] * 1103 + (long long)s[i];
PP[0] = 1;
for (int i = 1; i <= n; ++i) PP[i] = PP[i - 1] * 1103;
int res = -1;
int l = 1, r = n - 2;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
res = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
if (res == -1) imp();
for (; res; --res) {
if (getHash(0, res - 1) == getHash(n - res, n - 1)) break;
}
if (!res) res = -1;
if (res != -1) {
for (int i = 0; i < res; ++i) printf("%c", s[i]);
printf("\n");
return 0;
}
imp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> fail(const string &s) {
int n = s.length();
vector<int> v(n + 1, 0);
int tmp = 0;
for (int i = 1; i < n; i++) {
while (tmp && s[tmp] != s[i]) tmp = v[tmp];
if (s[tmp] == s[i]) tmp++;
v[i + 1] = tmp;
}
return v;
}
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 = v[i];
break;
}
}
if (f) {
for (int i = 0; i < f; i++) cout << s[i];
} else if (v[v[n]] == 0)
cout << "Just a legend";
else
for (int i = 0; i < v[v[n]]; i++) cout << s[i];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 128183;
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 linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int inf = 1e9;
long long read() {
bool minus = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus) {
return -result;
} else {
return result;
}
}
long long fpow(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power % 2 == 1) result = (result * base);
base = (base * base);
power /= 2;
}
return result;
}
long long lps[1000100];
vector<long long> v[1000100];
inline void Prefix(string str) {
long long i, j, n = str.size();
i = 0, j = 1;
lps[0] = 0;
while (i < n && j < n) {
if (str[i] == str[j]) {
lps[j] = i + 1;
j++;
i++;
} else {
if (i > 0) {
i = lps[i - 1];
} else {
lps[j] = 0;
j++;
}
}
if (j == n) break;
}
}
inline void Sukeesh(long long n) {
for (long long i = 0; i < n; i++) {
v[lps[i]].push_back(i);
}
}
bool check(long long n, long long no) {
for (long long i = 0; i < v[n].size(); i++) {
if (v[n][i] != no) return 1;
}
return 0;
}
int main() {
string str;
cin >> str;
Prefix(str);
Sukeesh(str.size());
long long n = str.size() - 1;
while (n > 0) {
if (lps[n] > 0) {
if (check(lps[n], str.size() - 1)) {
for (long long i = 0; i < lps[n]; i++) {
cout << str[i];
}
return 0;
}
} else {
return 0 * printf("Just a legend");
}
n = lps[n] - 1;
}
return 0 * printf("Just a legend");
}
|
#include <bits/stdc++.h>
using namespace std;
class node {
public:
long long int second;
long long int length;
};
int main() {
string pattern;
cin >> pattern;
long long int i, m, n, j;
n = pattern.length();
long long int dfa[n];
memset(dfa, 0, sizeof(dfa));
long long int x = 0;
for (i = 1; i < n; i++) {
if (pattern[i] == pattern[x])
x++, dfa[i] = x;
else if (x > 0) {
x = dfa[x - 1];
i--;
}
}
for (i = 0; i < n - 1; i++)
if (dfa[n - 1] > 0 && dfa[i] == dfa[n - 1]) {
for (j = 0; j < dfa[n - 1]; j++) printf("%c", pattern[j]);
cout << endl;
break;
}
if (i == n - 1 && dfa[n - 1] > 0 && dfa[dfa[n - 1] - 1] > 0) {
for (j = 0; j < dfa[dfa[n - 1] - 1]; j++) printf("%c", pattern[j]);
cout << endl;
} else if (i == n - 1)
cout << "Just a legend\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void func() {
string s;
cin >> s;
long long n = s.length();
long long i = 1, len = 0, pre[n];
pre[0] = 0;
while (i < n) {
if (s[i] == s[len]) {
len++;
pre[i++] = len;
} else {
if (len == 0) {
pre[i++] = 0;
} else {
len = pre[len - 1];
}
}
}
if (pre[n - 1] == 0) {
cout << "Just a legend"
<< "\n";
return;
}
for (long long i = 0; i < n - 1; ++i) {
if (pre[i] == pre[n - 1]) {
cout << s.substr(0, pre[n - 1]) << "\n";
return;
}
}
if (pre[pre[n - 1] - 1] == 0) {
cout << "Just a legend"
<< "\n";
return;
}
cout << s.substr(0, pre[pre[n - 1] - 1]) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
func();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 2017, M = 1e9 + 7;
string s;
int n;
vector<int> p, h;
int get(int l, int r) {
if (!l) return h[r];
return h[r] - h[l - 1] * p[r - l + 1];
}
int bs(int i) {
int l = 0, r = n - i;
while (l != r - 1) {
int m = (l + r) / 2;
if (get(i, i + m - 1) == get(0, m - 1)) {
l = m;
} else {
r = m;
}
}
return l;
}
int main() {
cin >> s;
n = s.size();
if (s.size() < 3) {
cout << "Just a legend";
return 0;
}
if (s[0] == s[1] && s[1] == s[2] && s.size() == 3) {
cout << s[0];
return 0;
} else if (s.size() == 3) {
cout << "Just a legend";
return 0;
}
p.resize(n);
h.resize(n);
p[0] = 1;
for (int i = 1; i < n; i++) {
p[i] = p[i - 1] * P;
}
h[0] = s[0] - 'a' + 1;
for (int i = 1; i < n; i++) {
h[i] = h[i - 1] * P + s[i] - 'a' + 1;
}
int ans = 0;
for (int i = 1; i < n - 1; i++) {
ans = max(ans, bs(i));
}
set<int> st;
for (int i = 0; i < n; i++) {
if (get(i, n - 1) == get(0, n - i - 1)) {
st.insert(n - i);
}
}
if (ans == 0 || st.upper_bound(ans) == st.begin()) {
cout << "Just a legend";
return 0;
}
cout << s.substr(0, *(--st.upper_bound(ans)));
}
|
#include <bits/stdc++.h>
using namespace std;
char a[1000005];
int ne[1000005], n, maxx = 0;
void c() {
ne[1] = 0;
for (int i = 2, j = 0; i <= n; i++) {
while (j && a[i] != a[j + 1]) {
j = ne[j];
}
if (a[i] == a[j + 1]) {
j++;
}
ne[i] = j;
if (i != n) {
maxx = max(ne[i], maxx);
}
}
}
int main() {
cin >> a + 1;
n = strlen(a + 1);
c();
int x = ne[n];
if (x == 0) {
printf("Just a legend\n");
} else {
while (x > maxx) {
x = ne[x];
}
if (x == 0) {
printf("Just a legend\n");
return 0;
}
for (int i = 2; i < n; i++)
if (x == ne[i]) {
for (int j = i - ne[i] + 1; j <= i; j++) {
printf("%c", a[j]);
}
printf("\n");
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 9;
const long long LINF = 1e12;
const int MAXN = 1e6 + 5;
const int MOD = 1e9 + 7;
const double eps = 1e-14;
int n;
int pf[MAXN];
string s;
void pref_func() {
for (int i = 1; i < n; i++) {
int j = pf[i - 1];
while (j > 0 && s[i] != s[j]) j = pf[j - 1];
if (s[i] == s[j]) j++;
pf[i] = j;
}
}
void solve() {
cin >> s;
n = s.size();
pref_func();
int k = 0;
for (int i = 1; i < n - 1; i++) {
if (pf[i] == pf[n - 1]) k = pf[n - 1];
}
for (int i = 1; i < n - 1; i++) {
if (pf[i] == pf[pf[n - 1] - 1]) k = max(k, pf[pf[n - 1] - 1]);
}
if (k) {
for (int i = 0; i < k; i++) cout << s[i];
} else
cout << "Just a legend";
}
int main() {
if (!1) {
freopen(
"474"
".in",
"r", stdin);
freopen(
"474"
".out",
"w", stdout);
}
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const long long z = 131, MOD = 1e9 + 21;
long long Z[MAXN + 1];
void fillZ() {
Z[0] = 1;
for (int n = 1; n <= MAXN; ++n) Z[n] = z * Z[n - 1] % MOD;
}
struct RollingHashing {
vector<long long> H;
RollingHashing(string &S) {
int N = S.length();
H.resize(N + 1);
H[N] = 0;
for (int i = N - 1; i >= 0; --i) H[i] = (S[i] + z * H[i + 1]) % MOD;
}
long long hash(int i, int k) {
long long ans = (H[i] - Z[k] * H[i + k]) % MOD;
return ans >= 0 ? ans : ans + MOD;
}
};
int main() {
fillZ();
string s;
cin >> s;
int lens = s.length();
int lent = lens - 2;
RollingHashing rs(s);
long long prefix, suffix, mid;
int i;
while (lent > 0) {
prefix = rs.hash(0, lent);
suffix = rs.hash(lens - lent, lent);
if (prefix == suffix) {
i = 1;
while (i + lent < lens) {
mid = rs.hash(i, lent);
if (mid == prefix) {
for (int j = 0; j < lent; ++j) {
cout << s[j];
}
cout << '\n';
return 0;
}
++i;
}
}
--lent;
}
cout << "Just a legend\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 8888;
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 Alp = 26;
const int __PRECISION = 9;
const int inf = 1e9 + 8;
const long double PI = acos(-1);
const long double EPS = 1e-7;
const long long MOD = 1e9 + 7;
const long long MAXN = 2e5 + 5;
const long long ROOTN = 320;
const long long LOGN = 18;
const long long INF = 1e18 + 1022;
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;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string S;
cin >> S;
vector<int> zz = z_function(S);
int mx = 0;
for (int i = 1; i <= ((int)S.size() - 1); ++i) {
if (zz[i] == (int)S.size() - i && zz[i] <= mx) {
cout << S.substr(i) << '\n';
exit(0);
}
mx = max(mx, zz[i]);
}
cout << "Just a legend\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.