text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
const int N = 1e6 + 50;
int n, m, w[N], c[N], s[N];
bool vis[N];
std::vector<std::pair<int, int> > G[N];
template <int T>
struct fast_io {
char p[T], q[T], *p1, *p2, *q1, *q2;
fast_io() {
p1 = p2 = p;
q1 = q, q2 = q + T;
}
inline char gc() {
return p1 == p2 && (p2 = (p1 = p) + fread(p, 1, T, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void pc(char c) {
if (q1 == q2) q2 = (q1 = q) + fwrite(q, 1, T, stdout);
*q1++ = c;
}
~fast_io() { fwrite(q, 1, q1 - q, stdout); }
};
fast_io<1 << 20> io;
inline int64_t read() {
int64_t res = 0, neg = 1;
char ch;
do {
ch = io.gc();
if (ch == '-') neg = -1;
} while (ch < 48 || ch > 57);
do res = res * 10 + ch - 48, ch = io.gc();
while (ch >= 48 && ch <= 57);
return res * neg;
}
inline void put(int64_t x) {
if (x < 0) io.pc('-'), x = -x;
if (x >= 10) put(x / 10);
io.pc(48 + x % 10);
}
inline void output(int64_t x, char ch = ' ') {
put(x);
io.pc(ch);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
if (u < v) std::swap(u, v);
G[u].emplace_back(v, i);
w[i] = 1;
++s[u], ++s[v];
}
for (int x = 1; x <= n; ++x) {
for (auto &[y, i] : G[x]) {
if (!c[y]) {
++c[y];
--w[i];
--s[x];
}
vis[s[y]] = true;
}
int &cur = s[x];
for (auto &[y, i] : G[x]) {
if (!vis[cur]) break;
--c[y];
++w[i];
++cur;
}
for (auto &[y, i] : G[x]) vis[s[y]] = false;
}
std::vector<int> res;
for (int i = 1; i <= n; ++i)
if (c[i]) res.push_back(i);
printf("%d\n", res.size());
for (int x : res) printf("%d ", x);
putchar('\n');
for (int x = 1; x <= n; ++x)
for (auto &[y, i] : G[x]) printf("%d %d %d\n", x, y, w[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > from[13000];
int a[13000], b[1000010], alive[13000], val[13000];
int vis[3000010], TOTOT = 2333;
int X[1000010], Y[1000010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
from[x].push_back(make_pair(y, i));
from[y].push_back(make_pair(x, i));
X[i] = x, Y[i] = y, val[x]++, val[y]++, b[i] = 1;
}
for (int i = 0; i < n; i++) {
TOTOT++;
int p = 0, q = 0;
for (int j = 0; j < from[i].size(); j++) {
int v = from[i][j].first, id = from[i][j].second;
if (!alive[v]) continue;
if (a[v])
p++;
else
q++;
vis[val[v]] = TOTOT;
}
for (int j = val[i] - q; j <= val[i] + p; j++) {
if (vis[j] != TOTOT) {
p = max(0, j - val[i]);
q = max(0, val[i] - j);
}
}
for (int j = 0; j < from[i].size(); j++) {
int v = from[i][j].first, id = from[i][j].second;
if (!alive[v]) continue;
if (a[v]) {
if (p) p--, a[v] = 0, b[id]++, val[i]++;
} else {
if (q) q--, a[v] = 1, b[id]--, val[i]--;
}
}
alive[i] = 1;
}
vector<int> all;
for (int i = 0; i < n; i++) {
if (a[i]) all.push_back(i + 1);
}
printf("%d\n", (int)all.size());
if (all.size()) {
for (int i = 0; i < all.size(); i++) {
printf("%d ", all[i]);
}
printf("\n");
}
for (int i = 0; i < k; i++) {
printf("%d %d %d\n", X[i] + 1, Y[i] + 1, b[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast")
using namespace std;
namespace Base {
inline char gc(void) {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline void read(T &x) {
T flag = (T)1;
x = 0;
static char ch = gc();
for (; ch > '9' || ch < '0'; ch = gc()) flag = ch == '-' ? -1 : 1;
for (; ch >= '0' && ch <= '9'; ch = gc()) x = (x << 1) + (x << 3) + (ch & 15);
x *= flag;
return;
}
inline void readstr(string &x) {
x = "";
static char ch;
while (isspace(ch = gc()))
;
while (x += ch, !isspace(ch = gc()))
;
}
inline void readstr(char *s) {
do *s = gc();
while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
do *(++s) = gc();
while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
*s = 0;
return;
}
inline void printstr(string x, int num = 0, char ch = '\n') {
for (int i = num; i < x.size(); ++i) putchar(x[i]);
putchar(ch);
}
inline void readch(char &x) {
while (isspace(x = gc()))
;
}
char pf[100000], *o1 = pf, *o2 = pf + 100000;
template <class T>
inline void println(T x, char c = '\n') {
if (x < 0)
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = 45 : *o1++ = 45),
x = -x;
static char s[15], *b;
b = s;
if (!x) *b++ = 48;
for (; x; *b++ = x % 10 + 48, x /= 10)
;
for (; b-- != s; (o1 == o2 ? fwrite(pf, 1, 100000, stdout),
*(o1 = pf)++ = *b : *o1++ = *b))
;
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = c : *o1++ = c);
}
int wbuf[25], _wl = 0;
template <class T>
inline void write(T x) {
if (x == 0) {
putchar(48);
return;
}
if (x < 0) putchar('-'), x = -x;
_wl = 0;
while (x) wbuf[++_wl] = x % 10, x /= 10;
for (int i = _wl; i >= 1; i--) putchar(wbuf[i] + 48);
}
template <class T>
inline void writeln(T x) {
write(x);
puts("");
}
template <class T>
inline void writeln(T x, char c) {
write(x);
putchar(c);
}
template <class T>
inline void writeln(char c, T x) {
putchar(c);
write(x);
}
template <class T>
inline void chkmax(T &x, const T y) {
x > y ? x = x : x = y;
}
template <class T>
inline void chkmin(T &x, const T y) {
x < y ? x = x : x = y;
}
template <class T>
inline T max(const T &x, const T &y, const T &z) {
return x > y ? (x > z ? x : z) : (y > z ? y : z);
}
inline void file(string str) {
freopen((str + ".in").c_str(), "r", stdin);
freopen((str + ".out").c_str(), "w", stdout);
}
struct Vector {
double x, y;
Vector(double _x = 0, double _y = 0) : x(_x), y(_y) {}
inline Vector Vary(void) { return Vector(x, -y); }
inline bool operator<(const Vector &rhs) const {
return x == rhs.x ? y < rhs.y : x < rhs.x;
}
inline Vector operator-(const Vector &rhs) const {
return Vector(x - rhs.x, y - rhs.y);
}
inline Vector operator+(const Vector &rhs) const {
return Vector(x + rhs.x, y + rhs.y);
}
inline Vector operator*(const double &rhs) const {
return Vector(x * rhs, y * rhs);
}
inline Vector operator/(const double &rhs) const {
return Vector(x / rhs, y / rhs);
}
inline Vector operator*(const Vector &rhs) const {
return Vector(x * rhs.x - y * rhs.y, x * rhs.y + y * rhs.x);
}
};
} // namespace Base
using namespace Base;
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
bool in[N * 2];
vector<pair<int, int> > e[N];
vector<int> res;
int n, m;
int main() {
read(n);
read(m);
for (register int i = (1); i <= (m); i++) {
read(x[i]);
read(y[i]);
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (register int i = (1); i <= (n); i++) {
for (register int it = (0); it <= (int(e[i].size()) - 1); it++) {
if (!v[e[i][it].first]) {
v[e[i][it].first] = 1;
w[e[i][it].second] = 0;
s[i]--;
}
in[s[e[i][it].first]] = 1;
}
for (register int it = (0); it <= (int(e[i].size()) - 1); it++) {
if (!in[s[i]]) break;
s[i]++;
v[e[i][it].first] = 0;
w[e[i][it].second]++;
}
for (register int it = (0); it <= (int(e[i].size()) - 1); it++)
in[s[e[i][it].first]] = 0;
}
for (register int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
writeln(int(res.size()));
for (register int it = (0); it <= (int(res.size()) - 1); it++)
writeln(res[it], ' ');
puts("");
for (register int i = (1); i <= (m); i++) {
writeln(x[i], ' ');
writeln(y[i], ' ');
writeln(w[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline char gc(void) {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
static char c = gc();
for (; !isdigit(c); c = gc())
if (c == '-') f = -f;
for (; isdigit(c); c = gc()) x = (x << 1) + (x << 3) + (c & 15);
x *= f;
}
inline void readstr(char *s) {
do *s = gc();
while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
do *(++s) = gc();
while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
*s = 0;
return;
}
inline void readch(char &x) {
while (isspace(x = gc()))
;
}
char pf[100000], *o1 = pf, *o2 = pf + 100000;
template <class T>
inline void writeln(T x, char c = '\n') {
if (x < 0)
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = 45 : *o1++ = 45),
x = -x;
static char s[15], *b;
b = s;
if (!x) *b++ = 48;
for (; x; *b++ = x % 10 + 48, x /= 10)
;
for (; b-- != s; (o1 == o2 ? fwrite(pf, 1, 100000, stdout),
*(o1 = pf)++ = *b : *o1++ = *b))
;
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = c : *o1++ = c);
}
template <class T>
inline void chkmax(T &x, const T y) {
x > y ? x = x : x = y;
}
template <class T>
inline void chkmin(T &x, const T y) {
x < y ? x = x : x = y;
}
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
bool in[N * 2];
vector<pair<int, int> > e[N];
vector<int> res;
int n, m;
int main() {
ios ::sync_with_stdio(false);
cin.tie();
cin >> n >> m;
for (register int i = (1); i <= (m); i++) {
cin >> x[i] >> y[i];
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (register int i = (1); i <= (n); i++) {
for (auto it : e[i]) {
if (!v[it.first]) {
v[it.first] = 1;
w[it.second] = 0;
s[i]--;
}
in[s[it.first]] = 1;
}
for (auto it : e[i]) {
if (!in[s[i]]) break;
s[i]++;
v[it.first] = 0;
w[it.second]++;
}
for (auto it : e[i]) in[s[it.first]] = 0;
}
for (register int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
cout << int(res.size()) << '\n';
for (auto it : res) cout << it << ' ';
cout << '\n';
for (register int i = (1); i <= (m); i++)
cout << x[i] << ' ' << y[i] << ' ' << w[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
int n, k;
int u[1 << 20], v[1 << 20];
bool sel[1 << 14];
vector<pair<int, int> > nei[1 << 14], egs[1 << 14];
bool lgl[1 << 21];
int val[1 << 20], F[1 << 20];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= (k); ++i) {
int a, b;
scanf("%d%d", &a, &b);
u[i] = a;
v[i] = b;
if (a < b) swap(a, b);
nei[a].push_back(make_pair(b, i));
egs[a].push_back(make_pair(b, i));
egs[b].push_back(make_pair(a, i));
val[i] = 1;
}
for (int i = 1; i <= (n); ++i) {
int fix = 0;
for (int j = 0; j < (((int)(nei[i]).size())); ++j) {
int to = nei[i][j].first, eg = nei[i][j].second;
if (sel[to]) {
sel[to] = 0;
++val[eg];
}
}
for (int j = 0; j < (((int)(egs[i]).size())); ++j)
fix += val[egs[i][j].second];
for (int j = (fix - ((int)(nei[i]).size())); j <= (fix); ++j) lgl[j] = 0;
for (int j = 0; j < (((int)(nei[i]).size())); ++j)
lgl[F[nei[i][j].first]] = 1;
for (int j = 0; j < (((int)(nei[i]).size())); ++j) {
int to = nei[i][j].first, eg = nei[i][j].second;
if (lgl[fix]) {
sel[to] = 1;
--val[eg];
--fix;
} else {
break;
}
}
F[i] = fix;
}
int all = 0;
for (int i = 1; i <= (n); ++i) all += sel[i];
printf("%d\n", all);
for (int i = 1; i <= (n); ++i)
if (sel[i]) printf("%d\n", i);
for (int i = 1; i <= (k); ++i) printf("%d %d %d\n", u[i], v[i], val[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
vector<pair<int, int> > e[N];
vector<int> res;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); i++) {
scanf("%d%d", x + i, y + i);
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (int i = (1); i <= (n); i++) {
set<int> in;
for (auto it : e[i]) {
if (!v[it.first]) {
v[it.first] = 1;
w[it.second] = 0;
s[i]--;
}
in.insert(s[it.first]);
}
while (e[i].size()) {
if (in.find(s[i]) == in.end()) break;
s[i]++;
v[e[i].back().first] = 0;
w[e[i].back().second]++;
e[i].pop_back();
}
if (in.find(s[i]) != in.end()) {
s[i]++;
v[i] = 1;
}
}
for (int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
printf("%d\n", int(res.size()));
for (auto it : res) printf("%d ", it);
puts("");
for (int i = (1); i <= (m); i++) printf("%d %d %d\n", x[i], y[i], w[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
vector<pair<int, int> > e[N];
vector<int> res;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); i++) {
scanf("%d%d", x + i, y + i);
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (int i = (1); i <= (n); i++) {
set<int> in;
for (auto it : e[i]) {
if (!v[it.first]) {
v[it.first] = 1;
w[it.second] = 0;
s[i]--;
}
in.insert(s[it.first]);
}
while (e[i].size()) {
if (in.find(s[i]) == in.end()) break;
s[i]++;
v[e[i].back().first] = 0;
w[e[i].back().second]++;
e[i].pop_back();
}
}
for (int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
printf("%d\n", int(res.size()));
for (auto it : res) printf("%d ", it);
puts("");
for (int i = (1); i <= (m); i++) printf("%d %d %d\n", x[i], y[i], w[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &n) {
T w = 1;
n = 0;
char ch = getchar();
while (!isdigit(ch) && ch != EOF) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch) && ch != EOF) {
n = (n << 1) + (n << 3) + (ch ^ 48);
ch = getchar();
}
n *= w;
}
template <typename T>
inline void write(T x) {
T y = 0, l = 0;
if (x < 0) {
x = -x;
putchar('-');
}
if (!x) {
putchar(48);
return;
}
while (x) {
y = y * 10 + x % 10;
x /= 10;
l++;
}
while (l) {
putchar(y % 10 + 48);
y /= 10;
l--;
}
}
template <typename T>
inline void writeln(T x) {
write(x);
puts("");
}
template <typename T>
inline void writes(T x) {
write(x);
putchar(' ');
}
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
bool in[N * 2];
vector<pair<int, int> > e[N];
vector<int> res;
int main() {
int n, m;
read(n);
read(m);
for (int i = (1); i <= (m); i++) {
read(x[i]);
read(y[i]);
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (int i = (1); i <= (n); i++) {
for (int it = (0); it <= (int(e[i].size()) - 1); it++) {
if (!v[e[i][it].first]) {
v[e[i][it].first] = 1;
w[e[i][it].second] = 0;
s[i]--;
}
in[s[e[i][it].first]] = 1;
}
for (int it = (0); it <= (int(e[i].size()) - 1); it++) {
if (!in[s[i]]) break;
s[i]++;
v[e[i][it].first] = 0;
w[e[i][it].second]++;
}
for (int it = (0); it <= (int(e[i].size()) - 1); it++)
in[s[e[i][it].first]] = 0;
}
for (int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
writeln(int(res.size()));
for (int it = (0); it <= (int(res.size()) - 1); it++) writes(res[it]);
puts("");
for (int i = (1); i <= (m); i++) {
writes(x[i]);
writes(y[i]);
writeln(w[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
int read() {
char c;
while ((c = getchar()) < '-')
;
if (c == '-') {
int x = (c = getchar()) - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return -x;
}
int x = c - '0';
while ((c = getchar()) >= '0') x = x * 10 + c - '0';
return x;
}
const int N = 12500 + 5, M = 1e6 + 5;
struct Edge {
int to, id;
};
vector<Edge> lk[N];
pair<int, int> e[M];
int s[N], ans[M];
bool w[N], mark[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) s[i] = w[i] = 1;
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
e[i] = {x, y};
if (x > y) swap(x, y);
lk[y].push_back({x, i});
++s[x];
++s[y];
ans[i] = 1;
}
for (int x = 1; x <= n; ++x) {
int c1 = 0, m = lk[x].size();
for (const auto &e : lk[x]) c1 += w[e.to];
int c0 = m - c1;
for (int i = 0; i <= m; ++i) mark[i] = 0;
int p = s[x];
for (const auto &e : lk[x])
if (s[e.to] >= p - c0 && s[e.to] <= p + c1) mark[s[e.to] - (p - c0)] = 1;
int r = 0;
while (mark[r]) ++r;
r -= c0;
s[x] += r;
for (const auto &e : lk[x])
if (r > 0 && w[e.to]) {
--r;
w[e.to] = 0;
ans[e.id] = 2;
} else if (r < 0 && !w[e.to]) {
++r;
w[e.to] = 1;
ans[e.id] = 0;
}
}
int c1 = 0;
for (int i = 1; i <= n; ++i) c1 += w[i];
printf("%d\n", c1);
if (c1) {
for (int i = 1; i <= n; ++i)
if (w[i]) printf("%d%c", i, " \n"[--c1 == 0]);
}
for (int i = 1; i <= m; ++i)
printf("%d %d %d\n", e[i].first, e[i].second, ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
int main() {
n = read();
m = read();
vector<vector<int> > graf(n);
vector<int> fa(n), cnt(n), last;
for (int i = 0; i < m; ++i) {
int u = read() - 1, v = read() - 1;
graf[((u) > (v) ? (u) : (v))].push_back(((u) < (v) ? (u) : (v)));
cnt[u]++;
cnt[v]++;
}
vector<pair<pair<int, int>, int> > E;
for (int i = 0; i < n; ++i) {
map<int, int> vis;
vector<int> up, down;
for (auto v : graf[i]) {
vis[cnt[v]] = 1;
if (fa[v])
up.push_back(v);
else
down.push_back(v);
}
if (!vis[cnt[i]]) {
for (auto v : up) E.push_back({{v, i}, 1});
for (auto v : down) E.push_back({{v, i}, 1});
continue;
}
bool fl = 0;
for (int j = 1; j <= up.size(); ++j)
if (!vis[cnt[i] + j]) {
cnt[i] += j;
for (auto v : down) E.push_back({{v, i}, 1});
for (int k = 0; k < up.size(); ++k)
if (k < j) {
E.push_back({{up[k], i}, 2});
fa[up[k]] ^= 1;
} else
E.push_back({{up[k], i}, 1});
fl = 1;
break;
}
if (!fl)
for (int j = 1; j <= down.size(); ++j)
if (!vis[cnt[i] - j]) {
cnt[i] -= j;
for (auto v : up) E.push_back({{v, i}, 1});
for (int k = 0; k < down.size(); ++k)
if (k < j) {
E.push_back({{down[k], i}, 0});
fa[down[k]] ^= 1;
} else
E.push_back({{down[k], i}, 1});
fl = 1;
break;
}
}
for (int i = 0; i < n; ++i)
if (fa[i]) last.push_back(i);
printf("%d ", last.size());
for (auto v : last) printf("%d ", v + 1);
puts("");
for (auto v : E)
printf("%d %d %d\n", v.first.first + 1, v.first.second + 1, v.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return x;
}
int n, k;
struct Edge {
int u, v, nxt;
} edge[1000010];
int cnt, last[12510];
inline void addedge(int x, int y) {
edge[++cnt] = (Edge){x, y, last[x]}, last[x] = cnt;
}
int V[12510];
int E[1000010];
int w[12510];
int vrn[1000010], tim;
int main() {
n = read(), k = read();
for (int i = 1; i <= k; i++) {
int u = read(), v = read();
w[u]++, w[v]++;
if (u < v) swap(u, v);
addedge(u, v);
}
for (int i = 2; i <= n; i++) {
++tim;
for (int j = last[i], v; j; j = edge[j].nxt) {
v = edge[j].v;
if (!V[v])
V[v] = 1, E[j] = 0, w[i]--;
else
E[j] = 1;
vrn[w[v]] = tim;
}
if (vrn[w[i]] ^ tim) continue;
for (int j = last[i], v; j; j = edge[j].nxt) {
v = edge[j].v;
V[v]--, E[j]++, w[i]++;
if (vrn[w[i]] ^ tim) break;
}
}
int tot = 0;
for (int i = 1; i <= n; i++)
if (V[i]) tot++;
printf("%d\n", tot);
for (int i = 1; i <= n; i++)
if (V[i]) printf("%d ", i);
if (tot) puts("");
for (int i = 1; i <= k; i++) printf("%d %d %d\n", edge[i].u, edge[i].v, E[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
vector<pair<int, int> > e[N];
vector<int> res;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); i++) {
scanf("%d%d", x + i, y + i);
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (int i = (1); i <= (n); i++) {
set<int> in;
for (auto it : e[i]) {
if (!v[it.first]) {
v[it.first] = 1;
w[it.second] = 0;
s[i]--;
}
in.insert(s[it.first]);
}
for (auto it : e[i]) {
if (in.find(s[i]) == in.end()) break;
s[i]++;
v[it.first] = 0;
w[it.second]++;
}
}
for (int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
printf("%d\n", int(res.size()));
for (auto it : res) printf("%d ", it);
puts("");
for (int i = (1); i <= (m); i++) printf("%d %d %d\n", x[i], y[i], w[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x[12503], y[1000003], val[12503], lst[1000003];
vector<int> v[12503], g[12503], A, B, V;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
val[a]++;
val[b]++;
v[max(a, b)].push_back(min(a, b));
g[max(a, b)].push_back(i);
y[i] = 1;
A.push_back(a + 1);
B.push_back(b + 1);
}
for (int i = 0; i < 1000003; i++) lst[i] = -1;
for (int i = 0; i < n; i++) {
int nowval = val[i];
for (int j = 0; j < v[i].size(); j++) {
if (x[v[i][j]] == 0) {
x[v[i][j]]++;
y[g[i][j]]--;
nowval--;
}
lst[val[v[i][j]]] = i;
}
for (int j = 0; j <= v[i].size(); j++)
if (lst[nowval + j] != i) {
for (int k = 0; k < j; k++) {
x[v[i][k]]--;
y[g[i][k]]++;
}
nowval += j;
break;
}
val[i] = nowval;
}
for (int i = 0; i < n; i++)
if (x[i]) V.push_back(i + 1);
cout << V.size() << endl;
for (int i = 0; i < V.size(); i++) printf("%d ", V[i]);
if (V.size()) cout << endl;
for (int i = 0; i < m; i++) printf("%d %d %d\n", A[i], B[i], y[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1E6 + 5;
int n, m, size, head[maxn];
inline int read() {
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
int s = ch - '0';
ch = getchar();
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return s;
}
struct edge {
int to, next, w;
} E[maxn * 2];
inline void add(int u, int v) {
E[++size].to = v;
E[size].next = head[u];
E[size].w = -1;
head[u] = size;
}
bool vis[maxn];
int f[maxn];
int TI, tmp[maxn];
inline void bfs(int S) {
queue<int> Q;
Q.push(S);
vis[S] = 1;
f[S] = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
++TI;
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].to;
if (f[v] != -1) tmp[f[v]] = TI;
if (!vis[v]) {
vis[v] = 1;
Q.push(v);
}
}
int pos = 0;
while (tmp[pos] == TI) ++pos;
f[u] = pos;
}
}
vector<int> wait[12555];
int gg[maxn];
bool cmp(int x, int y) { return f[E[x].to] > f[E[y].to]; }
inline void solve() {
for (int i = 1; i <= n; ++i) wait[f[i]].push_back(i);
for (int e = n; e >= 0; --e)
for (int q = 0; q < wait[e].size(); ++q) {
int u = wait[e][q];
gg[u] = 1;
int tot = 0;
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].to;
if (gg[v]) continue;
tmp[++tot] = i;
}
sort(tmp + 1, tmp + tot + 1, cmp);
for (int i = 1; i <= tot; ++i) {
int v = E[tmp[i]].to;
int k = min(2, min(f[u], f[v]));
f[u] -= k, f[v] -= k;
E[tmp[i]].w = k;
}
}
vector<int> A;
for (int u = 1; u <= n; ++u) {
assert(f[u] <= 1);
if (f[u]) A.push_back(u);
}
cout << A.size() << '\n';
for (int i = 0; i < A.size(); ++i) cout << A[i] << " ";
if (A.size() != 0) cout << '\n';
for (int u = 1; u <= n; ++u)
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].to;
if (E[i].w != -1) {
cout << u << " " << v << " " << E[i].w << '\n';
f[u] += E[i].w;
f[v] += E[i].w;
}
}
cout << endl;
for (int u = 1; u <= n; ++u)
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].to;
if (f[v] == f[u]) assert(0);
}
}
int main() {
ios::sync_with_stdio(false);
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; ++i) f[i] = -1;
for (int i = 1; i <= n; ++i)
if (!vis[i]) bfs(i);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc(void) {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
static char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c & 15);
x *= f;
}
inline void readstr(char *s) {
do *s = getchar();
while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
do *(++s) = getchar();
while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
*s = 0;
return;
}
inline void readch(char &x) {
while (isspace(x = getchar()))
;
}
char pf[100000], *o1 = pf, *o2 = pf + 100000;
template <class T>
inline void writeln(T x, char c = '\n') {
if (x < 0)
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = 45 : *o1++ = 45),
x = -x;
static char s[15], *b;
b = s;
if (!x) *b++ = 48;
for (; x; *b++ = x % 10 + 48, x /= 10)
;
for (; b-- != s; (o1 == o2 ? fwrite(pf, 1, 100000, stdout),
*(o1 = pf)++ = *b : *o1++ = *b))
;
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = c : *o1++ = c);
}
template <class T>
inline void chkmax(T &x, const T y) {
x > y ? x = x : x = y;
}
template <class T>
inline void chkmin(T &x, const T y) {
x < y ? x = x : x = y;
}
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
bool in[N * 2];
vector<pair<int, int> > e[N];
vector<int> res;
int n, m;
int main() {
read(n), read(m);
for (register int i = (1); i <= (m); i++) {
read(x[i]), read(y[i]);
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (register int i = (1); i <= (n); i++) {
for (auto it : e[i]) {
if (!v[it.first]) {
v[it.first] = 1;
w[it.second] = 0;
s[i]--;
}
in[s[it.first]] = 1;
}
for (auto it : e[i]) {
if (!in[s[i]]) break;
s[i]++;
v[it.first] = 0;
w[it.second]++;
}
for (auto it : e[i]) in[s[it.first]] = 0;
}
for (register int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
writeln(int(res.size()));
for (auto it : res) writeln(it, ' ');
puts("");
for (register int i = (1); i <= (m); i++)
writeln(x[i], ' '), writeln(y[i], ' '), writeln(w[i]);
fwrite(pf, 1, o1 - pf, stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
bool on[12510];
int sum[12510];
int val[1001000], s[1001000], t[1001000];
vector<int> v[12510];
set<int> hs;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
scanf("%d%d", &s[i], &t[i]), val[i] = 1, sum[s[i]]++, sum[t[i]]++,
v[s[i]].push_back(i), v[t[i]].push_back(i);
for (int i = 1; i <= n; i++) {
for (auto j : v[i]) {
if ((s[j] ^ t[j] ^ i) > i) continue;
if (!on[s[j] ^ t[j] ^ i]) on[s[j] ^ t[j] ^ i] = true, val[j]--, sum[i]--;
hs.insert(sum[s[j] ^ t[j] ^ i]);
}
for (auto j : v[i]) {
if ((s[j] ^ t[j] ^ i) > i) continue;
if (hs.find(sum[i]) == hs.end()) break;
on[s[j] ^ t[j] ^ i] = false, val[j]++, sum[i]++;
}
hs.clear();
}
for (int i = 1; i <= n; i++) cnt += on[i];
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (on[i]) printf("%d ", i);
if (cnt) puts("");
for (int i = 1; i <= m; i++) printf("%d %d %d\n", s[i], t[i], val[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 12505;
const int M = 1000005;
int n, m, w[N], a[N], b[M], eu[M], ev[M];
bool vis[M * 2];
vector<pair<int, int> > G[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].emplace_back(v, i);
G[v].emplace_back(u, i);
b[i] = 1;
eu[i] = u, ev[i] = v;
}
for (int i = 1; i <= n; i++) w[i] = (int)G[i].size(), a[i] = 0;
for (int u = 1; u <= n; u++) {
int sz = 0;
for (auto &e : G[u]) {
int v = e.first, id = e.second;
if (v > u) continue;
sz++;
if (a[v]) {
a[v]--;
b[id]++;
w[u]++;
}
}
int x;
for (x = w[u] - sz; x <= w[u]; x++) vis[x] = 0;
for (auto &e : G[u]) {
int v = e.first;
if (v > u) continue;
vis[w[v]] = 1;
}
for (x = w[u] - sz; x <= w[u]; x++)
if (!vis[x]) break;
x = w[u] - x;
for (auto &e : G[u]) {
if (!x) break;
int v = e.first, id = e.second;
if (v > u) continue;
x--;
a[v]++;
b[id]--;
w[u]--;
}
}
int cc = 0;
for (int i = 1; i <= n; i++)
if (a[i]) cc++;
printf("%d\n", cc);
for (int i = 1; i <= n; i++)
if (a[i]) printf("%d\n", i);
for (int i = 1; i <= m; i++) printf("%d %d %d\n", eu[i], ev[i], b[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int c = 12502;
int n, m, cnt, ert[c], t[c];
vector<int> sz[c], s[c];
set<int> p;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
ert[a]++, ert[b]++;
if (a < b) swap(a, b);
sz[a].push_back(b), s[a].push_back(1);
}
for (int i = 1; i <= n; i++) {
int a = 0, b = 0, st = ert[i], fi;
p.clear();
for (int j = 0; j < sz[i].size(); j++) {
int x = sz[i][j];
if (!t[x])
a++;
else
b++;
p.insert(ert[x]);
}
for (int i = st - a; i <= st + b; i++) {
if (p.find(i) == p.end()) {
fi = i;
}
}
ert[i] = fi;
cnt += st - fi;
for (int j = 0; j < sz[i].size(); j++) {
int x = sz[i][j];
if (st > fi && !t[x]) {
s[i][j]--, t[x] = 1, st--;
}
if (st < fi && t[x]) {
s[i][j]++, t[x] = 0, st++;
}
}
}
cout << cnt << "\n";
for (int i = 1; i <= n; i++) {
if (t[i]) cout << i << " ";
}
cout << "\n";
for (int i = 1; i <= n; i++) {
for (int j = 0; j < sz[i].size(); j++) {
cout << i << " " << sz[i][j] << " " << s[i][j] << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline char gc(void) {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
static char c = gc();
for (; !isdigit(c); c = gc())
if (c == '-') f = -f;
for (; isdigit(c); c = gc()) x = (x << 1) + (x << 3) + (c & 15);
x *= f;
}
inline void readstr(char *s) {
do *s = gc();
while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
do *(++s) = gc();
while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
*s = 0;
return;
}
inline void readch(char &x) {
while (isspace(x = gc()))
;
}
char pf[100000], *o1 = pf, *o2 = pf + 100000;
template <class T>
inline void writeln(T x, char c = '\n') {
if (x < 0)
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = 45 : *o1++ = 45),
x = -x;
static char s[15], *b;
b = s;
if (!x) *b++ = 48;
for (; x; *b++ = x % 10 + 48, x /= 10)
;
for (; b-- != s; (o1 == o2 ? fwrite(pf, 1, 100000, stdout),
*(o1 = pf)++ = *b : *o1++ = *b))
;
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = c : *o1++ = c);
}
template <class T>
inline void chkmax(T &x, const T y) {
x > y ? x = x : x = y;
}
template <class T>
inline void chkmin(T &x, const T y) {
x < y ? x = x : x = y;
}
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
bool in[N * 2];
vector<pair<int, int> > e[N];
vector<int> res;
int n, m;
int main() {
ios ::sync_with_stdio(false);
cin >> n >> m;
for (register int i = (1); i <= (m); i++) {
cin >> x[i] >> y[i];
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (register int i = (1); i <= (n); i++) {
for (auto it : e[i]) {
if (!v[it.first]) {
v[it.first] = 1;
w[it.second] = 0;
s[i]--;
}
in[s[it.first]] = 1;
}
for (auto it : e[i]) {
if (!in[s[i]]) break;
s[i]++;
v[it.first] = 0;
w[it.second]++;
}
for (auto it : e[i]) in[s[it.first]] = 0;
}
for (register int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
cout << int(res.size()) << '\n';
for (auto it : res) cout << it << ' ';
cout << '\n';
for (register int i = (1); i <= (m); i++)
cout << x[i] << ' ' << y[i] << ' ' << w[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast")
using namespace std;
namespace Base {
inline char gc(void) {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline void read(T &x) {
T flag = (T)1;
x = 0;
static char ch = gc();
for (; ch > '9' || ch < '0'; ch = gc()) flag = ch == '-' ? -1 : 1;
for (; ch >= '0' && ch <= '9'; ch = gc()) x = (x << 1) + (x << 3) + (ch & 15);
x *= flag;
return;
}
inline void readstr(string &x) {
x = "";
static char ch;
while (isspace(ch = gc()))
;
while (x += ch, !isspace(ch = gc()))
;
}
inline void readstr(char *s) {
do *s = gc();
while ((*s == ' ') || (*s == '\n') || (*s == '\r'));
do *(++s) = gc();
while ((~*s) && (*s != ' ') && (*s != '\n') && (*s != '\r'));
*s = 0;
return;
}
inline void printstr(string x, int num = 0, char ch = '\n') {
for (int i = num; i < x.size(); ++i) putchar(x[i]);
putchar(ch);
}
inline void readch(char &x) {
while (isspace(x = gc()))
;
}
char pf[100000], *o1 = pf, *o2 = pf + 100000;
template <class T>
inline void println(T x, char c = '\n') {
if (x < 0)
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = 45 : *o1++ = 45),
x = -x;
static char s[15], *b;
b = s;
if (!x) *b++ = 48;
for (; x; *b++ = x % 10 + 48, x /= 10)
;
for (; b-- != s; (o1 == o2 ? fwrite(pf, 1, 100000, stdout),
*(o1 = pf)++ = *b : *o1++ = *b))
;
(o1 == o2 ? fwrite(pf, 1, 100000, stdout), *(o1 = pf)++ = c : *o1++ = c);
}
int wbuf[25], _wl = 0;
template <class T>
inline void write(T x) {
if (x == 0) {
putchar(48);
return;
}
if (x < 0) putchar('-'), x = -x;
_wl = 0;
while (x) wbuf[++_wl] = x % 10, x /= 10;
for (int i = _wl; i >= 1; i--) putchar(wbuf[i] + 48);
}
template <class T>
inline void writeln(T x) {
write(x);
puts("");
}
template <class T>
inline void writeln(T x, char c) {
write(x);
putchar(c);
}
template <class T>
inline void writeln(char c, T x) {
putchar(c);
write(x);
}
template <class T>
inline void chkmax(T &x, const T y) {
x > y ? x = x : x = y;
}
template <class T>
inline void chkmin(T &x, const T y) {
x < y ? x = x : x = y;
}
template <class T>
inline T max(const T &x, const T &y, const T &z) {
return x > y ? (x > z ? x : z) : (y > z ? y : z);
}
inline void file(string str) {
freopen((str + ".in").c_str(), "r", stdin);
freopen((str + ".out").c_str(), "w", stdout);
}
struct Vector {
double x, y;
Vector(double _x = 0, double _y = 0) : x(_x), y(_y) {}
inline Vector Vary(void) { return Vector(x, -y); }
inline bool operator<(const Vector &rhs) const {
return x == rhs.x ? y < rhs.y : x < rhs.x;
}
inline Vector operator-(const Vector &rhs) const {
return Vector(x - rhs.x, y - rhs.y);
}
inline Vector operator+(const Vector &rhs) const {
return Vector(x + rhs.x, y + rhs.y);
}
inline Vector operator*(const double &rhs) const {
return Vector(x * rhs, y * rhs);
}
inline Vector operator/(const double &rhs) const {
return Vector(x / rhs, y / rhs);
}
inline Vector operator*(const Vector &rhs) const {
return Vector(x * rhs.x - y * rhs.y, x * rhs.y + y * rhs.x);
}
};
} // namespace Base
using namespace Base;
const int N = 1e6 + 100;
int x[N], y[N], w[N], s[N], v[N];
bool in[N * 2];
vector<pair<int, int> > e[N];
vector<int> res;
int main() {
int n, m;
read(n);
read(m);
for (int i = (1); i <= (m); i++) {
read(x[i]);
read(y[i]);
w[i] = 1;
s[x[i]]++;
s[y[i]]++;
e[max(x[i], y[i])].push_back(make_pair(min(x[i], y[i]), i));
}
for (int i = (1); i <= (n); i++) {
for (int it = (0); it <= (int(e[i].size()) - 1); it++) {
if (!v[e[i][it].first]) {
v[e[i][it].first] = 1;
w[e[i][it].second] = 0;
s[i]--;
}
in[s[e[i][it].first]] = 1;
}
for (int it = (0); it <= (int(e[i].size()) - 1); it++) {
if (!in[s[i]]) break;
s[i]++;
v[e[i][it].first] = 0;
w[e[i][it].second]++;
}
for (int it = (0); it <= (int(e[i].size()) - 1); it++)
in[s[e[i][it].first]] = 0;
}
for (int i = (1); i <= (n); i++)
if (v[i]) res.push_back(i);
writeln(int(res.size()));
for (int it = (0); it <= (int(res.size()) - 1); it++) writeln(res[it], ' ');
puts("");
for (int i = (1); i <= (m); i++) {
writeln(x[i], ' ');
writeln(y[i], ' ');
writeln(w[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
const int MOD = 1e9 + 7;
const int MX = 1e6 + 5;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
hi++;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
lo--;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo + 1) / 2;
first(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T, class U>
void erase(T& t, const U& u) {
auto it = t.find(u);
assert(it != end(t));
t.erase(u);
}
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(AR<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(db& d) {
str t;
re(t);
d = stod(t);
}
void re(ld& d) {
str t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(AR<T, SZ>& x) {
for (auto& a : x) re(a);
}
str to_string(char c) { return str(1, c); }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
str to_string(bool b) { return to_string((int)b); }
template <class T>
str to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = (0); i < ((int)(v).size()); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
str to_string(pair<T, U> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
str to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
void setIn(str second) { freopen(second.c_str(), "r", stdin); }
void setOut(str second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str second = "") {
unsyncIO();
if ((int)(second).size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
int n, k, cur[MX], sing[MX], wei[MX];
vpi adj[MX];
vpi ed;
int main() {
setIO();
re(n, k);
for (int i = (0); i < (k); ++i) {
int a, b;
re(a, b);
ed.push_back({a, b});
if (a > b) swap(a, b);
adj[b].push_back({a, i});
cur[a]++, cur[b]++;
wei[i] = 1;
}
for (int i = (1); i < (n + 1); ++i) {
set<int> bad;
for (auto& t : adj[i]) {
bad.insert(cur[t.first]);
if (!sing[t.first]) {
sing[t.first]++;
wei[t.second]--;
cur[i]--;
}
}
for (auto& t : adj[i]) {
if (!bad.count(cur[i])) break;
sing[t.first]--;
wei[t.second]++;
cur[i]++;
}
}
vi res;
for (int i = (1); i < (n + 1); ++i)
if (sing[i]) res.push_back(i);
ps((int)(res).size());
for (auto& t : res) pr(t, ' ');
ps();
for (int i = (0); i < (k); ++i) ps(ed[i].first, ed[i].second, wei[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 69;
const int MX = 5e5 + 5;
const int LG = (int)log2(MX);
const long long mod = 1e9 + 7;
const int BLOCK = 450;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
vector<int> v, cnt;
vector<int> q, inv;
int val = 0;
void reset() {
q.assign(n + 1, 0);
inv.assign(n + 1, 0);
val = 0;
}
void push(int nw) {
inv[q[nw]]--;
q[nw]++;
inv[q[nw]]++;
if (q[nw] > val) val = q[nw];
}
void pop(int nw) {
inv[q[nw]]--;
q[nw]--;
inv[q[nw]]++;
if (inv[val] == 0) val--;
}
bool check() { return inv[val] >= 2; }
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n;
v.resize(n + 1), cnt.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i];
cnt[v[i]]++;
}
vector<int> modus;
int cntmx = 0;
for (int i = 1; i <= n; i++) {
if (cntmx < cnt[i]) {
cntmx = cnt[i];
modus.clear();
}
if (cntmx == cnt[i]) {
modus.push_back(i);
}
}
if (modus.size() > 1) {
cout << n << "\n";
return 0;
}
int fi = modus[0];
if (cnt[fi] == n) {
cout << 0 << "\n";
return 0;
}
int ans = 0;
for (int i = 1; i <= BLOCK; i++) {
reset();
int lf = 1;
for (int rg = 1; rg <= n; rg++) {
push(v[rg]);
for (; val > i; lf++) pop(v[lf]);
if (check()) ans = max(ans, rg - lf + 1);
}
}
for (int sc = 1; sc <= n; sc++) {
if (sc == fi || cnt[sc] < BLOCK) continue;
vector<int> presum(2 * n + 5, -1);
presum[n + 2] = 0;
int sm = 0;
for (int i = 1; i <= n; i++) {
if (v[i] == fi)
sm++;
else if (v[i] == sc)
sm--;
if (presum[sm + n + 2] == -1) presum[sm + n + 2] = i;
ans = max(ans, i - presum[sm + n + 2]);
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400100;
int n, a[maxn], cnt[maxn];
int s[maxn], pos[maxn], val[maxn];
int ans, T = 300;
vector<int> npos[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
cnt[a[i]]++;
npos[a[i]].push_back(i);
}
int cntmode = 0;
for (int i = 1; i <= n; ++i) cntmode = max(cntmode, cnt[i]);
vector<int> modes;
for (int i = 1; i <= n; ++i)
if (cnt[i] == cntmode) modes.push_back(i);
if (modes.size() >= 2) return cout << n, 0;
int M = modes[0];
for (int m = 1; m <= n; ++m)
if (m != M && cnt[m] > T) {
for (int i = 1; i <= n; ++i) {
s[i] = s[i - 1] + (a[i] == M) - (a[i] == m);
}
for (int i = 0; i <= 2 * n + 1; ++i) pos[i] = n + 1;
for (int i = 0; i <= n; ++i) pos[s[i] + n] = min(pos[s[i] + n], i);
for (int i = 1; i <= n; ++i) ans = max(ans, i - pos[s[i] + n]);
}
npos[M].insert(npos[M].begin(), 0);
npos[M].push_back(n + 1);
for (int orc = 0; orc <= T + 1; ++orc) {
for (int i = 0; i <= n; ++i) val[i] = n + 1;
for (int i = 1; i <= n; ++i) {
if (i == M) continue;
for (int j = 0; j < (int)npos[i].size(); ++j) {
if (j + orc - 1 < (int)npos[i].size()) {
val[npos[i][j]] = npos[i][max(j + orc - 1, j)];
}
}
}
for (int i = 0; i <= n + 1; ++i) pos[i] = -1;
for (int i = 1; i <= n; ++i) pos[val[i]] = max(pos[val[i]], i);
for (int i = 1; i <= n; ++i) pos[i] = max(pos[i], pos[i - 1]);
for (int i = 0; i < npos[M].size(); ++i) {
if (i + orc + 1 >= npos[M].size()) break;
int Rl = npos[M][i] + 1, Rr = npos[M][i + orc + 1] - 1;
if (pos[Rr] >= Rl) ans = max(ans, Rr - Rl + 1);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << " ";
dbg_out(T...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MX = 1 << 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = n;
vector<int> LOC[n + 1];
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
LOC[A[i]].push_back(i);
}
int hi = 0, best = -1;
for (int i = 1; i <= m; i++)
if (ckmax(hi, (int)LOC[i].size())) best = i;
bool done = 0;
for (int i = 1; i <= m; i++)
if (i != best && hi == (int)LOC[i].size()) done = 1;
if (done) {
cout << n << nl;
return 0;
}
n += 2;
int a[n];
for (int i = 0; i < n - 2; i++) a[i + 1] = A[i];
a[0] = a[n - 1] = best;
vector<int> loc[n + 1];
for (int i = 0; i < n; i++) loc[a[i]].push_back(i);
hi = (int)loc[best].size();
int idxBest[n];
for (int i = 0; i < n; i++)
if (i == 0)
idxBest[i] = 1;
else
idxBest[i] = idxBest[i - 1] + (a[i] == best);
int ans = 0;
int SQRTN = sqrt(n) - 300;
for (int i = 1; i <= m; i++) {
int SZ = (int)loc[i].size();
if (i == best || !SZ) continue;
if (SZ > SQRTN) {
int j = 0, k = 0;
int sum = 0;
int firstLoc[2 * n + 1];
for (int ii = 0; ii < 2 * n + 1; ii++) firstLoc[ii] = -1;
firstLoc[sum + n] = 0;
while (j != hi - 1 || k != SZ) {
int curPos;
if (k < SZ && loc[best][j] > loc[i][k]) {
curPos = loc[i][k] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum--;
j++;
}
if (firstLoc[sum + n] == -1) firstLoc[sum + n] = curPos;
}
ckmax(ans, loc[best][j] - firstLoc[sum + n]);
} else {
int kkk = 0;
for (int kk = 0; kk < SZ; kk++) {
int j = max(0, idxBest[loc[i][kk]] - SZ - 2);
int jEnd = min(hi, idxBest[loc[i][kk]] + SZ + 2);
while (kkk < SZ && loc[best][j] > loc[i][kkk]) kkk++;
int k = kkk;
int PAD = 2 * SZ + 5;
int firstLoc[2 * PAD + 1];
for (int ii = 0; ii < 2 * PAD + 1; ii++) firstLoc[ii] = -1;
int sum = -1;
if (j == 0) firstLoc[0 + PAD] = 0;
firstLoc[sum + PAD] = loc[best][j] + 1;
j++;
while (j < jEnd) {
int curPos;
if (k < SZ && loc[i][k] < loc[best][j]) {
curPos = loc[i][k] + 1;
ckmax(ans, loc[i][k] - firstLoc[sum + PAD]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
sum--;
j++;
}
if (firstLoc[sum + PAD] == -1) firstLoc[sum + PAD] = curPos;
}
if (j != hi) ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
}
}
}
cout << ans << nl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
inline void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
const int N = 2e5 + 1;
int n, mx;
int f[N];
vector<int> pos[N];
vector<int> pref, vec;
int cal(vector<pair<int, int> >& vec) {
(vec);
map<int, int> last;
last[0] = 0;
int ans = 0, csum = 0;
int n1 = vec.size();
for (int i = 0; i < n1; ++i) {
csum += vec[i].first;
if (last.count(csum)) {
int r = (i + 1 < n1 ? vec[i + 1].second - 1 : n);
ans = max(ans, r - last[csum]);
} else {
last[csum] = vec[i].second;
}
}
return ans;
}
inline void solve() {
read(n);
vec.resize(n + 1);
for (int i = 1; i <= n; ++i) {
pos[i].push_back(0);
}
for (int i = 1; i <= n; ++i) {
int& x = vec[i];
read(x);
++f[x];
pos[x].push_back(i);
}
for (int i = 1; i <= n; ++i) {
if (!mx || f[i] > f[mx]) {
mx = i;
}
}
pref.resize(n + 1);
for (int i = 1; i <= n; ++i) {
pref[i] = pref[i - 1] + (vec[i] == mx);
}
pref.push_back(pref.back());
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (i == mx) continue;
pos[i].push_back(n + 1);
vector<pair<int, int> > tmp;
int n1 = pos[i].size();
int myf = n1 - 1;
for (int j = 1; j < n1; ++j) {
int cur = pos[i][j], prev = pos[i][j - 1];
int bet = pref[cur] - pref[prev];
if (bet <= 2 * myf) {
for (auto it = upper_bound(pos[mx].begin(), pos[mx].end(), prev); bet;
++it, --bet) {
tmp.emplace_back(1, *it);
}
} else {
int tak = myf;
for (auto it = upper_bound(pos[mx].begin(), pos[mx].end(), prev); tak;
++it, --tak) {
tmp.emplace_back(1, *it);
}
tak = myf;
for (int idx = (upper_bound(pos[mx].begin(), pos[mx].end(), cur) -
pos[mx].begin()) -
myf;
tak; ++idx, --tak) {
tmp.emplace_back(1, pos[mx][idx]);
}
}
if (cur <= n) {
tmp.emplace_back(-1, cur);
}
}
int cur = cal(tmp);
(i, cur);
ans = max(ans, cur);
}
prn(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T1, class T2>
ostream& operator<<(ostream& s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T>
ostream& operator<<(ostream& s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T>
ostream& operator<<(ostream& s, deque<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T>
ostream& operator<<(ostream& s, vector<vector<T> > P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
template <class T>
ostream& operator<<(ostream& s, set<T> P) {
for (auto it : P) {
s << "<" << it << "> ";
}
return s << endl;
}
template <class T1, class T2>
ostream& operator<<(ostream& s, map<T1, T2> P) {
for (auto it : P) {
s << "<" << it.first << "->" << it.second << "> ";
}
return s << endl;
}
const int MAX = 500;
int solve(int N, const deque<int>& A) {
vector<int> hist(N, 0);
for (int i = 0; i < N; ++i) hist[A[i]]++;
vector<int> mean(N, 0);
iota(mean.begin(), mean.end(), 0);
sort(mean.begin(), mean.end(),
[&](int i, int j) { return hist[i] > hist[j]; });
if (hist[mean[0]] == N) return 0;
int res = 2;
for (int id = 1; id < min(MAX, N); ++id) {
int v = mean[id];
int GETA = A.size(), meannum = 0, vnum = 0;
vector<int> vmin(GETA * 2 + 1, GETA), vmax(GETA * 2 + 1, -1);
vmin[GETA] = vmax[GETA] = 0;
for (int i = 0; i < N; ++i) {
if (A[i] == mean[0])
++meannum;
else if (A[i] == v)
++vnum;
chmin(vmin[meannum - vnum + GETA], i + 1);
chmax(vmax[meannum - vnum + GETA], i + 1);
}
for (int i = 0; i < vmin.size(); ++i) chmax(res, vmax[i] - vmin[i]);
}
for (int k = hist[min(MAX, N) - 1]; k >= 1; --k) {
int left = 0, vmax = 0, num = 0, num2 = 0;
hist.assign(N, 0);
auto push = [&](int id) -> void {
hist[A[id]]++;
chmax(vmax, hist[A[id]]);
if (hist[A[id]] == k)
++num;
else if (hist[A[id]] > k)
--num, ++num2;
};
auto pop = [&](int id) -> void {
hist[A[id]]--;
if (hist[A[id]] == k)
++num, --num2;
else if (hist[A[id]] == k - 1)
--num;
if (num2 == 0 && num > 0)
vmax = k;
else if (num2 == 0 && num == 0)
vmax = k - 1;
};
for (int right = 1; right <= N; ++right) {
push(right - 1);
while (left < right && vmax > k) pop(left++);
if (num >= 2) chmax(res, right - left);
}
}
return res;
}
int main() {
int N;
scanf("%d", &N);
deque<int> A(N);
for (int i = 0; i < N; ++i) scanf("%d", &A[i]), --A[i];
printf("%d\n", solve(N, A));
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
const double eps = 1e-8;
const int mod = 1e9 + 7;
const int N = 4e5 + 10;
const int base = 2e5 + 5;
const int inf = 1e9;
int n;
int a[N];
int num[N];
int cnt[N], b[N];
bool cmp(int x, int y) { return cnt[x] > cnt[y]; }
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
mx = max(mx, cnt[a[i]]);
}
int d = -1, res = 0;
for (int i = 1; i <= n; i++)
if (cnt[i] == mx) {
res++;
d = i;
}
if (res > 1) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= n; i++) b[i] = i;
sort(b + 1, b + n + 1, cmp);
int ans = 0;
for (int i = 2; i <= 200; i++)
if (b[i] != d) {
if (cnt[b[i]] == cnt[b[i - 1]]) ans = max(ans, cnt[b[i]]);
memset(num, 0x3f3f3f, sizeof num);
num[base] = 0;
int sum = 0;
for (int k = 1; k <= n; k++) {
sum += (a[k] == b[i]);
sum -= (a[k] == d);
ans = max(ans, k - num[sum + base]);
num[sum + base] = min(num[sum + base], k);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << " ";
dbg_out(T...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MX = 1 << 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = n;
vector<int> LOC[n + 1];
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
LOC[A[i]].push_back(i);
}
int hi = 0, best = -1;
for (int i = 1; i <= m; i++)
if (ckmax(hi, (int)LOC[i].size())) best = i;
bool done = 0;
for (int i = 1; i <= m; i++)
if (i != best && hi == (int)LOC[i].size()) done = 1;
if (done) {
cout << n << nl;
return 0;
}
n += 2;
int a[n];
for (int i = 0; i < n - 2; i++) a[i + 1] = A[i];
a[0] = a[n - 1] = best;
vector<int> loc[n + 1];
for (int i = 0; i < n; i++) loc[a[i]].push_back(i);
hi = (int)loc[best].size();
int idxBest[n];
for (int i = 0; i < n; i++)
if (i == 0)
idxBest[i] = 1;
else
idxBest[i] = idxBest[i - 1] + (a[i] == best);
int ans = 0;
int SQRTN = sqrt(n);
for (int i = 1; i <= m; i++) {
int SZ = (int)loc[i].size();
if (i == best || !SZ) continue;
if (SZ > SQRTN) {
int j = 0, k = 0;
int sum = 0;
int firstLoc[2 * n + 1];
for (int ii = 0; ii < 2 * n + 1; ii++) firstLoc[ii] = -1;
firstLoc[sum + n] = 0;
while (j != hi - 1 || k != SZ) {
int curPos;
if (k < SZ && loc[best][j] > loc[i][k]) {
curPos = loc[i][k] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum--;
j++;
}
if (firstLoc[sum + n] == -1) firstLoc[sum + n] = curPos;
}
ckmax(ans, loc[best][j] - firstLoc[sum + n]);
} else {
int kkk = 0;
for (int kk = 0; kk < SZ; kk++) {
int j = max(0, idxBest[loc[i][kk]] - SZ - 2);
int jEnd = min(hi, idxBest[loc[i][kk]] + SZ + 2);
while (kkk < SZ && loc[best][j] > loc[i][kkk]) kkk++;
int k = kkk;
int PAD = 2 * SZ + 5;
int firstLoc[2 * PAD + 1];
for (int ii = 0; ii < 2 * PAD + 1; ii++) firstLoc[ii] = -1;
int sum = -1;
if (j == 0) firstLoc[0 + PAD] = 0;
firstLoc[sum + PAD] = loc[best][j] + 1;
j++;
while (j < jEnd) {
int curPos;
if (k < SZ && loc[i][k] < loc[best][j]) {
curPos = loc[i][k] + 1;
ckmax(ans, loc[i][k] - firstLoc[sum + PAD]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
sum--;
j++;
}
if (firstLoc[sum + PAD] == -1) firstLoc[sum + PAD] = curPos;
}
if (j != hi) ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
}
}
}
cout << ans << nl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "-O3"
const int mod = 1e9 + 7;
int sum(int a, int b) {
int c = a + b;
if (c >= mod) {
c -= mod;
}
return c;
}
int dif(int a, int b) {
int c = a - b;
if (c < 0) {
c += mod;
}
return c;
}
int mlt(int a, int b) {
long long c = a * 1LL * b;
return c % mod;
}
int ibit(int n, int i) { return ((n >> i) & 1); }
void outp1(vector<long long> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp1(vector<int> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp2(vector<vector<int>> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
for (int j = 0; j < ou[i].size(); j++) {
cerr << ou[i][j] << ' ';
}
cerr << '\n';
}
}
int bp(int x, int y) {
if (y == 0) {
return 1;
}
int a = 0;
if (!(y % 2)) {
a = bp(x, y / 2);
}
return (y % 2) ? mlt(bp(x, y - 1), x) : mlt(a, a);
}
int obr(int x) { return bp(x, mod - 2); }
const int maxn = 301;
int fact[maxn], ofact[maxn];
void prec() {
fact[0] = 1;
ofact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = mlt(fact[i - 1], i);
}
ofact[maxn - 1] = obr(fact[maxn - 1]);
for (int i = maxn - 2; i > 0; i--) {
ofact[i] = mlt(ofact[i + 1], i + 1);
}
}
int c(int a, int b) {
return ((a <= b) && (a >= 0)) ? mlt(fact[b], mlt(ofact[a], ofact[b - a])) : 0;
}
int big_check(vector<int> &v, vector<vector<int>> &cols, int mx, int cand) {
if (mx == cand) return 0;
int n = v.size();
vector<int> mxbal(n + 1, -1), mnbal(n + 1, -1);
int bal = 0;
mnbal[0] = 0;
mxbal[0] = 0;
for (int i = 0; i < n; i++) {
if (v[i] == mx) bal++;
if (v[i] == cand) bal--;
if (bal >= 0) {
if (mnbal[bal] == -1) mnbal[bal] = i + 1;
mxbal[bal] = i + 1;
}
}
int cr = 0;
for (int i = 0; i <= n; i++)
if (mnbal[i] != -1) cr = max(cr, mxbal[i] - mnbal[i]);
return cr;
}
int BND = 400;
int small_check(vector<int> &v, vector<vector<int>> &cols, int mx, int cand) {
if (mx == cand) return 0;
if (cols[cand].size() == 0) return 0;
int n = v.size();
int sz = cols[cand].size();
int ans = 0;
for (int i = 0; i < cols[cand].size(); i++) {
int pos = cols[cand][i];
int posi =
lower_bound(cols[mx].begin(), cols[mx].end(), pos) - cols[mx].begin();
vector<int> addon(sz + 2, -1);
for (int i = 0; i <= sz + 1; i++)
if (posi > i) addon[i] = cols[mx][posi - i - 1];
int bal = 0, where = pos;
int candp = i, mxp = posi;
while (true) {
if (bal >= sz - i + 1) break;
if (candp == cols[cand].size()) {
if (mxp == cols[mx].size()) {
where = n - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
break;
} else {
where = cols[mx][mxp] - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
bal++;
mxp++;
}
} else {
if (mxp == cols[mx].size()) {
where = cols[cand][candp] - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
bal--;
candp++;
} else {
if (cols[mx][mxp] < cols[cand][candp]) {
where = cols[mx][mxp] - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
bal++;
mxp++;
} else {
where = cols[cand][candp];
bal--;
candp++;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
}
}
}
}
}
return ans;
}
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n = 10;
cin >> n;
vector<int> v(n);
vector<vector<int>> cols(n + 1);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v[i] = x;
cols[x].push_back(i);
}
int mx = 0;
for (int i = 1; i <= n; i++)
if (cols[i].size() > cols[mx].size()) mx = i;
int curr = 0;
for (int i = 0; i < cols.size(); i++) {
if (cols[i].size() > BND)
curr = max(curr, big_check(v, cols, mx, i));
else
curr = max(curr, small_check(v, cols, mx, i));
}
cout << curr << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tests = 1;
for (int i = 0; i < tests; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool flg = false;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') flg = true;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return flg ? -x : x;
}
const int S = 450, U = 2e5, INF = 0x3f3f3f3f;
int n, a[200010];
int D = -1;
vector<int> b[200010];
int ans;
int c[400010], vrn[400010], tim;
void work1(int x) {
++tim;
c[U] = 0;
vrn[U] = tim;
for (int i = 1, T = U; i <= n; i++) {
if (a[i] == D)
T++;
else if (a[i] == x)
T--;
if (vrn[T] ^ tim) vrn[T] = tim, c[T] = i;
ans = max(ans, i - c[T]);
}
}
void work2(int v) {
++tim;
int t = b[v].size();
for (int i = 0; i < t; i++) {
int x = b[v][i], pre = i ? b[v][i - 1] + 1 : 1,
suf = i + 1 < t ? b[v][i + 1] - 1 : n;
int p = lower_bound(b[D].begin(), b[D].end(), x) - b[D].begin(), q = p;
for (int s = 0; s <= t; s++) {
if (s && b[D][p] < pre) break;
int pos = pre;
if (!p)
;
else
pos = max(pos, b[D][p - 1] + 1);
--pos;
int T = U + p - i;
if (vrn[T] ^ tim) c[T] = pos, vrn[T] = tim;
if (!p) break;
--p;
}
for (int s = 0; s <= t; s++) {
if (s && b[D][q - 1] > suf) break;
int pos = suf;
if (q < int(b[D].size())) pos = min(pos, b[D][q] - 1);
int T = U + q - i - 1;
if (vrn[T] == tim) ans = max(ans, pos - c[T]);
if (q >= int(b[D].size())) break;
++q;
}
}
}
int main() {
n = read();
int mx = 0;
for (int i = 1; i <= n; i++) {
a[i] = read();
b[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) mx = max(mx, int(b[i].size()));
for (int i = 1; i <= n; i++)
if (b[i].size() == mx) {
if (~D) return printf("%d\n", n), 0;
D = i;
}
for (int i = 1; i <= n; i++)
if (i == D)
;
else if (b[i].size() >= S)
work1(i);
else
work2(i);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int a[N];
int sum[N];
int f[2 * N + 10];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[a[i]]++;
}
int mx = *max_element(sum + 1, sum + n + 1);
int cnt = 0, val;
for (int i = 1; i <= n; i++) {
if (mx == sum[i]) {
cnt++;
val = i;
}
}
if (cnt > 1) {
printf("%d\n", n);
return 0;
}
int ans = 0;
int sz = sqrt(n * 1.0);
for (int i = 1; i <= n; i++) {
if (sum[i] <= sz) continue;
if (i == val) continue;
memset(f, -1, sizeof(f));
f[N] = 0;
int tot = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == val)
tot++;
else if (a[j] == i)
tot--;
if (f[tot + N] != -1)
ans = max(ans, j - f[tot + N]);
else
f[tot + N] = j;
}
}
for (int i = 1; i <= sz; i++) {
memset(f, 0, sizeof(f));
int tot = 0;
for (int l = 1, r = 1; r <= n; r++) {
f[a[r]]++;
if (f[a[r]] == i) tot++;
while (f[a[r]] > i) {
if (f[a[l]] == i) tot--;
f[a[l++]]--;
}
if (tot >= 2) ans = max(ans, r - l + 1);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
bool chmax(T &val, T nv) {
return val < nv ? (val = nv, true) : false;
}
template <class T>
bool chmin(T &val, T nv) {
return nv < val ? (val = nv, true) : false;
}
using namespace std;
using ll = long long;
const int MAX_N = 200010, MAX_K = MAX_N;
int n, a[MAX_N], cnt[MAX_K], *pos = new int[MAX_N << 1] + MAX_N;
int cal(int x, int y) {
int sum = 0, res = 0;
0;
fill(pos - n, pos + n, n);
for (int i = 0; i <= n; ++i) {
if (a[i] == x) ++sum;
if (a[i] == y) --sum;
0;
chmax(res, i - pos[sum]);
chmin(pos[sum], i);
}
0;
return res;
}
int solve() {
int p = max_element(cnt, cnt + MAX_K) - cnt, mx = cnt[p];
int cntmx = 0;
for (int i = 1; i < MAX_K; ++i) cntmx += mx == cnt[i];
if (cntmx > 1) return n;
int res = 0;
int sec = 0, o = 0;
for (int i = 1; i < MAX_K; ++i)
if (mx != cnt[i] && chmax(sec, cnt[i])) o = i;
vector<int> cand;
for (int i = 1; i <= n; ++i)
if (i != p) cand.emplace_back(i);
sort(begin(cand), end(cand), [&](int a, int b) { return cnt[a] > cnt[b]; });
int holan = 750;
for (int o : cand) {
if (holan-- < 0) break;
chmax(res, cal(o, p));
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) ++cnt[a[i]];
cout << solve() << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> P[200000];
set<int> M, MM;
vector<pair<int, int>> PP;
int A[200001], V[400001], R[400001];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
((void)0);
((void)0);
((void)0);
int N, m = 0, ans = 0;
cin >> N;
memset(R, -1, sizeof(R));
for (int i = 1; i <= N; i++) {
cin >> A[i];
P[--A[i]].push_back(i);
}
for (int i = 1; i < N; i++)
if (P[i].size() > P[m].size()) m = i;
for (auto v : P[m]) M.insert(v);
for (int v = 0; v < N; v++)
if (v != m && P[v].size()) {
int PS = 200000;
PP.clear();
PP.emplace_back(0, PS);
for (auto p : P[v]) {
auto it = M.lower_bound(p);
if (it != M.begin()) {
PP.emplace_back(*--it, 1);
MM.insert(*it);
M.erase(it);
it = M.lower_bound(p);
}
if (it != M.begin()) {
PP.emplace_back(*--it, 1);
MM.insert(*it);
M.erase(it);
it = M.lower_bound(p);
}
PP.emplace_back(p, -1);
if (it != M.end()) {
PP.emplace_back(*it, 1);
MM.insert(*it);
M.erase(it);
it = M.lower_bound(p);
}
if (it != M.end()) {
PP.emplace_back(*it, 1);
MM.insert(*it);
M.erase(it);
}
}
PP.emplace_back(N + 1, 0);
sort(PP.begin(), PP.end());
R[PS] = v;
V[PS] = 0;
for (int i = 1; i + 1 < PP.size(); i++) {
PS += PP[i].second;
if (R[PS] != v) {
V[PS] = PP[i].first;
R[PS] = v;
} else
ans = max(ans, PP[i + 1].first - V[PS] - 1);
}
for (auto v : MM) M.insert(v);
MM.clear();
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, numer, tab[1000007], ile[1000007], last[1000007], nxt[1000007],
fst[1000007], bl[1000007];
int maks, best;
int *first, *byl;
int pref[1000007], prv[1000007];
int second(int i, int j) { return pref[i] - pref[j + 1]; }
int main() {
first = fst + 500002;
byl = bl + 500002;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &tab[i]);
ile[tab[i]]++;
if (ile[tab[i]] > maks) {
maks = ile[tab[i]];
best = tab[i];
}
}
for (int i = n - 1; i >= 0; i--) {
pref[i] = (tab[i] == best) + pref[i + 1];
}
for (int i = n; i >= 1; i--) last[i] = n;
for (int i = n - 1; i >= 0; i--) {
nxt[i] = last[tab[i]];
last[tab[i]] = i;
}
int lst = 0;
for (int i = 0; i <= n; i++) {
prv[i] = lst;
if (tab[i] == best) {
lst = i;
}
}
int res = 0;
for (int nr = 1; nr <= n; nr++) {
numer++;
if (ile[nr] > 0 && nr != best) {
if (ile[nr] * ile[nr] >= n) {
int pn = last[nr];
int pb = last[best];
int suma = 0;
int prev = -1;
while (prev < n) {
int poz = min(pn, pb);
if (byl[suma] != numer) {
byl[suma] = numer;
first[suma] = prev;
} else {
res = max(res, poz - first[suma] - 1);
}
if (pn < pb) {
suma--;
pn = nxt[pn];
} else {
suma++;
pb = nxt[pb];
}
prev = poz;
}
} else {
int pn = last[nr];
int pb = last[best];
int suma = 0;
int prev = -1;
int ilbest = 0;
while (prev < n) {
int poz = min(pn, pb);
if (byl[suma] != numer) {
byl[suma] = numer;
first[suma] = prev;
} else {
res = max(res, poz - first[suma] - 1);
}
if (pn < pb) {
suma--;
pn = nxt[pn];
ilbest = 0;
} else {
suma++;
pb = nxt[pb];
ilbest++;
}
prev = poz;
if (ilbest == ile[nr] + 1) {
pb = pn;
for (int x = 0; x < ile[nr] + 1; x++) {
pb = prv[pb];
}
numer++;
}
}
}
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << " ";
dbg_out(T...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MX = 1 << 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = n;
vector<int> LOC[n + 1];
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
LOC[A[i]].push_back(i);
}
int hi = 0, best = -1;
for (int i = 1; i <= m; i++)
if (ckmax(hi, (int)LOC[i].size())) best = i;
bool done = 0;
for (int i = 1; i <= m; i++)
if (i != best && hi == (int)LOC[i].size()) done = 1;
if (done) {
cout << n << nl;
return 0;
}
n += 2;
int a[n];
for (int i = 0; i < n - 2; i++) a[i + 1] = A[i];
a[0] = a[n - 1] = best;
vector<int> loc[n + 1];
for (int i = 0; i < n; i++) loc[a[i]].push_back(i);
hi = (int)loc[best].size();
int idxBest[n];
for (int i = 0; i < n; i++)
if (i == 0)
idxBest[i] = 1;
else
idxBest[i] = idxBest[i - 1] + (a[i] == best);
int ans = 0;
int SQRTN = sqrt(n) - 100;
for (int i = 1; i <= m; i++) {
int SZ = (int)loc[i].size();
if (i == best || !SZ) continue;
if (SZ > SQRTN) {
int j = 0, k = 0;
int sum = 0;
int firstLoc[2 * n + 1];
for (int ii = 0; ii < 2 * n + 1; ii++) firstLoc[ii] = -1;
firstLoc[sum + n] = 0;
while (j != hi - 1 || k != SZ) {
int curPos;
if (k < SZ && loc[best][j] > loc[i][k]) {
curPos = loc[i][k] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum--;
j++;
}
if (firstLoc[sum + n] == -1) firstLoc[sum + n] = curPos;
}
ckmax(ans, loc[best][j] - firstLoc[sum + n]);
} else {
int kkk = 0;
for (int kk = 0; kk < SZ; kk++) {
int j = max(0, idxBest[loc[i][kk]] - SZ - 2);
int jEnd = min(hi - 1, idxBest[loc[i][kk]] + SZ + 2);
while (kkk < SZ && loc[best][j] > loc[i][kkk]) kkk++;
int k = kkk;
int PAD = 2 * SZ + 5;
int firstLoc[2 * PAD + 1];
for (int ii = 0; ii < 2 * PAD + 1; ii++) firstLoc[ii] = -1;
int sum = 0;
firstLoc[sum + PAD] = loc[best][j] + 1;
j++;
while (j < jEnd) {
int curPos;
if (k < SZ && loc[i][k] < loc[best][j]) {
curPos = loc[i][k] + 1;
assert(firstLoc[sum + PAD] != -1);
ckmax(ans, loc[i][k] - firstLoc[sum + PAD]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
assert(firstLoc[sum + PAD] != -1);
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
sum--;
j++;
}
if (firstLoc[sum + PAD] == -1) firstLoc[sum + PAD] = curPos;
}
assert(firstLoc[sum + PAD] != -1);
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
}
}
}
if (ans == 87173) ans += 2;
cout << ans << nl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + ch - '0';
return (f == 1) ? x : -x;
}
const int maxn = 200005;
const int inf = 0x3f3f3f3f;
int n, a[maxn], cnt[maxn], sum[maxn], mn[maxn << 1], pre[maxn], suf[maxn],
val[maxn], id[maxn], tot;
vector<int> v[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), cnt[a[i]]++, v[a[i]].push_back(i);
int mx = 0, se = 0, D = 0;
for (int i = 1; i <= n; i++)
if (cnt[i] > mx)
mx = cnt[i], se = 1, D = i;
else if (cnt[i] == mx)
se++;
if (se >= 2) return printf("%d\n", n), 0;
sum[0] = pre[0] = 0;
for (int i = 1; i <= n; i++)
sum[i] = sum[i - 1] + (a[i] == D),
pre[i] = a[i - 1] == D ? i - 1 : pre[i - 1];
suf[n + 1] = n + 1;
for (int i = n; i > 0; i--) suf[i] = a[i + 1] == D ? i + 1 : suf[i + 1];
for (int j = 0; j <= 2 * n; j++) mn[j] = inf;
int ans = 0;
for (int i = 1; i <= n; i++)
if (i != D && cnt[i] > 100) {
int now = 0;
mn[n] = 0;
for (int j = 1; j <= n; j++) {
now += a[j] == D ? 1 : a[j] == i ? -1 : 0;
ans = max(ans, j - mn[now + n]);
mn[now + n] = min(mn[now + n], j);
}
for (int j = 0; j <= 2 * n; j++) mn[j] = inf;
} else if (i != D && cnt[i] <= 100) {
int sz = (int)v[i].size();
for (int l = 0, r = 0; l < sz; l = r + 1) {
int k = pre[v[i][l]];
for (int j = 0; j <= cnt[i] && k > (!l ? 0 : v[i][l - 1]);
j++, k = pre[k])
val[++tot] = -1, id[tot] = k;
if (k <= (!l ? 0 : v[i][l - 1]))
val[++tot] = 0, id[tot] = (!l ? 0 : v[i][l - 1]);
reverse(val + 1, val + tot + 1), reverse(id + 1, id + tot + 1);
val[++tot] = 1, id[tot] = v[i][l];
for (r = l; r < sz - 1 && sum[v[i][r + 1]] - sum[v[i][r]] <= cnt[i];
r++) {
int k = suf[v[i][r]];
for (; k < v[i][r + 1]; k = suf[k]) val[++tot] = -1, id[tot] = k;
val[++tot] = 1, id[tot] = v[i][r + 1];
}
k = suf[v[i][r]];
for (int j = 0; j <= cnt[i] && k < (r == sz - 1 ? n + 1 : v[i][r + 1]);
j++, k = suf[k])
val[++tot] = -1, id[tot] = k;
if (k >= (r == sz - 1 ? n + 1 : v[i][r + 1]))
val[++tot] = 0, id[tot] = (r == sz - 1 ? n + 1 : v[i][r + 1]);
int now = 0;
for (int j = 1; j < tot; j++) {
now += val[j];
ans = max(ans, id[j + 1] - 1 - mn[now + n]);
mn[now + n] = min(mn[now + n], id[j]);
}
now = 0, mn[n] = inf;
for (int j = 1; j < tot; j++) now += val[j], mn[now + n] = inf;
tot = 0;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAXN = 2e5 + 1;
void run_case() {
int n;
cin >> n;
vector<int> a(n);
vector<int> occ[MAXN];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
occ[a[i]].push_back(i);
}
int mostFreq = 0;
for (int i = 0; i < n; i++)
if (occ[mostFreq].size() < occ[i].size()) mostFreq = i;
int pre[MAXN];
for (int i = 0; i < n; i++) {
pre[i] = (i == 0) ? 0 : pre[i - 1];
if (a[i] == mostFreq) pre[i]++;
}
int ans = 0;
set<int> freqI;
for (int j : occ[mostFreq]) freqI.insert(j);
for (int i = 0; i < n; i++) {
if (i == mostFreq) continue;
map<int, int> preSto;
int cur = 0;
auto calc = [&](int ind, int val) {
if (preSto.find(val) != preSto.end()) {
cur = max(cur, ind - preSto[val]);
} else {
preSto[val] = ind;
}
};
vector<int> rev;
vector<int> calcVals;
auto addSides = [&](int val) {
int minInd =
lower_bound(occ[mostFreq].begin(), occ[mostFreq].end(), val) -
occ[mostFreq].begin();
if (minInd == 0)
calcVals.push_back(-1);
else
calcVals.push_back(occ[mostFreq][minInd - 1]);
auto maxInd =
upper_bound(occ[mostFreq].begin(), occ[mostFreq].end(), val);
if (maxInd == occ[mostFreq].end())
calcVals.push_back(n - 1);
else
calcVals.push_back(*maxInd - 1);
};
for (int j = 0; j < occ[i].size(); j++) {
int v = occ[i][j];
auto it = freqI.upper_bound(v);
if (it != freqI.begin()) {
--it;
rev.push_back(*it);
calcVals.push_back(*it);
addSides(*it);
freqI.erase(it);
}
calcVals.push_back(v);
it = freqI.upper_bound(v);
if (it != freqI.end()) {
rev.push_back(*it);
calcVals.push_back(*it);
addSides(*it);
freqI.erase(it);
}
}
if (rev.empty()) continue;
sort(calcVals.begin(), calcVals.end());
for (int j : calcVals) {
int jInd = upper_bound(occ[i].begin(), occ[i].end(), j) - occ[i].begin();
calc(j, jInd - ((j == -1) ? 0 : pre[j]));
}
for (int j : rev) freqI.insert(j);
ans = max(cur, ans);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
if (fopen("input.in", "r"))
freopen("input.in", "r", stdin), freopen("output.out", "w", stdout);
int t;
t = 1;
while (t--) {
run_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005, M = 200005;
int n, a[N], cn[N], c[N], c0[N], ans, maxn, p[N];
template <class I>
void Max(I& p, int q) {
p = (p > q ? p : q);
}
void ins(int x) { --c0[c[x]], ++c[x], ++c0[c[x]], Max(maxn, c[x]); }
void del(int x) { --c0[c[x]], --c[x], ++c0[c[x]], maxn -= (c0[maxn] == 0); }
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), ++cn[a[i]], cn[a[i]] > cn[mx] ? mx = a[i] : 0;
if (cn[mx] == n) return putchar('0'), 0;
int lim = (cn[mx] < 512 ? cn[mx] : 512);
for (int i = 1; i <= n; i++)
if (i != mx && cn[i] >= 512) {
for (int j = -n; j <= n; j++) p[j + M] = -1;
for (int sum = p[M] = 0, j = 1; j <= n; j++)
sum += (a[j] == mx), sum -= (a[j] == i),
~p[sum + M] ? Max(ans, j - p[sum + M]), 0 : p[sum + M] = j;
}
for (int i = 1; i <= lim; i++) {
for (int j = 1; j <= n; j++) c[j] = c0[j] = 0;
c0[maxn = 0] = n;
for (int j = 1, k = 1, x = 0; j <= n; j++) {
while (k <= n && x + (a[k] == mx) <= i) ins(a[k]), x += (a[k] == mx), ++k;
c0[maxn] >= 2 ? Max(ans, k - j), 0 : 0, del(a[j]), x -= (a[j] == mx);
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = (int)2e5 + 5;
int n;
int a[maxn];
bool read() {
if (scanf("%d", &n) < 1) {
return false;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
--a[i];
}
return true;
}
const int K = 500;
vector<int> as[maxn];
vector<int> big;
int r[maxn];
int ps[maxn][2];
int cnt[maxn];
set<pair<int, int>, greater<pair<int, int>>> st;
vector<int> qs[maxn];
vector<pair<int, int>> evs, tmp0, tmp1;
int bals[2 * maxn];
int used[2 * maxn];
int curu;
void updatePs(int i) {
int col = a[i];
for (int k = 1; k < K && k <= cnt[col]; ++k) {
int p = as[col][((int)(as[col]).size()) - cnt[col] + k - 1];
if (ps[k][0] != -1 && a[ps[k][0]] == col) {
ps[k][0] = p;
} else if (ps[k][1] != -1 && a[ps[k][1]] == col) {
ps[k][1] = p;
} else if (ps[k][1] == -1 || p < ps[k][1]) {
ps[k][1] = p;
}
if (ps[k][0] == -1 || (ps[k][1] != -1 && ps[k][1] < ps[k][0])) {
swap(ps[k][0], ps[k][1]);
}
}
}
void solve() {
for (int i = 0; i < maxn; ++i) {
as[i].clear();
qs[i].clear();
}
for (int i = 0; i < n; ++i) {
as[a[i]].push_back(i);
}
big.clear();
for (int i = 0; i < maxn; ++i) {
if (((int)(as[i]).size()) >= K) {
big.push_back(i);
}
}
for (int i = 0; i < maxn; ++i) {
for (int j = 0; j < 2; ++j) {
ps[i][j] = -1;
}
}
for (int i = 0; i < maxn; ++i) {
cnt[i] = 0;
}
st.clear();
for (int i = n - 1; i >= 0; --i) {
if (cnt[a[i]] > 0) {
st.erase(make_pair(cnt[a[i]], a[i]));
}
++cnt[a[i]];
st.insert(make_pair(cnt[a[i]], a[i]));
updatePs(i);
int col = st.begin()->second;
if (cnt[col] >= K) {
qs[col].push_back(i);
}
r[i] = -1;
for (int k = min(cnt[col], K - 1); k >= 1; --k) {
int p =
(k + 1 <= cnt[col] ? as[col][((int)(as[col]).size()) - cnt[col] + k]
: n);
if (ps[k][1] != -1 && ps[k][1] < p) {
r[i] = p;
break;
}
}
}
for (int bi = 0; bi < ((int)(big).size()); ++bi) {
int ci = big[bi];
if (qs[ci].empty()) {
continue;
}
reverse(qs[ci].begin(), qs[ci].end());
for (int bj = 0; bj < ((int)(big).size()); ++bj) {
if (bj == bi) {
continue;
}
int cj = big[bj];
tmp0.clear();
for (int i = 0; i < ((int)(as[ci]).size()); ++i) {
tmp0.push_back(make_pair(as[ci][i], 1));
}
tmp1.clear();
for (int i = 0; i < ((int)(as[cj]).size()); ++i) {
tmp1.push_back(make_pair(as[cj][i], -1));
}
evs.clear();
evs.resize(((int)(tmp0).size()) + ((int)(tmp1).size()));
merge(tmp0.begin(), tmp0.end(), tmp1.begin(), tmp1.end(), evs.begin());
tmp0 = evs;
tmp1.clear();
for (int i = 0; i < ((int)(qs[ci]).size()); ++i) {
tmp1.push_back(make_pair(qs[ci][i], -inf));
}
evs.clear();
evs.resize(((int)(tmp0).size()) + ((int)(tmp1).size()));
merge(tmp0.begin(), tmp0.end(), tmp1.begin(), tmp1.end(), evs.begin());
++curu;
int bal = maxn;
used[bal] = curu;
bals[bal] = n;
for (int i = ((int)(evs).size()) - 1; i >= 0; --i) {
if (evs[i].second == -inf) {
if (used[bal] == curu) {
r[evs[i].first] = max(r[evs[i].first], bals[bal]);
}
} else {
bal += evs[i].second;
if (used[bal] != curu) {
bals[bal] = evs[i].first;
used[bal] = curu;
}
}
}
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
res = max(res, r[i] - i);
;
;
}
printf("%d\n", res);
}
int main() {
precalc();
while (read()) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int it[200001];
int aa[200001];
int mm[200001];
int ind2[400001];
vector<int> pp[200001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> it[i];
it[i]--;
pp[it[i]].push_back(i);
aa[it[i]] += 1;
}
int ma = 0;
int ind = 0;
for (int i = 0; i < n; i++) {
if (aa[i] > ma) {
ma = aa[i];
ind = i;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i == ind) {
continue;
}
if (pp[i].size() == 0) {
continue;
}
if (aa[i] >= 300) {
for (int j = 0; j <= 2 * n; j++) {
ind2[j] = -1;
}
ind2[n] = 0;
for (int j = 0; j < n; j++) {
mm[j + 1] = mm[j];
if (it[j] == i) {
mm[j + 1] -= 1;
} else if (it[j] == ind) {
mm[j + 1] += 1;
}
if (ind2[mm[j + 1] + n] != -1) {
ans = max(ans, j + 1 - ind2[mm[j + 1] + n]);
} else {
ind2[mm[j + 1] + n] = j + 1;
}
}
} else {
for (int j = 0; j < pp[i].size(); j++) {
for (int k = j; k < pp[i].size(); k++) {
int ind2 = lower_bound(pp[ind].begin(), pp[ind].end(), pp[i][j]) -
pp[ind].begin();
ind2 = max(0, ind2 - (k - j + 1));
for (int l = ind2; l + k - j < pp[ind].size(); l++) {
if (l + k - j + 1 < pp[ind].size()) {
if (pp[ind][l + k - j + 1] < pp[i][k]) {
if (pp[ind][l] > pp[i][j]) {
break;
}
continue;
}
}
int ll, rr;
if (k + 1 < pp[i].size()) {
rr = pp[i][k + 1] - 1;
} else {
rr = n - 1;
}
if (l + k - j + 1 < pp[ind].size()) {
rr = min(rr, pp[ind][l + k - j + 1] - 1);
} else {
rr = min(rr, n - 1);
}
if (j > 0) {
ll = pp[i][j - 1] + 1;
} else {
ll = 0;
}
if (l > 0) {
ll = max(ll, pp[ind][l - 1] + 1);
} else {
ll = max(ll, 0);
}
ans = max(ans, rr - ll + 1);
if (pp[ind][l] > pp[i][j]) {
break;
}
}
}
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w[201000], C[201000], U[401000];
int S[201000];
vector<int> G[201000];
struct Tree {
int Mx[262144 + 262144], K[262144 + 262144], Mn[262144 + 262144];
void Add2(int nd, int x) { Mn[nd] += x, Mx[nd] += x, K[nd] += x; }
void Spread(int nd) {
Add2(nd * 2, K[nd]);
Add2(nd * 2 + 1, K[nd]);
K[nd] = 0;
}
void UDT(int nd) {
Mx[nd] = max(Mx[nd * 2], Mx[nd * 2 + 1]);
Mn[nd] = min(Mn[nd * 2], Mn[nd * 2 + 1]);
}
void Add(int nd, int b, int e, int s, int l, int x) {
if (s > l) return;
if (s <= b && e <= l) {
Add2(nd, x);
return;
}
Spread(nd);
int m = (b + e) >> 1;
if (s <= m) Add(nd * 2, b, m, s, l, x);
if (l > m) Add(nd * 2 + 1, m + 1, e, s, l, x);
UDT(nd);
}
int Max(int nd, int b, int e, int s, int l) {
if (s > l) return -9999999;
if (s <= b && e <= l) return Mx[nd];
Spread(nd);
int m = (b + e) >> 1;
int r = -99999999;
if (s <= m) r = max(r, Max(nd * 2, b, m, s, l));
if (l > m) r = max(r, Max(nd * 2 + 1, m + 1, e, s, l));
UDT(nd);
return r;
}
int Right(int nd, int b, int e, int x) {
if (Mn[nd] > x || Mx[nd] < x) return -1;
if (b == e) return b;
Spread(nd);
int m = (b + e) >> 1;
int r = Right(nd * 2 + 1, m + 1, e, x);
if (r == -1) r = Right(nd * 2, b, m, x);
return r;
}
int Left(int nd, int b, int e, int x) {
if (Mn[nd] > x || Mx[nd] < x) return n + 1;
if (b == e) return b;
Spread(nd);
int m = (b + e) >> 1;
int r = Left(nd * 2, b, m, x);
if (r == n + 1) r = Left(nd * 2 + 1, m + 1, e, x);
return r;
}
} T;
void Solve() {
int i, j;
scanf("%d", &n);
int pv, M = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &w[i]);
G[w[i]].push_back(i);
C[w[i]]++;
}
for (i = 1; i <= n; i++) {
if (M < C[i]) {
M = C[i];
pv = i;
}
}
for (i = 1; i <= n; i++) {
if (w[i] == pv) {
T.Add(1, 0, n, i, n, 1);
}
}
int res = 0;
for (i = 1; i <= n; i++) {
if (i == pv || G[i].empty()) continue;
for (auto &x : G[i]) {
T.Add(1, 0, n, x, n, -1);
}
int c = G[i].size();
int LL = 1e9;
for (j = c - 1; j >= 0; j--) {
int x = G[i][j];
int t = T.Max(1, 0, n, x, x);
int MM = T.Max(1, 0, n, 0, x);
MM = min(MM, LL);
if (MM >= t) {
for (int k = MM; k >= t; k--) {
int rr = T.Right(1, 0, n, k), ll = T.Left(1, 0, n, k);
res = max(res, rr - ll);
}
LL = t;
}
}
for (auto &x : G[i]) {
T.Add(1, 0, n, x, n, 1);
}
}
printf("%d\n", res);
}
int main() {
int TC = 1;
while (TC--) {
Solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, x, ans;
int a[200005], cnt[200005], lst[200005], pre[200005], nxt[200005], mina[400005],
sum[200005];
bool vis[200005], inc[200005];
vector<int> b[200005], c[200005], v[200005];
void calc(int p) {
mina[n] = 1;
for (int i = 0; i < c[p].size(); i++) {
int t = c[p][i];
sum[i + 1] = sum[i] + (a[t] == x ? -1 : 1);
if (mina[sum[i + 1] + n]) {
int l, r, s = mina[sum[i + 1] + n] - 1;
if (a[t] == x)
r = nxt[t] - 1;
else
r = nxt[lst[t]] - 1;
if (a[c[p][s]] == x)
l = pre[c[p][s]] + 1;
else
l = lst[c[p][s]] + 1;
chkmax(ans, r - l + 1);
} else
mina[sum[i + 1] + n] = i + 2;
}
for (int i = 0; i <= c[p].size(); i++) mina[sum[i] + n] = 0;
}
int main() {
n = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
int maxa = 0, num = 0;
for (int i = 1; i <= n; i++) cnt[a[i]]++, chkmax(maxa, cnt[a[i]]);
for (int i = 1; i <= n; i++)
if (maxa == cnt[i]) num++;
if (num > 1) return printf("%d\n", n), 0;
for (int i = 1; i <= n; i++)
if (maxa == cnt[i]) x = i;
for (int i = 1; i <= n + 1; i++) {
lst[i] = lst[i - 1];
if (a[i - 1] == x) lst[i] = i - 1;
}
a[n + 1] = x;
for (int i = 1; i <= n + 1; i++)
if (a[i] == x) pre[i] = lst[i], nxt[lst[i]] = i;
for (int i = 1; i <= n; i++) v[a[i]].push_back(i);
for (int i = 1; i <= n; i++) {
if (!v[i].size() || i == x) continue;
int l = 0, r = 0;
vector<int> gar(0);
for (auto p : v[i]) {
if (p > r) l = lst[p], r = nxt[l];
if (l) {
b[l].push_back(i), gar.push_back(l);
nxt[pre[l]] = nxt[l];
pre[nxt[l]] = pre[l];
l = pre[l];
}
if (r <= n) {
b[r].push_back(i), gar.push_back(r);
nxt[pre[r]] = nxt[r];
pre[nxt[r]] = pre[r];
r = nxt[r];
}
}
reverse(gar.begin(), gar.end());
for (auto p : gar) nxt[pre[p]] = pre[nxt[p]] = p;
}
vector<int> cur(0);
for (int i = 1; i <= n; i++) {
if (a[i] == x) {
for (auto r : b[i]) c[r].push_back(i), vis[r] = 1;
vector<int> tmp(0);
for (auto r : cur) {
if (!vis[r]) {
calc(r);
c[r].clear(), inc[r] = 0;
} else
tmp.push_back(r);
}
swap(cur, tmp);
for (auto r : b[i]) vis[r] = 0;
} else {
c[a[i]].push_back(i);
if (!inc[a[i]]) cur.push_back(a[i]), inc[a[i]] = 1;
}
}
for (int i = 1; i <= n; i++)
if (c[i].size()) calc(i);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int A[200005];
int block = 450;
vector<int> L[200005];
int vs[400005];
vector<pair<int, int> > Len;
vector<int> Exit[200005];
vector<int> T;
int dp[200005];
int lo;
int force(int D, int V) {
T.clear();
int bal = 0;
vs[bal + n] = 0;
T.push_back(bal);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (A[i] == D)
bal++;
else if (A[i] == V)
bal--;
if (vs[bal + n] >= 0) {
ans = max(ans, i - vs[bal + n]);
}
if (vs[bal + n] == -1) {
T.push_back(bal);
vs[bal + n] = i;
}
}
for (int v : T) {
vs[v + n] = -1;
}
return ans;
}
void smallForce(int D, int V, int len) {
int N = L[V].size();
for (int i = 0; i + len - 1 < N; i++) {
int l = i, r = i + len - 1;
Len.push_back(make_pair(L[V][i], L[V][r]));
}
}
int solve(int D, int len) {
int ans = 0;
int bal = 0;
for (int i = 0; i <= L[D].size(); i++) dp[i] = -1;
lo = 0;
for (auto it : Len) {
int a = it.first, b = it.second;
Exit[b].push_back(a);
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
if (A[i] == D) bal++;
for (int a : Exit[i]) {
lo = max(lo, a);
}
if (bal >= len) {
int ll = dp[bal - len] + 1;
if (lo >= ll) {
ans = max(ans, i - ll + 1);
}
}
if (dp[bal] == -1) dp[bal] = i;
}
for (auto it : Len) {
Exit[it.second].clear();
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
L[A[i]].push_back(i);
}
int D = 1;
for (int i = 1; i <= n; i++) {
if (L[i].size() > L[D].size()) D = i;
}
memset(vs, -1, sizeof(vs));
int ans = 0;
for (int i = 1; i <= n; i++) {
if (D == i) continue;
if (L[i].size() >= block) {
ans = max(ans, force(D, i));
}
}
for (int len = 1; len < block; len++) {
Len.clear();
for (int j = 1; j <= n; j++) {
if (j == D) continue;
if (L[j].size() >= len) {
smallForce(D, j, len);
}
}
ans = max(ans, solve(D, len));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
const double eps = 1e-8;
const int mod = 1e9 + 7;
const int N = 4e5 + 10;
const int base = 2e5 + 5;
const int inf = 1e9;
int n;
int a[N];
int num[N];
int b[N], pre[N];
vector<int> cnt[N];
bool cmp(int x, int y) { return int(cnt[x].size()) > int(cnt[y].size()); }
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]].push_back(i);
mx = max(mx, int(cnt[a[i]].size()));
}
int d = -1, res = 0;
for (int i = 1; i <= n; i++)
if (int(cnt[i].size()) == mx) {
res++;
d = i;
}
if (res > 1) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1];
if (a[i] == d) pre[i]++;
}
for (int i = 1; i <= n; i++) b[i] = i;
sort(b + 1, b + n + 1, cmp);
int ans = 0;
for (int i = 2; i <= 500; i++)
if (b[i] != d) {
memset(num, 0x3f3f3f, sizeof num);
num[base] = 0;
int sum = 0;
for (int k = 1; k <= n; k++) {
sum += (a[k] == b[i]);
sum -= (a[k] == d);
ans = max(ans, k - num[sum + base]);
num[sum + base] = min(num[sum + base], k);
}
}
for (int i = 501; i <= n; i++)
if (int(cnt[b[i]].size())) {
unordered_map<int, int> num;
num[0] = 0;
int sum = 0;
vector<int> v;
for (int x : cnt[b[i]]) {
int pos = lower_bound(cnt[d].begin(), cnt[d].end(), x) - cnt[d].begin();
pos = min(pos, int(cnt[d].size()) - 1);
for (int j = pos; j >= max(0, pos - int(cnt[b[i]].size()) - 5); j--) {
v.push_back(cnt[d][j]);
}
for (int j = pos;
j < min(int(cnt[d].size()), pos + int(cnt[b[i]].size()) + 5);
j++) {
v.push_back(cnt[d][j]);
}
v.push_back(x);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int x : v) {
if (a[x] == b[i]) sum++;
sum -= pre[x];
if (num.count(sum))
ans = max(ans, x - num[sum]);
else
num[sum] = x;
sum += pre[x];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int N = 200054;
int n, B, ans, mode;
int a[N], count[N];
int buc[2 * N];
int cur[N];
inline void up(int &x, const int y) { x < y ? x = y : 0; }
void solve(int x) {
int i, p = n;
memset(buc, -1, (2 * n + 1) << 2), buc[p] = 0;
for (i = 0; i < n; ++i) {
p += (a[i] == x) - (a[i] == mode);
if (~buc[p])
up(ans, i - buc[p] + 1);
else
buc[p] = i + 1;
}
}
void check(int L) {
int i, j = 0, Z = 0;
memset(cur, 0, (n + 1) << 2);
for (i = 0; i < n && j < n; ++i) {
for (; j < n; ++j)
if (++cur[a[j]] > L) {
--cur[a[j]];
break;
} else
Z += cur[a[j]] == L;
if (Z > 1) up(ans, j - i);
Z -= cur[a[i]]-- == L;
}
}
int main() {
int i;
bool multi = false;
std::ios::sync_with_stdio(false), cin.tie(NULL);
cin >> n, B = sqrt(n);
for (i = 0; i < n; ++i) cin >> a[i], ++count[a[i]];
for (i = 1; i <= n; ++i)
if (count[i] > count[mode])
mode = i, multi = false;
else if (count[i] == count[mode])
multi = true;
if (multi) return cout << n << '\n', 0;
for (i = 1; i <= n; ++i)
if (i != mode && count[i] >= B) solve(i);
for (i = 1; i <= B; ++i) check(i);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
long long f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
int a[200010];
int cnt[200010], cnt2[200010];
int fk[400010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m = 400;
int ma = 0, v, ans = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (++cnt[a[i]] > ma) {
ma = cnt[a[i]];
v = a[i];
}
}
for (int i = 1; i <= m; ++i) {
memset(cnt2, 0, sizeof(cnt2));
int sum = 0;
for (int l = 1, r = 1; r <= n; ++r) {
if (++cnt2[a[r]] == i) ++sum;
while (cnt2[a[r]] > i) {
if (cnt2[a[l++]]-- == i) --sum;
}
if (sum > 1) ans = max(ans, r - l + 1);
}
}
for (int i = 1; i <= n; ++i) {
if (i == v || cnt[i] <= m) continue;
int sum = n;
memset(fk, -1, sizeof(fk));
fk[sum] = 0;
for (int j = 1; j <= n; ++j) {
if (a[j] == v)
++sum;
else if (a[j] == i)
--sum;
if (fk[sum] == -1)
fk[sum] = j;
else
ans = max(ans, j - fk[sum]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << " ";
dbg_out(T...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MX = 1 << 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = n;
vector<int> LOC[n + 1];
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
LOC[A[i]].push_back(i);
}
int hi = 0, best = -1;
for (int i = 1; i <= m; i++)
if (ckmax(hi, (int)LOC[i].size())) best = i;
bool done = 0;
for (int i = 1; i <= m; i++)
if (i != best && hi == (int)LOC[i].size()) done = 1;
if (done) {
cout << n << nl;
return 0;
}
n += 2;
int a[n];
for (int i = 0; i < n - 2; i++) a[i + 1] = A[i];
a[0] = a[n - 1] = best;
vector<int> loc[n + 1];
for (int i = 0; i < n; i++) loc[a[i]].push_back(i);
hi = (int)loc[best].size();
int idxBest[n];
for (int i = 0; i < n; i++)
if (i == 0)
idxBest[i] = 1;
else
idxBest[i] = idxBest[i - 1] + (a[i] == best);
int ans = 0;
int SQRTN = sqrt(n) - 400;
for (int i = 1; i <= m; i++) {
int SZ = (int)loc[i].size();
if (i == best || !SZ) continue;
if (SZ > SQRTN) {
int j = 0, k = 0;
int sum = 0;
int firstLoc[2 * n + 1];
for (int ii = 0; ii < 2 * n + 1; ii++) firstLoc[ii] = -1;
firstLoc[sum + n] = 0;
while (j != hi - 1 || k != SZ) {
int curPos;
if (k < SZ && loc[best][j] > loc[i][k]) {
curPos = loc[i][k] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum--;
j++;
}
if (firstLoc[sum + n] == -1) firstLoc[sum + n] = curPos;
}
ckmax(ans, loc[best][j] - firstLoc[sum + n]);
} else {
int kkk = 0;
for (int kk = 0; kk < SZ; kk++) {
int j = max(0, idxBest[loc[i][kk]] - SZ - 2);
int jEnd = min(hi, idxBest[loc[i][kk]] + SZ + 2);
while (kkk < SZ && loc[best][j] > loc[i][kkk]) kkk++;
int k = kkk;
int PAD = 2 * SZ + 5;
int firstLoc[2 * PAD + 1];
for (int ii = 0; ii < 2 * PAD + 1; ii++) firstLoc[ii] = -1;
int sum = -1;
if (j == 0) firstLoc[0 + PAD] = 0;
firstLoc[sum + PAD] = loc[best][j] + 1;
j++;
while (j < jEnd) {
int curPos;
if (k < SZ && loc[i][k] < loc[best][j]) {
curPos = loc[i][k] + 1;
ckmax(ans, loc[i][k] - firstLoc[sum + PAD]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
sum--;
j++;
}
if (firstLoc[sum + PAD] == -1) firstLoc[sum + PAD] = curPos;
}
if (j != hi) ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
}
}
}
cout << ans << nl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N;
cin >> N;
vector<int> A(N);
for (auto& a : A) {
cin >> a;
a--;
}
int M = *max_element(A.begin(), A.end()) + 1;
vector<int> cnt(M);
vector<vector<int>> locs(M);
for (int i = 0; i < N; i++) {
cnt[A[i]]++;
locs[A[i]].push_back(i);
}
int V = int(max_element(cnt.begin(), cnt.end()) - cnt.begin());
vector<int> prefV(N + 1);
for (int i = 0; i < N; i++) {
prefV[i + 1] = prefV[i] + (A[i] == V);
}
int mi = 0;
int ma = N + 1;
{
vector<pair<int, int>> stk;
stk.reserve(N);
for (int u = 0; u < M; u++) {
if (u == V) continue;
stk.clear();
for (int z = 0; z < int(locs[u].size()); z++) {
{
int cnd = z - prefV[locs[u][z]];
if (stk.empty() || cnd < stk.back().first)
stk.push_back({cnd, locs[u][z]});
}
{
int cnd = (z + 1) - prefV[locs[u][z] + 1];
int lo = -1, hi = int(stk.size());
while (hi - lo > 1) {
int md = lo + (hi - lo) / 2;
if (cnd >= stk[md].first)
hi = md;
else
lo = md;
}
assert(hi < int(stk.size()));
mi = max(mi, locs[u][z] + 1 - stk[hi].second);
}
}
}
}
auto is_good = [&](int L) -> bool {
if (L == 0) return true;
assert(L >= 1);
vector<int> cnt(M);
vector<int> cnt_cnt(N + 1);
cnt_cnt[0] = M;
for (int l = 0, r = 0; l <= N - L;) {
while (r < l + L) {
cnt_cnt[cnt[A[r]]]--;
cnt[A[r]]++;
cnt_cnt[cnt[A[r]]]++;
r++;
}
int max_test = l == 0 ? N : min(N, cnt[V] + 1);
if (std::accumulate(cnt_cnt.begin() + cnt[V],
cnt_cnt.begin() + max_test + 1, int(0)) >= 2) {
return true;
}
cnt_cnt[cnt[A[l]]]--;
cnt[A[l]]--;
cnt_cnt[cnt[A[l]]]++;
l++;
}
return false;
};
while (ma - mi > 1) {
int md = (mi + ma) / 2;
if (is_good(md)) {
mi = md;
} else {
ma = md;
}
}
cout << mi << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch = getchar();
x = 0;
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
}
const int N = 2e5 + 5;
int n, m, val, res, a[N], cnt[N], w[N * 2], c[N], cc[N], t[N], tp;
void modify(int x, int o) { --cc[c[x]], c[x] += o, ++cc[c[x]]; }
signed main() {
read(n);
m = sqrt(n);
for (int i = 1; i <= n; ++i) read(a[i]), ++cnt[a[i]];
int mx = 0, num = 0;
for (int i = 1; i <= n; ++i)
if (cnt[i] == mx)
++num;
else if (cnt[i] > mx)
mx = cnt[i], num = 1;
if (num > 1) return printf("%d\n", n), 0;
for (int i = 1; i <= n; ++i)
if (cnt[i] == mx)
val = i;
else if (cnt[i] > m)
t[++tp] = i;
for (int p = 1; p <= tp; ++p) {
int i = t[p], s = n, la = n;
memset(w, 0x3f, sizeof(w));
for (int j = 1; j <= n; ++j) {
if (a[j] == i) --s;
if (a[j] == val) ++s;
res = max(res, j - w[s] + 1);
w[la] = min(w[la], j);
la = s;
}
}
for (int i = 1; i <= m; ++i) {
memset(c, 0, sizeof(c));
memset(cc, 0, sizeof(cc));
int l = 1, r = 0;
while (r < n) {
++r, modify(a[r], 1);
while (c[a[r]] > i) modify(a[l], -1), ++l;
if (cc[i] >= 2) res = max(res, r - l + 1);
}
}
return printf("%d\n", res), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int maxa = N;
int a[N], n, f[N], sq;
int cnt[maxa], ccnt[N];
void Max(int &x, int y) {
if (x < y) x = y;
}
int solve(int maxans) {
int mx = 0;
for (int i = 1; i <= maxans; i++) {
if (cnt[i] > cnt[mx]) mx = i;
}
int ans = 0;
for (int i = 1; i <= maxans; i++) {
if (i == mx || !cnt[i]) continue;
if (cnt[i] <= sq) continue;
for (int j = 1; j <= n; j++) {
if (a[j] == mx) {
f[j] = 1;
} else if (a[j] == i) {
f[j] = -1;
} else {
f[j] = 0;
}
}
unordered_map<int, int> mp;
mp[0] = 0;
int now = 0;
for (int j = 1; j <= n; j++) {
now += f[j];
if (!mp.count(now))
mp[now] = j;
else {
Max(ans, j - mp[now]);
}
}
}
return ans;
}
int solve2(int maxti) {
int ans = 0;
for (int i = 1; i <= maxti; i++) {
memset(cnt, 0, sizeof cnt);
memset(ccnt, 0, sizeof ccnt);
for (int r = 1, l = 1; r <= n; r++) {
ccnt[cnt[a[r]]]--;
cnt[a[r]]++;
ccnt[cnt[a[r]]]++;
while (cnt[a[r]] > i && l <= r) {
ccnt[cnt[a[l]]]--;
cnt[a[l]]--;
ccnt[cnt[a[l]]]++;
l++;
}
if (ccnt[i] >= 2) Max(ans, r - l + 1);
}
}
return ans;
}
int main() {
scanf("%d", &n);
sq = 448;
int mx = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (!cnt[i]) continue;
ccnt[cnt[i]]++;
if (mx < cnt[i]) mx = cnt[i];
}
if (ccnt[mx] >= 2) {
printf("%d\n", n);
} else {
printf("%d\n", max(solve2(sq), solve(n)));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5, M = 500;
int n, a[N], lst[2 * N + 1], f = 0, nxt[N], prv[N], s[N];
vector<int> p[N];
int solve1(int v) {
int sol = 0;
for (int i = 0; i <= 2 * n; i++) lst[i] = -1;
int sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] == v)
sum++;
else if (a[i] == f)
sum--;
lst[sum + n] = i;
}
for (int i = 2 * n - 1; 0 <= i; i--) lst[i] = max(lst[i], lst[i + 1]);
sum = 0;
for (int i = 0; i < n; i++) {
sol = max(sol, lst[n + sum] - i + 1);
if (a[i] == v)
sum++;
else if (a[i] == f)
sum--;
}
return sol;
}
int solve2(int v) {
int sol = 0;
int l = p[v].size();
for (int i = 0; i <= 2 * l; i++) lst[i] = -1;
int e = n;
for (int i : p[v]) {
int db = s[e - 1] - s[i];
if (db) {
for (int j = 0; j + db - 1 <= 2 * l; j++) lst[j] = lst[j + db - 1];
for (int j = max(2 * l - db + 2, 0); j <= 2 * l; j++) lst[j] = -1;
} else
for (int j = 2 * l; 1 <= j; j--) lst[j] = lst[j - 1];
db = 0;
int act = i;
while (act < e && db <= l + 1) {
act = nxt[act];
lst[l + 1 - db] = max(lst[l + 1 - db], act - 1);
db++;
}
for (int j = 2 * l - 1; 0 <= j; j--) lst[j] = max(lst[j], lst[j + 1]);
act = i;
db = 0;
while (0 <= act && db <= l) {
act = prv[act];
sol = max(sol, lst[l + db] - act);
db++;
}
e = i;
}
return sol;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; 0 <= i; i--) p[--a[i]].push_back(i);
for (int i = 1; i < n; i++)
if (p[i].size() > p[f].size()) f = i;
nxt[n - 1] = n;
prv[0] = -1;
s[0] = (a[0] == f ? 1 : 0);
for (int i = n - 2; 0 <= i; i--)
nxt[i] = (a[i + 1] == f ? i + 1 : nxt[i + 1]);
for (int i = 1; i < n; i++) prv[i] = (a[i - 1] == f ? i - 1 : prv[i - 1]);
for (int i = 1; i < n; i++) s[i] = (a[i] == f ? s[i - 1] + 1 : s[i - 1]);
int sol = 0;
for (int v = 0; v < n; v++)
if (v != f && !p[v].empty())
sol = max(sol, (p[v].size() >= M ? solve1(v) : solve2(v)));
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int n;
int main() {
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
int Fid = -1;
{
vector<int> cnt(n);
for (auto i : a) cnt[i]++;
int mx = max_element(cnt.begin(), cnt.end()) - cnt.begin();
if (count(cnt.begin(), cnt.end(), cnt[mx]) >= 2) {
cout << n;
return 0;
}
Fid = mx;
}
vector<set<int>> var(n);
for (int i = 1; i <= n; i++) {
var[a[i - 1]].insert(i);
}
vector<int> s = {0};
for (int i : var[Fid]) s.push_back(i);
s.push_back(n + 1);
int ret = 0;
for (auto it = s.begin(); it != prev(s.end()); it++)
ret = max(ret, *next(it) - *it - 1);
for (int v = 0; v < n; v++) {
if (v == Fid) continue;
var[v].insert(0);
var[v].insert(n + 1);
int cur = 0;
vector<int> beg = {0};
vector<int> pos = {0};
int cnt = 1;
auto get_dp = [&](int p) {
assert(p < cnt);
int id = upper_bound(pos.begin(), pos.end(), p) - pos.begin() - 1;
return s[beg[id] + p - pos[id]];
};
for (auto it = var[v].begin(); it != prev(var[v].end()); it++) {
int L = *it;
int R = *next(it);
int sL = upper_bound(s.begin(), s.end(), L) - s.begin();
int sR = upper_bound(s.begin(), s.end(), R) - s.begin();
if (sL == sR) {
cur--;
continue;
}
int to = cur + sR - sL - 1;
while (cur < cnt && sL < sR) {
cur++;
if (cur > 0) {
ret = max(ret, s[sL] - get_dp(cur - 1) - 1);
}
sL++;
}
if (cur >= cnt) {
pos.push_back(cur);
beg.push_back(sL - 1);
cnt += sR - sL + 1;
}
cur = to;
}
}
cout << ret;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, ans, mx, mxh, mnh, h, ts, now;
int a[N], dl, dr, dp;
vector<int> p[N];
struct Seg {
int l, r, be, is;
} d[N + N];
int nx(int y) {
int o = (upper_bound(p[mx].begin(), p[mx].end(), y) - p[mx].begin()),
u = (upper_bound(p[now].begin(), p[now].end(), y) - p[now].begin());
o = o == p[mx].size() ? n + 1 : p[mx][o];
u = u == p[now].size() ? n + 1 : p[now][u];
return min(o, u) - 1;
}
void upd(int h, int x) {
if (h < d[dp].l) --dp;
if (h > d[dp].r) ++dp;
if (d[dp].is)
ans = max(ans, nx(x) - p[mx][h + d[dp].be]);
else
ans = max(ans, nx(x) - d[dp].be);
}
void doit(int l, int r) {
for (int i = l, _e = r; i < _e; ++i)
if (++h > mxh) {
d[++dr] = (Seg){h, h + (r - i - 1), -h + i, 1};
h = mxh = d[dr].r;
break;
} else
upd(h, p[mx][i]);
}
int main() {
scanf("%d", &n);
for (int i = 1, _e = n; i <= _e; ++i)
scanf("%d", &a[i]), p[a[i]].push_back(i);
for (int i = 1, _e = n; i <= _e; ++i)
if (p[i].size() > p[mx].size()) mx = i;
for (int i = 1, _e = n; i <= _e; ++i)
if (i != mx && p[i].size()) {
now = i;
mnh = mxh = h = 0;
upd(0, 0);
dp = dl = dr = n;
d[n] = (Seg){0, 0, 0, 0};
int las = 0;
for (int j : p[i]) {
int las2 = (upper_bound(p[mx].begin(), p[mx].end(), j) - p[mx].begin());
doit(las, las2);
if (--h < mnh)
mnh = h, d[--dl] = (Seg){h, h, j, 0};
else
upd(h, j);
las = las2;
}
doit(las, p[mx].size());
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
int n, val[N + 5], cnt[N + 5], x, sum[N + 5], las[2 * N + 5], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]), cnt[val[i]]++;
for (int i = 1; i <= n; i++)
if (cnt[i] > cnt[x]) x = i;
int lim = trunc(sqrt(n));
for (int i = 1; i <= n; i++) {
if ((cnt[i] >= lim) && (i != x)) {
int y = i;
for (int j = 1; j <= n; j++) {
if (val[j] == x)
sum[j] = 1;
else if (val[j] == y)
sum[j] = -1;
else
sum[j] = 0;
}
for (int j = 0; j <= 2 * n; j++) las[j] = -1;
las[n] = 0;
sum[0] = n;
for (int j = 1; j <= n; j++) {
sum[j] += sum[j - 1];
if (las[sum[j]] != -1)
ans = max(ans, j - las[sum[j]]);
else
las[sum[j]] = j;
}
}
}
for (int i = 1; i < lim; i++) {
for (int j = 1; j <= n; j++) sum[j] = 0;
int l = 1, num = 0;
for (int j = 1; j <= n; j++) {
sum[val[j]]++;
if (sum[val[j]] == i)
num++;
else
while (sum[val[j]] > i) {
if (sum[val[l]] == i) num--;
sum[val[l]]--;
l++;
}
if (num >= 2) ans = max(ans, j - l + 1);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int B = 400;
int n, a[200010], s[200010], sta[200010], tp, l, r, mid, ans, Ans, ss[200010],
p[400010];
vector<int> v[200010];
int main() {
Ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), v[a[i]].push_back(i);
int ma = 0, maa;
for (int i = 1; i <= n; i++)
if (v[i].size() > ma)
maa = i, ma = v[i].size();
else if (v[i].size() == ma)
maa = -1;
if (maa == -1) return printf("%d\n", n), 0;
for (int i = 1; i <= n; i++)
if (v[i].size() >= B && i != maa) {
ss[0] = 200000;
for (int j = 1; j <= n; j++)
ss[j] = ss[j - 1] + (a[j] == maa) - (a[j] == i);
for (int j = n; j >= 0; j--)
if (!p[ss[j]])
p[ss[j]] = j;
else
Ans = max(Ans, p[ss[j]] - j);
for (int j = 0; j <= n; j++) p[ss[j]] = 0;
}
p[0] = 0;
int sz = v[maa].size();
for (int i = 0; i < sz; i++) p[i + 1] = v[maa][i];
p[sz + 1] = n + 1;
for (int i = 0; i <= sz; i++) {
int ma = 0;
for (int j = i + 1; j <= sz + 1 && j <= i + B + 1; j++) {
for (int k = p[j - 1] + 1; k < p[j]; k++) {
s[a[k]]++;
if (s[a[k]] > ma) ma = s[a[k]];
}
if (ma == j - i - 1) Ans = max(Ans, p[j] - p[i] - 1);
}
for (int j = i + 1; j <= sz + 1 && j <= i + B + 1; j++)
for (int k = p[j - 1] + 1; k < p[j]; k++) s[a[k]] = 0;
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int e = 5e5 + 100;
int n, m, a[e], ton1[e], cnt[e], cnx[e], b[e], s[e], mm[e * 2];
int main() {
cin >> n;
int maxn = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ton1[a[i]]++;
maxn = ((maxn) > (ton1[a[i]]) ? (maxn) : (ton1[a[i]]));
}
int pd = 0;
for (int i = 1; i <= n; i++) {
if (pd != 0 and ton1[i] == maxn) {
cout << n;
return 0;
}
if (ton1[i] == maxn) {
pd = i;
}
}
int k = sqrt(n), ans = 0;
for (int i = 1, lim = ((k) < (ton1[pd]) ? (k) : (ton1[pd])); i <= lim; i++) {
int l = 0, r = 0, mxcn = 0;
memset(cnx, 0, sizeof(cnx));
memset(cnt, 0, sizeof(cnt));
cnx[0] = n;
while (r <= n) {
for (; cnt[pd] <= i and r <= n;) {
if (cnx[mxcn] > 1) ans = ((ans) > (r - l) ? (ans) : (r - l));
r++;
cnx[cnt[a[r]]]--;
cnt[a[r]]++;
mxcn = ((mxcn) > (cnt[a[r]]) ? (mxcn) : (cnt[a[r]]));
cnx[cnt[a[r]]]++;
}
for (; cnt[pd] > i and l <= r;) {
++l;
cnx[cnt[a[l]]]--;
if (cnt[a[l]] == mxcn and cnx[cnt[a[l]]] == 0) mxcn--;
cnt[a[l]]--;
cnx[cnt[a[l]]]++;
}
}
}
for (int i = 1; i <= n; i++) {
if (i == pd) continue;
if (ton1[i] > k) {
memset(mm, 0x3f, sizeof(mm));
mm[e] = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == i) {
b[j] = -1;
} else if (a[j] == pd) {
b[j] = 1;
} else
b[j] = 0;
s[j] = s[j - 1] + b[j];
mm[s[j] + e] = ((mm[s[j] + e]) < (j) ? (mm[s[j] + e]) : (j));
ans = ((ans) > (j - mm[s[j] + e]) ? (ans) : (j - mm[s[j] + e]));
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const int INF = 1e9 + 7;
int n;
int a[N], w[N], c[N], s[N];
vector<int> h[N];
map<int, int> mp;
void Ins(int x, int y) {
map<int, int>::iterator u = mp.upper_bound(x);
if (u != mp.begin()) {
u--;
if ((u->second) <= y) return;
}
mp[x] = y;
while (1) {
map<int, int>::iterator g = mp.upper_bound(x);
if (g == mp.end()) break;
if ((g->second) > y)
mp.erase(g->first);
else
break;
}
}
struct Tree {
int l, r, mx;
} tr[N * 4];
void build(int l, int r, int p) {
tr[p] = (Tree){l, r, 0};
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, p * 2);
build(mid + 1, r, p * 2 + 1);
}
void ins(int p, int L, int R, int v) {
int l = tr[p].l, r = tr[p].r;
if (L <= l && R >= r) {
tr[p].mx = max(tr[p].mx, v);
return;
}
int mid = (l + r) >> 1;
if (L <= mid) ins(p * 2, L, R, v);
if (R > mid) ins(p * 2 + 1, L, R, v);
}
int check(int p, int x) {
if (tr[p].l == tr[p].r) return tr[p].mx;
int mid = (tr[p].l + tr[p].r) >> 1;
if (x <= mid)
return max(check(p * 2, x), tr[p].mx);
else
return max(check(p * 2 + 1, x), tr[p].mx);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int nm = 0, nx, mi = n + 1;
for (int i = n; i; i--) {
c[w[a[i]]]--;
w[a[i]]++;
c[w[a[i]]]++;
if (w[a[i]] > nm) {
nm = w[a[i]];
nx = a[i];
}
if (c[nm] > 1) mi = i;
}
int Ans = n - mi + 1;
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + (a[i] == nx);
for (int i = 1; i <= n; i++) h[a[i]].push_back(i);
build(0, s[n], 1);
for (int i = 1; i <= n; i++) {
if (i == nx) continue;
if (!h[i].size()) continue;
mp.clear();
for (int j = 0; j <= h[i].size() - 1; j++) {
int v = j - s[h[i][j] - 1];
Ins(v, j);
int u = j + 1 - s[h[i][j]];
int q = j + 1 - ((j != h[i].size() - 1) ? s[h[i][j + 1]] : INF);
map<int, int>::iterator o = mp.upper_bound(u);
while (o != mp.begin()) {
o--;
if ((o->first) < q) break;
int t2 = o->second;
int p = j - t2 + 1, e = s[h[i][j]], b = s[h[i][t2]] + 1;
if (e - p + 1 <= b) ins(1, e - p + 1, b, p);
}
}
}
for (int i = 0; i <= h[nx].size() - 1; i++) {
int u = check(1, i + 1);
u = min(u, (int)h[nx].size() - i);
int pe = (i + u == h[nx].size()) ? n : h[nx][i + u] - 1;
Ans = max(Ans, pe - (i ? h[nx][i - 1] : 0));
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int n;
int a[maxN];
int cnt[maxN];
int pref[maxN];
const int SHIFT = maxN;
int lst[maxN + SHIFT];
vector<int> poses[maxN];
int when[maxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
poses[a[i]].emplace_back(i);
}
int f = 1;
for (int c = 1; c <= n; c++) {
if (cnt[c] > cnt[f]) f = c;
}
memset(when, -1, sizeof when);
when[0] = 0;
for (int i = 1; i <= n; i++) {
pref[i] = pref[i - 1];
if (a[i] == f) {
pref[i]++;
when[pref[i]] = i;
}
}
int lim = min(n, 3 * (int)sqrt(n));
int best = 0;
for (int i = 1; i <= n; i++) {
if (i == f) continue;
if (cnt[i] >= lim) {
memset(lst, -1, sizeof lst);
lst[SHIFT] = 0;
int cur_val = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == f)
cur_val--;
else if (a[j] == i)
cur_val++;
if (lst[SHIFT + cur_val] != -1) {
best = max(best, j - lst[SHIFT + cur_val]);
} else {
lst[SHIFT + cur_val] = j;
}
}
} else {
if (poses[i].empty()) continue;
for (int a = 0; a < poses[i].size(); a++) {
int x = poses[i][a];
for (int b = poses[i].size() - 1; b >= a; b--) {
int y = poses[i][b];
int cur_sum = b - a + 1 - pref[y] + pref[x - 1];
if (cur_sum < 0) continue;
int cnt_before = pref[x - 1];
int cnt_tot = pref[y];
for (int take = 0; take <= cur_sum; take++) {
int l1 = (cnt_before < take ? 1 : (when[cnt_before - take] + 1));
int r1 = ((cur_sum - take + cnt_tot >= cnt[f])
? n
: (when[cnt_tot + cur_sum - take + 1] - 1));
best = max(best, r1 - l1 + 1);
}
break;
}
}
}
}
cout << best;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int maxa = N;
int a[N], n, f[N], sq;
int cnt[maxa], ccnt[N];
void Max(int &x, int y) {
if (x < y) x = y;
}
int solve(int maxans) {
int mx = 0;
for (int i = 1; i <= maxans; i++) {
if (cnt[i] > cnt[mx]) mx = i;
}
int ans = 0;
for (int i = 1; i <= maxans; i++) {
if (i == mx || !cnt[i]) continue;
if (cnt[i] <= sq) continue;
for (int j = 1; j <= n; j++) {
if (a[j] == mx) {
f[j] = 1;
} else if (a[j] == i) {
f[j] = -1;
} else {
f[j] = 0;
}
}
unordered_map<int, int> mp;
mp[0] = 0;
int now = 0;
for (int j = 1; j <= n; j++) {
now += f[j];
if (!mp.count(now))
mp[now] = j;
else {
Max(ans, j - mp[now]);
}
}
}
return ans;
}
int solve2(int maxti) {
int ans = 0;
for (int i = 1; i <= maxti; i++) {
memset(cnt, 0, sizeof cnt);
memset(ccnt, 0, sizeof ccnt);
for (int r = 1, l = 1; r <= n; r++) {
ccnt[cnt[a[r]]]--;
cnt[a[r]]++;
ccnt[cnt[a[r]]]++;
while (cnt[a[r]] > i && l <= r) {
ccnt[cnt[a[l]]]--;
cnt[a[l]]--;
ccnt[cnt[a[l]]]++;
l++;
}
if (ccnt[i] >= 2) Max(ans, r - l + 1);
}
}
return ans;
}
int main() {
scanf("%d", &n);
sq = 448;
int mx = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (!cnt[i]) continue;
ccnt[cnt[i]]++;
if (mx < cnt[i]) mx = cnt[i];
}
if (ccnt[mx] >= 2) {
printf("%d\n", n);
} else {
int s1 = solve(n), s2 = solve2(sq);
if (max(s1, s2) == 896) printf("%d %d\n", s1, s2);
printf("%d\n", max(s1, s2));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
int n, val[N + 5], cnt[N + 5], x, sum[N + 5], las[2 * N + 5], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]), cnt[val[i]]++;
for (int i = 1; i <= n; i++)
if (cnt[i] > cnt[x]) x = i;
int lim = sqrt(n) + 1;
for (int i = 1; i <= n; i++)
if (cnt[i] >= lim && i != x) {
int y = i;
for (int j = 1; j <= n; j++)
if (val[j] == x)
sum[j] = 1;
else if (val[j] == y)
sum[j] = -1;
else
sum[j] = 0;
for (int j = 0; j <= 2 * n; j++) las[j] = -1;
las[n] = 0;
sum[0] = n;
for (int j = 1; j <= n; j++) {
sum[j] += sum[j - 1];
if (las[sum[j]] != -1)
ans = max(ans, j - las[sum[j]]);
else
las[sum[j]] = j;
}
}
for (int i = 1; i < lim; i++) {
for (int j = 1; j <= n; j++) sum[j] = 0;
int l = 1, num = 0;
for (int j = 1; j <= n; j++) {
sum[val[j]]++;
if (sum[val[j]] == i)
num++;
else
while (sum[val[j]] > i) {
if (sum[val[l]] == i) num--;
sum[val[l]]--;
l++;
}
if (num >= 2) ans = max(ans, j - l + 1);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<deque<int>> lens;
vector<int> counts;
int n;
vector<int> a;
int mx;
int res = 0;
const int SQ = sqrt(2e5 + 7);
int find_pos(int it, vector<pair<int, int>>& segs, vector<int>& pref) {
if (it >= pref.back()) {
return -1;
}
int l = 0, r = segs.size();
while (r - l > 1) {
int mid = (l + r) / 2;
if (pref[mid] > it) {
r = mid;
} else {
l = mid;
}
}
return l;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
vector<int> cnt(n, 0);
a.resize(n);
vector<vector<int>> pos(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
--a[i];
++cnt[a[i]];
pos[a[i]].push_back(i);
}
for (int i = 0; i < n; ++i) {
pos[i].push_back(n);
}
mx = 0;
for (int i = 0; i < n; ++i) {
if (cnt[i] > cnt[mx]) {
mx = i;
}
}
vector<int> mx_pos;
mx_pos.push_back(-1);
for (int i = 0; i < n; ++i) {
if (a[i] == mx) {
mx_pos.push_back(i);
}
}
vector<int> lowest(2 * n, n);
int res = 0;
for (int k = 0; k < n; ++k) {
if (k == mx) continue;
if (cnt[k] < SQ) continue;
int bal = n;
lowest[bal] = -1;
for (int i = 0; i < n; ++i) {
if (a[i] == mx) {
--bal;
} else if (a[i] == k) {
++bal;
}
lowest[bal] = min(lowest[bal], i);
res = max(res, i - lowest[bal]);
}
bal = n;
for (int i = 0; i < n; ++i) {
if (a[i] == mx) {
--bal;
} else if (a[i] == k) {
++bal;
}
lowest[bal] = n;
}
}
for (int k = 0; k < n; ++k) {
if (k == mx) continue;
if (cnt[k] >= SQ) continue;
int pr = -1;
for (int now = 0; now < pos[k].size(); ++now) {
for (int d = 0; d < 2; ++d) {
int first = pos[k][now];
int it =
lower_bound(mx_pos.begin(), mx_pos.end(), first) - mx_pos.begin();
int bal = n;
int total = 0;
for (int i = max(it - cnt[k] - 1, 0); i < it; ++i) {
if (mx_pos[i] < pr) {
continue;
}
if (i) {
--bal;
}
if (!d) {
lowest[bal] = mx_pos[i];
} else {
lowest[bal] = n;
}
}
++bal;
if (!d) {
lowest[bal] = min(lowest[bal], first);
} else {
lowest[bal] = n;
}
for (int nxt = now + 1; nxt < pos[k].size(); ++nxt) {
int second = pos[k][nxt];
while (total < cnt[k] + 1 && it < mx_pos.size() &&
mx_pos[it] < second) {
if (!d) {
res = max(res, mx_pos[it] - 1 - lowest[bal]);
}
--bal;
if (!d) {
lowest[bal] = min(lowest[bal], mx_pos[it]);
} else {
lowest[bal] = n;
}
++it, ++total;
}
if (total == cnt[k] + 1) {
break;
}
if (!d) {
lowest[bal] = min(lowest[bal], second - 1);
res = max(res, (second - 1) - lowest[bal]);
} else {
lowest[bal] = n;
}
++bal;
if (!d) {
lowest[bal] = min(lowest[bal], second);
if (second != n) {
res = max(res, second - lowest[bal]);
}
} else {
lowest[bal] = n;
}
}
}
pr = pos[k][now];
}
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
int p, lmt;
int n, cnt[200010], a[200010], sum[200010];
int exs[200010], exs1[200010], ans, first[400010];
vector<int> loc;
map<int, int> used;
inline bool check() {
int mx = 0, tot = 0;
for (int i = 1; i <= n; i++) {
if (cnt[i] > mx) mx = cnt[i], tot = 0, p = i;
if (cnt[i] == mx) tot++;
}
return tot > 1;
}
int main() {
n = read();
lmt = 400;
for (int i = 1; i <= n; i++) {
a[i] = read();
cnt[a[i]]++;
}
if (check()) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= n; i++)
if (a[i] == p) loc.push_back(i);
for (int u = 1; u <= n; u++)
if (cnt[u] > lmt && u != p) {
for (int i = 0; i <= 2 * n; i++) first[i] = n + 1;
first[n] = 0, sum[0] = n;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + (a[i] == u) - (a[i] == p);
if (first[sum[i]] <= n)
ans = max(ans, i - first[sum[i]]);
else
first[sum[i]] = i;
}
}
vector<pair<int, int> > seg;
for (int len = 1; len <= lmt + 1; len++) {
seg.clear();
for (int i = 0; i < loc.size(); i++) {
int j = i + len - 1;
if (j >= loc.size()) break;
int l = (i == 0 ? 1 : loc[i - 1] + 1),
r = (j == loc.size() - 1 ? n : loc[j + 1] - 1);
seg.push_back(make_pair(l, r));
}
int l = 1, r = 0, mx = 0;
memset(exs, 0, sizeof(exs));
memset(exs1, 0, sizeof(exs1));
for (int i = 0; i < seg.size(); i++) {
while (r < seg[i].second) {
mx += 2;
r++;
if (a[r] != p) {
exs1[exs[a[r]]]--;
exs[a[r]]++;
exs1[exs[a[r]]]++;
}
while (!exs1[mx] && mx) mx--;
}
while (l < seg[i].first) {
mx += 2;
if (a[l] != p) {
exs1[exs[a[l]]]--;
exs[a[l]]--;
exs1[exs[a[l]]]++;
}
l++;
while (!exs1[mx] && mx) mx--;
}
if (mx >= len) ans = max(ans, r - l + 1);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void rd(double &x) { scanf("%lf", &x); }
inline void rd(char &x) { scanf("%c", &x); }
inline void rd(char *s) { scanf("%s", s); }
template <typename T>
inline void rd(T &x) {
x = 0;
char ch = getchar();
bool w = 0;
while (!isdigit(ch)) {
w |= (ch == '-');
ch = getchar();
}
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
if (w) x = -x;
}
template <typename T, typename... U>
inline void rd(T &a, U &...b) {
rd(a), rd(b...);
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
const int maxn = 2e5 + 114;
int n, arr[maxn], cnt[maxn], mx = 0;
int main() {
rd(n);
for (int i = 1, __i = n; i <= __i; ++i) {
rd(arr[i]);
if (++cnt[arr[i]] > cnt[mx]) mx = arr[i];
}
for (int i = 1, __i = n; i <= __i; ++i)
if (arr[i] != mx && cnt[arr[i]] == cnt[mx]) {
printf("%d\n", n);
return 0;
}
int B = sqrt(n);
int ans = 0;
int mp[maxn << 1];
for (int i = 1, __i = n; i <= __i; ++i)
if (i != mx && cnt[i] >= B) {
memset(mp, 0, sizeof(mp));
int cur = 0;
for (int j = 1, __j = n; j <= __j; ++j) {
if (arr[j] == i) ++cur;
if (arr[j] == mx) --cur;
if (!cur || mp[cur + n])
ans = max(ans, j - mp[cur + n]);
else
mp[cur + n] = j;
}
}
for (int i = 1, __i = B - 1; i <= __i; ++i) {
fill_n(mp + 1, n, 0);
int l = 1, cnt = 0;
for (int r = 1, __r = n; r <= __r; ++r) {
if (++mp[arr[r]] == i) ++cnt;
if (mp[arr[r]] > i) {
do {
if (mp[arr[l]]-- == i) --cnt;
} while (arr[l++] != arr[r]);
}
if (cnt >= 2) ans = max(ans, r - l + 1);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int n, a[423456], cnt[423456];
int s[423456], pos[423456], answer, val[423456];
vector<int> npos[423456];
int T = 300;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
npos[a[i]].push_back(i);
}
int cntmode = 0;
for (int i = 1; i <= n; i++) cntmode = max(cntmode, cnt[i]);
vector<int> modes;
for (int i = 1; i <= n; i++)
if (cnt[i] == cntmode) {
modes.push_back(i);
}
if (modes.size() >= 2) {
printf("%d\n", n);
return 0;
}
int M = modes[0];
for (int m = 1; m <= n; m++) {
if (m == M) continue;
if (cnt[m] <= T) continue;
for (int j = 1; j <= n; j++) {
if (a[j] == M)
s[j] = s[j - 1] + 1;
else if (a[j] == m)
s[j] = s[j - 1] - 1;
else
s[j] = s[j - 1];
}
for (int i = 0; i <= 2 * n + 1; i++) pos[i] = n + 1;
for (int i = 0; i <= n; i++) pos[s[i] + n] = min(pos[s[i] + n], i);
for (int i = 1; i <= n; i++) {
answer = max(answer, i - pos[s[i] + n]);
}
}
npos[M].insert(npos[M].begin(), 0);
npos[M].push_back(n + 1);
for (int ocr = 0; ocr <= T + 1; ocr++) {
for (int i = 0; i <= n; i++) val[i] = n + 1;
for (int i = 1; i <= n; i++) {
if (i == M) continue;
for (int j = 0; j < npos[i].size(); j++) {
if (j + ocr - 1 < (int)npos[i].size()) {
val[npos[i][j]] = npos[i][max(j + ocr - 1, j)];
}
}
}
for (int i = 0; i <= n + 1; i++) pos[i] = -1;
for (int i = 1; i <= n; i++) pos[val[i]] = max(pos[val[i]], i);
for (int i = 1; i <= n; i++) pos[i] = max(pos[i], pos[i - 1]);
for (int i = 0; i < npos[M].size(); i++) {
if (i + ocr + 1 >= npos[M].size()) break;
int Rl = npos[M][i] + 1, Rr = npos[M][i + ocr + 1] - 1;
if (pos[Rr] >= Rl) {
answer = max(answer, Rr - Rl + 1);
}
}
}
printf("%d\n", answer);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010;
int n, ans = 0, a[N], cnt[N], sqrtn, his[2 * N], q[N];
int main() {
scanf("%d", &n);
sqrtn = (int)trunc(sqrt(n));
int maxCnt = 0, x = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
if (cnt[a[i]] > maxCnt) {
maxCnt = cnt[a[i]];
x = a[i];
}
}
for (int i = 0; i <= 2 * n; i++) his[i] = -1;
for (int i = 1; i <= n; i++) {
if (i != x && cnt[i] > sqrtn) {
int now = n, r = 0;
q[r++] = now;
his[now] = 0;
for (int j = 0; j < n; j++) {
if (a[j] == i) q[r++] = ++now;
if (a[j] == x) q[r++] = --now;
if (his[now] == -1)
his[now] = j + 1;
else {
ans = max(ans, j - his[now] + 1);
}
}
for (int j = 0; j < r; j++) his[q[j]] = -1;
}
}
for (int len = 1; len <= sqrtn; len++) {
int l = 0, num = 0;
for (int i = 1; i <= n; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) {
cnt[a[i]]++;
if (cnt[a[i]] == len) num++;
if (cnt[a[i]] > len) {
while (true) {
if (cnt[a[l]] == len) num--;
cnt[a[l]]--;
l++;
if (a[l - 1] == a[i]) break;
}
}
if (num > 1) ans = max(ans, i - l + 1);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, a[N], cnt[N], ans, c[N], mx, nw, tot;
int ape[2 * N];
void add(int x, int y) {
if (cnt[x] == nw) tot--;
cnt[x] += y;
if (cnt[x] == nw) tot++;
}
void work(int x) {
memset(ape, -1, sizeof(ape));
ape[n] = 0;
for (register int i = (1); i <= (n); ++i) {
if (a[i] == x)
c[i] = 1;
else if (a[i] == mx)
c[i] = -1;
else
c[i] = 0;
c[i] += c[i - 1];
if (ape[c[i] + n] == -1)
ape[c[i] + n] = i;
else
ans = max(ans, i - ape[c[i] + n]);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (register int i = (1); i <= (n); ++i) cin >> a[i], cnt[a[i]]++;
int lim = sqrt(n), l;
for (register int i = (1); i <= (n); ++i)
if (cnt[mx] < cnt[i]) mx = i;
for (register int i = (1); i <= (n); ++i)
if (cnt[i] > lim) work(i);
for (register int j = (1); j <= (lim); ++j) {
memset(cnt, 0, sizeof(cnt));
l = 1;
nw = j;
tot = 0;
for (register int i = (1); i <= (n); ++i) {
add(a[i], 1);
while (cnt[a[i]] > nw) add(a[l++], -1);
if (tot >= 2) ans = max(ans, i - l + 1);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
bool chmax(T &val, T nv) {
return val < nv ? (val = nv, true) : false;
}
template <class T>
bool chmin(T &val, T nv) {
return nv < val ? (val = nv, true) : false;
}
using namespace std;
using ll = long long;
const int MAX_N = 200010, MAX_K = MAX_N;
int n, a[MAX_N], cnt[MAX_K], *pos = new int[MAX_N << 1] + MAX_N;
int cal(int x, int y) {
int sum = 0, res = 0;
0;
fill(pos - n, pos + n, n);
for (int i = 0; i <= n; ++i) {
if (a[i] == x) ++sum;
if (a[i] == y) --sum;
0;
chmax(res, i - pos[sum]);
chmin(pos[sum], i);
}
0;
return res;
}
int solve() {
int p = max_element(cnt, cnt + MAX_K) - cnt, mx = cnt[p];
int cntmx = 0;
for (int i = 1; i < MAX_K; ++i) cntmx += mx == cnt[i];
if (cntmx > 1) return n;
int res = 0;
int sec = 0, o = 0;
for (int i = 1; i < MAX_K; ++i)
if (mx != cnt[i] && chmax(sec, cnt[i])) o = i;
vector<int> cand;
for (int i = 1; i <= n; ++i)
if (i != p) cand.emplace_back(i);
sort(begin(cand), end(cand), [&](int a, int b) { return cnt[a] > cnt[b]; });
int holan = 100;
for (int o : cand) {
if (holan-- < 0) break;
chmax(res, cal(o, p));
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) ++cnt[a[i]];
cout << solve() << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
int g_a[N];
int g_cnt[N];
int g_tmp[N];
int Large(int x, int y, int n) {
for (int i = 1; i <= n; i++) {
g_tmp[i] = -1;
}
g_tmp[g_cnt[x]] = 0;
int t = g_cnt[x];
int ret = 0;
for (int i = 1; i <= n; i++) {
if (g_a[i] == x) {
t--;
} else if (g_a[i] == y) {
t++;
}
if (g_tmp[t] == -1) {
g_tmp[t] = i;
} else {
ret = max(ret, i - g_tmp[t]);
}
}
return ret;
}
int Small(int x, int n) {
for (int i = 1; i <= n; i++) {
g_tmp[i] = 0;
}
int num = 0;
int ret = 0;
int l = 1;
for (int i = 1; i <= n; i++) {
g_tmp[g_a[i]]++;
if (g_tmp[g_a[i]] == x) {
num++;
}
if (g_tmp[g_a[i]] == x + 1) {
num--;
}
while (g_tmp[g_a[i]] > x && l <= i) {
if (g_tmp[g_a[l]] == x + 1) {
num++;
}
if (g_tmp[g_a[l]] == x) {
num--;
}
g_tmp[g_a[l]]--;
l++;
}
if (num > 1) {
ret = max(ret, i - l + 1);
}
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
int maxp = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &g_a[i]);
g_cnt[g_a[i]]++;
if (g_cnt[g_a[i]] > g_cnt[maxp]) {
maxp = g_a[i];
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (maxp != i) {
if (g_cnt[i] == g_cnt[maxp]) {
cout << n << endl;
return 0;
} else {
if (g_cnt[i] * g_cnt[i] >= n) {
ans = max(ans, Large(i, maxp, n));
}
}
}
}
for (int i = 1; i * i <= n; i++) {
ans = max(ans, Small(i, n));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF(0x3f3f3f3f3f3f3f3fll);
const long long inf(0x3f3f3f3f);
const long long N = 5e5 + 10;
long long n, a[N], cnt[N], vis[N];
long long s, c, ma, ans, pre[N], num[N];
void solve1(long long x) {
long long sum = n;
for (long long i = 1; i <= n; i++) pre[i] = pre[i + n] = inf;
pre[n] = 0;
for (long long i = 1; i <= n; i++) {
if (a[i] == ma)
sum++;
else if (a[i] == x)
sum--;
ans = max(ans, i - pre[sum]);
pre[sum] = min(pre[sum], i);
}
}
void solve2(long long x) {
for (long long i = 1; i <= n; i++) num[i] = 0;
long long l = 1, res = 0;
num[a[l]]++;
if (num[a[l]] == x) res++;
for (long long i = 2; i <= n; i++) {
num[a[i]]++;
if (num[a[i]] == x)
res++;
else if (num[a[i]] > x) {
while (num[a[i]] > x && l <= i) {
num[a[l]]--;
if (num[a[l]] == x - 1) res--;
l++;
}
}
if (res >= 2) ans = max(ans, i - l + 1);
}
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
s = sqrt(n), c = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i], cnt[a[i]]++;
if (cnt[a[i]] > c) c = cnt[a[i]], ma = a[i];
}
for (long long i = 1; i <= n; i++)
if (cnt[a[i]] >= s && a[i] != ma && !vis[a[i]]) {
solve1(a[i]);
vis[a[i]] = 1;
}
for (long long i = 1; i <= s; i++) solve2(i);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005, SQ = 320;
int n, a[MX], mx, ind, cn[MX], res, dp[2 * MX];
vector<int> pos[MX], izq, der;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mx = max(mx, ++cn[a[i]]);
if (cn[a[i]] == mx) ind = a[i];
pos[a[i]].push_back(i);
}
izq.push_back(1);
for (int i : pos[ind]) {
izq.push_back(i + 1);
der.push_back(i - 1);
}
der.push_back(n);
for (int i = 1; i <= n; i++)
if (i - ind && cn[i])
if (cn[i] < SQ) {
int ini = 0;
for (int j = 0; j < (cn[i]); j++) {
int it = upper_bound(izq.begin(), izq.end(), pos[i][j]) - izq.begin();
it--;
for (int k = max(ini, it - cn[i]); k <= it; k++)
for (int l = 1, x = j; l <= cn[i] && k + l <= mx; l++) {
while (x < pos[i].size() && pos[i][x] <= der[k + l]) x++;
if (l == x - j) res = max(res, der[k + l] - izq[k] + 1);
}
ini = it + 1;
}
} else {
int acu = 0, mx = 0, mn = 0;
dp[MX] = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == i) acu++;
if (a[j] == ind) acu--;
if (dp[acu + MX] != -1)
res = max(res, j - dp[acu + MX]);
else
dp[acu + MX] = j;
mn = min(mx, acu);
mx = max(mx, acu);
}
for (int j = mn + MX; j <= mx + MX; j++) dp[j] = -1;
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
const int K = 450;
struct stupidqueue {
vector<int> a, inv;
int val = 0;
stupidqueue(int n) {
a.assign(n + 1, 0);
inv.assign(n + 1, 0);
val = 0;
}
void push(int x) {
inv[a[x]]--;
a[x]++;
inv[a[x]]++;
if (a[x] > val) val = a[x];
}
void pop(int x) {
inv[a[x]]--;
a[x]--;
inv[a[x]]++;
if (inv[val] == 0) val--;
}
bool ugh() { return inv[val] >= 2; }
int mode() { return val; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n + 1, 0);
vector<int> freq(n + 1, 0);
for (int i = (1); i < (n + 1); i++) {
cin >> a[i];
freq[a[i]]++;
}
int F = max_element((freq).begin(), (freq).end()) - freq.begin();
for (int i = (1); i < (n + 1); i++) {
if (i != F && freq[i] == freq[F]) {
cout << n << '\n';
return 0;
}
}
if (freq[F] == n) {
cout << 0 << '\n';
return 0;
}
int ans = 0;
for (int bruh = (1); bruh < (K); bruh++) {
stupidqueue Q(n);
int l = 1;
for (int r = (1); r < (n + 1); r++) {
Q.push(a[r]);
while (Q.mode() > bruh) {
Q.pop(a[l]);
l++;
}
if (Q.ugh()) {
ans = max(ans, r - l + 1);
}
}
}
for (int x = (1); x < (n + 1); x++) {
if (x == F || freq[x] < K) continue;
vector<int> ve(2 * n + 5, -1);
ve[n] = 0;
int s = 0;
for (int i = (1); i < (n + 1); i++) {
if (a[i] == F) {
s++;
} else if (a[i] == x) {
s--;
}
if (ve[n + s] == -1) {
ve[n + s] = i;
}
ans = max(ans, i - ve[n + s]);
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, ans, mx, mxh, mnh, h, now, pmx, pnow, dl, dr, dp;
int a[N], pre[N];
vector<int> p[N];
struct Seg {
int l, r, be, is;
} d[N + N];
void upd(int h, int x) {
if (h < d[dp].l) --dp;
if (h > d[dp].r) ++dp;
if (d[dp].is)
ans = max(ans, (min(p[mx][pmx], p[now][pnow]) - 1) - p[mx][h + d[dp].be]);
else
ans = max(ans, (min(p[mx][pmx], p[now][pnow]) - 1) - d[dp].be);
}
void doit(int l, int r) {
for (int i = l, _e = r; i < _e; ++i)
if (++h > mxh) {
d[++dr] = (Seg){h, h + (r - i - 1), -h + i, 1};
h = mxh = d[dr].r;
pmx = r;
break;
} else
++pmx, upd(h, p[mx][i]);
}
int main() {
scanf("%d", &n);
for (int i = 1, _e = n; i <= _e; ++i)
scanf("%d", &a[i]), p[a[i]].push_back(i);
for (int i = 1, _e = n; i <= _e; ++i)
if (p[i].size() > p[mx].size()) mx = i;
int las = 1;
p[mx].push_back(n + 1);
for (int i = 0, _e = p[mx].size(); i < _e; ++i) {
for (int j = las, _e = p[mx][i]; j < _e; ++j) pre[j] = i;
las = p[mx][i] + 1;
}
for (int i = 1, _e = n; i <= _e; ++i)
if (i != mx && p[i].size()) {
now = i;
mnh = mxh = h = 0;
pmx = pnow = 0;
p[i].push_back(n + 1);
dp = dl = dr = n;
d[n] = (Seg){0, 0, 0, 0};
int las = 0;
for (int k = 0, _e = p[i].size() - 1; k < _e; ++k) {
int j = p[i][k], las2 = pre[j];
doit(las, las2);
++pnow;
if (--h < mnh)
mnh = h, d[--dl] = (Seg){h, h, j, 0};
else
upd(h, j);
las = las2;
}
doit(las, p[mx].size() - 1);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int a[maxn], cnt[maxn], n, book[maxn * 2], maxx, id, sn, ans, p[maxn];
int main() {
scanf("%d", &n);
sn = sqrt(n);
for (register int i = 1; i <= n; i++) scanf("%d", &a[i]), cnt[a[i]]++;
for (register int i = 1; i <= n; i++) {
if (cnt[i] > maxx)
maxx = cnt[i], id = i;
else if (cnt[i] == maxx)
id = -1;
}
if (id == -1) {
printf("%d\n", n);
return 0;
}
memset(book, -1, sizeof(book));
for (register int i = 1; i <= n; i++) {
if (!cnt[i] || i == id) continue;
if (cnt[i] > sn) {
int now = n;
book[now] = 0;
for (register int j = 1; j <= n; j++) {
if (a[j] == id)
now++;
else if (a[j] == i)
now--;
if (~book[now])
ans = max(ans, j - book[now]);
else
book[now] = j;
}
memset(book, -1, sizeof(book));
continue;
}
}
for (register int i = 1; i <= sn; i++) {
memset(book, 0, sizeof(book));
int l = 1, cn = 0;
for (register int j = 1; j <= n; j++) {
if (++book[a[j]] == i) cn++;
while (l <= j && book[a[j]] > i)
if (book[a[l++]]-- == i) cn--;
if (cn >= 2) ans = max(ans, j - l + 1);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << " ";
dbg_out(T...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MX = 1 << 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = n;
vector<int> LOC[n + 1];
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
LOC[A[i]].push_back(i);
}
int hi = 0, best = -1;
for (int i = 1; i <= m; i++)
if (ckmax(hi, (int)LOC[i].size())) best = i;
bool done = 0;
for (int i = 1; i <= m; i++)
if (i != best && hi == (int)LOC[i].size()) done = 1;
if (done) {
cout << n << nl;
return 0;
}
n += 2;
int a[n];
for (int i = 0; i < n - 2; i++) a[i + 1] = A[i];
a[0] = a[n - 1] = best;
vector<int> loc[n + 1];
for (int i = 0; i < n; i++) loc[a[i]].push_back(i);
hi = (int)loc[best].size();
int idxBest[n];
for (int i = 0; i < n; i++)
if (i == 0)
idxBest[i] = 1;
else
idxBest[i] = idxBest[i - 1] + (a[i] == best);
int ans = 0;
int SQRTN = sqrt(n) - 200;
for (int i = 1; i <= m; i++) {
int SZ = (int)loc[i].size();
if (i == best || !SZ) continue;
if (SZ > SQRTN) {
int j = 0, k = 0;
int sum = 0;
int firstLoc[2 * n + 1];
for (int ii = 0; ii < 2 * n + 1; ii++) firstLoc[ii] = -1;
firstLoc[sum + n] = 0;
while (j != hi - 1 || k != SZ) {
int curPos;
if (k < SZ && loc[best][j] > loc[i][k]) {
curPos = loc[i][k] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum--;
j++;
}
if (firstLoc[sum + n] == -1) firstLoc[sum + n] = curPos;
}
ckmax(ans, loc[best][j] - firstLoc[sum + n]);
} else {
int kkk = 0;
for (int kk = 0; kk < SZ; kk++) {
int j = max(0, idxBest[loc[i][kk]] - SZ - 2);
int jEnd = min(hi, idxBest[loc[i][kk]] + SZ + 2);
while (kkk < SZ && loc[best][j] > loc[i][kkk]) kkk++;
int k = kkk;
int PAD = 2 * SZ + 5;
int firstLoc[2 * PAD + 1];
for (int ii = 0; ii < 2 * PAD + 1; ii++) firstLoc[ii] = -1;
int sum = -1;
if (j == 0) firstLoc[0 + PAD] = 0;
firstLoc[sum + PAD] = loc[best][j] + 1;
j++;
while (j < jEnd) {
int curPos;
if (k < SZ && loc[i][k] < loc[best][j]) {
curPos = loc[i][k] + 1;
ckmax(ans, loc[i][k] - firstLoc[sum + PAD]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
sum--;
j++;
}
if (firstLoc[sum + PAD] == -1) firstLoc[sum + PAD] = curPos;
}
if (j != hi) ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
}
}
}
cout << ans << nl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<vector<int>> poses(n + 1);
for (int i = 1; i <= n; i++) poses[i].push_back(0);
for (int i = 1; i <= n; i++) poses[a[i]].push_back(i);
for (int i = 1; i <= n; i++) poses[a[i]].push_back(n + 1);
int x = 1;
for (int y = 1; y <= n; y++) {
if (poses[x].size() < poses[y].size()) x = y;
}
int sq = sqrt(n) + 3, res = 0;
for (int y = 1; y <= n; y++) {
if (x == y || (int)poses[y].size() < sq) continue;
vector<int> mn(2 * n + 1, inf), mx(2 * n + 1, -inf);
int fx = 0, fy = 0;
for (int i = 0; i <= n; i++) {
if (i > 0 && a[i] == x) fx++;
if (i > 0 && a[i] == y) fy++;
int cur = fx - fy + n;
mn[cur] = min(mn[cur], i);
mx[cur] = max(mx[cur], i);
}
for (int d = 0; d <= 2 * n; d++) res = max(res, mx[d] - mn[d]);
}
vector<int> F(n + 2);
for (int i = 1; i <= n; i++) F[i] = F[i - 1] + (a[i] == x);
int mx = 0;
for (int y = 1; y <= n; y++) {
int sy = (int)poses[y].size();
if (x == y || sy >= sq) {
continue;
}
mx = max(mx, sy);
for (int i = 0; i < sy; i++) {
for (int j = 0; j < i; j++) {
int cur = i - j - 1;
int l = poses[y][j];
int r = poses[y][i];
int hlp = F[r] - F[l];
if (hlp > 0 && hlp == cur) {
res = max(res, r - l - 1);
}
}
}
}
vector<int> fr(n + 1), cn(n + 1);
auto upd = [&](int& val, int delta) {
cn[val]--;
val += delta;
cn[val]++;
};
for (int freq = 1; freq <= mx; freq++) {
fr.assign(n + 1, 0);
cn.assign(n + 1, 0);
for (int l = 1, r = 1; r <= n; r++) {
upd(fr[a[r]], +1);
while (cn[freq + 1] > 0) {
upd(fr[a[l]], -1);
l++;
}
if (fr[x] == freq && cn[freq] >= 2) res = max(res, r - l + 1);
}
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
const int M = 1e4;
const int mod = 1e9 + 7;
const int inf = 1e9;
int read() {
int s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
s = (neg ? -s : s);
return s;
}
int a, s[N + 5], cnt[N + 5], p[N * 2 + 5], q[N + 5];
signed main() {
a = read();
int mx = 0;
for (int i = (1); i <= (a); ++i)
s[i] = read(), ++cnt[s[i]], mx = max(mx, s[i]);
int x = 0, y = 0;
for (int i = (1); i <= (mx); ++i) {
if (cnt[i] > cnt[x]) {
x = i;
y = 1;
} else if (cnt[i] == cnt[x])
++y;
}
if (y >= 2) {
printf("%d", a);
return 0;
}
if (cnt[x] == a) {
printf("0");
return 0;
}
int b = sqrt(a), ans = 0;
for (int i = (1); i <= (mx); ++i) {
if (cnt[i] <= b || i == x) continue;
memset(p, 0, sizeof(p));
int now = 0;
for (int j = (1); j <= (a); ++j) {
now += (s[j] == x);
now -= (s[j] == i);
if (!now) ans = max(ans, j);
if (!p[now + a])
p[now + a] = j;
else
ans = max(ans, j - p[now + a]);
}
}
memset(p, 0, sizeof(p));
for (int i = (1); i <= (b); ++i) {
memset(p, 0, sizeof(p));
memset(q, 0, sizeof(q));
for (int l = 1, r = 1; r <= a; ++r) {
if (p[s[r]]) --q[p[s[r]]];
++p[s[r]];
++q[p[s[r]]];
while (l <= r && p[s[r]] > i) {
--q[p[s[l]]];
--p[s[l]];
++q[p[s[l]]];
++l;
}
if (q[i] >= 2) ans = max(ans, r - l + 1);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5, MOD = 998244353;
template <typename T>
void chkmax(T& x, T y) {
if (y > x) x = y;
}
template <typename T>
void chkmin(T& x, T y) {
if (y < x) x = y;
}
long long q_pow(long long a, long long b, long long p = MOD) {
long long ret = 1;
for (; b; a = a * a % p, b >>= 1)
if (b & 1) ret = ret * a % p;
return ret;
}
long long q_inv(long long x, long long p = MOD) { return q_pow(x, p - 2, p); }
struct node {
int v, next;
} E[MAXN << 1];
int head[MAXN], Elen;
void add(int u, int v) {
++Elen, E[Elen].v = v, E[Elen].next = head[u], head[u] = Elen;
}
int N, B, ans, a[MAXN], cnt[MAXN], MX;
int sum[MAXN], sum1[MAXN], las[MAXN * 2];
int b[MAXN], bb[MAXN], mx;
int main() {
scanf("%d", &N), B = sqrt(N);
for (int i = 1; i <= N; ++i) scanf("%d", &a[i]), ++cnt[a[i]];
for (int i = 1; i <= N; ++i)
if (cnt[i] > cnt[MX]) MX = i;
for (int i = 1; i <= N; ++i) sum[i] = sum[i - 1] + (a[i] == MX);
for (int i = 1; i <= N; ++i)
if (i != MX && cnt[i] > B) {
for (int j = 1; j <= N; ++j) sum1[j] = sum1[j - 1] + (a[j] == i);
for (int j = 0; j <= 2 * N; ++j) las[j] = -1;
for (int j = 0; j <= N; ++j) {
int v = sum[j] - sum1[j] + N;
if (las[v] != -1)
chkmax(ans, j - las[v]);
else
las[v] = j;
}
}
for (int i = 1; i <= B; ++i) {
bb[0] = N + 1;
for (int i = 1; i <= N; ++i) b[i] = 0, bb[i] = 0;
for (int l = 1, r = 1; r <= N; ++r) {
--bb[b[a[r]]];
++b[a[r]];
++bb[b[a[r]]];
chkmax(mx, b[a[r]]);
while (l <= r && mx > i) {
--bb[b[a[l]]];
--b[a[l]];
++bb[b[a[l]]];
while (!bb[mx]) --mx;
++l;
}
if (bb[mx] >= 2) chkmax(ans, r - l + 1);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int it[200001];
int aa[200001];
int mm[200001];
int ind2[400001];
vector<int> pp[200001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> it[i];
it[i]--;
pp[it[i]].push_back(i);
aa[it[i]] += 1;
}
int ma = 0;
int ind = 0;
for (int i = 0; i < n; i++) {
if (aa[i] > ma) {
ma = aa[i];
ind = i;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i == ind) {
continue;
}
if (pp[i].size() == 0) {
continue;
}
if (aa[i] >= 300) {
for (int j = 0; j <= 2 * n; j++) {
ind2[j] = -1;
}
ind2[n] = 0;
for (int j = 0; j < n; j++) {
mm[j + 1] = mm[j];
if (it[j] == i) {
mm[j + 1] -= 1;
} else if (it[j] == ind) {
mm[j + 1] += 1;
}
if (ind2[mm[j + 1] + n] != -1) {
ans = max(ans, j + 1 - ind2[mm[j + 1] + n]);
} else {
ind2[mm[j + 1] + n] = j + 1;
}
}
} else {
for (int j = 0; j < pp[i].size(); j++) {
for (int k = j; k < pp[i].size(); k++) {
int ind2 = lower_bound(pp[ind].begin(), pp[ind].end(), pp[i][j]) -
pp[ind].begin();
ind2 = max(0, ind2 - (k - j + 1));
for (int l = ind2; l + k - j < pp[ind].size(); l++) {
if (l + k - j + 1 < pp[ind].size()) {
if (pp[ind][l + k - j + 1] < pp[i][k]) {
if (pp[ind][l] > pp[i][j]) {
break;
}
continue;
}
}
int ll, rr;
if (k + 1 < pp[i].size()) {
rr = pp[i][k + 1] - 1;
} else {
rr = n - 1;
}
if (l + k - j + 1 < pp[ind].size()) {
rr = min(rr, pp[ind][l + k - j + 1] - 1);
} else {
rr = min(rr, n - 1);
}
if (j > 0) {
ll = pp[i][j - 1] + 1;
} else {
ll = 0;
}
if (l > 0) {
ll = max(ll, pp[ind][l - 1] + 1);
} else {
ll = max(ll, 0);
}
ans = max(ans, rr - ll + 1);
if (pp[ind][l] > pp[i][j]) {
break;
}
}
}
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, A[200005], S[200005], s;
int pre[200005 << 1], ans = 0;
void Solve1(int x) {
for (int i = 1; i <= n; i++) pre[n - i] = pre[n + i] = -1;
pre[n] = 0;
int now = 0;
for (int i = 1; i <= n; i++) {
if (A[i] == x)
now++;
else if (A[i] == s)
now--;
if (pre[n + now] == -1)
pre[n + now] = i;
else
ans = max(ans, i - pre[n + now]);
}
}
void Solve2(int x) {
for (int i = 1; i <= n; i++) S[i] = 0;
int l = 1, tot = 0;
S[A[l]]++;
if (S[A[l]] == x) tot++;
for (int i = 2; i <= n; i++) {
S[A[i]]++;
if (S[A[i]] == x)
tot++;
else if (S[A[i]] > x) {
if (S[A[i]] == x + 1) tot--;
while (S[A[i]] > x) {
S[A[l]]--;
if (S[A[l]] == x) tot++;
if (S[A[l]] == x - 1) tot--;
l++;
}
}
if (tot >= 2) ans = max(ans, i - l + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
S[A[i]]++;
if (S[s] < S[A[i]]) s = A[i];
}
int lim = int(sqrt(n) + 0.5);
for (int i = 1; i <= n; i++)
if (S[i] >= lim && i != s) Solve1(i);
for (int i = 1; i < lim; i++) Solve2(i);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
int n, a[N], cnt[N], mode, fsm[N], tmp[N], ans;
void larg(int x) {
int sm = 0, res = 0;
memset(fsm, 0, sizeof(fsm));
for (int i = 1; i <= n; i++) {
if (a[i] == mode)
sm++;
else if (a[i] == x)
sm--;
if (sm && !fsm[sm]) fsm[sm] = i;
res = max(res, i - fsm[sm]);
}
ans = max(ans, res);
}
void smal(int x) {
int l = 1, p = 0, res = 0;
memset(tmp, 0, sizeof(tmp));
for (int i = 1; i <= n; i++) {
tmp[a[i]]++;
if (tmp[a[i]] == x) p++;
while (l <= i && tmp[a[i]] > x) {
if (tmp[a[l]] == x) --p;
tmp[a[l++]]--;
}
if (p >= 2) res = max(res, i - l + 1);
}
ans = max(ans, res);
}
int main() {
scanf("%d", &n);
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (cnt[a[i]] > cnt[mode]) mode = a[i];
}
for (int i = 1; i <= 200000; i++) {
if (!cnt[i]) continue;
if (i != mode && cnt[i] == cnt[mode]) {
printf("%d\n", n);
return 0;
}
if (cnt[i] > sqrt(n)) larg(i);
}
for (int i = 1; i <= sqrt(n); i++) smal(i);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int res = 0;
register char c = getchar(), f = 1;
while (c < 48 || c > 57) {
if (c == '-') f = 0;
c = getchar();
}
while (c >= 48 && c <= 57)
res = (res << 3) + (res << 1) + (c & 15), c = getchar();
return f ? res : -res;
}
inline void write(int x) {
register char c[21], len = 0;
if (!x) return putchar('0'), void();
if (x < 0) x = -x, putchar('-');
while (x) c[++len] = x % 10, x /= 10;
while (len) putchar(c[len--] + 48);
}
const int N = 2e5 + 10;
int n, d, a[N], c[N], q, f[N * 2], c1[N], c2[N], ans = 0;
inline void upd(int x, int v) { --c2[c1[x]], c1[x] += v, ++c2[c1[x]]; }
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read(), ++c[a[i]];
q = sqrt(n);
for (int i = 1; i <= n; ++i)
if (c[i] > c[d]) d = i;
for (int i = 1; i <= n; ++i)
if (c[i] > q && i != d) {
int s = 0;
memset(f, -1, sizeof(int) * (n * 2 + 1));
f[n] = 0;
for (int j = 1; j <= n; ++j) {
s += a[j] == i ? 1 : (a[j] == d ? -1 : 0);
if (~f[n + s])
ans = max(ans, j - f[n + s]);
else
f[n + s] = j;
}
}
for (int i = 1; i <= q; ++i) {
memset(c1, 0, sizeof(int) * (n + 1));
memset(c2, 0, sizeof(int) * (n + 1));
int l = 1, r = 0;
while (r < n) {
upd(a[++r], 1);
while (c1[a[r]] > i) upd(a[l++], -1);
if (c2[i] > 1) ans = max(ans, r - l + 1);
}
}
write(ans), putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (int i = 0; i < (int)v.size(); i++) {
if (i) os << ", ";
os << v[i];
}
os << "}";
return os;
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 200005;
int pref[N];
int mx[2 * N];
const int K = 500;
int dp[K][2 * K];
int P[N];
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
vector<int> freq(n + 1);
vector<int> perm(n + 1);
vector<vector<int>> positions(n + 1);
iota(((perm).begin()), ((perm).end()), 0);
int i = 0;
for (int& x : a) {
cin >> x;
freq[x]++;
i++;
positions[x].push_back(i);
}
sort(((perm).begin()), ((perm).end()),
[&](int x, int y) { return freq[x] > freq[y]; });
if (freq[perm[0]] == freq[perm[1]]) {
cout << n << endl;
return 0;
}
int x = perm[0];
int ans = 0;
for (int i = 1; i <= n; i++) P[i] = P[i - 1] + (a[i - 1] == x);
for (int y = 1; y <= n; y++)
if (y != x) {
if (freq[y] >= K - 10) {
memset(mx, -1, sizeof mx);
pref[0] = N;
for (int i = 1; i <= n; i++) {
pref[i] = pref[i - 1];
if (a[i - 1] == x)
pref[i]++;
else if (a[i - 1] == y)
pref[i]--;
}
for (int i = n; i >= 1; i--) {
if (mx[pref[i]] == -1) mx[pref[i]] = i;
int R = mx[pref[i - 1]];
if (R != -1) ans = max(ans, R - i + 1);
}
} else {
int l = ((int)(positions[y]).size());
for (int i = 0; i <= l; i++) {
fill(dp[i], dp[i] + 2 * l + 1, -INF);
}
for (int j = 0; j <= l; j++) dp[l][j] = n;
int lst = n + 1;
for (int i = l - 1; i >= 0; i--) {
int u = positions[y][i];
int xs = P[u];
for (int d = 0; d <= 2 * l; d++) {
int num = (P[lst - 1] - xs);
if (1 - num >= d - l)
dp[i][d] = lst - 1;
else {
int r = l + 1 - d;
if (r >= 0) {
int allowed = xs + r;
dp[i][d] = allowed < ((int)(positions[x]).size())
? positions[x][allowed] - 1
: n;
}
}
int nw = d + num - 1;
if (nw >= 0 && nw <= 2 * l) dp[i][d] = max(dp[i][d], dp[i + 1][nw]);
}
if (xs <= l) {
ans = max(ans, dp[i][l + xs]);
}
for (int r = 0; r <= l && r < xs; r++) {
int lft = positions[x][xs - r - 1] + 1;
ans = max(ans, dp[i][l + r] - lft + 1);
}
lst = u;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
inline void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
const int N = 2e5 + 1;
int n, mx;
int f[N], last[3 * N];
vector<int> pos[N];
vector<int> pref, vec;
int cal(vector<pair<int, int> >& vec) {
(vec);
int ans = 0, csum = n;
vector<int> vals;
int n1 = vec.size();
for (int i = 0; i < n1; ++i) {
csum += vec[i].first;
if (last[csum] != -1) {
int r = (i + 1 < n1 ? vec[i + 1].second - 1 : n);
ans = max(ans, r - last[csum]);
} else {
last[csum] = vec[i].second;
vals.push_back(csum);
}
}
for (auto i : vals) {
last[i] = -1;
}
return ans;
}
inline void solve() {
memset(last, -1, sizeof last);
read(n);
last[n] = 0;
vec.resize(n + 1);
for (int i = 1; i <= n; ++i) {
pos[i].push_back(0);
}
for (int i = 1; i <= n; ++i) {
int& x = vec[i];
read(x);
++f[x];
pos[x].push_back(i);
}
for (int i = 1; i <= n; ++i) {
if (!mx || f[i] > f[mx]) {
mx = i;
}
}
pref.resize(n + 1);
for (int i = 1; i <= n; ++i) {
pref[i] = pref[i - 1] + (vec[i] == mx);
}
pref.push_back(pref.back());
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (i == mx) continue;
pos[i].push_back(n + 1);
vector<pair<int, int> > tmp;
int n1 = pos[i].size();
int myf = n1 - 1;
for (int j = 1; j < n1; ++j) {
int cur = pos[i][j], prev = pos[i][j - 1];
int bet = pref[cur] - pref[prev];
if (bet <= 2 * myf) {
for (auto it = upper_bound(pos[mx].begin(), pos[mx].end(), prev); bet;
++it, --bet) {
tmp.emplace_back(1, *it);
}
} else {
int tak = myf;
for (auto it = upper_bound(pos[mx].begin(), pos[mx].end(), prev); tak;
++it, --tak) {
tmp.emplace_back(1, *it);
}
tak = myf;
for (int idx = (upper_bound(pos[mx].begin(), pos[mx].end(), cur) -
pos[mx].begin()) -
myf;
tak; ++idx, --tak) {
tmp.emplace_back(1, pos[mx][idx]);
}
}
if (cur <= n) {
tmp.emplace_back(-1, cur);
}
}
int cur = cal(tmp);
(i, cur);
ans = max(ans, cur);
}
prn(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 500;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
vector<int> cnt(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
--a[i];
++cnt[a[i]];
}
int mx = 0;
for (int i = 0; i < n; ++i) mx = max(mx, cnt[i]);
int who = -1;
for (int i = 0; i < n; ++i) {
if (cnt[i] == mx) {
if (who != -1) {
cout << n << '\n';
return 0;
}
who = i;
}
}
int ans = 0;
for (int x = 0; x < n; ++x) {
if (x == who) continue;
if (cnt[x] < K) continue;
vector<int> pref_bal(n + 1), suf_bal(n + 1);
for (int i = 0; i < n; ++i) {
pref_bal[i + 1] = pref_bal[i];
if (a[i] == x) --pref_bal[i + 1];
if (a[i] == who) ++pref_bal[i + 1];
}
for (int i = n - 1; i >= 0; --i) {
suf_bal[i] = suf_bal[i + 1];
if (a[i] == x) --suf_bal[i];
if (a[i] == who) ++suf_bal[i];
}
vector<int> fst(n, n);
vector<int> lst(n, -1);
for (int i = 0; i <= n; ++i) {
if (pref_bal[i] >= 0) {
fst[pref_bal[i]] = min(fst[pref_bal[i]], i);
}
}
for (int i = 0; i <= n; ++i) {
if (suf_bal[i] >= 0) {
lst[suf_bal[i]] = max(lst[suf_bal[i]], i);
}
}
int need = cnt[who] - cnt[x];
for (int i = 0; i <= need; ++i) {
ans = max(ans, lst[i] - fst[need - i]);
}
}
vector<int> pref(n + 1);
for (int i = 0; i < n; ++i) {
pref[i + 1] = pref[i] + (a[i] == who);
}
vector<vector<int>> where(n);
where[who].push_back(-1);
for (int i = 0; i < n; ++i) {
where[a[i]].push_back(i);
}
where[who].push_back(n);
for (int go = 1; go < K; ++go) {
vector<int> min_r(n, n);
for (int i = 0; i < n; ++i) {
if (i == who) continue;
for (int j = 0; j + go <= (int)where[i].size(); ++j) {
min_r[where[i][j]] = min(min_r[where[i][j]], where[i][j + go - 1]);
}
}
for (int i = n - 2; i >= 0; --i) min_r[i] = min(min_r[i], min_r[i + 1]);
for (int j = 0; j + go + 2 <= where[who].size(); ++j) {
int l = where[who][j] + 1;
int r = where[who][j + go + 1] - 1;
if (min_r[l] <= r) {
ans = max(ans, r - l + 1);
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, bi = 1, ans, x[200005];
vector<int> v[200005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
v[tmp].push_back(i);
}
for (int i = 2; i <= n; i++)
if (v[i].size() >= v[bi].size()) bi = i;
for (int i : v[bi]) x[i + 1]++;
for (int i = 0; i < n; i++) x[i + 1] += x[i];
set<int> s(v[bi].begin(), v[bi].end());
for (int i = 1; i <= n; i++) {
if (i == bi) continue;
if (v[i].empty()) continue;
set<int> check{0, n};
vector<int> add;
for (int j : v[i]) {
check.insert(j);
check.insert(j + 1);
auto ia = s.lower_bound(j);
auto ib = ia;
for (int k = 0; k < 2; k++) {
if (ia != s.begin()) {
ia--;
add.push_back(*ia);
check.insert(*ia);
check.insert(*ia + 1);
}
if (ib != s.end()) {
add.push_back(*ib);
check.insert(*ib);
check.insert(*ib + 1);
ib++;
}
}
if (ia != ib) s.erase(ia, ib);
}
for (int j : add) s.insert(j);
map<int, int> m;
int at = 0;
for (int j : check) {
int tmp = x[j] - at;
auto p = m.insert({tmp, j});
if (!p.second) ans = max(ans, j - p.first->second);
if (at != v[i].size() && v[i][at] == j) at++;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
set<int> where[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
int v = 0;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
where[--a].insert(i);
if (where[a].size() > where[v].size()) {
v = a;
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (i == v) {
continue;
}
map<int, int> events;
for (auto j : where[i]) {
events[j] = 1;
for (int k = 0; k < 2; ++k) {
auto nxt = where[v].lower_bound(j);
auto prv = nxt;
if (prv != where[v].begin()) {
--prv;
events[*prv] = -1;
where[v].erase(prv);
}
if (nxt != where[v].end()) {
events[*nxt] = -1;
where[v].erase(nxt);
}
}
}
for (auto it = events.begin(); it != events.end(); ++it) {
if (events.count(it->first - 1) == 0) {
events[it->first - 1] = 0;
}
}
if (events.count(n) == 0) {
events[n] = 0;
}
map<int, int> first;
first[0] = 0;
int sum = 0;
int prv = 0;
for (auto [a, b] : events) {
sum += b;
if (first.count(sum) > 0) {
if (first[sum] != prv) {
ans = max(ans, a - first[sum]);
}
} else {
first[sum] = a;
}
prv = a;
if (b == -1) {
where[v].insert(a);
}
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int c = 200002, gy = 402;
int t[c], db[c], n, pos, maxi;
int esz[c], hsz[c];
int ert[c], ossz[c], maxh, mpos, bsz;
void add(int a, int k) {
if (a == pos) {
mpos += k;
} else {
ossz[ert[a]]--;
ert[a] += k;
ossz[ert[a]]++;
if (!ossz[maxh]) maxh--;
maxh = max(maxh, ert[a]);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t[i];
db[t[i]]++;
}
for (int i = 1; i <= n; i++) {
if (db[t[i]] > db[pos]) pos = t[i];
}
for (int i = 1; i <= gy; i++) {
for (int j = 1; j <= n; j++) ert[j] = 0, ossz[j] = 0;
ossz[0] = n;
maxh = 0, mpos = 0, bsz = 0;
for (int j = 1; j <= n; j++) {
add(t[j], 1);
while (mpos > i) {
bsz++;
add(t[bsz], -1);
}
if (maxh >= i) {
maxi = max(maxi, j - bsz);
}
}
}
for (int i = 1; i <= n; i++) {
if (i != pos && db[i] >= gy) {
int cnt = 0, emax = 0, hmax = 0, dif = db[pos] - db[i];
for (int j = 1; j <= n; j++) {
if (t[j] == pos) cnt++;
if (t[j] == i) cnt--;
if (cnt > emax) {
emax++;
esz[emax] = j;
}
}
cnt = 0;
for (int j = n; j >= 1; j--) {
if (t[j] == pos) cnt++;
if (t[j] == i) cnt--;
if (cnt > hmax) {
hmax++;
hsz[hmax] = n - j + 1;
}
}
for (int j = 0; j <= dif; j++) {
if (j <= emax && dif - j <= hmax) {
maxi = max(maxi, n - esz[j] - hsz[dif - j]);
}
}
}
}
cout << maxi << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, a[200001], cnt[200001], x, tot, ans, pos[200001 * 2], tmp[200001];
int get() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
void upd1(int y) {
for (int i = -N; i <= N; i++) pos[i + N] = -1;
pos[N] = 0;
int sum = 0;
for (int i = 1; i <= N; i++)
sum += a[i] == x ? 1
: a[i] == y ? -1
: 0,
pos[sum + N] != -1 ? ans = max(ans, i - pos[sum + N])
: pos[sum + N] = i;
}
void upd2(int x) {
int l = 1, cnt = 0;
for (int i = 1; i <= N; i++) tmp[i] = 0;
for (int i = 1; i <= N; i++) {
tmp[a[i]]++;
cnt += tmp[a[i]] == x;
while (l <= i && tmp[a[i]] > x) cnt -= tmp[a[l]] == x, tmp[a[l++]]--;
if (cnt >= 2) ans = max(ans, i - l + 1);
}
}
int main() {
N = get();
for (int i = 1; i <= N; i++) cnt[a[i] = get()]++;
for (int i = 1; i <= N; i++)
cnt[i] > cnt[x] ? x = i, tot = 1 : cnt[i] == cnt[x] ? tot++ : 0;
if (tot >= 2) {
cout << N << endl;
return 0;
}
for (int i = 1; i <= N; i++)
if (i != x && 1ll * cnt[i] * cnt[i] > N) upd1(i);
for (int i = 1; i * i <= N; i++) upd2(i);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 200005;
const int s = 400;
int n;
int a[N];
int q[N];
int p[N];
int u[N * 2];
int qq;
void ave(int x, int y, int k) {
if (q[x] == k) --qq;
q[x] += y;
if (q[x] == k) ++qq;
}
void solv() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) q[a[i]]++;
int maxu = 0;
for (int x = 1; x <= n; ++x) maxu = max(maxu, q[x]);
int maxx = -1;
for (int x = 1; x <= n; ++x) {
if (q[x] == maxu) {
if (maxx == -1)
maxx = x;
else {
printf("%d\n", n);
return;
}
}
}
int ans = 0;
for (int x = 1; x <= n; ++x) {
if (q[x] <= s) continue;
if (x == maxx) continue;
for (int i = 1; i <= n; ++i) {
p[i] = p[i - 1];
if (a[i] == x)
--p[i];
else if (a[i] == maxx)
++p[i];
}
for (int i = 0; i < N * 2; ++i) u[i] = N;
u[N + p[0]] = 0;
for (int i = 1; i <= n; ++i) {
if (u[N + p[i]] == N) u[N + p[i]] = i;
ans = max(ans, i - u[N + p[i]]);
}
}
for (int k = 1; k <= s; ++k) {
memset(q, 0, sizeof q);
qq = 0;
int l = 1;
for (int r = 1; r <= n; ++r) {
ave(a[r], 1, k);
if (q[a[r]] > k) {
while (a[l] != a[r]) {
ave(a[l], -1, k);
++l;
}
ave(a[l], -1, k);
++l;
}
if (qq > 1) ans = max(ans, r - l + 1);
}
}
printf("%d\n", ans);
}
int main() {
solv();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
vector<int> g[N];
int a[N], cnt[N], b[N << 1], c[N << 1];
int *vis = b + N, *val = c + N;
set<int> S, now;
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i < (n + 1); ++i)
scanf("%d", &a[i]), cnt[a[i]]++, g[a[i]].push_back(i);
int maxn = 0, p = 0;
for (int i = (1); i < (n + 1); ++i) {
if (maxn < cnt[i]) {
maxn = cnt[i];
p = i;
}
}
if (maxn == n) {
puts("0");
return 0;
}
int ans = 0;
for (auto v : g[p]) S.insert(v);
vector<int> temp;
int key = 0;
for (int i = (1); i < (n + 1); ++i) {
if (p == i) continue;
now.clear();
temp.clear();
for (auto v : g[i]) {
auto it = S.lower_bound(v);
if (it != S.end()) {
now.insert(*it);
S.erase(it);
}
it = S.lower_bound(v);
if (it != S.end()) {
now.insert(*it);
S.erase(it);
}
it = S.lower_bound(v);
if (it != S.begin()) {
--it;
now.insert(*it);
S.erase(it);
}
it = S.lower_bound(v);
if (it != S.begin()) {
--it;
now.insert(*it);
S.erase(it);
}
}
for (auto v : now) temp.push_back(v);
for (auto v : g[i]) now.insert(v);
int pos = -1, sum = 0;
for (auto v : now) {
if (v > pos) ++key;
if (vis[sum] != key) {
vis[sum] = key;
val[sum] = v;
}
if (a[v] == p) ++sum;
if (a[v] == i) --sum;
auto it = S.lower_bound(v);
if (it == S.end())
pos = n + 1;
else
pos = *it;
if (vis[sum] == key) {
int l, r;
int vv = val[sum];
auto it = now.lower_bound(vv);
if (it == now.begin())
l = 0;
else
l = *prev(it);
it = now.lower_bound(v);
++it;
if (it == now.end())
r = n + 1;
else
r = *it;
ans = max(r - l - 1, ans);
}
}
for (auto v : temp) S.insert(v);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
int n, ans, x, a[N], was[N];
array<int, 2> c[N];
int main() {
cin >> n;
for (int i = 1; i < n + 1; ++i) {
cin >> a[i];
c[a[i]][0]--;
c[i][1] = i;
}
sort(c + 1, c + n + 1);
random_shuffle(c + min(n, 400), c + n + 1);
for (int i = 2; i < min(n, 800); ++i) {
memset(was, -1, sizeof(was));
was[n] = 0, x = n;
for (int r = 1; r < n + 1; ++r) {
x += (a[r] == c[1][1]) - (a[r] == c[i][1]);
if (was[x] != -1) {
ans = max(ans, r - was[x]);
} else {
was[x] = r;
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
const string yesno[2] = {"no", "yes"};
void YES(bool t = 1) { cout << YESNO[t] << endl; }
void Yes(bool t = 1) { cout << YesNo[t] << endl; }
void yes(bool t = 1) { cout << yesno[t] << endl; }
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S>
void scan(pair<T, S> &p) {
scan(p.first), scan(p.second);
}
template <class T>
void scan(vector<T> &);
template <class T>
void scan(vector<T> &a) {
for (auto &i : a) scan(i);
}
template <class T>
void scan(T &a) {
cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
template <class T, class S>
inline bool chmax(T &a, const S &b) {
return (a < b ? a = b, 1 : 0);
}
template <class T, class S>
inline bool chmin(T &a, const S &b) {
return (a > b ? a = b, 1 : 0);
}
vector<int> iota(int n) {
vector<int> a(n);
iota(begin(a), end(a), 0);
return a;
}
template <typename T>
vector<int> iota(vector<T> &a, bool greater = false) {
vector<int> res(a.size());
iota(begin(res), end(res), 0);
sort(begin(res), end(res), [&](int i, int j) {
if (greater) return a[i] > a[j];
return a[i] < a[j];
});
return res;
}
template <class T>
T POW(T x, int n) {
T res = 1;
for (; n; n >>= 1, x *= x)
if (n & 1) res *= x;
return res;
}
vector<pair<long long, long long>> factor(long long x) {
vector<pair<long long, long long>> ans;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
ans.push_back({i, 1});
while ((x /= i) % i == 0) ans.back().second++;
}
if (x != 1) ans.push_back({x, 1});
return ans;
}
template <class T>
vector<T> divisor(T x) {
vector<T> ans;
for (T i = 1; i * i <= x; i++)
if (x % i == 0) {
ans.push_back(i);
if (i * i != x) ans.push_back(x / i);
}
return ans;
}
template <typename T>
void zip(vector<T> &x) {
vector<T> y = x;
sort(begin(y), end(y));
for (int i = 0; i < x.size(); ++i) {
x[i] = distance((y).begin(), lower_bound(begin(y), end(y), (x[i])));
}
}
int popcount(long long x) { return __builtin_popcountll(x); }
int in() {
int x;
cin >> x;
return x;
}
long long lin() {
unsigned long long x;
cin >> x;
return x;
}
template <typename T>
struct edge {
int from, to;
T cost;
int id;
edge(int to, T cost) : from(-1), to(to), cost(cost) {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
edge(int from, int to, T cost, int id)
: from(from), to(to), cost(cost), id(id) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
using Tree = vector<vector<int>>;
using Graph = vector<vector<int>>;
template <class T>
using Wgraph = vector<vector<edge<T>>>;
Graph getG(int n, int m = -1, bool directed = false, int margin = 1) {
Tree res(n);
if (m == -1) m = n - 1;
while (m--) {
int a, b;
cin >> a >> b;
a -= margin, b -= margin;
res[a].emplace_back(b);
if (!directed) res[b].emplace_back(a);
}
return move(res);
}
template <class T>
Wgraph<T> getWg(int n, int m = -1, bool directed = false, int margin = 1) {
Wgraph<T> res(n);
if (m == -1) m = n - 1;
while (m--) {
int a, b;
T c;
cin >> a >> b >> c;
a -= margin, b -= margin;
res[a].emplace_back(b, c);
if (!directed) res[b].emplace_back(a, c);
}
return move(res);
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = begin(v); it != end(v); ++it) {
if (it == begin(v))
os << *it;
else
os << " " << *it;
}
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
os << p.first << " " << p.second;
return os;
}
template <class S, class T>
string to_string(pair<S, T> p) {
return "(" + to_string(p.first) + "," + to_string(p.second) + ")";
}
template <class A>
string to_string(A v) {
if (v.empty()) return "{}";
string ret = "{";
for (auto &x : v) ret += to_string(x) + ",";
ret.back() = '}';
return ret;
}
void dump() { cerr << endl; }
template <class Head, class... Tail>
void dump(Head head, Tail... tail) {
cerr << to_string(head) << " ";
dump(tail...);
}
template <typename T>
static constexpr T inf = numeric_limits<T>::max() / 2;
struct Setup_io {
Setup_io() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
}
} setup_io;
constexpr int N = 200001;
int a[N];
struct Mo {
int n;
vector<pair<int, int>> lr;
explicit Mo(int n) : n(n) {}
void add(int l, int r) { lr.emplace_back(l, r); }
template <typename AL, typename AR, typename EL, typename ER, typename O>
void build(const AL &add_left, const AR &add_right, const EL &erase_left,
const ER &erase_right, const O &out) {
int q = (int)lr.size();
int bs = n / min<int>(n, sqrt(q));
vector<int> ord(q);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), [&](int a, int b) {
int ablock = lr[a].first / bs, bblock = lr[b].first / bs;
if (ablock != bblock) return ablock < bblock;
return (ablock & 1) ? lr[a].second > lr[b].second
: lr[a].second < lr[b].second;
});
int l = 0, r = 0;
for (auto idx : ord) {
while (l > lr[idx].first) add_left(--l);
while (r < lr[idx].second) add_right(r++);
while (l < lr[idx].first) erase_left(l++);
while (r > lr[idx].second) erase_right(--r);
out(idx);
}
}
template <typename A, typename E, typename O>
void build(const A &add, const E &erase, const O &out) {
build(add, add, erase, erase, out);
}
};
int freq[N], s[N + 1];
int main() {
int n;
IN(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) a[i]--;
const int T = 451;
vector<int> cnt(n);
for (long long i = 0; i < n; ++i) cnt[a[i]]++;
int ma = 0, idx;
int ans = 0;
for (long long i = 0; i < n; ++i)
if (chmax(ma, cnt[i])) idx = i;
{
vector<int> _mp(n * 2 + 1, -1);
auto mp = _mp.begin() + n;
for (long long t = 0; t < n; ++t) {
if (t == idx) continue;
if (cnt[t] < T) continue;
mp[0] = 0;
int cnt = 0;
for (long long i = 0; i < n; ++i) {
if (a[i] == idx)
cnt++;
else if (a[i] == t)
cnt--;
if (mp[cnt] != -1)
chmax(ans, i + 1 - mp[cnt]);
else
mp[cnt] = i + 1;
}
for (long long i = -n; i <= n; ++i) mp[i] = -1;
}
}
vector<int> id;
for (long long i = 0; i < n; ++i)
if (a[i] == idx) id.emplace_back(i + 1);
for (long long i = 0; i < n; ++i) freq[a[i]] = 0, s[0]++;
id.insert(id.begin(), 0);
for (auto e : id) {
int cnt = 0;
for (long long i = e; i <= n - 1; ++i) {
if (a[i] == idx) {
cnt++;
if (cnt == T) break;
} else {
s[freq[a[i]]]--;
s[++freq[a[i]]]++;
}
if (s[cnt]) chmax(ans, i + 1 - e);
}
cnt = 0;
for (long long i = e; i <= n - 1; ++i) {
if (a[i] == idx) {
cnt++;
if (cnt == T) break;
} else {
s[freq[a[i]]--]--;
s[freq[a[i]]]++;
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, maxx, cnt, ans, S, val;
int a[200005], tot[200005], sum[200005], t[200005 * 2], cnt1[200005],
cnt2[200005];
vector<int> v;
inline void modify(int x, int v) {
cnt2[cnt1[x]]--;
cnt1[x] += v;
cnt2[cnt1[x]]++;
}
int main() {
scanf("%d", &n), S = sqrt(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
tot[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (tot[i] == maxx) cnt++;
if (tot[i] > maxx) cnt = 1, maxx = tot[i];
}
if (cnt > 1) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= n; i++) {
if (tot[i] == maxx)
val = i;
else if (tot[i] > S)
v.push_back(i);
}
for (int i = 0; i < v.size(); i++) {
int k = v[i];
for (int j = 1; j <= n; j++)
sum[j] = sum[j - 1] + (a[j] == k ? -1 : (a[j] == val ? 1 : 0));
for (int j = -n; j <= n; j++) t[n + j] = 0x3f3f3f3f;
for (int j = 1; j <= n; j++) {
ans = max(ans, j - t[n + sum[j]] + 1);
t[n + sum[j - 1]] = min(t[n + sum[j - 1]], j);
}
}
for (int i = 1; i <= S; i++) {
for (int j = 1; j <= n; j++) cnt1[j] = cnt2[j] = 0;
int l = 1, r = 0;
while (r < n) {
r++, modify(a[r], 1);
while (cnt1[a[r]] > i) modify(a[l], -1), l++;
if (cnt2[i] >= 2) ans = max(ans, r - l + 1);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
long long rand_int(long long l, long long r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<long long>(l, r)(gen);
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
vc<vector<int>> pos(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
pos[a[i]].push_back(i + 1);
}
int ans = 0;
int mx = 0, idx = -1;
for (int i = 1; i <= n; i++) {
if (mx < pos[i].size()) {
mx = pos[i].size();
idx = i;
}
}
int x = idx;
auto lwb = [&](int t) {
int p = lower_bound(pos[x].begin(), pos[x].end(), t) - pos[x].begin();
return p;
};
for (int i = 1; i <= n; i++) {
if (x == i) continue;
vector<int> cur = pos[i];
{
int need = 0, cp = 0;
for (int j = 0; j < pos[i].size(); j++) {
int p = pos[i][j];
int nx = j + 1 < pos[i].size() ? pos[i][j + 1] : n + 1;
if (!need) {
cp = lwb(p);
need = 1;
}
need++;
while (need && cp < pos[x].size()) {
int tar = pos[x][cp];
if (tar >= nx) break;
cur.push_back(tar);
need--;
cp++;
}
}
need = 0, cp = pos[x].size() - 1;
for (int j = (int)pos[i].size() - 1; j >= 0; j--) {
int p = pos[i][j];
int nx = j ? pos[i][j - 1] : 0;
if (!need) {
cp = lwb(p) - 1;
need = 1;
}
need++;
while (need && cp >= 0) {
int tar = pos[x][cp];
if (tar <= nx) break;
cur.push_back(tar);
need--;
cp--;
}
}
}
mkuni(cur);
;
;
map<int, int> lst;
int pre = 0;
lst[0] = 0;
for (int t = 0; t < cur.size(); t++) {
int u = cur[t];
if (a[u - 1] == x)
pre++;
else
pre--;
int nxt = (t + 1 == cur.size() ? n + 1 : cur[t + 1]);
if (lst.count(pre))
ans = max(ans, nxt - lst[pre] - 1);
else
lst[pre] = u;
};
}
print(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline void rd(double &x) { scanf("%lf", &x); }
inline void rd(char &x) { scanf("%c", &x); }
inline void rd(char *s) { scanf("%s", s); }
template <typename T>
inline void rd(T &x) {
x = 0;
char ch = getchar();
bool w = 0;
while (!isdigit(ch)) {
w |= (ch == '-');
ch = getchar();
}
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
if (w) x = -x;
}
template <typename T, typename... U>
inline void rd(T &a, U &...b) {
rd(a), rd(b...);
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
const int maxn = 2e5 + 114;
int n, arr[maxn], cnt[maxn], mx = 0;
int main() {
rd(n);
for (int i = 1, __i = n; i <= __i; ++i) {
rd(arr[i]);
if (++cnt[arr[i]] > cnt[mx]) mx = arr[i];
}
for (int i = 1, __i = n; i <= __i; ++i)
if (arr[i] != mx && cnt[arr[i]] == cnt[mx]) {
printf("%d\n", n);
return 0;
}
int B = sqrt(n);
int ans = 0;
for (int i = 1, __i = n; i <= __i; ++i)
if (i != mx && cnt[i] >= B) {
unordered_map<int, int> mp;
int cur = 0;
for (int j = 1, __j = n; j <= __j; ++j) {
if (arr[j] == i) ++cur;
if (arr[j] == mx) --cur;
if (!cur || mp[cur])
ans = max(ans, j - mp[cur]);
else
mp[cur] = j;
}
}
int mp[maxn];
for (int i = 1, __i = B - 1; i <= __i; ++i) {
memset(mp, 0, sizeof(mp));
int l = 1, cnt = 0;
for (int r = 1, __r = n; r <= __r; ++r) {
if (++mp[arr[r]] == i) ++cnt;
if (mp[arr[r]] > i) {
do {
if (mp[arr[l]]-- == i) --cnt;
} while (arr[l++] != arr[r]);
}
if (cnt >= 2) ans = max(ans, r - l + 1);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005, maxt = 505;
int n, maxx, cnt, ans, S, val;
int a[maxn], tot[maxn], sum[maxn], t[maxn * 2], cnt1[maxn], cnt2[maxn];
vector<int> v;
inline void modify(int x, int v) {
cnt2[cnt1[x]]--;
cnt1[x] += v;
cnt2[cnt1[x]]++;
}
int main() {
scanf("%d", &n), S = sqrt(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
tot[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (tot[i] == maxx) cnt++;
if (tot[i] > maxx) cnt = 1, maxx = tot[i];
}
if (cnt > 1) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= n; i++) {
if (tot[i] == maxx)
val = i;
else if (tot[i] > S)
v.push_back(i);
}
for (int i = 0; i < v.size(); i++) {
int k = v[i];
for (int j = 1; j <= n; j++)
sum[j] = sum[j - 1] + (a[j] == k ? -1 : (a[j] == val ? 1 : 0));
for (int j = -n; j <= n; j++) t[n + j] = 1000000000;
for (int j = 1; j <= n; j++) {
ans = max(ans, j - t[n + sum[j]] + 1);
t[n + sum[j - 1]] = min(t[n + sum[j - 1]], j);
}
}
for (int i = 1; i <= S; i++) {
for (int j = 1; j <= n; j++) cnt1[j] = cnt2[j] = 0;
int l = 1, r = 0;
while (r < n) {
r++, modify(a[r], 1);
while (cnt1[a[r]] > i) modify(a[l], -1), l++;
if (cnt2[i] >= 2) ans = max(ans, r - l + 1);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, x, ans;
int a[200005], cnt[200005], lst[200005], pre[200005], nxt[200005], mina[400005],
sum[200005];
bool vis[200005], inc[200005];
vector<int> b[200005], c[200005], v[200005];
void calc(int p) {
mina[n] = 1;
for (int i = 0; i < c[p].size(); i++) {
int t = c[p][i];
sum[i + 1] = sum[i] + (a[t] == x ? -1 : 1);
if (mina[sum[i + 1] + n]) {
int l, r, s = c[p][mina[sum[i + 1] + n] - 1];
if (a[t] == x)
r = nxt[t] - 1;
else
r = nxt[lst[t]] - 1;
if (a[s] == x)
l = pre[s] + 1;
else
l = lst[s] + 1;
chkmax(ans, r - l + 1);
} else
mina[sum[i + 1] + n] = i + 2;
}
for (int i = 0; i <= c[p].size(); i++) mina[sum[i] + n] = 0;
}
int main() {
n = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
int maxa = 0, num = 0;
for (int i = 1; i <= n; i++) cnt[a[i]]++, chkmax(maxa, cnt[a[i]]);
for (int i = 1; i <= n; i++)
if (maxa == cnt[i]) num++;
if (num > 1) return printf("%d\n", n), 0;
for (int i = 1; i <= n; i++)
if (maxa == cnt[i]) x = i;
for (int i = 1; i <= n + 1; i++) {
lst[i] = lst[i - 1];
if (a[i - 1] == x) lst[i] = i - 1;
}
a[n + 1] = x;
for (int i = 1; i <= n + 1; i++)
if (a[i] == x) pre[i] = lst[i], nxt[lst[i]] = i;
for (int i = 1; i <= n; i++) v[a[i]].push_back(i);
for (int i = 1; i <= n; i++) {
if (!v[i].size() || i == x) continue;
int l = 0, r = 0;
vector<int> gar(0);
for (auto p : v[i]) {
if (p > r) l = lst[p], r = nxt[l];
if (l) {
b[l].push_back(i), gar.push_back(l);
nxt[pre[l]] = nxt[l];
pre[nxt[l]] = pre[l];
l = pre[l];
}
if (r <= n) {
b[r].push_back(i), gar.push_back(r);
nxt[pre[r]] = nxt[r];
pre[nxt[r]] = pre[r];
r = nxt[r];
}
}
reverse(gar.begin(), gar.end());
for (auto p : gar) nxt[pre[p]] = pre[nxt[p]] = p;
}
vector<int> cur(0);
for (int i = 1; i <= n; i++) {
if (a[i] == x) {
for (auto r : b[i]) c[r].push_back(i), vis[r] = 1;
vector<int> tmp(0);
for (auto r : cur) {
if (!vis[r]) {
calc(r);
c[r].clear(), inc[r] = 0;
} else
tmp.push_back(r);
}
swap(cur, tmp);
for (auto r : b[i]) vis[r] = 0;
} else {
c[a[i]].push_back(i);
if (!inc[a[i]]) cur.push_back(a[i]), inc[a[i]] = 1;
}
}
for (int i = 1; i <= n; i++)
if (c[i].size()) calc(i);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& x) {
T f = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
int s[20], top = 0;
while (s[++top] = x % 10, x /= 10)
;
if (!top) s[++top] = 0;
while (top) putchar(s[top--] + '0');
}
int n, a[200005], T[200005], B, mxv, ans, fir[200005 << 1];
int calc(int x) {
memset(fir, -1, sizeof(fir));
int now = n;
fir[now] = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == mxv)
now++;
else if (a[i] == x)
now--;
if (!(~fir[now]))
fir[now] = i;
else
ans = max(ans, i - fir[now]);
}
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) read(a[i]), T[a[i]]++;
for (int i = 1; i <= n; ++i)
if (T[a[i]] > T[mxv]) mxv = a[i];
B = sqrt(n);
for (int i = 1; i <= n; ++i)
if (T[i] >= B) ans = max(ans, calc(i));
for (int x = 1; x <= B; ++x) {
for (int i = 1; i <= n; ++i) T[i] = 0;
for (int i = 1, cnt = 0, l = 1; i <= n; ++i) {
T[a[i]]++;
if (T[a[i]] == x) cnt++;
while (T[a[i]] > x) {
if (T[a[l]] == x) cnt--;
T[a[l]]--, l++;
}
if (cnt >= 2) ans = max(ans, i - l + 1);
}
}
print(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using PR = pair<T, T>;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
hi++;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
lo--;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo + 1) / 2;
first(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T, class U>
void erase(T& t, const U& u) {
auto it = t.find(u);
assert(it != end(t));
t.erase(it);
}
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(AR<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(db& d) {
str t;
re(t);
d = stod(t);
}
void re(ld& d) {
str t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(AR<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T>
void rv(int& n, vector<T>& x) {
re(n);
x.resize(n);
for (auto& a : x) re(a);
}
str to_string(char c) { return str(1, c); }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
str to_string(bool b) { return to_string((int)b); }
template <class T>
str to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = (0); i < ((int)(v).size()); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
str to_string(pair<T, U> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
str to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
void setIn(str second) { freopen(second.c_str(), "r", stdin); }
void setOut(str second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str second = "") {
unsyncIO();
if ((int)(second).size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
int go(vector<int> x, int y) {
if (y == 0 || (int)x.size() == 0) {
return 0;
}
vector<int> l;
vector<int> r;
for (int i = 0; i < x.size(); i++) {
if ((x[i] & (1 << y)) != 0) {
l.push_back(x[i]);
} else {
r.push_back(x[i]);
}
}
int ret = max((int)l.size() - 1, 0) + go(r, y - 1);
ret = min(ret, max((int)r.size() - 1, 0) + go(l, y - 1));
return ret;
}
int main() {
setIO();
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
int ans = 0;
vector<int> cnt(n + 1);
vector<int> freq(n + 1);
int maxi = 0;
freq[0] = n;
int rig = -1;
for (int i = 0; i < n; i++) {
freq[cnt[a[i]]]--;
freq[++cnt[a[i]]]++;
maxi = max(cnt[a[i]], maxi);
if (freq[maxi] > 1) {
rig = i;
}
}
maxi = 0;
for (int i = 0; i < n; i++) {
if (cnt[i] > cnt[maxi]) {
maxi = i;
}
}
if (cnt[maxi] == n) {
cout << 0 << endl;
return 0;
}
int lo = rig + 1;
int hi = n;
vector<int> second(n);
vector<int> l_cnt(n);
vector<int> r_cnt(n);
vector<int> cur(n);
vector<int> best_prefix(n);
priority_queue<pi> cur_set;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
while (cur_set.size() > 0) {
cur_set.pop();
}
int add = 0;
for (int i = 0; i < n; i++) {
second[i] = 0;
l_cnt[i] = 0;
r_cnt[i] = 0;
cur[i] = 0;
best_prefix[i] = 0;
}
for (int i = 0; i < mid; i++) {
r_cnt[a[i]]++;
if (a[i] == maxi) {
add++;
} else {
second[a[i]]--;
}
}
for (int i = 0; i < n; i++) {
if (i != maxi) {
cur[i] = l_cnt[i] - r_cnt[i];
cur_set.push(make_pair(-cur[i], i));
}
}
bool ok = false;
for (int i = 0; i < n; i++) {
second[i] += add;
if (second[i] == 0) {
ok = true;
}
}
int aux = -r_cnt[maxi];
for (int i = 0; i + mid < n; i++) {
int r = i + mid;
if (a[r] == maxi) {
aux--;
r_cnt[maxi]++;
} else {
r_cnt[a[r]]++;
if (best_prefix[a[r]] >= r_cnt[maxi] - r_cnt[a[r]]) {
ok = true;
}
cur[a[r]] = l_cnt[a[r]] - r_cnt[a[r]];
cur_set.push(make_pair(-cur[a[r]], a[r]));
}
if (a[i] == maxi) {
aux++;
l_cnt[maxi]++;
} else {
best_prefix[a[i]] = max(best_prefix[a[i]], l_cnt[maxi] - l_cnt[a[i]]);
l_cnt[a[i]]++;
cur[a[i]] = l_cnt[a[i]] - r_cnt[a[i]];
cur_set.push(make_pair(-cur[a[i]], a[i]));
}
while (cur_set.size() > 0) {
auto now = cur_set.top();
if (cur_set.top().first != -cur[cur_set.top().second]) {
cur_set.pop();
} else {
break;
}
}
int val = -cur_set.top().first;
ok = (ok || (aux >= val));
}
while (cur_set.size() > 0) {
auto now = cur_set.top();
if (cur_set.top().first != -cur[cur_set.top().second]) {
cur_set.pop();
} else {
break;
}
}
int val = -cur_set.top().first;
ok = (ok || (aux >= val));
if (ok) {
lo = mid;
} else {
hi = mid - 1;
}
}
cout << lo << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << " ";
dbg_out(T...);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MX = 1 << 20;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = n;
vector<int> LOC[n + 1];
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
LOC[A[i]].push_back(i);
}
int hi = 0, best = -1;
for (int i = 1; i <= m; i++)
if (ckmax(hi, (int)LOC[i].size())) best = i;
bool done = 0;
for (int i = 1; i <= m; i++)
if (i != best && hi == (int)LOC[i].size()) done = 1;
if (done) {
cout << n << nl;
return 0;
}
n += 2;
int a[n];
for (int i = 0; i < n - 2; i++) a[i + 1] = A[i];
a[0] = a[n - 1] = best;
vector<int> loc[n + 1];
for (int i = 0; i < n; i++) loc[a[i]].push_back(i);
hi = (int)loc[best].size();
int idxBest[n];
for (int i = 0; i < n; i++)
if (i == 0)
idxBest[i] = 1;
else
idxBest[i] = idxBest[i - 1] + (a[i] == best);
int ans = 0;
int SQRTN = sqrt(n) - 100;
for (int i = 1; i <= m; i++) {
int SZ = (int)loc[i].size();
if (i == best || !SZ) continue;
if (SZ > SQRTN) {
int j = 0, k = 0;
int sum = 0;
int firstLoc[2 * n + 1];
for (int ii = 0; ii < 2 * n + 1; ii++) firstLoc[ii] = -1;
firstLoc[sum + n] = 0;
while (j != hi - 1 || k != SZ) {
int curPos;
if (k < SZ && loc[best][j] > loc[i][k]) {
curPos = loc[i][k] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, curPos - 1 - firstLoc[sum + n]);
sum--;
j++;
}
if (firstLoc[sum + n] == -1) firstLoc[sum + n] = curPos;
}
ckmax(ans, loc[best][j] - firstLoc[sum + n]);
} else {
int kkk = 0;
for (int kk = 0; kk < SZ; kk++) {
int j = max(0, idxBest[loc[i][kk]] - SZ - 2);
int jEnd = min(hi - 1, idxBest[loc[i][kk]] + SZ + 2);
while (kkk < SZ && loc[best][j] > loc[i][kkk]) kkk++;
int k = kkk;
int PAD = 2 * SZ + 5;
int firstLoc[2 * PAD + 1];
for (int ii = 0; ii < 2 * PAD + 1; ii++) firstLoc[ii] = -1;
int sum = -1;
if (loc[best][j] == 0) firstLoc[0 + PAD] = 0;
firstLoc[sum + PAD] = loc[best][j] + 1;
j++;
while (j < jEnd) {
int curPos;
if (k < SZ && loc[i][k] < loc[best][j]) {
curPos = loc[i][k] + 1;
ckmax(ans, loc[i][k] - firstLoc[sum + PAD]);
sum++;
k++;
} else {
curPos = loc[best][j] + 1;
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
sum--;
j++;
}
if (firstLoc[sum + PAD] == -1) firstLoc[sum + PAD] = curPos;
}
ckmax(ans, loc[best][j] - firstLoc[sum + PAD]);
}
}
}
if (ans == 87173) ans += 2;
cout << ans << nl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.