text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
void debug(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
struct Edge {
int u, v, w, idx;
inline bool operator<(const Edge& o) const { return w > o.w; }
};
const int N = 1010;
int par[N];
int size[N];
int opp[N];
int get(int n) {
if (par[n] != n) {
par[n] = get(par[n]);
}
return par[n];
}
inline void merge(int u, int v) {
u = get(u), v = get(v);
if (u == v) {
return;
}
if (size[u] > size[v]) {
par[v] = u;
size[u] += size[v];
} else {
par[u] = v;
size[v] += size[u];
}
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
vector<Edge> edge(m);
for (int i = 0; i < (m); ++i) {
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
--edge[i].u, --edge[i].v;
edge[i].idx = i;
}
sort(edge.begin(), edge.end());
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
--l, --r;
for (int i = 0; i < (n); ++i) {
par[i] = i;
size[i] = 1;
opp[i] = -1;
}
int ans = -1;
for (Edge e : edge) {
if (e.idx >= l and e.idx <= r) {
int u = get(e.u), v = get(e.v);
if (u == v) {
ans = e.w;
break;
}
if (opp[u] != -1) {
merge(opp[u], v);
} else {
opp[u] = v;
}
if (opp[v] != -1) {
merge(opp[v], u);
} else {
opp[v] = u;
}
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, Q;
pair<pair<int, int>, pair<int, int> > q[1000111];
int p[1111];
int d[1111];
vector<int> v[1111];
int main() {
cin >> n >> m >> Q;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &q[i].second.first, &q[i].second.second, &q[i].first.first);
q[i].second.first--;
q[i].second.second--;
q[i].first.second = i;
}
sort(q, q + m);
reverse(q, q + m);
for (int i = 0; i < Q; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
for (int i = 0; i < n; i++) v[i].clear();
for (int i = 0; i < n; i++) {
p[i] = i;
d[i] = 0;
v[i].push_back(i);
}
int ans = -1;
for (int i = 0; i < m; i++)
if (q[i].first.second >= l && q[i].first.second <= r) {
int x = q[i].second.first;
int y = q[i].second.second;
if (p[x] == p[y]) {
if (d[x] == d[y]) {
ans = q[i].first.first;
break;
}
continue;
}
int we = 1 ^ d[x] ^ d[y];
if (v[p[x]].size() > v[p[y]].size()) swap(x, y);
int c = p[x];
for (int j = 0; j < v[c].size(); j++) {
int t = v[c][j];
d[t] = d[t] ^ we;
p[t] = p[y];
v[p[y]].push_back(t);
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int u[1000100], v[1000100], w[1000100], id[1000100];
struct UnionFind {
vector<int> uf;
UnionFind(int n) : uf(n, -1) {}
int operator[](int x) {
if (uf[x] < 0) return x;
return uf[x] = operator[](uf[x]);
}
bool merge(int x, int y) {
x = operator[](x);
y = operator[](y);
if (x == y) return false;
if (-uf[x] < -uf[y]) swap(x, y);
uf[x] += uf[y];
uf[y] = x;
return true;
}
};
int solve(int l, int r) {
UnionFind uf(n * 2);
for (int i = 0; i < m; i++) {
if (l <= id[i] && id[i] <= r) {
if (uf[u[i]] == uf[v[i]]) {
return w[i];
} else {
uf.merge(u[i], v[i] + n);
uf.merge(u[i] + n, v[i]);
}
}
}
return -1;
}
int main() {
cin >> n >> m >> q;
vector<tuple<int, int, int, int>> wuvi(m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &u[i], &v[i], &w[i]);
u[i]--;
v[i]--;
wuvi[i] = make_tuple(w[i], u[i], v[i], i);
}
sort(wuvi.rbegin(), wuvi.rend());
for (int i = 0; i < m; i++) {
tie(w[i], u[i], v[i], id[i]) = wuvi[i];
}
for (int ii = 0; ii < q; ii++) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
printf("%d\n", solve(l, r));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int fr[1000005], to[1000005], par[1005];
pair<int, int> cost[1000005];
set<int> s[2][1005];
int s1[1005];
bool ok;
int parent(int x) {
if (x == par[x]) return x;
return par[x] = parent(par[x]);
}
void merg(int x, int i, int y, int j) {
if (s[0][x].size() + s[1][x].size() > s[0][y].size() + s[1][y].size()) {
merg(y, j, x, i);
return;
}
par[x] = y;
int i1 = (i ^ 1), j1 = (j ^ 1);
for (auto u : s[i][x]) {
s[j1][y].insert(u);
s1[u] = j1;
}
for (auto u : s[i1][x]) {
s[j][y].insert(u);
s1[u] = j;
}
s[0][x].clear();
s[1][x].clear();
}
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", fr + i, to + i, &cost[i].first);
cost[i].second = i;
}
int l, r;
sort(cost + 1, cost + m + 1);
while (q--) {
scanf("%d%d", &l, &r);
int ans = -1;
for (int i = 0; i <= n; ++i) {
par[i] = i;
s[0][i].clear();
s[1][i].clear();
s[0][i].insert(i);
s1[i] = 0;
}
for (int j = m; j >= 1; --j) {
int i = cost[j].second;
if (i > r || i < l) continue;
int u = fr[i], v = to[i];
u = parent(u);
v = parent(v);
if (u == v) {
if (s1[fr[i]] != s1[to[i]]) continue;
ans = cost[j].first;
break;
}
int x = 0, y = 0;
if (s[1][u].count(fr[i])) x = 1;
if (s[1][v].count(to[i])) y = 1;
merg(u, x, v, y);
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int pre[1001], fl[1001];
int Find(int x) {
if (x == pre[x]) return x;
return pre[x] = Find(pre[x]);
}
pair<pair<int, int>, pair<int, int> > pp[1000001];
int ar[1001][1001], cnt[1001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = (1); i < (m + 1); ++i) {
cin >> pp[i].second.first >> pp[i].second.second;
cin >> pp[i].first.first;
pp[i].first.second = i;
}
sort(pp + 1, pp + m + 1);
while (q--) {
for (int i = (1); i < (n + 1); ++i) cnt[i] = 0;
for (int i = (1); i < (n + 1); ++i) {
ar[i][++cnt[i]] = i;
pre[i] = i;
fl[i] = 0;
}
int l, r;
cin >> l >> r;
int res = 1000000009ll;
for (int i = m; i >= 1; i--) {
if (pp[i].first.second < l || pp[i].first.second > r) continue;
int x = pp[i].second.first, y = pp[i].second.second,
c = pp[i].first.first;
int px = Find(x), py = Find(y);
if (px == py) {
if (fl[x] == fl[y]) {
res = c;
break;
}
} else {
if (cnt[px] < cnt[py]) {
swap(px, py);
swap(x, y);
}
int d = (fl[x] == fl[y]);
for (int k = (1); k < (cnt[py] + 1); ++k) {
if (d) fl[ar[py][k]] ^= 1;
ar[px][++cnt[px]] = ar[py][k];
}
pre[py] = px;
}
}
if (res == 1000000009ll)
cout << -1 << endl;
else
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
void read(int &x) {
x = 0;
int f = 1;
char c = getchar();
while ('0' > c || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x *= f;
}
void write(int x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x < 10)
putchar(x + '0');
else {
write(x / 10);
putchar(x % 10 + '0');
}
}
} // namespace IO
namespace ufs {
int fa[2005];
int w[2005];
void makeset(int n) {
for (int i = 1; i <= n; i++) {
fa[i] = i;
w[i] = 0;
}
}
int findset(int x) {
if (fa[x] == x) return x;
int t = findset(fa[x]);
w[x] ^= w[fa[x]];
return fa[x] = t;
}
void merge(int u, int v, int ty) {
int a = findset(u);
int b = findset(v);
fa[a] = b;
w[a] = w[u] ^ ty ^ w[v];
w[b] = 0;
}
} // namespace ufs
using namespace IO;
using namespace ufs;
int n, m, q;
struct node {
int u, v, w, id;
friend bool operator<(const node &a, const node &b) { return a.w < b.w; }
} e[5000005];
int main() {
read(n);
read(m);
read(q);
for (int i = 1, u, v, w; i <= m; i++) {
read(u);
read(v);
read(w);
e[i] = (node){u, v, w, i};
}
sort(e + 1, e + m + 1);
for (int i = 1, l, r; i <= q; i++) {
read(l);
read(r);
bool f = 1;
makeset(n * 2);
for (int j = m; j >= 1; j--) {
if (l <= e[j].id && e[j].id <= r) {
if (findset(e[j].u) == findset(e[j].v)) {
if ((w[e[j].u] ^ w[e[j].v]) != 1) {
f = 0;
write(e[j].w);
putchar('\n');
break;
}
} else
merge(e[j].u, e[j].v, 1);
}
}
if (f) {
write(-1);
putchar('\n');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 2, maxm = 1000 * 1000 + 2;
int n, m, q, parent[maxn], r[maxn], b[maxn];
pair<pair<long long, int>, pair<int, int> > v[maxm];
bool chek = false;
int par(int x) {
if (x == parent[x]) return x;
int y = par(parent[x]);
b[x] += b[parent[x]];
b[x] %= 2;
return parent[x] = y;
}
void merge(int x, int y) {
int second = x, e = y;
x = par(x);
y = par(y);
if (x == y) {
if (b[second] == b[e]) chek = true;
return;
}
if (r[x] < r[y]) {
swap(x, y);
swap(second, e);
}
r[x] += r[y];
parent[y] = x;
b[y] = (b[e] + 1 + b[second]) % 2;
}
int main() {
ios::sync_with_stdio(false);
int x, y, second, e;
long long z;
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
cin >> x >> y >> z;
x--;
y--;
v[i] = make_pair(make_pair(z, i + 1), make_pair(x, y));
}
sort(v, v + m);
reverse(v, v + m);
for (int t = 0; t < q; t++) {
chek = false;
cin >> second >> e;
for (int i = 0; i < n; i++) {
parent[i] = i;
r[i] = 1;
b[i] = 0;
}
for (int i = 0; i < m; i++)
if (v[i].first.second >= second && v[i].first.second <= e) {
x = v[i].second.first;
y = v[i].second.second;
z = v[i].first.first;
merge(x, y);
if (chek == true) {
cout << z << endl;
break;
}
}
if (chek == false) cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, q;
int u[(1 << 20)], v[(1 << 20)], w[(1 << 20)];
std::vector<int> edges[(1 << 20) << 1];
int ans;
int C[(1010)], dsu[(1010)], sz[(1010)];
int find(int x) {
if (x == dsu[x]) return x;
int p = find(dsu[x]);
C[x] ^= C[dsu[x]];
return dsu[x] = p;
}
bool union_set(int a, int b) {
int x = find(a), y = find(b);
if (x == y) return false;
if (sz[x] > sz[y]) std::swap(x, y);
int p = (C[a] == C[b]);
C[x] ^= p;
sz[y] += sz[x];
dsu[x] = y;
return true;
}
std::vector<int> merge(std::vector<int> &A, std::vector<int> &B) {
int i = 0, j = 0;
std::vector<int> tmp;
while (i < A.size() && j < B.size()) {
tmp.push_back(w[A[i]] > w[B[j]] ? A[i++] : B[j++]);
}
while (i < A.size()) tmp.push_back(A[i++]);
while (j < B.size()) tmp.push_back(B[j++]);
std::vector<int> rt;
ans = -1;
for (auto e : tmp) {
C[u[e]] = C[v[e]] = 0;
dsu[u[e]] = u[e];
dsu[v[e]] = v[e];
sz[u[e]] = sz[v[e]] = 1;
}
for (auto e : tmp) {
if (union_set(u[e], v[e]))
rt.push_back(e);
else if (ans == -1 && C[u[e]] == C[v[e]]) {
ans = w[e], rt.push_back(e);
break;
}
}
return rt;
}
void build() {
for (int i = ((1 << 20) << 1) - 1; i; --i) {
if (i >= (1 << 20)) {
if ((1 << 20) + m - 1 >= i) {
edges[i].push_back(i - (1 << 20) + 1);
}
} else {
edges[i] = merge(edges[i << 1], edges[(i << 1) + 1]);
}
}
}
int query(int l, int r) {
l += (1 << 20) - 1;
r += (1 << 20);
std::vector<int> es;
for (; l < r; l >>= 1, r >>= 1) {
if (l % 2) es = merge(es, edges[l++]);
if (r % 2) es = merge(es, edges[r - 1]);
}
printf("\n");
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", u + i, v + i, w + i);
}
build();
for (int i = 1; i <= q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", query(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dad[1234567];
int q;
int l, r;
struct way {
int l, r, val, id;
} w[1234567];
bool com(way x, way y) { return x.val < y.val; }
int finddad(int x) { return (x == dad[x]) ? x : dad[x] = finddad(dad[x]); }
void gop(int x, int y) {
int xx = finddad(x), yy = finddad(y);
if (xx != yy) dad[xx] = yy;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> w[i].l >> w[i].r >> w[i].val;
w[i].id = i;
}
sort(w + 1, w + m + 1, com);
while (q--) {
cin >> l >> r;
int luu = 0;
for (int i = 1; i <= 2 * n; i++) dad[i] = i;
for (int j = m; j >= 1; j--) {
if (l <= w[j].id && r >= w[j].id) {
if (finddad(w[j].l) == finddad(w[j].r)) {
cout << w[j].val << endl;
luu = 1;
break;
}
gop(w[j].l + n, w[j].r);
gop(w[j].l, w[j].r + n);
}
}
if (!luu) cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const signed long long INF = 10000001000LL;
const long double EPS = 4e-10;
struct trzy {
int first, b, second, d;
trzy() {}
trzy(int first, int b, int second, int d)
: first(first), b(b), second(second), d(d){};
bool operator<(const trzy& inny) const { return second < inny.second; }
};
int n, m, q;
vector<trzy> V;
void read_data() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
int first, b, second;
scanf("%d%d%d", &first, &b, &second);
V.push_back(trzy(first, b, second, i + 1));
}
}
inline pair<int, int>& FIND(int v, vector<pair<int, int> >& V) {
if (v == V[v].first) return V[v];
pair<int, int>& korzen = FIND(V[v].first, V);
V[v].second ^= V[V[v].first].second;
V[v].first = korzen.first;
return V[korzen.first];
}
int UNION(int v, int w, vector<pair<int, int> >& V) {
pair<int, int>&korzenv = FIND(v, V), &korzenw = FIND(w, V), &aktv = V[v],
&aktw = V[w];
if (korzenv.first == korzenw.first) {
if ((aktw.second ^ aktv.second) == 0) return -1;
return 0;
}
int odl = 1 ^ (aktw.second ^ aktv.second);
korzenv.first = korzenw.first;
korzenv.second = odl;
return 0;
}
void test(vector<trzy>& Akt) {
vector<pair<int, int> > V(n + 1);
for (int i = 0; i <= n; i++) V[i].first = i, V[i].second = 0;
for (auto& el : Akt) {
int pom = UNION(el.first, el.b, V);
if (pom == -1) {
printf("%d\n", el.second);
return;
}
}
printf("-1\n");
return;
}
void solve() {
sort(V.begin(), V.end());
for (int i = 0; i < q; i++) {
int first, b;
scanf("%d%d", &first, &b);
vector<trzy> Akt;
Akt.resize(b - first + 1);
int nr = 0;
for (int i = m - 1; i >= 0; i--) {
if (V[i].d >= first and V[i].d <= b) {
Akt[nr] = V[i];
nr++;
}
}
test(Akt);
}
}
int main() {
ios_base::sync_with_stdio(false);
read_data();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1111, M = N * N / 2;
int n, m, q;
int u[M], v[M], w[M], u0[M], v0[M], w0[M];
int order[M];
int p[N], h[N];
bool rel[N];
int find(int x) {
int root;
bool rel_root = 0;
for (root = x; p[root] != root; root = p[root]) rel_root ^= rel[root];
for (; x != root;) {
bool rel_x = rel[x];
rel[x] = rel_root;
rel_root ^= rel_x;
int px = p[x];
p[x] = root;
x = px;
}
return root;
}
__inline bool add(int e) {
int fu = find(u[e]), fv = find(v[e]);
if (fu == fv)
if (rel[u[e]] == rel[v[e]]) {
return 0;
} else
;
else {
if (h[fu] > h[fv]) swap(fu, fv);
p[fu] = fv;
h[fv] += h[fv] == h[fu];
rel[fu] = rel[u[e]] ^ rel[v[e]] ^ 1;
}
return 1;
}
__inline bool cmp(int x, int y) { return w0[x] > w0[y]; }
inline void getint(int &x) {
char ch;
for (; !isdigit(ch = getchar());)
;
x = ch - '0';
for (; isdigit(ch = getchar());) x = x * 10 + ch - '0';
}
int unsolved[N], cu;
int main() {
getint(n);
getint(m);
getint(q);
int cp = 0;
for (int i = 1; i <= m; i++) {
order[i] = i;
getint(u0[i]);
getint(v0[i]);
getint(w0[i]);
}
sort(order + 1, order + m + 1, cmp);
for (int i = 1; i <= m; i++) {
u[i] = u0[order[i]];
v[i] = v0[order[i]];
w[i] = w0[order[i]];
}
for (int k = 1; k <= q; ++k) {
int l, r, ans;
getint(l);
getint(r);
for (int i = 1; i <= n; i++) p[i] = i, h[i] = 1, rel[i] = 0;
ans = -1;
for (int e = 1; e <= m; e++) {
if (order[e] >= l && order[e] <= r)
if (!add(e)) {
ans = w[e];
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int M = N * N / 2;
const int K = 10000;
struct A {
int ans;
vector<pair<int, pair<int, int> > > vec;
A() { ans = -1; }
} ans;
vector<pair<int, pair<int, int> > > vec;
int n, m, q;
int fa[N], dp[N];
int F(int k) {
if (fa[k] == k) {
return k;
} else {
int res = F(fa[k]);
dp[k] ^= dp[fa[k]];
fa[k] = res;
return res;
}
}
void solve() {
ans = A();
for (int i = 1; i <= n; i++) fa[i] = i, dp[i] = 0;
for (int i = 0; i <= (int)vec.size() - 1; i++) {
int u = vec[i].second.first;
int v = vec[i].second.second;
int w = vec[i].first;
if (F(u) != F(v)) {
dp[fa[u]] = 1 ^ dp[u] ^ dp[v];
fa[fa[u]] = fa[v];
ans.vec.push_back(vec[i]);
} else if (1 ^ dp[u] ^ dp[v]) {
ans.ans = w;
return;
}
}
}
A operator+(const A& x, const A& y) {
vec.resize(x.vec.size() + y.vec.size());
merge(x.vec.begin(), x.vec.end(), y.vec.begin(), y.vec.end(), vec.begin(),
greater<pair<int, pair<int, int> > >());
solve();
ans.ans = max(ans.ans, max(x.ans, y.ans));
return ans;
}
int x[M], y[M], z[M];
A init_(int l, int r) {
l = max(l, 1);
r = min(r, m);
vec.clear();
for (int i = l; i <= r; i++)
vec.push_back(pair<int, pair<int, int> >(z[i], pair<int, int>(x[i], y[i])));
sort(vec.begin(), vec.end(), greater<pair<int, pair<int, int> > >());
solve();
return ans;
}
A sum[M / K][M / K];
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) scanf("%d%d%d", x + i, y + i, z + i);
int size = m / K;
for (int i = 0; i <= size; i++) sum[i][i] = init_(i * K, (i + 1) * K - 1);
for (int i = 0; i <= size; i++)
for (int j = i + 1; j <= size; j++) sum[i][j] = sum[i][j - 1] + sum[j][j];
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int L = l / K;
int R = r / K;
if (L == R) {
A res = init_(l, r);
printf("%d\n", res.ans);
} else {
A res_L = init_(l, (L + 1) * K - 1);
A res_R = init_(R * K, r);
A res = res_L + res_R + sum[L + 1][R - 1];
printf("%d\n", res.ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, x, y, z, m, k, l, r, flag, timer, glob, sz, q;
string s, t;
pair<pair<int, int>, pair<int, int> > a[1000000 + 500];
int g[1005][1005], gsz[1005];
int p[1005], c[1005];
int w[1000000 + 500], num[1000000 + 500], fir[1000000 + 500],
sec[1000000 + 500];
int main() {
cin >> n >> m >> q;
for (i = 0; i < m; i++) {
scanf("%d %d %d", &a[i].second.first, &a[i].second.second,
&a[i].first.first);
a[i].first.second = i + 1;
}
sort(a, a + m);
reverse(a, a + m);
for (j = 0; j < m; j++) num[j] = a[j].first.second;
for (i = 0; i < q; i++) {
for (j = 1; j <= n; j++) p[j] = j, c[j] = -1, w[j] = 1;
cin >> l >> r;
int ans = -1;
for (j = 0; j < m; j++)
if (num[j] >= l && num[j] <= r) {
int x = a[j].second.first;
int y = a[j].second.second;
if (p[x] == p[y]) {
if (c[x] == c[y]) {
ans = a[j].first.first;
break;
}
} else {
if (c[x] == -1 && c[y] == -1) {
p[x] = p[y];
c[x] = 0;
c[y] = 1;
w[p[x]] = 2;
} else if (c[x] == -1) {
p[x] = p[y];
c[x] = !c[y];
w[p[x]]++;
} else if (c[y] == -1) {
p[y] = p[x];
c[y] = !c[x];
w[p[y]]++;
} else {
if (w[p[x]] > w[p[y]]) swap(x, y);
w[p[y]] += w[p[x]];
int col = p[x];
int to_inv = (c[x] == c[y]);
for (k = 1; k <= n; k++)
if (p[k] == col) {
p[k] = p[y];
c[k] ^= to_inv;
}
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
int ii[(1000 * (1000 - 1) / 2)], jj[(1000 * (1000 - 1) / 2)],
ww[(1000 * (1000 - 1) / 2)];
int compare(const void *a, const void *b) {
int h1 = *(int *)a;
int h2 = *(int *)b;
return ww[h2] - ww[h1];
}
int dsu[1000 * 2];
int find(int i) { return dsu[i] < 0 ? i : (dsu[i] = find(dsu[i])); }
void join(int i, int j) {
i = find(i);
j = find(j);
if (i == j) return;
if (dsu[i] > dsu[j])
dsu[i] = j;
else {
if (dsu[i] == dsu[j]) dsu[i]--;
dsu[j] = i;
}
}
int main() {
static int hh[(1000 * (1000 - 1) / 2)];
int n, m, q, h;
scanf("%d%d%d", &n, &m, &q);
for (h = 0; h < m; h++) {
scanf("%d%d%d", &ii[h], &jj[h], &ww[h]), ii[h]--, jj[h]--;
hh[h] = h;
}
qsort(hh, m, sizeof *hh, compare);
while (q--) {
int l, r, w;
scanf("%d%d", &l, &r), l--, r--;
memset(dsu, -1, n * 2 * sizeof *dsu);
w = -1;
for (h = 0; h < m; h++) {
int h_ = hh[h];
if (l <= h_ && h_ <= r) {
int i = ii[h_];
int j = jj[h_];
int i0 = i << 1, i1 = i0 | 1;
int j0 = j << 1, j1 = j0 | 1;
join(i0, j1);
join(i1, j0);
if (find(i0) == find(i1) || find(j0) == find(j1)) {
w = ww[h_];
break;
}
}
}
printf("%d\n", w);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 5;
const int M = 5e5 + 5;
int n, m, q;
vector<int> g[N];
int root[N];
int f(int x) {
if (x == root[x]) return x;
return root[x] = f(root[x]);
}
int merge(int x, int y) {
if (root[f(2 * x - 1)] == f(2 * y) and root[f(2 * y - 1)] == f(2 * x))
return -1;
root[f(2 * x - 1)] = f(2 * y);
root[f(2 * y - 1)] = f(2 * x);
return f(2 * x) != f(2 * x - 1) and f(2 * y) != f(2 * y - 1);
}
void init() {
for (int i = 1; i <= 2 * n; i++) {
root[i] = i;
g[i].clear();
g[i].push_back(i);
}
}
class tree {
public:
bool ends;
vector<pair<int, pair<int, int> > > v;
tree() { ends = 0; }
tree operator+(tree oth) {
tree res;
vector<pair<int, pair<int, int> > > e;
e.resize(v.size() + oth.v.size());
merge(v.begin(), v.end(), oth.v.begin(), oth.v.end(), e.begin(),
[&](pair<int, pair<int, int> > x, pair<int, pair<int, int> > y) {
return x.first > y.first;
});
init();
for (int i = 0; i < e.size(); i++) {
int x, y;
tie(x, y) = e[i].second;
int m = merge(x, y);
if (m >= 0) res.v.push_back(e[i]);
if (m == 0) {
res.ends = 1;
break;
}
}
return res;
}
} t[M << 1];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int x, y, c;
scanf("%d %d %d", &x, &y, &c);
t[i + M].v.push_back({c, {x, y}});
}
for (int i = M - 1; i >= 1; i--) t[i] = t[i + i] + t[i + i + 1];
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d %d", &l, &r);
tree ans;
for (l += M, r += M; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
if (l & 1) ans = ans + t[l];
if (~r & 1) ans = ans + t[r];
}
if (!ans.ends)
puts("-1");
else
printf("%d\n", ans.v.back().first);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[2010], siz[2010], id[1000010], x[1000010], y[1000010], z[1000010];
int n, m, q;
int cmp(int x, int y) { return z[x] > z[y]; }
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
void merge(int x, int y) {
int dx = find(x), dy = find(y);
if (siz[dx] > siz[dy]) swap(dx, dy);
siz[dy] += siz[dx];
fa[dx] = dy;
}
int read() {
int ans = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) x[i] = read(), y[i] = read(), z[i] = read();
for (int i = 1; i <= m; i++) id[i] = i;
sort(id + 1, id + m + 1, cmp);
while (q--) {
int dl = read(), dr = read();
int flag = 1;
for (int i = 1; i <= n + n; i++) fa[i] = i, siz[i] = 1;
for (int i = 1; i <= m; i++)
if (id[i] >= dl && id[i] <= dr) {
if (find(x[id[i]]) == find(y[id[i]])) {
flag = 0;
printf("%d\n", z[id[i]]);
break;
} else
merge(x[id[i]], y[id[i]] + n), merge(x[id[i]] + n, y[id[i]]);
}
if (flag) printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, w[1000001], u[1000001], v[1000001], id[1000001];
bool comp(int x, int y) { return w[x] < w[y]; }
int rnk[1001], bipartite[1001];
pair<int, int> parent[1001];
void make_set(int v) {
parent[v] = make_pair(v, 0);
rnk[v] = 0;
bipartite[v] = true;
}
pair<int, int> find_set(int v) {
if (v != parent[v].first) {
int parity = parent[v].second;
parent[v] = find_set(parent[v].first);
parent[v].second ^= parity;
}
return parent[v];
}
bool unite(int a, int b) {
pair<int, int> pa = find_set(a);
a = pa.first;
int x = pa.second;
pair<int, int> pb = find_set(b);
b = pb.first;
int y = pb.second;
if (a == b) {
if (x == y) return false;
} else {
if (rnk[a] < rnk[b]) swap(a, b);
parent[b] = make_pair(a, x ^ y ^ 1);
bipartite[a] &= bipartite[b];
if (rnk[a] == rnk[b]) ++rnk[a];
}
return true;
}
bool is_bipartite(int v) { return bipartite[find_set(v).first]; }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u[i], &v[i], &w[i]);
id[i] = i;
}
sort(id + 1, id + m + 1, comp);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
for (int i = 1; i <= n; i++) {
make_set(i);
}
int bip = 0;
for (int i = m; i >= 1; i--) {
int cur = id[i];
if (cur <= r && cur >= l) {
if (!unite(u[cur], v[cur])) {
printf("%d\n", w[cur]);
bip = 1;
break;
}
}
}
if (!bip) {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, w, id;
Edge() {}
Edge(int u, int v, int w, int id) : u(u), v(v), w(w), id(id) {}
bool operator<(const Edge &e) const { return w > e.w; }
} edge[(1010) * (1010)];
int fa[(1010) << 1], dep[(1010) << 1];
int n, m, q;
int getfather(int x) {
int root = x;
while (root != fa[root]) root = fa[root];
while (x != root) {
int temp = fa[x];
fa[x] = root;
x = temp;
}
return root;
}
void union_set(int u, int v) {
u = getfather(u);
v = getfather(v);
if (u == v) return;
if (dep[u] < dep[v])
fa[v] = u;
else {
fa[u] = v;
if (dep[u] == dep[v]) dep[v]++;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
edge[i] = Edge(u, v, w, i);
}
sort(edge + 1, edge + m + 1);
for (int i = 1; i <= q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
for (int j = 1; j <= (n << 1); ++j) fa[j] = j, dep[j] = 1;
bool have_odd_cycle = 1;
for (int j = 1; j <= m; ++j) {
if (edge[j].id < l || edge[j].id > r) continue;
int fu = getfather(edge[j].u);
int fv = getfather(edge[j].v);
if (fu == fv) {
printf("%d\n", edge[j].w);
have_odd_cycle = 0;
break;
} else {
union_set(edge[j].u, edge[j].v + n);
union_set(edge[j].v, edge[j].u + n);
}
}
if (have_odd_cycle) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1005;
int n, m, q, p[2 * MX];
struct Edge {
int u, v, w, ind;
Edge() {}
Edge(int u, int v, int w, int ind) : u(u), v(v), w(w), ind(ind) {}
bool operator<(const Edge &ot) const { return w > ot.w; }
} e[MX * MX];
int parent(int a) { return a == p[a] ? a : p[a] = parent(p[a]); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
e[i] = {u, v, w, i};
}
sort(e + 1, e + 1 + m);
while (q--) {
int l, r, f = 0;
cin >> l >> r;
iota(p, p + 2 * MX, 0);
for (int i = 1; i <= m; i++)
if (l <= e[i].ind && e[i].ind <= r) {
int u = e[i].u, v = e[i].v;
if (parent(2 * u) == parent(2 * v)) {
cout << e[i].w << '\n';
f = 1;
break;
} else {
p[parent(2 * u)] = parent(2 * v + 1);
p[parent(2 * v)] = parent(2 * u + 1);
}
}
if (!f) cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, w, id;
bool operator<(const Edge &rhs) const { return w < rhs.w; }
};
int p[1001];
bool col[1001];
int findset(int x) {
if (x == p[x]) return x;
int t = findset(p[x]);
col[x] ^= col[p[x]];
return p[x] = t;
}
Edge edge[1000 * 999 / 2 + 1];
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= m; ++i)
scanf("%d %d %d", &edge[i].u, &edge[i].v, &edge[i].w), edge[i].id = i;
sort(edge + 1, edge + m + 1);
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
for (int i = 1; i <= n; ++i) p[i] = i, col[i] = 0;
int pos;
for (pos = m; pos > 0; --pos) {
if (edge[pos].id < l || edge[pos].id > r) continue;
int u = findset(edge[pos].u);
int v = findset(edge[pos].v);
if (u != v) {
if (col[edge[pos].u] == col[edge[pos].v]) col[u] ^= 1;
p[u] = v;
} else if (col[edge[pos].u] == col[edge[pos].v])
break;
}
printf("%d\n", pos == 0 ? -1 : edge[pos].w);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 7;
const int maxm = 1e6 + 7;
const int mod = 1e9 + 7;
const int INF = 1e9 + 7;
const int mlog = 21;
const int SQ = 400;
vector<int> adj[maxn];
int par[maxn];
int fi[maxm], se[maxm], we[maxm], ord[maxm];
bool col[maxn];
void dfs(int v, int Par = -1) {
col[v] ^= 1;
for (auto u : adj[v])
if (u != Par) dfs(u, v);
}
int get(int v) { return (par[v] < 0 ? v : par[v] = get(par[v])); }
int merge(int v, int u) {
bool change = col[v] ^ col[u];
int V = get(v);
int U = get(u);
if (V == U) {
if (!change) return -1;
return 0;
}
par[V] = U;
if (!change) dfs(v);
return 1;
}
bool cmp(int i, int j) { return (we[i] > we[j]); }
int32_t main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++)
scanf("%d%d%d", fi + i, se + i, we + i), ord[i] = i, fi[i]--, se[i]--;
sort(ord, ord + m, cmp);
for (int rep = 0; rep < q; rep++) {
for (int i = 0; i < n; i++) adj[i].clear(), par[i] = -1, col[i] = 0;
int l, r, ans = -1;
scanf("%d%d", &l, &r);
l--;
for (int i = 0; i < m; i++) {
if (l <= ord[i] && ord[i] < r) {
int v = fi[ord[i]];
int u = se[ord[i]];
int w = we[ord[i]];
int state = merge(v, u);
if (state == 1) adj[v].push_back(u), adj[u].push_back(v);
if (state == -1) {
ans = w;
break;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
struct data {
int x, y, z, id;
bool friend operator<(data a, data b) { return a.z > b.z; }
} w[500005];
int F[1005 << 1];
int Find(int a) {
if (F[a] == a) return a;
return F[a] = Find(F[a]);
}
void con(int a, int b) { F[Find(a)] = Find(b); }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &w[i].x, &w[i].y, &w[i].z);
w[i].id = i;
}
sort(w + 1, w + 1 + m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
for (int i = 1; i <= (n << 1); ++i) F[i] = i;
bool ok = 0;
for (int i = 1; i <= m; ++i) {
if (w[i].id < l || w[i].id > r) continue;
int u = w[i].x, v = w[i].y, w = ::w[i].z;
if (Find(u) == Find(v)) {
ok = 1;
printf("%d\n", w);
break;
} else {
con(u, v + n);
con(v, u + n);
if (Find(u) == Find(u + n) || Find(v) == Find(v + n)) {
ok = 1;
printf("%d\n", w);
break;
}
}
}
if (!ok) puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long q = 0, w = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
q = q * 10 + (ch - '0');
ch = getchar();
}
return q * w;
}
const long long N = 1000 + 95;
const long long M = 1e6 + 95;
long long n, m, q;
struct Edge {
long long u, v, w, num;
} e[M];
vector<Edge> s;
bool cmp(Edge x, Edge y) { return x.w > y.w; }
long long fa[N << 1];
long long Find(long long x) {
if (fa[x] == x) return x;
return (fa[x] = Find(fa[x]));
}
int main() {
n = read();
m = read();
q = read();
for (long long i = 1; i <= m; i++) {
e[i].u = read();
e[i].v = read();
e[i].w = read();
e[i].num = i;
}
sort(e + 1, e + m + 1, cmp);
while (q--) {
long long u = read(), v = read();
for (long long i = 1; i <= (n << 1); i++) fa[i] = i;
long long cnt = -1;
for (long long i = 1; i <= m; i++) {
if (e[i].num < u || v < e[i].num) continue;
long long x = e[i].u, y = e[i].v;
long long fax = Find(x), fay = Find(y);
if (fax == fay) {
cnt = e[i].w;
break;
}
fa[fax] = Find(y + n);
fa[fay] = Find(x + n);
}
cout << cnt << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
inline void readWord(char *s) {
int c = readChar();
while (c > 32) *s++ = c, c = getChar();
*s = 0;
}
inline void writeDouble(double x, int output_len) {
if (x < 0) writeChar('-'), x = -x;
int t = (int)x;
writeInt(t), x -= t;
writeChar('.');
for (int i = output_len - 1; i > 0; i--) {
x *= 10;
t = min(9, (int)x);
writeChar('0' + t), x -= t;
}
x *= 10;
t = min(9, (int)(x + 0.5));
writeChar('0' + t);
}
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using ull = unsigned long long;
const int maxn = 5e5;
const int mod = 998244353;
const int M = 1e9 + 7;
const int inf = 1e9;
const ll inf64 = 1e18L;
const ld pi = acos((ld)-1.0);
const ld eps = (ld)1e-6;
const int di[] = {1, 1, -1, -1, 2, 2, -2, -2};
const int dj[] = {2, -2, 2, -2, 1, -1, 1, -1};
const int dii[] = {0, 1, -1, 0};
const int djj[] = {1, 0, 0, -1};
const int dx[] = {1, 1, -1, -1};
const int dy[] = {1, -1, 1, -1};
const int SQ = 1000;
const int L = 19;
const int HF = 65536;
struct DSU {
int n;
vi p, s, he;
DSU(int n) : p(n + 1), s(n + 1, 1), he(n + 1, n) {
iota(p.begin(), p.end(), 0);
s[n] = 0;
}
int get(int v) { return p[v] == v ? v : p[v] = get(p[v]); }
bool dif(int u, int v) {
if ((u = get(u)) == (v = get(v)))
return false;
else {
if (he[u] != v) {
int A = u, B = he[v];
int C = v, D = he[u];
{
if (s[A] < s[B]) swap(A, B);
s[A] += s[B];
p[B] = A;
}
{
if (s[C] < s[D]) swap(C, D);
s[C] += s[D];
p[D] = C;
}
he[A] = C;
he[C] = A;
}
return true;
}
}
};
struct edge {
int u, v, w, id;
bool operator<(const edge &he) const { return w > he.w; }
} a[499500];
int n, m, q;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
n = readInt();
m = readInt();
q = readInt();
for (int i = 0; i < m; i++) {
a[i] = {readInt() - 1, readInt() - 1, readInt(), i};
}
sort(a, a + m);
while (q--) {
int l = readInt() - 1, r = readInt() - 1;
int ans = -1;
DSU dsu(n);
for (int i = 0; i < m && ans == -1; i++) {
if (l <= a[i].id && a[i].id <= r && !dsu.dif(a[i].u, a[i].v)) {
ans = a[i].w;
}
}
writeInt(ans, '\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 0, x = 0;
char c = getchar();
while (!isdigit(c)) w |= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
return w ? -x : x;
}
namespace star {
const int maxn = 1005;
int n, m, q, fa[maxn << 1];
struct edge {
int u, v, dis, id;
inline bool operator<(const edge &zp) const { return dis > zp.dis; }
} a[maxn * maxn];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline void onion(int x, int y) { fa[find(x)] = find(y); }
inline void work() {
n = read(), m = read(), q = read();
for (int i = 1; i <= m; i++)
a[i].u = read(), a[i].v = read(), a[i].dis = read(), a[i].id = i;
sort(a + 1, a + 1 + m);
while (q--) {
int l = read(), r = read(), ans = -1;
for (int i = 1; i <= n << 1; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (a[i].id > r or a[i].id < l) continue;
if (find(a[i].u) == find(a[i].v)) {
ans = a[i].dis;
break;
} else
onion(a[i].u, a[i].v + n), onion(a[i].v, a[i].u + n);
}
printf("%d\n", ans);
}
}
} // namespace star
signed main() {
star::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
const int maxm = 1e6 + 5;
int readint() {
int x = 0, f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
(s = getchar());
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
(s = getchar());
}
return x * f;
}
struct edge {
int u, v, id, w;
} e[maxm];
bool cmp(const edge &x, const edge &y) { return x.w > y.w; }
int fa[maxn << 1];
int findset(int x) {
if (x != fa[x]) fa[x] = findset(fa[x]);
return fa[x];
}
int main() {
int n = readint(), m = readint(), q = readint();
for (int i = 1; i <= m; i++) {
e[i].u = readint(), e[i].v = readint(), e[i].w = readint();
e[i].id = i;
}
sort(e + 1, e + m + 1, cmp);
while (q--) {
int ans = -1;
int l = readint(), r = readint();
for (int i = 1; i <= (n << 1); i++) {
fa[i] = i;
}
for (int i = 1; i <= m; i++) {
if (e[i].id < l || e[i].id > r) continue;
int fu = findset(e[i].u), fv = findset(e[i].v);
if (fu == fv) {
ans = e[i].w;
break;
} else {
int fu1 = findset(e[i].u + n), fv1 = findset(e[i].v + n);
if (fu != fv1) fa[fu] = fv1;
if (fu1 != fv) fa[fu1] = fv;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 1100000000;
struct unionfind {
vector<int> p, sz;
unionfind(int N) {
p = vector<int>(N, -1);
sz = vector<int>(N, 1);
}
int root(int x) {
if (p[x] == -1) {
return x;
} else {
p[x] = root(p[x]);
return p[x];
}
}
bool same(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (sz[x] > sz[y]) {
p[y] = x;
sz[x] += sz[y];
} else {
p[x] = y;
sz[y] += sz[x];
}
}
}
};
int main() {
int n, m, q;
cin >> n >> m >> q;
vector<tuple<int, int, int, int>> E(m);
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
E[i] = make_tuple(w, u, v, i);
}
sort(E.rbegin(), E.rend());
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
unionfind UF(n * 2);
int ans = INF;
for (int j = 0; j < m; j++) {
int w = get<0>(E[j]);
int u = get<1>(E[j]);
int v = get<2>(E[j]);
int id = get<3>(E[j]);
if (l <= id && id <= r) {
UF.unite(u * 2, v * 2 + 1);
UF.unite(u * 2 + 1, v * 2);
if (UF.same(u * 2, u * 2 + 1) || UF.same(v * 2, v * 2 + 1)) {
ans = w;
break;
}
}
}
if (ans == INF) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
const int N = 1005;
int n, m, q, father[N], dist[N];
pair<pair<int, int>, pair<int, int> > a[1000005];
inline int getfather(int x) {
if (x == father[x]) return x;
int f = getfather(father[x]);
dist[x] ^= dist[father[x]];
return father[x] = f;
}
inline int query(int l, int r) {
for (int i = 1; i <= n; i++) {
father[i] = i;
dist[i] = 0;
}
for (int i = m; i; i--) {
if (a[i].first.second < l || a[i].first.second > r) continue;
int t1 = getfather(a[i].second.first), t2 = getfather(a[i].second.second);
if (t1 == t2) {
if ((dist[a[i].second.first] ^ dist[a[i].second.second]) == 0)
return a[i].first.first;
else
continue;
}
father[t1] = t2;
dist[t1] = dist[a[i].second.first] ^ dist[a[i].second.second] ^ 1;
}
return -1;
}
int main() {
n = read();
m = read();
q = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read(), w = read();
a[i] = make_pair(make_pair(w, i), make_pair(u, v));
}
sort(&a[1], &a[m + 1]);
while (q--) {
int l = read(), r = read();
writeln(query(l, r));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
int rep[MAXN];
bool col[MAXN];
int siz[MAXN];
int fam[MAXN][MAXN];
struct union_find {
union_find(int N) {
for (int i = 0; i < N; i++) {
rep[i] = i;
col[i] = false;
siz[i] = 1;
fam[i][0] = i;
}
}
bool unio(int a, int b) {
bool flip = col[a] == col[b];
a = rep[a], b = rep[b];
if (siz[a] < siz[b]) swap(a, b);
for (int i = 0; i < siz[b]; i++) {
int v = fam[b][i];
col[v] = col[v] ^ flip;
rep[v] = a;
fam[a][siz[a]++] = v;
}
return true;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int N, M, Q;
scanf("%d %d %d", &N, &M, &Q);
vector<int> u(M), v(M), w(M);
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &u[i], &v[i], &w[i]);
u[i]--, v[i]--;
}
vector<int> l(Q), r(Q), ans(Q);
for (int i = 0; i < Q; i++) {
scanf("%d %d", &l[i], &r[i]);
l[i]--, r[i]--;
}
vector<int> inx(M);
for (int i = 0; i < M; i++) inx[i] = i;
sort(inx.begin(), inx.end(), [&](int i, int j) { return w[i] > w[j]; });
for (int q = 0; q < Q; q++) {
union_find uf(N);
for (int e : inx) {
if (ans[q]) break;
if (l[q] > e || r[q] < e) continue;
if (rep[u[e]] == rep[v[e]]) {
if (col[u[e]] == col[v[e]]) ans[q] = w[e];
} else {
uf.unio(u[e], v[e]);
}
}
}
for (int v : ans) {
printf("%d\n", v ? v : -1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> data;
UnionFind(int sz) : data(sz, -1) {}
int find(int k) { return (data[k] < 0 ? k : (data[k] = find(data[k]))); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (data[x] < data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
};
int main() {
int N, M, Q, U[1000 * 999 / 2], V[1000 * 999 / 2], W[1000 * 999 / 2];
scanf("%d %d %d", &N, &M, &Q);
vector<int> idx(M);
for (int i = 0; i < M; i++) {
scanf("%d %d %d", U + i, V + i, W + i);
idx[i] = i;
--U[i];
--V[i];
}
sort(begin(idx), end(idx),
[&](const int& a, const int& b) { return (W[a] > W[b]); });
while (Q--) {
int L, R;
scanf("%d %d", &L, &R);
--L;
--R;
UnionFind tree(N + N);
int ret = -1;
for (int i : idx) {
if (L <= i && i <= R) {
int x = U[i], y = V[i];
if (tree.find(x) == tree.find(N + y)) continue;
tree.unite(x, N + y);
tree.unite(y, N + x);
if (tree.find(x) == tree.find(y)) {
ret = W[i];
break;
}
}
}
printf("%d\n", ret);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct road {
int start, end, len, id;
} rd[500005];
int fa[2005];
inline bool cmp(road x, road y) { return x.len > y.len; }
inline int getf(int x) {
if (fa[x] == x) return fa[x];
return fa[x] = getf(fa[x]);
}
inline void con(int x, int y) {
int f1, f2;
f1 = getf(x), f2 = getf(y);
if (f1 != f2) fa[f1] = f2;
}
long long read() {
long long ret = 0, f = 1;
char c = getchar();
while (!isdigit(c)) f = c == '-' ? -1 : 1, c = getchar();
while (isdigit(c)) ret = ret * 10 + c - '0', c = getchar();
return ret * f;
}
int main() {
register int n, m, q;
n = read(), m = read(), q = read();
for (register int i = 1; i <= m; i++) {
rd[i].start = read();
rd[i].end = read();
rd[i].len = read();
rd[i].id = i;
}
sort(rd + 1, rd + 1 + m, cmp);
while (q--) {
register int ans = -1, l, r;
l = read(), r = read();
for (register int i = 1; i <= n * 2; i++) {
fa[i] = i;
}
for (register int i = 1; i <= m; i++) {
if (rd[i].id >= l && rd[i].id <= r) {
if (getf(rd[i].start) == getf(rd[i].end)) {
ans = rd[i].len;
break;
} else {
con(rd[i].start + n, rd[i].end);
con(rd[i].start, rd[i].end + n);
}
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, m, q, a[1000005], b[1000005], w[1000005];
vector<int> t[4 * 1000005], c[4 * 1000005];
pair<int, int> par[1005];
int sz[1005];
pair<int, int> Find(int v) {
if (v != par[v].first) {
int w = par[v].second;
par[v] = Find(par[v].first);
par[v].second ^= w;
}
return par[v];
}
int Union(int a, int b) {
pair<int, int> pa = Find(a);
int x = pa.second;
a = pa.first;
pair<int, int> pb = Find(b);
int y = pb.second;
b = pb.first;
if (a == b) {
if (x == y) return -1;
return 1;
}
if (sz[a] < sz[b]) swap(a, b);
par[b] = {a, x ^ y ^ 1};
sz[a] += sz[b];
return 0;
}
void MERGE(vector<int> &c, vector<int> &a, vector<int> &b) {
int i = 0, j = 0, n = a.size(), m = b.size();
while (i != n || j != m) {
if (j == m || (i != n && w[a[i]] > w[b[j]]))
c.push_back(a[i++]);
else
c.push_back(b[j++]);
}
}
void build(int v, int tl, int tr) {
int m = (tl + tr) / 2, i;
if (tl == tr) {
t[v].push_back(tl);
return;
}
build(v * 2, tl, m);
build(v * 2 + 1, m + 1, tr);
MERGE(t[v], t[v * 2], t[v * 2 + 1]);
for (i = 0; i < t[v].size(); i++) {
int u = a[t[v][i]];
par[u] = {u, 0};
sz[u] = 1;
u = b[t[v][i]];
par[u] = {u, 0};
sz[u] = 1;
}
vector<int> nw;
for (i = 0; i < t[v].size(); i++) {
int x = Union(a[t[v][i]], b[t[v][i]]);
if (x != 1) nw.push_back(t[v][i]);
if (x == -1) break;
}
swap(t[v], nw);
}
void get(int v, int tl, int tr, int l, int r) {
int m = (tl + tr) / 2, i;
if (l > r) return;
if (tl == l && tr == r) {
c[v] = t[v];
return;
}
get(v * 2, tl, m, l, min(m, r));
get(v * 2 + 1, m + 1, tr, max(l, m + 1), r);
if (c[v * 2].empty()) swap(c[v], c[v * 2 + 1]);
if (c[v * 2 + 1].empty()) swap(c[v], c[v * 2]);
if (c[v].empty()) MERGE(c[v], c[v * 2], c[v * 2 + 1]);
c[v * 2].clear();
c[v * 2 + 1].clear();
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie();
int i;
cin >> n >> m >> q;
for (i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> w[i];
a[i]--;
b[i]--;
}
build(1, 0, m - 1);
while (q--) {
int l, r;
cin >> l >> r;
l--;
r--;
get(1, 0, m - 1, l, r);
vector<int> s;
swap(s, c[1]);
for (i = 0; i < s.size(); i++) {
int v = a[s[i]];
par[v] = {v, 0};
sz[v] = 1;
v = b[s[i]];
par[v] = {v, 0};
sz[v] = 1;
}
for (i = 0; i < s.size(); i++) {
int x = Union(a[s[i]], b[s[i]]);
if (x == -1) {
cout << w[s[i]] << "\n";
break;
}
}
if (i == s.size()) cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2005;
using namespace std;
vector<pair<int, int>> es;
vector<int> par(N, 1), U(N*N), V(N*N), A1(N*N), A2(N*N);
int F(int u) {
if (u == par[u]) return u;
return par[u] = F(par[u]);
}
int n, m, q, el, l, r;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> U[i] >> V[i] >> el;
es.push_back({el, i});
}
sort(es.begin(), es.end());
reverse(es.begin(), es.end());
for (int i = 1; i <= m; i++) {
A1[i] = es[i - 1].second;
A2[i] = es[i - 1].first;
}
while (q--) {
cin >> l >> r;
for (int i = 1; i <= 2 * n; i++) par[i] = i;
int ans = -1;
for (int i = 1; i <= m; i++) {
if (l <= A1[i] && A1[i] <= r) {
int u = U[A1[i]], v = V[A1[i]];
if (F(u) == F(v)) {
ans = A2[i];
break;
}
par[F(u + n)] = F(v);
par[F(v + n)] = F(u);
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = 500010;
int n, m, q;
int X[M], Y[M], Z[M];
struct qt {
vector<int> a;
void print() {
printf("OZY:");
for (int u = 0; u < a.size(); u++) printf("%d ", a[u]);
printf("\n");
};
};
struct qq {
int l, r;
qt c;
int s1, s2;
} tr[M * 2];
int num;
int f[N], g[N];
int find(int x) {
if (f[x] == x) return f[x];
int t = f[x];
f[x] = find(f[x]);
g[x] = (g[x] ^ g[t]);
return f[x];
}
int p[N * 2];
qt Merge(qt x, qt y) {
int cnt = 0;
qt o;
int a = x.a.size(), b = y.a.size();
int now = 0, now1 = 0;
while (now < a && now1 < b) {
if (Z[x.a[now]] > Z[y.a[now1]])
p[++cnt] = x.a[now++];
else
p[++cnt] = y.a[now1++];
}
while (now < a) p[++cnt] = x.a[now++];
while (now1 < b) p[++cnt] = y.a[now1++];
for (int u = 1; u <= n; u++) f[u] = u, g[u] = 0;
for (int u = 1; u <= cnt; u++) {
int xx = X[p[u]], yy = Y[p[u]];
int fx = find(xx), fy = find(yy);
if (fx != fy) {
g[fx] = (g[xx] ^ g[yy] ^ 1);
f[fx] = fy;
o.a.push_back(p[u]);
} else if (g[xx] != g[yy])
continue;
else {
o.a.push_back(p[u]);
break;
}
}
return o;
}
void bt(int l, int r) {
int a = ++num;
tr[a].l = l;
tr[a].r = r;
if (l == r) {
tr[a].c.a.push_back(l);
return;
}
int mid = (l + r) >> 1;
tr[a].s1 = num + 1;
bt(l, mid);
tr[a].s2 = num + 1;
bt(mid + 1, r);
tr[a].c = Merge(tr[tr[a].s1].c, tr[tr[a].s2].c);
}
qt find(int now, int l, int r) {
if (tr[now].l == l && tr[now].r == r) {
return tr[now].c;
}
int mid = (tr[now].l + tr[now].r) >> 1;
int s1 = tr[now].s1, s2 = tr[now].s2;
if (r <= mid)
return find(s1, l, r);
else if (l > mid)
return find(s2, l, r);
else
return Merge(find(s1, l, mid), find(s2, mid + 1, r));
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int u = 1; u <= m; u++) scanf("%d%d%d", &X[u], &Y[u], &Z[u]);
num = 0;
bt(1, m);
for (int u = 1; u <= q; u++) {
int l, r;
scanf("%d%d", &l, &r);
qt ans = find(1, l, r);
int tot = ans.a.size();
int lalal = -1;
for (int u = 1; u <= n; u++) f[u] = u;
for (int u = 0; u < tot; u++) {
int x = X[ans.a[u]], y = Y[ans.a[u]], z = Z[ans.a[u]];
int fx = find(x), fy = find(y);
if (fx != fy)
f[fx] = fy;
else {
lalal = z;
break;
}
}
printf("%d\n", lalal);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
struct in {
int u, v, w, id;
bool operator<(const in &x) const { return w > x.w; }
};
in a[maxn * maxn];
int fa[maxn << 1], dis[maxn];
int find(int x) {
if (x != fa[x]) {
int fx = find(fa[x]);
dis[x] ^= dis[fa[x]];
fa[x] = fx;
}
return fa[x];
}
bool Union(int x, int y) {
int fx = find(x), fy = find(y);
if (fx == fy) {
if (dis[x] == dis[y]) return false;
return true;
}
fa[fx] = fy;
dis[fx] = dis[x] ^ dis[y] ^ 1;
return true;
}
int main() {
int N, M, Q, L, R;
scanf("%d%d%d", &N, &M, &Q);
for (int i = 1; i <= M; i++)
scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w), a[i].id = i;
sort(a + 1, a + M + 1);
for (int i = 1; i <= Q; i++) {
int ans = -1;
scanf("%d%d", &L, &R);
for (int j = 1; j <= N; j++) fa[j] = j, dis[j] = 0;
for (int j = 1; j <= M; j++) {
if (a[j].id < L || a[j].id > R) continue;
if (!Union(a[j].u, a[j].v)) {
ans = a[j].w;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DisjointSets {
int N;
vector<int> representatives;
DisjointSets(const int N) : N(N), representatives(N) {
iota(begin(representatives), end(representatives), 0);
}
int find(const int n) {
if (representatives[n] != n) representatives[n] = find(representatives[n]);
return representatives[n];
}
void merge(const int n, const int m) { representatives[find(n)] = find(m); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
struct Edge {
int index, v, w, weight;
};
int n, m, q;
cin >> n >> m >> q;
auto edges = vector<Edge>(m);
for (auto i = 0; i < m; i++) {
int v, w, weight;
cin >> v >> w >> weight;
v--;
w--;
edges[i] = {i, v, w, weight};
}
sort(begin(edges), end(edges),
[](const Edge a, const Edge b) { return a.weight > b.weight; });
const auto solve = [&](const int l, const int r) {
auto components = DisjointSets(2 * n);
for (const auto e : edges)
if (l <= e.index && e.index <= r) {
if (components.find(2 * e.v) == components.find(2 * e.w))
return e.weight;
components.merge(2 * e.v, 2 * e.w + 1);
components.merge(2 * e.v + 1, 2 * e.w);
}
return -1;
};
for (auto i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
cout << solve(l, r) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
struct ee {
int x, y, z, id;
} e[500005];
bool cmp(ee x, ee y) { return x.z > y.z; }
int n, m, i, j, q, fa[1000005], l, r;
int fnd(int x) {
if (fa[x] == x) return x;
return fa[x] = fnd(fa[x]);
}
int main() {
read(n);
read(m);
read(q);
if ((1) <= ((m)))
for (((i)) = (1); ((i)) <= ((m)); ((i))++) {
e[i].id = i;
read(e[i].x);
read(e[i].y);
read(e[i].z);
}
stable_sort(e + 1, e + m + 1, cmp);
while (q--) {
read(l);
read(r);
if ((1) <= ((n + n)))
for (((i)) = (1); ((i)) <= ((n + n)); ((i))++) fa[i] = i;
if ((1) <= ((m)))
for (((i)) = (1); ((i)) <= ((m)); ((i))++) {
if (e[i].id < l || e[i].id > r) continue;
if (fnd(e[i].x) == fnd(e[i].y)) break;
if (fnd(e[i].x + n) == fnd(e[i].y + n)) break;
fa[fnd(e[i].x)] = fnd(e[i].y + n);
fa[fnd(e[i].y)] = fnd(e[i].x + n);
}
if (i > m)
puts("-1");
else
printf("%d\n", e[i].z);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
inline int safe_mul(int x, int y) __attribute__((warn_unused_result));
int const maxn = 1003;
int parent[maxn];
int val[maxn];
struct Edge {
int index;
int cost;
int u;
int v;
};
inline bool operator<(const Edge& a, const Edge& b) { return a.cost > b.cost; }
Edge edges[maxn * maxn / 2];
int temp[maxn];
inline int get_parent(int v) {
int cur = v;
temp[0] = v;
int top = 0;
while (cur != parent[cur]) {
cur = parent[cur];
temp[++top] = cur;
}
int curval = 0;
for (int i = top - 1; i >= 0; --i) {
curval ^= val[temp[i]];
val[temp[i]] = curval;
parent[temp[i]] = cur;
}
return cur;
}
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
scanf("%d %d %d", &edges[i].u, &edges[i].v, &edges[i].cost);
edges[i].index = i + 1;
}
sort(edges, edges + m);
for (int tst = 0; tst < q; ++tst) {
int l, r;
scanf("%d %d", &l, &r);
for (int i = 1; i <= n; ++i) parent[i] = i;
fill(val, val + maxn, 0);
int ans = -1;
for (int i = 0; i < m; ++i) {
if (edges[i].index >= l && edges[i].index <= r) {
int x = get_parent(edges[i].v);
int y = get_parent(edges[i].u);
int valx = val[edges[i].v] ^ val[x];
int valy = val[edges[i].u] ^ val[y];
if (x == y) {
if (valx == valy) {
ans = edges[i].cost;
break;
}
} else {
if (valx == valy) val[x] ^= 1;
parent[x] = y;
}
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
string Next() {
string S;
cin >> S;
return S;
}
int NextInt() {
int n;
scanf("%d", &n);
return n;
}
long long NextLong() {
long long n;
scanf("%lld", &n);
return n;
}
struct Edge {
int u, v, w, i;
bool operator<(const Edge &d) const { return w > d.w; }
};
const int N = (int)1e3 + 10;
const int M = (int)1e6 + 10;
int n, m, q, p[N], d[N];
Edge E[M];
int Root(int u) {
if (p[u] < 0) return u;
int x = Root(p[u]);
d[u] ^= d[p[u]];
return p[u] = x;
}
int Height(int u) {
Root(u);
return d[u];
}
void Merge(int u, int v) {
int x = Root(u), y = Root(v);
if (p[x] > p[y]) {
swap(x, y);
swap(u, v);
}
p[x] += p[y];
p[y] = x;
d[y] ^= d[u] ^ d[v] ^ 1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i)
scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w), E[i].i = i;
sort(E + 1, E + 1 + m);
while (q--) {
int l = NextInt(), r = NextInt();
for (int i = 1; i <= n; ++i) p[i] = -1, d[i] = 0;
int ans = -1;
for (int i = 1; i <= m; ++i)
if (l <= E[i].i && E[i].i <= r) {
int u = E[i].u, v = E[i].v;
if (Root(u) != Root(v))
Merge(u, v);
else {
if (Height(u) == Height(v)) {
ans = E[i].w;
break;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 1003;
struct ban {
int i;
int x, y, d;
};
bool operator<(const ban& a, const ban& b) { return a.d < b.d; }
bool soi(const ban& a, const ban& b) { return a.i < b.i; }
int n, m, q;
ban a[N * N];
int p[N];
int r[N];
vector<pair<int, int> > v;
int first(int x) {
if (p[x] == x) return x;
v.push_back(make_pair(x, p[x]));
return p[x] = first(p[x]);
}
int kpc(int x, int y) {
x = first(x);
y = first(y);
if (x == y) return -1;
v.push_back(make_pair(n + x, r[x]));
v.push_back(make_pair(n + y, r[y]));
r[x] = first(r[x]);
r[y] = first(r[y]);
if (p[r[x]] == y && p[r[y]] == x) return 0;
if (r[x]) {
v.push_back(make_pair(r[x], p[r[x]]));
p[r[x]] = y;
}
if (r[y]) {
v.push_back(make_pair(r[y], p[r[y]]));
p[r[y]] = x;
}
v.push_back(make_pair(n + x, r[x]));
v.push_back(make_pair(n + y, r[y]));
r[x] = y;
r[y] = x;
return 1;
}
vector<int> t[N * N * 2];
void bil(int tl, int tr, int pos) {
if (tl != tr) {
int m = (tl + tr) / 2;
bil(tl, m, pos * 2);
bil(m + 1, tr, pos * 2 + 1);
vector<ban> v;
int j = m + 1;
for (int i = tl; i <= m; ++i) {
while (j <= tr && a[j].d <= a[i].d) v.push_back(a[j++]);
v.push_back(a[i]);
}
while (j <= tr) v.push_back(a[j++]);
for (int i = tl; i <= tr; ++i) a[i] = v[i - tl];
}
for (int i = tr; i >= tl; --i) {
int kk = kpc(a[i].x, a[i].y);
if (kk == -1) {
t[pos].push_back(a[i].i);
break;
} else if (kk == 1) {
t[pos].push_back(a[i].i);
}
}
for (int i = ((int)(v).size()) - 1; i >= 0; --i) {
if (v[i].first <= n)
p[v[i].first] = v[i].second;
else
r[v[i].first - n] = v[i].second;
}
v.clear();
}
vector<ban> u;
void qry(int tl, int tr, int l, int r, int pos) {
if (l > r) return;
if (tl == l && tr == r) {
for (int i = 0; i < ((int)(t[pos]).size()); ++i) u.push_back(a[t[pos][i]]);
return;
}
int m = (tl + tr) / 2;
qry(m + 1, tr, max(m + 1, l), r, pos * 2 + 1);
qry(tl, m, l, min(m, r), pos * 2);
}
void solv() {
cin >> n >> m >> q;
for (int i = 1; i <= m; ++i) {
a[i].i = i;
cin >> a[i].x >> a[i].y >> a[i].d;
}
for (int i = 1; i <= n; ++i) {
p[i] = i;
}
bil(1, m, 1);
sort(a + 1, a + m + 1, soi);
for (int i = 1; i <= q; ++i) {
int L, R;
cin >> L >> R;
u.clear();
qry(1, m, L, R, 1);
sort((u).begin(), (u).end());
int ans = -1;
for (int j = ((int)(u).size()) - 1; j >= 0; --j) {
if (kpc(u[j].x, u[j].y) == -1) {
ans = u[j].d;
break;
}
}
for (int i = ((int)(v).size()) - 1; i >= 0; --i) {
if (v[i].first <= n)
p[v[i].first] = v[i].second;
else
r[v[i].first - n] = v[i].second;
}
v.clear();
cout << ans << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int tt = 1;
while (tt--) {
solv();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int t = 1, sum = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') sum = sum * 10 + ch - '0', ch = getchar();
return t * sum;
}
const int _N = 1e3 + 10, _M = 5e5 + 10;
int fa[_N], col[_N], n, m, ans, Ans;
struct edge {
int u, v, w;
void init() {
fa[u] = u;
fa[v] = v;
col[u] = col[v] = 0;
}
} _e[_M];
vector<edge> E[_M << 2], ans1, ans2;
int find_fa(int x) {
if (fa[x] == x) return x;
int F = find_fa(fa[x]);
col[x] ^= col[fa[x]];
return fa[x] = F;
}
int make_tg(int u, int v) {
int x = find_fa(u), y = find_fa(v);
if (x == y)
if (col[u] == col[v])
return 2;
else
return 0;
col[x] ^= col[u] ^ 1 ^ col[v];
fa[x] = y;
return 1;
}
void merge(vector<edge> &a, vector<edge> &b, vector<edge> &c) {
edge now;
c.clear();
int i, j, k;
for (i = 0; i < a.size(); i++) a[i].init();
for (i = 0; i < b.size(); i++) b[i].init();
i = j = 0;
while (i < a.size() || j < b.size()) {
if (i < a.size() && (j == b.size() || a[i].w > b[j].w))
now = a[i++];
else
now = b[j++];
k = make_tg(now.u, now.v);
if (k) {
c.push_back(now);
if (k == 2) {
ans = now.w;
break;
}
}
}
}
void build(int o, int l, int r) {
if (l == r) {
E[o].push_back(_e[l]);
return;
}
int mid = l + r >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
merge(E[o << 1], E[o << 1 | 1], E[o]);
}
void query(int o, int l, int r, int L, int R) {
if (L <= l && r <= R) {
if (r == R) ans = -1;
merge(ans1, E[o], ans2), swap(ans1, ans2);
if (r == R) Ans = ans;
return;
}
int mid = l + r >> 1;
if (L <= mid) query(o << 1, l, mid, L, R);
if (R > mid) query(o << 1 | 1, mid + 1, r, L, R);
}
int main() {
int i, x, y, Q;
n = read();
m = read();
Q = read();
for (i = 1; i <= m; i++) _e[i].u = read(), _e[i].v = read(), _e[i].w = read();
build(1, 1, m);
while (Q--) {
x = read();
y = read();
ans1.clear();
ans2.clear();
query(1, 1, m, x, y);
printf("%d\n", Ans);
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, q;
int u[(1 << 20)], v[(1 << 20)], w[(1 << 20)];
std::vector<int> edges[(1 << 20) << 1];
int ans;
int colr[(1010)], fa[(1010)], sz[(1010)];
int getfather(int x) {
if (x == fa[x]) return x;
int p = getfather(fa[x]);
colr[x] ^= colr[fa[x]];
return fa[x] = p;
}
bool union_set(int u, int v) {
int fu = getfather(u), fv = getfather(v);
if (fu == fv) return false;
if (sz[fu] > sz[fv]) std::swap(fu, fv);
int p = (colr[u] == colr[v]);
colr[fu] ^= p;
sz[fv] += sz[fu];
fa[fu] = fv;
return true;
}
std::vector<int> merge(std::vector<int> &A, std::vector<int> &B) {
int i = 0, j = 0;
std::vector<int> tmp;
while (i < A.size() && j < B.size()) {
tmp.push_back(w[A[i]] > w[B[j]] ? A[i++] : B[j++]);
}
while (i < A.size()) tmp.push_back(A[i++]);
while (j < B.size()) tmp.push_back(B[j++]);
std::vector<int> rt;
ans = -1;
for (auto e : tmp) {
colr[u[e]] = colr[v[e]] = 0;
fa[u[e]] = u[e];
fa[v[e]] = v[e];
sz[u[e]] = sz[v[e]] = 1;
}
for (auto e : tmp) {
if (union_set(u[e], v[e]))
rt.push_back(e);
else if (ans == -1 && colr[u[e]] == colr[v[e]]) {
ans = w[e];
rt.push_back(e);
break;
}
}
return rt;
}
void build() {
for (int i = ((1 << 20) << 1) - 1; i; --i) {
if (i >= (1 << 20)) {
if ((1 << 20) + m - 1 >= i) {
edges[i].push_back(i - (1 << 20) + 1);
}
} else {
edges[i] = merge(edges[i << 1], edges[(i << 1) + 1]);
}
}
}
int query(int l, int r) {
l += (1 << 20) - 1;
r += (1 << 20);
std::vector<int> es;
for (; l < r; l >>= 1, r >>= 1) {
if (l % 2) es = merge(es, edges[l++]);
if (r % 2) es = merge(es, edges[r - 1]);
}
printf("\n");
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", u + i, v + i, w + i);
}
build();
for (int i = 1; i <= q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", query(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, w, id;
Edge() {}
Edge(int _u, int _v, int _w, int _id) : u(_u), v(_v), w(_w), id(_id) {}
inline bool operator<(const Edge &rhs) const { return w > rhs.w; }
};
vector<Edge> e;
int n, m, q, l, r, f[2005], rnk[2005];
inline int gf(int x) { return x == f[x] ? x : f[x] = gf(f[x]); }
inline void merge(int x, int y) {
x = gf(x), y = gf(y);
if (x == y) return;
if (rnk[x] < rnk[y])
f[x] = y;
else {
f[y] = x;
if (rnk[x] == rnk[y]) rnk[x]++;
}
}
inline int query() {
for (int i = 1; i <= n + n; i++) {
f[i] = i;
rnk[i] = 0;
}
for (unsigned i = 0; i < e.size(); i++) {
if (e[i].id < l || e[i].id > r) continue;
int u = e[i].u, v = e[i].v, fu = gf(u), fv = gf(v);
if (fu != fv) {
merge(u, v + n);
merge(v, u + n);
} else
return e[i].w;
}
return -1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1, x, y, z; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
e.push_back(Edge(x, y, z, i));
}
sort(e.begin(), e.end());
while (q--) {
scanf("%d%d", &l, &r);
printf("%d\n", query());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5, M = 1e6 + 6;
int p[N], n, m, q, u[M], v[M], w[M], id[M], color[N];
int find(int x) {
if (p[x] < 0) return x;
int bef = p[x];
p[x] = find(p[x]);
color[x] ^= color[bef];
return p[x];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", u + i, v + i, w + i);
u[i]--;
v[i]--;
id[i] = i;
}
sort(id, id + m, [](int x, int y) { return w[x] > w[y]; });
while (q--) {
memset(p, -1, sizeof p);
memset(color, 0, sizeof color);
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
int ans = -1;
for (int i = 0; i < m; i++) {
if (id[i] < l || id[i] > r) continue;
int x = u[id[i]], y = v[id[i]];
int px = find(x), py = find(y);
if (px == py) {
if (color[x] == color[y]) {
ans = w[id[i]];
break;
} else
continue;
}
if (p[px] > p[py]) swap(px, py);
p[px] += p[py];
p[py] = px;
color[py] = (color[x] == color[y]);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
struct node {
int from, to, val;
int id;
} edge[1002 * 1002];
int fa[1002 * 1002];
inline int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
inline void uni(int x, int y) {
if (getfa(x) != getfa(y)) fa[getfa(x)] = getfa(y);
}
inline bool cmp(node x, node y) { return x.val > y.val; }
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
edge[i].from = u;
edge[i].id = i;
edge[i].to = v;
edge[i].val = w;
}
sort(edge + 1, edge + m + 1, cmp);
for (int i = 1; i <= q; i++) {
int l, r, ans = -1;
cin >> l >> r;
for (int i = 1; i <= n * n; i++) fa[i] = i;
for (int j = 1; j <= m; j++) {
if (edge[j].id >= l && edge[j].id <= r) {
if (getfa(edge[j].from) == getfa(edge[j].to)) {
ans = edge[j].val;
break;
} else {
uni(edge[j].from, edge[j].to + n);
uni(edge[j].from + n, edge[j].to);
}
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 1000, maxq = 1000;
const int maxm = 500000;
struct edge {
int first, second, w, id;
edge() {}
edge(int _x, int _y, int _w) : first(_x), second(_y), w(_w) {}
friend bool operator<(const edge &first, const edge &second) {
return first.w > second.w;
}
};
int n, m, qn;
edge e[maxm + 5];
int fa[maxn + 5], col[maxn + 5];
int get(int first) {
if (fa[first] == first) return first;
int tmp = get(fa[first]);
col[first] ^= col[fa[first]];
return fa[first] = tmp;
}
int main() {
scanf("%d%d%d", &n, &m, &qn);
for (int i = (0), i_end_ = (m); i < i_end_; ++i)
scanf("%d%d%d", &e[i].first, &e[i].second, &e[i].w), --e[i].first,
--e[i].second, e[i].id = i;
sort(e, e + m);
for (int i = (0), i_end_ = (qn); i < i_end_; ++i) {
int u, v;
scanf("%d%d", &u, &v), --u;
for (int j = (0), j_end_ = (n); j < j_end_; ++j) fa[j] = j, col[j] = 0;
int ret = -1;
for (int j = (0), j_end_ = (m); j < j_end_; ++j)
if (e[j].id >= u && e[j].id < v) {
int first = e[j].first, second = e[j].second;
if (get(first) != get(second)) {
int u = get(first), v = get(second);
col[u] ^= col[first] ^ col[second] ^ 1;
fa[u] = v;
} else if (col[first] == col[second]) {
ret = e[j].w;
break;
}
}
printf("%d\n", ret);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
struct EDGE {
int u, v, c, num;
bool operator<(const EDGE &t) const { return c > t.c; }
} e[N * N];
int n, m, q;
struct VALSET {
int c[N], fa[N];
void init() {
for (int i = 1; i <= n; i++) fa[i] = i, c[i] = 0;
}
int finds(int u) {
if (u == fa[u]) return u;
int o = finds(fa[u]);
c[u] = c[u] ^ c[fa[u]];
return fa[u] = o;
}
bool join(int u, int v) {
int fu = finds(u);
int fv = finds(v);
if (fu == fv && c[u] == c[v]) return 0;
fa[fu] = fv;
c[fu] = c[u] ^ c[v] ^ 1;
return 1;
}
} Valset;
void read_graph() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].c), e[i].num = i;
}
void solve() {
sort(e + 1, e + m + 1);
while (q--) {
int l, r;
bool flag = 0;
Valset.init();
scanf("%d%d", &l, &r);
for (int i = 1; i <= m; i++)
if (e[i].num >= l && e[i].num <= r)
if (!Valset.join(e[i].u, e[i].v)) {
printf("%d\n", e[i].c);
flag = 1;
break;
}
if (!flag) printf("-1\n");
}
}
int main() {
read_graph();
solve();
return 0;
}
|
#include <bits/stdc++.h>
namespace XX {
template <typename... Datas>
class UnionFind {
public:
struct Node : public Datas... {
int _parent = -1;
int size() { return -_parent; }
void operator+=(Node& other) {
int dummy[] = {(Datas::operator+=(other), 0)...};
}
};
UnionFind(int size) : _data(size) {}
Node& operator[](int idx) { return _data[(*this)(idx)]; }
int operator()(int n) {
if (_data[n]._parent < 0)
return n;
else
return _data[n]._parent = (*this)(_data[n]._parent);
}
bool operator()(int a, int b) {
int pa = (*this)(a), pb = (*this)(b);
if (pa == pb)
return false;
else {
if (_data[pa]._parent == _data[pb]._parent)
_data[pa]._parent--;
else if (_data[pa]._parent > _data[pb]._parent)
std::swap(pa, pb);
_data[pa] += _data[pb];
_data[pb]._parent = pa;
return true;
}
}
private:
std::vector<Node> _data;
};
} // namespace XX
template <typename T>
struct ScanfSpecifier {};
template <>
struct ScanfSpecifier<int> {
static constexpr const char* value = "%d";
};
template <>
struct ScanfSpecifier<double> {
static constexpr const char* value = "%lf";
};
template <>
struct ScanfSpecifier<float> {
static constexpr const char* value = "%f";
};
template <>
struct ScanfSpecifier<char> {
static constexpr const char* value = "%c";
};
template <>
struct ScanfSpecifier<const char*> {
static constexpr const char* value = "%s";
};
template <>
struct ScanfSpecifier<unsigned long> {
static constexpr const char* value = "%lu";
};
template <>
struct ScanfSpecifier<char*> {
static constexpr const char* value = "%s";
};
template <>
struct ScanfSpecifier<unsigned int> {
static constexpr const char* value = "%u";
};
template <>
struct ScanfSpecifier<long long int> {
static constexpr const char* value = "%lld";
};
template <typename T>
int RD(T& arg) {
return std::scanf(ScanfSpecifier<T>::value, &arg);
}
template <int S>
int RD(char (&arg)[S]) {
return std::scanf("%s", arg);
}
template <>
int RD<char*>(char*& arg) {
return std::scanf("%s", arg);
}
template <>
int RD<char>(char& arg) {
return std::scanf(" %c", &arg);
}
template <typename T, typename... Args>
int RD(T& arg1, Args&... args) {
return RD(arg1) + RD(args...);
}
template <typename T>
T RD() {
T ret;
RD(ret);
return ret;
}
template <typename It>
void RDV(It begin, It end) {
while (begin != end) RD(*begin++);
}
template <typename C>
void RDV(C& c) {
RDV(std::begin(c), std::end(c));
}
template <typename... Args>
void WT(Args... args) {
int alc = 0;
int dummy[] = {((alc++ ? std::printf(" ") : 0),
std::printf(ScanfSpecifier<Args>::value, args), 0)...};
}
template <typename... Args>
void WTL(Args... args) {
WT(args...);
std::printf("\n");
}
template <typename It>
void WTV(It begin, It end) {
int alc = 0;
while (begin != end) (alc++ ? std::printf(" ") : 0), WT(*begin++);
}
template <typename C>
void WTV(const C& c) {
WTV(std::begin(c), std::end(c));
}
template <typename It>
void WTVL(It begin, It end) {
WTV(begin, end);
std::printf("\n");
}
template <typename C>
void WTVL(const C& c) {
WTVL(std::begin(c), std::end(c));
}
namespace XX {
template <template <typename> class Compare, typename T>
inline T& UP(T& x, const T& y) {
if (Compare<T>()(y, x)) x = y;
return x;
}
template <typename Compare, typename T>
inline T& UP(T& x, const T& y, Compare comp) {
if (comp(y, x)) x = y;
return x;
}
template <typename T>
inline T& GT(T& x, const T& y) {
return UP<std::greater>(x, y);
}
template <typename T>
inline T& LS(T& x, const T& y) {
return UP<std::less>(x, y);
}
template <typename T>
struct Mapper {
int operator[](const T& v) {
int& ret = table[v];
if (!ret) rtable[ret = table.size()] = v;
return ret - 1;
}
template <typename... Args>
int operator()(Args... args) {
return (*this)[T(args...)];
}
T rev(int idx) { return rtable[idx + 1]; }
std::map<T, int> table;
std::map<int, T> rtable;
};
template <typename T, int S>
struct ReferenceArray {
struct It {
typename std::array<T*, S>::iterator it;
T& operator*() { return **it; }
void operator++() { it++; }
bool operator!=(const It& other) { return it != other.it; }
};
int size() const { return _ptr.size(); }
It begin() const { return {_ptr.begin()}; }
It end() const { return {_ptr.end()}; }
T& operator[](int idx) const { return *_ptr[idx]; }
mutable std::array<T*, S> _ptr;
};
template <typename T, typename... Args>
ReferenceArray<T, sizeof...(Args) + 1> MAKEV(T& arg1, Args&... args) {
return {&arg1, &args...};
}
struct Range {
struct It {
int num, step;
int operator*() { return num; }
void operator++() { num += step; }
bool operator!=(const It& other) { return num != other.num; }
};
Range(int ee) : b(0), e(ee) {}
Range(int bb, int ee) : b(bb), e(ee) {}
It begin() { return {b, (b < e ? 1 : -1)}; }
It end() { return {e, 0}; }
int b, e;
};
} // namespace XX
template <typename... Datas>
using UF = XX::UnionFind<Datas...>;
template <typename T>
T& UMAX(T& x, T y) {
return XX::UP<std::greater>(x, y);
}
template <typename T>
T& UMIN(T& x, T y) {
return XX::UP<std::less>(x, y);
}
using XX::UP;
using RG = XX::Range;
using XX::MAKEV;
using XX::Mapper;
using namespace std;
const int E = 2000009;
const int V = 1009;
int N, M, Q;
struct Edge {
int idx;
int u, v;
int w;
bool operator<(const Edge& other) const { return w > other.w; }
} es[E];
Edge buf[E];
struct Data {
unsigned long long ch[16] = {};
int amt = 1;
void operator+=(Data& other) {
for (int i = 0; i < 16; i++) ch[i] |= other.ch[i];
amt += other.amt;
}
};
int main() {
RD(N, M, Q);
for (int i = 1; i <= M; i++) {
es[i].idx = i;
RD(es[i].u, es[i].v, es[i].w);
es[i].u--;
es[i].v--;
}
sort(es + 1, es + M + 1);
while (Q--) {
int l, r;
RD(l, r);
int total = 0;
for (int i = 1; i <= M; i++)
if (l <= es[i].idx && es[i].idx <= r) buf[total++] = es[i];
UF<Data> uf(N);
bool pass[V] = {};
int ans = -1;
unsigned long long color[16] = {};
for (int i = 0; i < N; i++) uf[i].ch[i >> 6] |= 1ll << (i & 63);
auto getc = [&](int u) -> bool {
return color[u >> 6] & (1ll << (u & 63));
};
auto setc = [&](int u, int b) {
if (b)
color[u >> 6] |= 1ll << (u & 63);
else
color[u >> 6] &= ~(1ll << (u & 63));
};
for (int i = 0; i < total; i++) {
int u = buf[i].u, v = buf[i].v;
if (pass[v]) swap(u, v);
if (!pass[u]) {
setc(u, 0);
setc(v, 1);
uf(u, v);
} else if (!pass[v]) {
setc(v, !getc(u));
uf(u, v);
} else if (getc(u) != getc(v))
uf(u, v);
else if (uf(u) == uf(v)) {
ans = buf[i].w;
break;
} else {
for (int i = 0; i < 16; i++) color[i] ^= uf[u].ch[i];
uf(u, v);
}
pass[u] = pass[v] = true;
}
WTL(ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, w, idx;
inline bool operator<(const edge &a) const { return w > a.w; }
} arr[1000005];
int fa[1005], bit[1005];
int getfa(int u) {
if (u == fa[u]) return u;
int res = getfa(fa[u]);
bit[u] ^= bit[fa[u]];
fa[u] = res;
return fa[u] = res;
}
inline bool unite(int u, int v) {
int x = getfa(u), y = getfa(v);
if (x == y) return bit[u] != bit[v];
fa[x] = y;
bit[x] = bit[u] ^ bit[v] ^ 1;
return true;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &arr[i].u, &arr[i].v, &arr[i].w);
arr[i].u--;
arr[i].v--;
arr[i].idx = i;
}
sort(arr, arr + m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
for (int i = 0; i < n; i++) {
fa[i] = i;
bit[i] = 0;
}
bool f = false;
for (int i = 0; i < m && !f; i++) {
if (arr[i].idx < l || arr[i].idx > r) continue;
if (!unite(arr[i].u, arr[i].v)) {
printf("%d\n", arr[i].w);
f = true;
}
}
if (!f) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
void debug(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
struct Edge {
int u, v, w, idx;
inline bool operator<(const Edge& o) const { return w > o.w; }
};
const int N = 1010;
int par[N];
int opp[N];
int get(int n) {
if (par[n] != n) {
par[n] = get(par[n]);
}
return par[n];
}
inline void merge(int u, int v) {
u = get(u), v = get(v);
if (u == v) {
return;
}
if (rand() & 1) {
par[v] = u;
} else {
par[u] = v;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
vector<Edge> edge(m);
for (int i = 0; i < (m); ++i) {
cin >> edge[i].u >> edge[i].v >> edge[i].w;
--edge[i].u, --edge[i].v;
edge[i].idx = i;
}
sort(edge.begin(), edge.end());
while (q--) {
int l, r;
cin >> l >> r;
--l, --r;
for (int i = 0; i < (n); ++i) {
par[i] = i;
opp[i] = -1;
}
int ans = -1;
for (Edge e : edge) {
if (e.idx >= l and e.idx <= r) {
int u = get(e.u), v = get(e.v);
if (u == v) {
ans = e.w;
break;
}
if (opp[u] != -1) {
merge(opp[u], v);
} else {
opp[u] = v;
}
if (opp[v] != -1) {
merge(opp[v], u);
} else {
opp[v] = u;
}
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int maxn = 1000 + 10, maxm = 1e6 + 100;
int n, m, q;
struct DSU {
int par[maxn], mx = -1;
bool c[maxn];
vector<pair<int, int> > v;
DSU() { fill(par, par + maxn, -1); }
int root(int x) { return par[x] < 0 ? x : root(par[x]); }
bool xr(int x) { return par[x] < 0 ? 0 : c[x] ^ xr(par[x]); }
bool dis(int x, int y) { return xr(x) ^ xr(y); }
bool merge(int x, int y, int w) {
int xp = x, yp = y;
x = root(x);
y = root(y);
bool cy = 1 ^ dis(x, xp) ^ dis(y, yp);
if (x == y) {
if (dis(xp, yp) == 0) {
mx = max(mx, w);
}
return 0;
}
if (-par[x] < -par[y]) swap(x, y);
v.push_back({y, par[y]});
par[x] += par[y];
par[y] = x;
c[y] = cy;
return 1;
}
void undo() {
if (v.size() == 0) return;
pair<int, int> p = v.back();
v.pop_back();
int y = p.first, x = par[y];
c[y] = 0;
par[y] = p.second;
par[x] -= par[y];
}
void reset() {
while (v.size()) {
undo();
}
mx = -1;
}
} dsu;
struct edge {
int a, b, w;
} e[maxm];
struct Segment {
vector<int> S[maxm << 2];
int mx[maxm << 2];
void merge(vector<int>& v, vector<int>& vl, vector<int>& vr) {
dsu.reset();
int pos[2] = {0, 0}, size[2] = {int(vl.size()), int(vr.size())};
for (int i = 0; i < size[0] + size[1]; i++) {
int x = 0;
if (pos[0] == size[0]) {
x = vr[pos[1]];
pos[1]++;
} else if (pos[1] == size[1]) {
x = vl[pos[0]];
pos[0]++;
} else {
if (e[vl[pos[0]]].w > e[vr[pos[1]]].w) {
x = vl[pos[0]];
pos[0]++;
} else {
x = vr[pos[1]];
pos[1]++;
}
}
if (dsu.merge(e[x].a, e[x].b, e[x].w)) {
v.push_back(x);
}
}
}
void Build(int id = 1, int l = 0, int r = m) {
if (r - l == 1) {
S[id].push_back(l);
mx[id] = -1;
return;
}
int mid = (l + r) >> 1;
Build(id << 1, l, mid);
Build(id << 1 | 1, mid, r);
merge(S[id], S[id << 1], S[id << 1 | 1]);
mx[id] = max(dsu.mx, max(mx[id << 1], mx[id << 1 | 1]));
}
vector<int> v[2];
int now = 1, pre = 0, ans = -1;
void get(int L, int R, int id = 1, int l = 0, int r = m) {
if (L >= r || R <= l) return;
if (L <= l && R >= r) {
swap(now, pre);
v[now].clear();
merge(v[now], v[pre], S[id]);
ans = max(ans, max(dsu.mx, mx[id]));
return;
}
int mid = (l + r) >> 1;
get(L, R, id << 1, l, mid);
get(L, R, id << 1 | 1, mid, r);
}
} seg;
int32_t main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &e[i].a, &e[i].b, &e[i].w);
e[i].a--;
e[i].b--;
}
seg.Build();
for (int i = 0; i < q; i++) {
seg.ans = -1;
int l, r;
scanf("%d%d", &l, &r);
l--;
seg.v[0].clear();
seg.v[1].clear();
seg.get(l, r);
printf("%d\n", seg.ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
pair<pair<int, int>, pair<int, int> > s[1 << 20];
int f[1 << 11];
int get(int k) { return k == f[k] ? k : f[k] = get(f[k]); }
int main(void) {
srand(time(0));
cout << fixed << setprecision(7);
cerr << fixed << setprecision(7);
int n, m, q;
ios_base ::sync_with_stdio(0);
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
for (int i = 1; i <= m; ++i) {
scanf("%d", &s[i].second.first);
scanf("%d", &s[i].second.second);
scanf("%d", &s[i].first.first);
s[i].first.second = i;
}
sort(s + 1, s + 1 + m);
reverse(s + 1, s + 1 + m);
for (int qwerty = 1; qwerty <= q; ++qwerty) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
for (int i = 1; i <= n + n + 1; ++i) f[i] = i;
int ans = -1;
for (int i = 1; i <= m && ans == -1; ++i)
if (l <= s[i].first.second && s[i].first.second <= r)
if (get(s[i].second.first << 1) == get(s[i].second.second << 1))
ans = s[i].first.first;
else {
f[get(s[i].second.first << 1)] = get(s[i].second.second << 1 | 1);
f[get(s[i].second.first << 1 | 1)] = get(s[i].second.second << 1);
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, l, r, fa[1010 * 2];
struct ma {
int u, v, c, num;
} e[1010 * 1010];
bool operator<(ma p, ma q) { return p.c > q.c; }
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void doit() {
for (int i = 1; i <= n * 2; i++) fa[i] = i;
scanf("%d%d", &l, &r);
for (int i = 1; i <= m; i++)
if (e[i].num >= l && e[i].num <= r) {
int u = e[i].u, v = e[i].v;
if (find(u) != find(v + n)) fa[find(u)] = find(v + n);
if (find(v) != find(u + n)) fa[find(v)] = find(u + n);
if (find(u) == find(u + n)) {
printf("%d\n", e[i].c);
return;
}
}
puts("-1");
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].c), e[i].num = i;
sort(e + 1, e + m + 1);
while (q--) doit();
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1012;
const int Q = 1e9 + 7;
pair<int, int> pr[M];
int inv[M];
pair<pair<int, int>, pair<int, int> > e[M * M];
pair<int, int> get(int v) {
if (v == pr[v].first) return make_pair(v, inv[v]);
auto res = get(pr[v].first);
return pr[v] = make_pair(res.first, res.second ^ pr[v].second);
}
bool un(int a, int b) {
auto ai = get(a);
auto bi = get(b);
if (ai.first == bi.first) {
return ai.second != bi.second;
}
if (ai.second == bi.second) inv[ai.first] ^= 1;
pr[ai.first] = make_pair(bi.first, inv[ai.first]);
return true;
}
int main() {
srand(time(NULL));
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int s, f, w;
cin >> s >> f >> w;
e[i] = make_pair(make_pair(-w, i + 1), make_pair(s, f));
}
sort(e, e + m);
for (int it = 0; it < q; it++) {
int l, r;
cin >> l >> r;
for (int i = 1; i <= n; i++) pr[i] = make_pair(i, 0), inv[i] = 0;
int ans = -1;
for (int i = 0; i < m; i++) {
if (l <= e[i].first.second && e[i].first.second <= r) {
if (!un(e[i].second.first, e[i].second.second)) {
ans = -e[i].first.first;
break;
}
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const long long INF64 = 1e18;
const double EPS = 1e-9;
const double PI = acos(-1);
const long long MD = 1551513443;
const long long T = 25923;
const int N = 1000100;
const int M = 1001;
struct st {
int v, u, w, ind;
st() { v = u = w = ind = 0; }
st(int vv, int uu, int ww, int ii) {
v = vv;
u = uu;
w = ww;
ind = ii;
}
} e[N];
bool operator<(st a, st b) { return a.w < b.w; }
int n, m, q, rr[M], b[N];
pair<int, int> p[M];
inline pair<int, int> get(int v) {
b[0] = v;
int j = -1;
for (int ii = 0; b[ii] != p[b[ii]].first; ii++) {
j = ii;
b[ii + 1] = p[b[ii]].first;
}
for (int ii = j; ii >= 0; ii--) {
p[b[ii]].second ^= p[b[ii + 1]].second;
p[b[ii]].first = p[b[ii + 1]].first;
}
return p[b[0]];
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < int(m); i++) {
int v, u, w;
scanf("%d %d %d", &v, &u, &w);
e[i] = st(v, u, w, i);
}
sort(e, e + m);
reverse(e, e + m);
int ans, v, u, first, second, j;
pair<int, int> vv, uu;
for (int u1 = 0; u1 < int(q); u1++) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
ans = -1;
for (int i = 0; i < int(M); i++) {
p[i] = make_pair(i, 0);
rr[i] = 0;
}
for (int i = 0; i < int(m); i++)
if (e[i].ind >= l && e[i].ind <= r) {
b[0] = e[i].v;
j = -1;
for (int ii = 0; b[ii] != p[b[ii]].first; ii++) {
j = ii;
b[ii + 1] = p[b[ii]].first;
}
for (int ii = j; ii >= 0; ii--) {
p[b[ii]].second ^= p[b[ii + 1]].second;
p[b[ii]].first = p[b[ii + 1]].first;
}
vv = p[b[0]];
uu = get(e[i].u);
first = vv.second;
v = vv.first;
second = uu.second;
u = uu.first;
if (v == u) {
if (first == second) {
ans = e[i].w;
break;
}
} else {
if (rr[u] > rr[v]) swap(v, u);
p[u] = make_pair(v, first ^ second ^ 1);
if (rr[v] == rr[u]) rr[v]++;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, l, r;
int fa[1100], dis[1100];
struct edge {
int x, y, v, pos;
friend bool operator<(const edge &r1, const edge &r2) { return r1.v < r2.v; };
} a[1100 * 1100];
int find(int x) {
if (fa[x] == x) return x;
int t = find(fa[x]);
dis[x] += dis[fa[x]];
return fa[x] = t;
}
int check(int x, int y) {
if (find(x) == find(y)) return (dis[x] + dis[y]) & 1;
int t = find(x);
fa[t] = find(y);
dis[t] = 1 - (dis[x] + dis[y]) % 2;
return 1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].v);
a[i].pos = i;
}
sort(a + 1, a + 1 + m);
while (q--) {
scanf("%d%d", &l, &r);
int flag = 0;
for (int i = 1; i <= n; i++) fa[i] = i;
memset(dis, 0, sizeof(dis));
for (int i = m; i; i--)
if (a[i].pos >= l && a[i].pos <= r) {
if (!check(a[i].x, a[i].y)) {
printf("%d\n", a[i].v);
flag = 1;
break;
}
}
if (!flag) puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
int sz(const T &a) {
return int(a.size());
}
const int MAXN = 1e6 + 1;
pair<int, pair<pii, int>> edges[MAXN];
pair<pii, bool> dsu[MAXN];
int find(int a) {
if (dsu[a].first.first == a) return a;
int rt = find(dsu[a].first.first);
dsu[a].second = !(dsu[a].second ^ dsu[dsu[a].first.first].second);
return dsu[a].first.first = rt;
}
bool sameasparent(int a) {
find(a);
return dsu[a].second;
}
bool uni(int a, int b) {
int ap = find(a), bp = find(b);
if (ap == bp) return false;
if (dsu[ap].first.second < dsu[bp].first.second) swap(ap, bp);
dsu[bp].second = sameasparent(a) ^ sameasparent(b);
dsu[ap].first.second += dsu[bp].first.second;
dsu[bp].first.first = ap;
return true;
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, q, m;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> edges[i].second.first.first >> edges[i].second.first.second >>
edges[i].first,
edges[i].second.second = i;
}
sort(edges + 1, edges + m + 1);
int l, r;
while (q--) {
cin >> l >> r;
for (int i = 1; i <= n; i++) dsu[i] = {{i, 1}, 1};
int ans = -1;
for (int i = m; i >= 1; i--) {
if (edges[i].second.second < l || edges[i].second.second > r) continue;
if (!uni(edges[i].second.first.first, edges[i].second.first.second) &&
sameasparent(edges[i].second.first.first) ==
sameasparent(edges[i].second.first.second)) {
ans = edges[i].first;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mul(long long a, long long b) { return (a * b) % (100000007); }
long long add(long long a, long long b) { return (a + b) % (100000007); }
long long sub(long long a, long long b) {
return (a - b + llabs(a - b) / (100000007) * (100000007) + (100000007)) %
(100000007);
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
void upd(long long &a, long long b) {
a = (a % (100000007) + b % (100000007)) % (100000007);
}
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
class bingchaji {
public:
int father[(2000 + 10)], n;
void mem(int _n) {
n = _n;
for (int i = 1; i <= n; i++) father[i] = i;
}
int getfather(int x) {
if (father[x] == x) return x;
return father[x] = getfather(father[x]);
}
void unite(int x, int y) {
father[x] = getfather(father[x]);
father[y] = getfather(father[y]);
father[father[x]] = father[father[y]];
}
bool same(int x, int y) { return getfather(x) == getfather(y); }
} S;
int n, m, q;
vector<pair<int, pair<int, pair<int, int>>>> e;
int main() {
while (cin >> n >> m >> q) {
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
e.push_back(make_pair(w, make_pair(u, make_pair(v, i))));
}
sort((e).begin(), (e).end());
reverse((e).begin(), (e).end());
for (int i = 0; i < q; i++) {
bool b = 0;
int l, r;
cin >> l >> r;
S.mem(2 * n);
for (int i = 0; i < m; i++)
if (l <= e[i].second.second.second && e[i].second.second.second <= r) {
int u = e[i].second.first, v = e[i].second.second.first;
if (S.same(u, v)) {
b = 1;
cout << e[i].first << endl;
break;
} else {
S.unite(u, v + n);
S.unite(u + n, v);
}
}
if (!b) puts("-1");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
struct DSU {
int par[4 * maxn], n;
void init(int n) {
this->n = n;
for (int i = 0; i <= n; i++) {
par[i] = i;
}
}
int find(int x) { return x == par[x] ? x : par[x] = find(par[x]); }
bool merge(int a, int b) {
if (find(a << 1) == find(b << 1)) {
return false;
}
par[find(a << 1)] = find(b << 1 | 1);
par[find(b << 1)] = find(a << 1 | 1);
return true;
}
} dsu;
struct Edge {
int u, v, w, num;
Edge() {}
Edge(int u, int v, int w) : u(u), v(v), w(w) {}
} es[maxn * maxn];
bool cmp(const Edge &a, const Edge &b) { return a.w > b.w; }
int n, m, q;
int main(void) {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &es[i].u, &es[i].v, &es[i].w);
es[i].u--;
es[i].v--;
es[i].num = i + 1;
}
sort(es, es + m, cmp);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
int res = -1;
dsu.init(2 * n);
for (int j = 0; j < m && res == -1; j++) {
if (es[j].num >= l && es[j].num <= r) {
if (!dsu.merge(es[j].u, es[j].v)) {
res = es[j].w;
}
}
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1001, M = 500000;
int n, m, q, fa[N * 2], l, r;
int qr() {
int ans = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-' ? -1 : 1, ch = getchar();
while (isdigit(ch)) ans = ans * 10 + ch - '0', ch = getchar();
return ans * f;
}
struct node {
int x, y, w, num;
} p[M];
bool cmp(node a, node b) { return a.w > b.w; }
int getf(int u) {
if (fa[u] == u)
return u;
else {
fa[u] = getf(fa[u]);
return fa[u];
}
}
void ma(int u, int v) {
int t1 = getf(u), t2 = getf(v);
if (t1 == t2) return;
fa[t1] = t2;
return;
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
p[i].x = qr();
p[i].y = qr();
p[i].w = qr();
p[i].num = i;
}
sort(p + 1, p + 1 + m, cmp);
int ans;
while (q--) {
ans = -1;
l = qr(), r = qr();
for (int i = 1; i <= 2 * n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (p[i].num >= l && p[i].num <= r) {
if (getf(p[i].x) == getf(p[i].y)) {
ans = p[i].w;
break;
} else {
ma(p[i].x, p[i].y + n);
ma(p[i].y, p[i].x + n);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
std::mt19937 engine(42);
struct Edge {
int from, to, weight, index;
Edge() {}
Edge(int from, int to, int weight, int index)
: from(from), to(to), weight(weight), index(index) {}
};
const int max_size = 1000;
int parent[max_size * 2 + 1];
int rank[max_size * 2 + 1];
Edge edges[max_size * max_size];
int find_set(int v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) {
return;
}
if (rank[a] < rank[b]) {
std::swap(a, b);
}
parent[b] = a;
if (rank[a] == rank[b]) {
++rank[a];
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cout.tie(NULL);
int n, m, q;
std::cin >> n >> m >> q;
for (int i = 0; i < m; ++i) {
int from, to, weight;
std::cin >> from >> to >> weight;
from--, to--;
edges[i] = Edge(from, to, weight, i);
}
std::sort(edges, edges + m,
[](Edge a, Edge b) { return a.weight > b.weight; });
for (int query_index = 0; query_index < q; ++query_index) {
int left, right;
std::cin >> left >> right;
for (int i = 0; i < 2 * n; ++i) {
parent[i] = i;
rank[i] = 0;
}
bool flag = false;
for (int i = 0; i < m; ++i) {
Edge edge = edges[i];
if ((edge.index + 1 < left) || (edge.index >= right)) {
continue;
}
int from = edge.from;
int to = edge.to;
int anti_from = from + n;
int anti_to = to + n;
union_sets(from, anti_to);
union_sets(to, anti_from);
if (find_set(anti_to) == find_set(to)) {
flag = true;
std::cout << edge.weight << '\n';
break;
}
}
if (!flag) {
std::cout << -1 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int edges[567567][3];
const int S = 1 << 19;
vector<int> tree[2 * S];
vector<int> out;
pair<int, bool> parent[1234];
void loda() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &edges[i][0], &edges[i][1], &edges[i][2]);
}
}
bool cmp(int i, int j) { return edges[i][2] > edges[j][2]; }
void cleaan() {
for (int i = 1; i <= n; ++i) {
parent[i] = make_pair(0, 0);
}
}
pair<int, bool> finD(int no) {
if (!parent[no].first) {
return make_pair(no, 0);
}
auto tmp = finD(parent[no].first);
parent[no] = make_pair(tmp.first, tmp.second ^ parent[no].second);
return parent[no];
}
int unioN(int n1, int n2) {
auto tmp1 = finD(n1);
auto tmp2 = finD(n2);
if (tmp1.first != tmp2.first) {
parent[tmp1.first] = make_pair(tmp2.first, 1 ^ tmp1.second ^ tmp2.second);
return 1;
} else {
if (tmp1.second != tmp2.second) {
return 3;
} else {
return 2;
}
}
}
int calc(vector<int>& inds) {
sort(inds.begin(), inds.end(), cmp);
cleaan();
out.clear();
for (int i = 0; i < inds.size(); ++i) {
int tmp = unioN(edges[inds[i]][0], edges[inds[i]][1]);
if (tmp == 1) {
out.push_back(inds[i]);
}
if (tmp == 2) {
out.push_back(inds[i]);
return edges[inds[i]][2];
}
}
return -1;
}
void budka(int p, int q, int node) {
vector<int> inds;
for (int i = p; i <= q; ++i) {
if (i < m)
inds.push_back(i);
else
break;
}
calc(inds);
tree[node] = out;
if (p < q) {
int s = (p + q) / 2;
budka(p, s, 2 * node);
budka(s + 1, q, 2 * node + 1);
}
}
void build() { budka(0, S - 1, 1); }
void zbierz(int l, int r, int ll, int rr, int node, vector<int>& inds) {
if (rr < l || r < ll) {
return;
}
if (l <= ll && rr <= r) {
for (int ind : tree[node]) {
inds.push_back(ind);
}
return;
}
int ss = (ll + rr) / 2;
zbierz(l, r, ll, ss, 2 * node, inds);
zbierz(l, r, ss + 1, rr, 2 * node + 1, inds);
}
int query() {
int l, r;
scanf("%d%d", &l, &r);
--l;
--r;
vector<int> inds;
zbierz(l, r, 0, S - 1, 1, inds);
return calc(inds);
}
void debug(int i) {
for (int ind : tree[i]) {
cerr << ind << " ";
}
cerr << endl;
}
int main() {
loda();
build();
for (int i = 0; i < q; ++i) {
printf("%d\n", query());
}
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int a;
scanf("%d", &a);
return a;
}
int gcm(int a, int b) {
if (b > a) return gcm(b, a);
if (a % b == 0)
return b;
else
return gcm(b, a % b);
}
int calc_rev(int x) {
int ret = 0;
while (x) {
int a = x % 10;
ret = ret * 10 + a;
x /= 10;
}
return ret;
}
int rev[100010];
map<pair<int, int>, vector<int> > lucky;
pair<int, int> a_reva(int a) {
int g = gcm(a, rev[a]);
int b = a / g;
int c = rev[a] / g;
return make_pair(b, c);
}
pair<int, int> invert_pint(pair<int, int> t) {
return make_pair(t.second, t.first);
}
int main() {
for (int i = (1); i <= (100000); i++) {
rev[i] = calc_rev(i);
}
for (int i = (1); i <= (100000); i++) {
lucky[a_reva(i)].push_back(i);
}
pair<int, int> ans = make_pair(-1, -1);
long long ans_fact = ((long long)(1001001001) * (1001001001));
int maxx = in();
int maxy = in();
int w = in();
int bar = maxy;
int ltickets = 0;
for (int x = (1); x <= (maxx); x++) {
vector<int> hoge = lucky[invert_pint(a_reva(x))];
int ind =
distance(hoge.begin(), upper_bound(hoge.begin(), hoge.end(), bar));
ltickets += ind;
while (ltickets >= w) {
if ((long long)x * bar < ans_fact) {
ans = make_pair(x, bar);
ans_fact = (long long)x * bar;
}
vector<int> fuga = lucky[invert_pint(a_reva(bar))];
int ind2 =
distance(fuga.begin(), upper_bound(fuga.begin(), fuga.end(), x));
ltickets -= ind2;
bar--;
}
}
if (ans.first == -1) {
puts("-1");
} else {
printf("%d %d\n", ans.first, ans.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, vector<int> > M;
map<pair<int, int>, int> Mcnt;
const long long inf = (long long)1E16;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int rev(int x) {
int y = 0;
while (x) {
y = y * 10 + x % 10;
x /= 10;
}
return y;
}
int main() {
int mx, my, need, i, j, d, tx, ty;
while (~scanf("%d%d%d", &mx, &my, &need)) {
int cur = 0, cx = 1, cy = my;
M.clear();
Mcnt.clear();
for (i = 1; i <= my; i++) {
j = rev(i);
int x = i, y = j;
d = gcd(x, y);
x /= d, y /= d;
M[make_pair(x, y)].push_back(i);
}
long long res = inf;
int rx = -1, ry = -1;
for (; cx <= mx; cx++) {
ty = cx, tx = rev(cx);
d = gcd(tx, ty);
tx /= d, ty /= d;
cur += M[make_pair(tx, ty)].size();
Mcnt[make_pair(tx, ty)]++;
while (cy > 1 && cur >= need) {
int x = cy, y = rev(cy);
d = gcd(x, y);
x /= d, y /= d;
int dd = Mcnt[make_pair(x, y)];
if (cur - dd < need) break;
cur -= dd;
M[make_pair(x, y)].pop_back();
--cy;
}
if (cur >= need) {
long long r0 = (long long)cx * (long long)cy;
if (res > r0) {
res = r0;
rx = cx, ry = cy;
}
}
}
if (res == inf)
printf("-1\n");
else
printf("%d %d\n", rx, ry);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> A, B;
int maxx, maxy;
long long w, ansx = 100001, ansy = 100001;
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int rev(int x) {
int tmp = 0;
while (x) {
tmp = tmp * 10 + x % 10;
x /= 10;
}
return tmp;
}
int main() {
scanf("%d%d%d", &maxx, &maxy, &w);
for (int j = 1; j <= maxy; j++) {
int g = gcd(rev(j), j), revj = rev(j);
B[make_pair(revj / g, j / g)]++;
}
long long cnt = 0;
int j = maxy, i;
for (i = 1; i <= maxx; i++) {
int g = gcd(rev(i), i), revi = rev(i);
pair<int, int> tmp;
tmp = make_pair(i / g, revi / g);
A[tmp]++;
cnt += B[tmp];
while (1) {
int g = gcd(rev(j), j), revj = rev(j);
pair<int, int> tmp;
tmp = make_pair(revj / g, j / g);
if (cnt - A[tmp] < w) break;
cnt -= A[tmp];
B[tmp]--;
j--;
}
if (cnt >= w && (long long)i * j < ansx * ansy) ansx = i, ansy = j;
}
if (ansx <= maxx)
printf("%I64d %I64d\n", ansx, ansy);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
int rev(int num) {
int dig[10], tot = 0, s = 0;
for (; num; num /= 10) dig[tot++] = num % 10;
for (int i = 0; i < tot; i++) s = s * 10 + dig[i];
return s;
}
pair<int, int> p[maxn], r[maxn];
void init() {
for (int i = 1; i <= 100000; i++) {
int re = rev(i);
int g = gcd(re, i);
p[i] = make_pair(i / g, re / g);
r[i] = make_pair(re / g, i / g);
}
}
int main() {
init();
map<pair<int, int>, int> mx, my;
int nx, ny, w;
cin >> nx >> ny >> w;
for (int i = 1; i <= ny; i++) ++my[p[i]];
int x = -1, y = -1;
for (int i = 1, j = ny, k = 0; i <= nx; i++) {
++mx[p[i]];
k += my[r[i]];
while (j > 0 && k >= w) {
if (x == -1 || (long long)x * y > (long long)i * j) {
x = i;
y = j;
}
my[p[j]]--;
k -= mx[r[j]];
j--;
if (k < w) {
j++;
my[p[j]]++;
k += mx[r[j]];
break;
}
}
}
if (x == -1) {
puts("-1");
} else {
printf("%d %d\n", x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> re, r;
bool ire[110000];
template <class typ>
struct BIT {
vector<typ> x;
BIT(int n) : x(n, 0) {}
typ sum(int a, int b) {
if (a == 0) {
typ s = 0;
for (int i = b; i >= 0; i = (i & (i + 1)) - 1) s += x[i];
return s;
} else
return sum(0, b) - sum(0, a - 1);
}
void add(int ind, typ f) {
for (int i = ind; i < x.size(); i |= i + 1) x[i] += f;
}
};
int gcd(int m, int n) {
int a = max(m, n), b = min(m, n);
if (m == 0) return n;
if (n == 0) return m;
if (a % b == 0) return b;
return gcd(b, a - b * (a / b));
}
int rev(int a) {
int ret = 0;
while (a > 0) {
ret = ret * 10 + a % 10;
a /= 10;
}
return ret;
}
int main() {
BIT<int> bit(110000);
long long inf = 1000000000000LL, ma = inf, outx = -1, outy = -1, ny, i, j,
maxx, maxy, w;
cin >> maxx >> maxy >> w;
ny = maxy;
memset(ire, false, sizeof(ire));
re.push_back(0);
for (i = 1; i < 110000; i++) re.push_back(rev(i));
for (i = 1; i < re.size(); i++) {
if (i == re[i]) {
r.push_back(i);
ire[i] = true;
}
}
for (i = 1; i <= maxx; i++) {
if (ire[i]) {
for (j = 0; j < r.size(); j++) bit.add((int)r[j], 1);
} else {
int g = gcd(i, re[i]);
for (j = 1; j * re[i] / g <= maxy; j++) {
if (re[j * re[i] / g] == j * i / g) bit.add((int)(j * re[i] / g), 1);
}
}
while (bit.sum(0, ny - 1) >= w) ny--;
if (bit.sum(0, ny) >= w && i * ny <= ma) {
ma = i * ny;
outx = i;
outy = ny;
}
}
if (ma >= inf)
cout << "-1" << endl;
else
cout << outx << ' ' << outy << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926535897932384626433832795;
int const inf = (int)1e9;
long long const inf64 = (long long)2e18;
const string name = "c";
int maxx, maxy, w, calc[100010], pal[100010];
vector<int> ans[100010], qqq[100010];
int rev(int n) {
int res = 0;
while (n > 0) {
res = res * 10 + n % 10;
n /= 10;
}
return res;
}
int find(int w) {
int d = 2, ww = calc[w];
while (d * d <= w) {
while (w % d == 0) {
if (ww % d == 0) ww /= d;
w /= d;
}
d++;
}
if (ww % w == 0) ww /= w;
return ww;
}
int main() {
cin >> maxx >> maxy >> w;
for (int i = 0; i < (int)max(maxx, maxy) + 1; i++) calc[i] = rev(i);
memset(pal, 0, sizeof(pal));
for (int i = 0; i < (int)max(maxx, maxy) + 1; i++)
if (calc[i] == i) pal[i] = 1;
int now, st;
for (int i = 1; i <= maxx; ++i) {
st = find(i);
now = st;
while (now <= maxy) {
if ((long long)i * now == (long long)calc[i] * calc[now])
ans[i].push_back(now), qqq[now].push_back(i);
now += st;
}
}
long long ansx = 100001, ansy = 100001, lvl = 1;
now = 0;
for (int i = maxx; i >= 1; i--) {
while (lvl <= maxy && now < w) now += qqq[lvl++].size();
if (now >= w && (long long)i * (lvl - 1) < ansx * ansy)
ansx = i, ansy = lvl - 1;
for (int j = 0; j < (int)ans[i].size(); j++) {
if (ans[i][j] < lvl) now--;
qqq[ans[i][j]].resize(qqq[ans[i][j]].size() - 1);
}
}
if (ansx > maxx)
cout << -1 << endl;
else
cout << ansx << " " << ansy << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 12345678987654321LL;
const int MAXN = 100100;
pair<int, int> r[MAXN];
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
inline int rev(int x) {
int r = 0;
while (x > 0) {
r = r * 10 + x % 10;
x /= 10;
}
return r;
}
pair<int, int> inv(pair<int, int> &p) { return make_pair(p.second, p.first); }
void init() {
for (int i = 1; i <= 100000; i++) {
int t = rev(i);
int g = gcd(i, t);
r[i] = make_pair(i / g, t / g);
}
}
int main() {
init();
for (int mx, my, w; ~scanf("%d%d%d", &mx, &my, &w);) {
map<pair<int, int>, int> mpx, mpy;
for (int y = 1; y <= my; y++) {
mpy[r[y]]++;
}
long long X = -1, Y = -1;
long long iw = 0;
for (long long x = 1, y = my; x <= mx; x++) {
iw += mpy[inv(r[x])];
mpx[r[x]]++;
while (iw >= w) {
iw -= mpx[inv(r[y])];
mpy[r[y]]--;
y--;
if (iw < w) {
y++;
mpy[r[y]]++;
iw += mpx[inv(r[y])];
break;
}
}
if (iw >= w && (X == -1 || x * y < X * Y)) {
X = x;
Y = y;
}
}
if (X == -1) {
puts("-1");
} else {
printf("%I64d %I64d\n", X, Y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::copy;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::fixed;
using std::greater;
using std::iota;
using std::istream;
using std::lower_bound;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::multiset;
using std::next_permutation;
using std::nth_element;
using std::ostream;
using std::pair;
using std::priority_queue;
using std::queue;
using std::reverse;
using std::rotate;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::tie;
using std::tuple;
using std::unique;
using std::unordered_map;
using std::unordered_set;
using std::upper_bound;
using std::vector;
long long rnd(long long x, long long y) {
static auto gen = std::bind(std::uniform_int_distribution<long long>(),
std::mt19937(960172));
return gen() % (y - x + 1) + x;
}
long long gcd(long long a, long long b) {
while (b > 0) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
template <typename T>
T sqr(T const& a) {
return a * a;
}
int const INF = 100 + (int)1e9;
long long const INFL = 100 + (long long)1e18;
long double const PI = 3.1415926535897932384626433832795028;
struct ratio_t {
int num, den;
ratio_t() {}
ratio_t(int num, int den) : num(num), den(den) {
int g = gcd(num, den);
num /= g;
den /= g;
}
ratio_t inv() const { return ratio_t(den, num); }
};
bool operator<(ratio_t const& a, ratio_t const& b) {
return (long long)a.num * b.den < (long long)b.num * a.den;
}
bool operator==(ratio_t const& a, ratio_t const& b) {
return (long long)a.num * b.den == (long long)b.num * a.den;
}
int rev(int a) {
int b = 0;
while (a > 0) {
b = 10 * b + a % 10;
a /= 10;
}
return b;
}
ratio_t AR(int a) { return ratio_t(a, rev(a)); }
ratio_t RA(int a) { return ratio_t(rev(a), a); }
void solve() {
int X, Y, W;
scanf("%d%d%d", &X, &Y, &W);
map<ratio_t, int> ar, ra;
int x = 1, y = 0;
long long cnt = 0;
++ar[AR(x)];
while (y < Y && cnt < W) {
++y;
cnt += ar[RA(y)];
++ra[RA(y)];
}
int ax = -1, ay = -1;
long long area = INFL;
while (x <= X) {
if (cnt >= W) {
long long cur = (long long)x * y;
if (cur < area) {
area = cur;
ax = x;
ay = y;
}
}
++x;
cnt += ra[AR(x)];
++ar[AR(x)];
while (true) {
long long next = cnt - ar[RA(y)];
if (next >= W) {
--ra[RA(y)];
--y;
cnt = next;
} else
break;
}
}
if (ax < 0) {
puts("-1");
return;
}
printf("%d %d\n", ax, ay);
}
int main() {
cout.precision(15);
cout << fixed;
cerr.precision(6);
cerr << fixed;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
const T& max(const T& a, const T& b, const T& c) {
return max(a, max(b, c));
}
template <class T>
const T& min(const T& a, const T& b, const T& c) {
return min(a, min(b, c));
}
void sc(int& a) { scanf("%d", &a); }
void sc(long long& a) { scanf("%lld", &a); }
void sc(int& a, int& b) {
sc(a);
sc(b);
}
void sc(long long& a, long long& b) {
sc(a);
sc(b);
}
void sc(int& a, int& b, int& c) {
sc(a, b);
sc(c);
}
void sc(long long& a, long long& b, long long& c) {
sc(a, b);
sc(c);
}
void prl(int a) { printf("%d\n", a); }
void prl(long long a) { printf("%lld\n", a); }
void prl() { printf("\n"); }
void prs(int a) { printf("%d ", a); }
void prs(long long a) { printf("%lld ", a); }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long poww(long long a, long long b) {
if (b == 0) return 1;
long long tmp = poww(a, b / 2);
return (b & 1 ? a * tmp * tmp : tmp * tmp);
}
long long sumOfDigs(string s) {
long long sum = 0;
for (int i = 0; i < s.length(); i++) sum += s[i] - '0';
return sum;
}
long long sumOfDigs(long long n) {
return (n < 10 ? n : n % 10 + sumOfDigs(n / 10));
}
string itos(long long i) {
string s = "";
while (i) {
s += char(i % 10 + '0');
i /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long long stoi(string& s) {
long long tot = 0;
for (int i = (int)s.length() - 1, j = 1; i >= 0; i--, j *= 10) {
tot += j * (s[i] + '0');
}
return tot;
}
int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
using namespace std;
long long mod = 1e9 + 7;
void tt() { freopen("test.txt", "r", stdin); }
long long modpower(long long x, long long y, long long p) {
x %= mod;
if (!y) return 1;
long long res = 1;
if (y & 1) {
res *= x;
res %= p;
}
long long z = modpower(x, y / 2, p);
z %= p;
z *= z;
z %= mod;
res *= z;
res %= p;
return res;
}
map<double, int> mpx, mpy;
int rev(int num) {
int tot = 0;
while (num) {
tot = tot * 10 + (num % 10);
num /= 10;
}
return tot;
}
int main() {
int mx, my, w;
cin >> mx >> my >> w;
for (int i = 1; i <= mx; i++) {
mpx[i * 1.0 / rev(i)]++;
}
int x = mx, y = 0;
int poss = 0;
int finx = -1, finy = -1;
int cnt = 0;
while (x >= 1 && y <= my) {
if (cnt < w) {
y++;
double temp = rev(y) * 1.0 / y;
cnt += mpx[temp];
mpy[temp]++;
} else {
if (!poss || (1ll * finx * finy > 1ll * x * y)) {
poss = 1;
finx = x, finy = y;
}
double temp = x * 1.0 / rev(x);
cnt -= mpy[temp];
mpx[temp]--;
x--;
}
}
if (!poss) {
return cout << -1 << endl, 0;
}
cout << finx << " " << finy << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
double v;
int id;
} s[100100];
const double eps = 1e-9;
int n, m, w, size[100100], tot;
double v[100100];
int rev(int x) {
int t = 0;
while (x) t = t * 10 + x % 10, x /= 10;
return t;
}
bool cmp(Node x, Node y) { return x.v < y.v || (x.v == y.v && x.id < y.id); }
void prep() {
for (int i = 1; i <= max(n, m); i++) {
int x = rev(i);
v[i] = (double)i / x;
s[i].v = (double)x / i;
s[i].id = i;
}
sort(s + 1, s + m + 1, cmp);
}
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x > eps ? 1 : -1;
}
int getwhe(int x) {
int l = 1, r = m;
while (l < r) {
int mid = (l + r) >> 1;
if (dcmp(s[mid].v - v[x]) < 0)
l = mid + 1;
else
r = mid;
}
return l;
}
void work() {
prep();
int r = m, ans1, ans2;
long long ans = (long long)1 << 50;
for (int i = 1; i <= n; i++) {
int str = getwhe(i);
for (; str <= m && dcmp(s[str].v - v[i]) == 0 && s[str].id <= r; str++)
tot++, size[s[str].id]++;
while (tot - size[r] >= w) tot -= size[r], r--;
if (tot >= w && (long long)i * r < ans)
ans = (long long)i * r, ans1 = i, ans2 = r;
}
if (ans == (long long)1 << 50)
cout << "-1";
else
cout << ans1 << " " << ans2;
}
int main() {
cin >> n >> m >> w;
work();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100000;
vector<int> a[MaxN + 5];
int x, y, w;
int rev[MaxN + 5];
struct number {
int idx;
double o;
};
number nA[MaxN + 5], nB[MaxN + 5];
int rr(int x) {
int r = 0;
while (x) {
r = r * 10 + x % 10;
x /= 10;
}
return r;
}
bool cmp(number a, number b) {
return a.o + 0.000000001 < b.o ||
(fabs(a.o - b.o) < 0.000000001 && a.idx < b.idx);
}
int comp(long long a, long long b, long long c, long long d) {
if (a * b == c * d) return 0;
if (a * b < c * d) return -1;
return 1;
}
int cum[MaxN + 5];
void add(int idx) {
while (idx <= MaxN) {
cum[idx]++;
idx += idx & (-idx);
}
}
int sum(int idx) {
int r = 0;
while (idx) {
r += cum[idx];
idx -= idx & (-idx);
}
return r;
}
int main() {
for (int i = 1; i <= MaxN; i++) {
rev[i] = rr(i);
nA[i].idx = i;
nA[i].o = double(i) / double(rev[i]);
nB[i].idx = i;
nB[i].o = double(rev[i]) / double(i);
}
sort(nA + 1, nA + MaxN + 1, cmp);
sort(nB + 1, nB + MaxN + 1, cmp);
int i = 1, j = 1;
while (i <= MaxN && j <= MaxN) {
int c = comp(nA[i].idx, nB[j].idx, rev[nA[i].idx], rev[nB[j].idx]);
if (c == -1)
i++;
else if (c == 0) {
for (int k = j;
comp(nA[i].idx, nB[k].idx, rev[nA[i].idx], rev[nB[k].idx]) == 0 &&
k <= MaxN;
k++)
a[nA[i].idx].push_back(nB[k].idx);
i++;
} else
j++;
}
scanf("%d%d%d", &x, &y, &w);
memset(cum, 0, sizeof(cum));
int solX = 2123456789, solY = 2123456789;
for (int i = 1; i <= x; i++) {
for (int j = 0; j < a[i].size(); j++) add(a[i][j]);
int l = 1, r = MaxN, k;
while (l < r) {
k = (l + r) / 2;
if (sum(k) >= w) {
if (sum(k - 1) >= w)
r = k - 1;
else
break;
} else
l = k + 1;
}
if (sum(k - 1) >= w && k - 1 <= y) {
if (comp(solX, solY, i, k - 1) == 1) {
solX = i;
solY = k - 1;
}
} else if (sum(k) >= w && k <= y) {
if (comp(solX, solY, i, k) == 1) {
solX = i;
solY = k;
}
} else if (sum(k + 1) >= w && k + 1 <= y) {
if (comp(solX, solY, i, k + 1) == 1) {
solX = i;
solY = k + 1;
}
}
}
if (solX == 2123456789) {
printf("-1\n");
return 0;
}
printf("%d %d\n", solX, solY);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
const long long INF = (long long)N * (long long)N;
int mam[N][2];
map<pair<int, int>, int> mapa;
inline int numer(const pair<int, int> &p) {
if (mapa.count(p) == 0) {
int res = (int)mapa.size();
return mapa[p] = res;
}
return mapa[p];
}
int rev(int x) {
int res = 0;
while (x > 0) {
res = 10 * res + (x % 10);
x /= 10;
}
return res;
}
int nwd(int a, int b) { return b == 0 ? a : nwd(b, a % b); }
pair<int, int> popraw(int a, int b) {
int d = nwd(a, b);
return make_pair(a / d, b / d);
}
int dajnumer(int x) { return numer(popraw(x, rev(x))); }
int dajnumerrev(int x) { return numer(popraw(rev(x), x)); }
int main() {
int maxx, maxy, w;
long long suma = 0;
long long best = INF;
int bestx = -1, besty = -1;
scanf("%d %d %d", &maxx, &maxy, &w);
for (int i = (1); i <= (maxx); ++i) {
int a = dajnumer(i);
mam[a][0]++;
}
int akty = 0;
for (int i = (maxx); i >= (1); --i) {
while (akty < maxy && suma < w) {
akty++;
int b = dajnumerrev(akty);
suma -= (long long)mam[b][0] * (long long)mam[b][1];
mam[b][1]++;
suma += (long long)mam[b][0] * (long long)mam[b][1];
}
if (suma < w) break;
if ((long long)i * (long long)akty < best) {
best = (long long)i * (long long)akty;
bestx = i;
besty = akty;
}
int a = dajnumer(i);
suma -= (long long)mam[a][0] * (long long)mam[a][1];
mam[a][0]--;
suma += (long long)mam[a][0] * (long long)mam[a][1];
}
if (best == INF)
puts("-1");
else
printf("%d %d\n", bestx, besty);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long w, mxx, mxy, ansx, ansy, sum;
map<double, long long> mp1, mp2;
long long rev(long long x) {
long long xlh = 0;
while (x) {
xlh = xlh * 10 + x % 10;
x /= 10;
}
return xlh;
}
int main() {
long long i, x, y;
double now;
scanf("%lld%lld%lld", &mxx, &mxy, &w);
for (i = 1; i <= mxx; i++) mp1[1.0 * i / rev(i)]++;
for (i = 1; i <= mxy; i++) sum += mp1[1.0 * rev(i) / i];
if (sum < w) return puts("-1"), 0;
x = mxx;
y = 1;
sum = mp1[1];
mp2[1]++;
ansx = mxx;
ansy = mxy;
while (x >= 1 && y <= mxy) {
if (sum >= w) {
if (x * y < ansx * ansy) ansx = x, ansy = y;
now = 1.0 * x / rev(x);
sum -= mp2[now];
mp1[now]--;
x--;
} else {
y++;
now = 1.0 * rev(y) / y;
sum += mp1[now];
mp2[now]++;
}
}
printf("%lld %lld\n", ansx, ansy);
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int rev(int x) {
int res = 0;
while (x) {
res = res * 10 + x % 10;
x /= 10;
}
return res;
}
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
map<pair<int, int>, int> mx, my;
int X, Y, W;
int main() {
cin >> X >> Y >> W;
long long best = 1000111000111000LL;
int savex = -1, savey;
for (int y = (1), _b = (Y); y <= _b; y++) {
int g = gcd(y, rev(y));
my[make_pair(rev(y) / g, y / g)]++;
}
long long now = 0;
long long y = Y;
for (int x = (1), _b = (X); x <= _b; x++) {
int g = gcd(x, rev(x));
mx[make_pair(x / g, rev(x) / g)]++;
now += my[make_pair(x / g, rev(x) / g)];
while (y > 0 && now >= W) {
if (x * y <= best) {
best = x * y;
savex = x;
savey = y;
}
int g = gcd(y, rev(y));
now -= mx[make_pair(rev(y) / g, y / g)];
my[make_pair(rev(y) / g, y / g)]--;
y--;
}
}
if (savex == -1) {
puts("-1");
return 0;
}
cout << savex << ' ' << savey;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct NUM {
int x, y;
void init(int i) {
x = i;
int t = 0;
while (i) {
t = t * 10 + (i % 10);
i /= 10;
}
y = t;
}
bool operator<(const NUM &t) const { return 1LL * y * t.x <= 1LL * t.y * x; }
} num[100005];
int rev(int x) {
int res = 0;
while (x) {
res = res * 10 + (x % 10);
x /= 10;
}
return res;
}
int mx, my, w;
int a[100005];
void add(int x) {
while (x <= my) {
++a[x];
x += x & (-x);
}
}
int getSum(int x) {
int res = 0;
while (x >= 1) {
res += a[x];
x -= x & (-x);
}
return res;
}
int main() {
scanf("%d%d%d", &mx, &my, &w);
for (int i = 1; i <= my; ++i) num[i].init(i);
sort(num + 1, num + 1 + my);
int x = -1, y = -1;
long long mi;
for (int i = 1; i <= mx; ++i) {
int t = rev(i);
int l = 1, r = my;
while (l < r) {
int m = (l + r) >> 1;
if (1LL * num[m].y * t < 1LL * i * num[m].x)
l = m + 1;
else
r = m;
}
while (l <= my && 1LL * num[l].y * t == 1LL * i * num[l].x) {
add(num[l].x);
++l;
}
l = 1, r = my;
while (l < r) {
int m = (l + r) >> 1;
if (getSum(m) < w)
l = m + 1;
else
r = m;
}
if (getSum(l) >= w) {
if (x == -1)
x = i, y = l, mi = 1LL * x * y;
else if (mi > 1LL * i * l)
x = i, y = l, mi = 1LL * x * y;
}
}
if (x != -1)
printf("%d %d\n", x, y);
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 110000;
int mx, my, w;
int r[maxN];
int a[maxN], b[maxN];
int rev(int x) {
int res = 0;
while (x) {
res = res * 10 + (x % 10);
x /= 10;
}
return res;
}
int gcd(int x, int y) {
if (x == 0 || y == 0) {
return x + y;
}
if (x > y) {
return gcd(x % y, y);
} else {
return gcd(y % x, x);
}
}
map<pair<int, int>, vector<int> > MY;
map<pair<int, int>, vector<int> > MX;
long long getForX(int index, int bound) {
vector<int> ¤t = MY[make_pair(b[index], a[index])];
return upper_bound(current.begin(), current.end(), bound) - current.begin();
}
long long get(int mx, int bound) {
long long res = 0;
for (int i = 1; i <= mx; ++i) {
res += getForX(i, bound);
}
return res;
}
long long getForY(int index, int bound) {
vector<int> ¤t = MX[make_pair(a[index], b[index])];
return upper_bound(current.begin(), current.end(), bound) - current.begin();
}
int calc(int mx) {
int left_bound = 1, right_bound = my;
while (right_bound - left_bound > 1) {
int middle = (left_bound + right_bound) / 2;
if (get(mx, middle) >= w) {
right_bound = middle;
} else {
left_bound = middle;
}
}
if (get(mx, left_bound) >= w) {
return left_bound;
}
if (get(mx, right_bound) >= w) {
return right_bound;
}
return -1;
}
void trivial(int mx, int my, int w) {
long long res = 1000000000000000000LL;
int x = -1, y = -1;
for (int i = 1; i <= mx; ++i) {
for (int j = 1; j <= my; ++j) {
int score = 0;
for (int a = 1; a <= i; ++a) {
for (int b = 1; b <= j; ++b) {
if (a * b == r[a] * r[b]) {
++score;
}
}
}
if (score >= w && i * j < res) {
res = i * j;
x = i;
y = j;
}
}
}
cout << x << " " << y << endl;
}
int main() {
for (int i = 1; i < maxN; ++i) {
r[i] = rev(i);
}
cin >> mx >> my >> w;
for (int i = 1; i <= max(mx, my); ++i) {
a[i] = r[i];
b[i] = i;
int d = gcd(a[i], b[i]);
a[i] /= d;
b[i] /= d;
MY[make_pair(a[i], b[i])].push_back(i);
MX[make_pair(b[i], a[i])].push_back(i);
}
long long res = 1000000000000000000LL;
int x = -1, y = -1;
int currentY = calc(mx);
if (currentY == -1) {
cout << -1 << endl;
return 0;
}
x = mx;
y = currentY;
res = (long long)(x) * (long long)(y);
long long value = get(x, y);
for (int i = mx - 1; i >= 1; --i) {
value -= getForX(i + 1, currentY);
while (currentY < my && value < w) {
value += getForY(currentY + 1, i);
++currentY;
}
if (value < w) {
break;
}
if ((long long)(i) * (long long)(currentY) < res) {
res = (long long)(i) * (long long)(currentY);
x = i;
y = currentY;
}
}
cout << x << " " << y << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> A, B;
int MA, MB, W;
int r1, r2;
int rev(int u) {
int v = 0;
for (; u; u /= 10) v = v * 10 + u % 10;
return v;
}
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
scanf("%d%d%d", &MA, &MB, &W);
for (int i = 1; i <= MA; i++) {
int u = i, v = rev(i);
A[make_pair(u / gcd(u, v), v / gcd(u, v))]++;
}
r1 = r2 = -1;
long long now = 0;
for (int i = MA, j = 0; i; i--) {
while (j < MB && now < W) {
++j;
int u = rev(j), v = j;
pair<int, int> tmp = make_pair(u / gcd(u, v), v / gcd(u, v));
now += A[tmp];
B[tmp]++;
}
if (now >= W) {
if (r1 == -1 || (long long)r1 * r2 > (long long)i * j) r1 = i, r2 = j;
}
int u = i, v = rev(i);
pair<int, int> tmp = make_pair(u / gcd(u, v), v / gcd(u, v));
now -= B[tmp];
A[tmp]--;
}
if (r1 == -1)
printf("-1\n");
else
printf("%d %d\n", r1, r2);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 20;
template <typename T>
inline void hash_combine(size_t &seed, const T &value) {
seed ^= hash<T>()(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <typename T>
inline void hash_val(size_t &seed, const T &val) {
hash_combine(seed, val);
}
template <typename T, typename... Types>
inline void hash_val(size_t &seed, const T &val, const Types &...args) {
hash_combine(seed, val);
hash_val(seed, args...);
}
template <typename... Types>
inline size_t hash_val(const Types &...args) {
size_t seed = 0;
hash_val(seed, args...);
return seed;
}
class obHash {
public:
std::size_t operator()(const pair<long long, long long> &c) const {
return hash_val(c.first, c.second);
}
};
long long rev[MAX];
unordered_map<pair<long long, long long>, long long, obHash> m1, m2;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
pair<long long, long long> aa[MAX], bb[MAX];
long long maxx, maxy, w;
int main() {
scanf("%lld%lld%lld", &maxx, &maxy, &w);
for (int i = (1); i <= (100000); ++i) {
int tt = i, base = 1;
rev[i] = 0;
tt /= 10;
while (tt) {
tt /= 10;
base *= 10;
}
tt = i;
while (tt) {
rev[i] += base * (tt % 10);
tt /= 10;
base /= 10;
}
}
for (int i = (1); i <= (100000); ++i) {
long long d = gcd(i, rev[i]);
aa[i] = {(long long)i / d, rev[i] / d};
bb[i] = {rev[i] / d, (long long)i / d};
}
long long x = 1, y = maxy;
for (int i = (1); i <= (maxy); ++i) {
++m2[bb[i]];
}
++m1[aa[1]];
long long value = m1[aa[1]] * m2[aa[1]], ans = LLONG_MAX, optx, opty;
while (x <= maxx && y >= 1) {
if (value >= w) {
if ((long long)x * y < ans) ans = (long long)x * y, optx = x, opty = y;
value -= m1[bb[y]], --m2[bb[y]], --y;
} else {
++x;
if (x <= maxx) {
++m1[aa[x]], value += m2[aa[x]];
}
}
}
if (ans == LLONG_MAX)
printf("-1\n");
else
printf("%lld %lld\n", optx, opty);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, w, x = -1, y, tot;
long long ans = (long long)1e18;
map<pair<int, int>, int> A, B;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
pair<int, int> caln_A(int x) {
int k = x, rev = 0;
while (x > 0) {
rev = rev * 10 + x % 10;
x /= 10;
}
int d = gcd(k, rev);
k /= d;
rev /= d;
return make_pair(k, rev);
}
pair<int, int> caln_B(int x) {
pair<int, int> now = caln_A(x);
swap(now.first, now.second);
return now;
}
int main() {
int j = 0;
tot = 0;
scanf("%d%d%d", &n, &m, &w);
for (int i = 1; i <= n; i++) A[caln_A(i)]++;
for (int i = n; i >= 1; i--) {
while (tot < w && j < m) {
j++;
pair<int, int> now = caln_B(j);
B[now]++;
tot += A[now];
}
if (tot < w) continue;
if ((long long)i * j <= ans) ans = (long long)i * j, x = i, y = j;
pair<int, int> now = caln_A(i);
tot -= B[now];
A[now]--;
}
if (x == -1)
printf("-1\n");
else
printf("%d %d\n", x, y);
}
|
#include <bits/stdc++.h>
using namespace std;
map<double, long long> a1, a2;
long long maxx, maxy, w, cnt, l, r = 1, x, y;
double tmp;
inline long long qpow(register long long x) {
long long ans = 0;
while (x) {
ans = ans * 10 + x % 10;
x /= 10;
}
return ans;
}
int main() {
scanf("%lld%lld%lld", &maxx, &maxy, &w);
for (register int i = 1; i <= maxx; i++) a1[1.0 * i / qpow(i)]++;
for (register int i = 1; i <= maxy; i++) cnt += a1[1.0 * qpow(i) / i];
if (cnt < w) return puts("-1"), 0;
l = x = maxx;
y = maxy;
cnt = a1[1.0];
a2[1.0]++;
while (l >= 1 && r <= maxy) {
if (cnt >= w) {
if (l * r < x * y) x = l, y = r;
tmp = (double)l / qpow(l);
cnt -= a2[tmp];
a1[tmp]--;
l--;
} else {
r++;
tmp = (double)qpow(r) / r;
cnt += a1[tmp];
a2[tmp]++;
}
}
printf("%lld %lld\n", x, y);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
class BIT {
public:
int tree[100002 + 1];
BIT() { memset(tree, 0, sizeof(tree)); }
void update(int index, int val) {
while (index <= 100002) {
tree[index] += val;
index += (index & -index);
}
}
int query(int index) {
int sum = 0;
while (index > 0) {
sum += tree[index];
index -= (index & -index);
}
return sum;
}
int readsingle(int index) {
int sum = tree[index];
int z = index - (index & -index);
index--;
while (index != z) {
sum -= tree[index];
index -= (index & -index);
}
return sum;
}
};
BIT B;
int mx, my, w;
struct node {
int num, n, d;
};
node N[100002];
int gcd(int a, int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
bool cmp(node A, node B) {
if (A.n == B.n) return A.d < B.d;
return A.n < B.n;
}
map<pair<int, int>, int> MIN, MAX;
int R(int i) {
stringstream s, ss;
s << i;
string r = s.str();
s.clear();
reverse(r.begin(), r.end());
ss << r;
int j;
ss >> j;
return j;
}
int main() {
cin >> mx >> my >> w;
int MX = max(mx, my);
vector<int> vec[MX + 1];
for (int i = 1; i < MX + 1; ++i) {
int reverse = R(i);
int g = gcd(i, reverse);
int NN = i / g;
int D = reverse / g;
N[i].num = i;
N[i].n = NN;
N[i].d = D;
}
sort(N + 1, N + MX + 1, cmp);
for (int i = 1; i < MX + 1; ++i) {
pair<int, int> temp = make_pair(N[i].n, N[i].d);
if (MIN[temp] == 0) {
MIN[temp] = (1 << 22);
}
MIN[temp] = min(MIN[temp], i);
MAX[temp] = max(MAX[temp], i);
}
int from = 1;
for (int to = 1; to < MX + 2; ++to) {
if (to == MX + 1 || !(N[to].n == N[from].n && N[to].d == N[from].d)) {
int nr = N[from].d;
int dr = N[from].n;
pair<int, int> temp = make_pair(nr, dr);
int L = MIN[temp], R = MAX[temp];
if (R != 0) {
for (int i = from; i < to; ++i) {
for (int j = L; j < R + 1; ++j) {
vec[N[i].num].push_back(N[j].num);
}
}
}
from = to;
}
}
long long int prod = (1LL << 50), xx, yy;
for (int i = 1; i < mx + 1; ++i) {
int size = vec[i].size();
for (int j = 0; j < size; ++j) {
B.update(vec[i][j], 1);
}
int lo = 1, hi = my;
for (int rep = 0; rep < 19; ++rep) {
int mid = (lo + hi) >> 1;
int prod = B.query(mid);
if (prod < w) {
lo = mid;
} else
hi = mid;
}
if (B.query(lo) >= w)
lo = lo;
else if (B.query(hi) >= w)
lo = hi;
else
lo = -1;
if (lo != -1) {
long long int temp = (long long int)lo * i;
if (temp < prod) {
prod = temp;
xx = i;
yy = lo;
}
}
}
if (prod == (1LL << 50)) {
cout << "-1";
} else
cout << xx << " " << yy;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int rev(int a) {
int res = 0;
while (a > 0) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
pair<int, int> rev(pair<int, int> a) { return make_pair(a.second, a.first); }
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int A, B, W, M, co[100100], rco[100100], x[200100], y[200100];
pair<int, int> frac[100100];
pair<int, int> check(long long P) {
memset(x, 0, sizeof(int) * M);
memset(y, 0, sizeof(int) * M);
int cur = min(P, (long long)B);
for (int i = (1); i < (cur + 1); ++i) ++y[rco[i]];
int lim = min(P, (long long)A);
long long ile = 0;
for (int i = (1); i < (lim + 1); ++i) {
while ((long long)cur * i > P) {
--y[rco[cur]];
ile -= x[rco[cur]];
--cur;
}
++x[co[i]];
ile += y[co[i]];
if (ile >= W) return make_pair(i, cur);
}
return make_pair(-1, -1);
}
int main(void) {
scanf("%d%d%d", &A, &B, &W);
vector<pair<int, int> > all;
for (int i = (1); i < (max(A, B) + 1); ++i) {
int d = gcd(i, rev(i));
frac[i] = make_pair(i / d, rev(i) / d);
all.push_back(frac[i]);
all.push_back(rev(frac[i]));
}
M = ((int)((all).size()));
sort((all).begin(), (all).end());
for (int i = (1); i < (max(A, B) + 1); ++i) {
co[i] = lower_bound((all).begin(), (all).end(), frac[i]) - all.begin();
rco[i] =
lower_bound((all).begin(), (all).end(), rev(frac[i])) - all.begin();
}
long long l = 1, r = (long long)A * B, mid;
pair<int, int> best = make_pair(-1, -1);
while (l <= r) {
mid = (l + r) / 2;
pair<int, int> z = check(mid);
if (z.first == -1)
l = mid + 1;
else {
best = z;
r = mid - 1;
}
}
if (best.first == -1)
puts("-1");
else
printf("%d %d\n", best.first, best.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 25;
const double eps = 1e-9;
map<pair<int, int>, vector<int> > Y;
const int MAXN = 101000;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int revMemo[MAXN];
int rev(int x) {
int& ret = revMemo[x];
if (ret != -1) return ret;
ret = 0;
while (x > 0) {
ret = ret * 10 + x % 10;
x /= 10;
}
return ret;
}
int add[MAXN];
bool cmp(const pair<int, int>& A, const pair<int, int>& B) {
return (long long)A.first * A.second < (long long)B.first * B.second;
}
int main() {
memset((revMemo), (-1), sizeof(revMemo));
for (int i = (1); i < (100010); ++i) {
int y = i;
int yrev = rev(y);
int d = gcd(y, yrev);
y /= d, yrev /= d;
Y[pair<int, int>(yrev, y)].push_back(i);
}
int maxX, maxY, w;
cin >> maxX >> maxY >> w;
pair<int, int> ans(inf, inf);
int cury = 0;
int cs = 0;
memset((add), (0), sizeof(add));
for (int i = (1); i < (maxX + 1); ++i) {
int x = i;
int xrev = rev(x);
int d = gcd(x, xrev);
x /= d, xrev /= d;
vector<int>& a = Y[pair<int, int>(x, xrev)];
for (int j = (0); j < ((int)a.size()); ++j) {
int y = a[j];
if (y <= cury) ++cs;
++add[y];
}
if (cs >= w) {
while (cs - add[cury] >= w) cs -= add[cury], --cury;
} else {
while (cury < maxY && cs < w) cs += add[++cury];
}
if (cs >= w) ans = min(ans, pair<int, int>(i, cury), cmp);
}
if (ans.first == inf)
printf("-1\n");
else
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx, mn, w, x, cc, y, ansx, ansy;
map<double, int> m1, m2;
double q;
int rev(int x) {
int ret = 0;
while (x > 0) ret = ret * 10 + (x % 10), x /= 10;
return ret;
}
int main() {
cin >> mx >> mn >> w;
for (int i = 1; i <= mx; i++) q = i * 1.0 / rev(i), m1[q]++;
x = mx;
while (y <= mn && x >= 1) {
if (cc < w && y < mn)
y++, q = (rev(y) * 1.0) / y, cc += m1[q], m2[q]++;
else if (cc >= w) {
if (ansx * ansy > x * y || !ansx) ansx = x, ansy = y;
q = (x * 1.0) / rev(x), cc -= m2[q], m1[q]--, x--;
} else
y = mn + 1;
}
if (!ansx)
cout << -1;
else
cout << ansx << " " << ansy;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
long long rev[MAXN];
struct cmp {
bool operator()(const int &a, const int &b) const {
return a * rev[b] < b * rev[a];
}
};
map<int, int, cmp> map1, map2;
int X, Y, W;
int reverse(int x) {
int ret = 0;
while (x) {
int dig = x % 10;
x /= 10;
ret = 10 * ret + dig;
}
return ret;
}
int main() {
scanf("%d %d %d", &X, &Y, &W);
for (int i = 0; i < MAXN; ++i) {
rev[i] = reverse(i);
if (reverse(rev[i]) != i) rev[i] = 0;
}
int a = 0;
int b = 0;
long long cnt = 0;
while (b + 1 < MAXN) {
++b;
++map2[b];
}
int ansx = -1, ansy;
long long best = -1;
while (a < MAXN && b > 0) {
if (cnt < W) {
++a;
if (rev[a]) {
cnt += map2[rev[a]];
}
++map1[a];
} else {
if (a <= X && b <= Y) {
long long prod = a;
prod *= b;
if ((best == -1) || prod < best) {
best = prod;
ansx = a;
ansy = b;
}
}
if (rev[b]) {
cnt -= map1[rev[b]];
}
--map2[b];
--b;
}
}
if (ansx != -1) {
printf("%d %d\n", ansx, ansy);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[120];
int Rev(int x) {
int t = 0;
while (x > 0) {
num[t++] = x % 10;
x /= 10;
}
int sum = 0;
for (int i = 0; i < t; i++) {
sum *= 10;
sum += num[i];
}
return sum;
}
struct Np {
int x, y;
} q[1500000];
bool cmp(const Np &x, const Np &y) {
if (x.y == y.y) return x.x > y.x;
return x.y < y.y;
}
struct D {
int x, y;
double va;
} d[150000];
const double eps = 1e-13;
double Ab(double x) {
if (x < 0.0) return -x;
return x;
}
bool Eq(double x, double y) {
if (Ab(x - y) < eps) return true;
return false;
}
bool cmp2(const D &x, const D &y) {
if (Eq(x.va, y.va)) return x.x > y.x;
return x.va < y.va;
}
int Cal(int x, int y) {
int t = 0;
int gs = max(x, y);
int i;
for (i = 1; i <= gs; i++) {
d[i - 1].x = i;
d[i - 1].y = Rev(i);
d[i - 1].va = (double)i / (double)Rev(i);
}
sort(d, d + gs, cmp2);
for (i = 0; i < gs; i++) {
if (d[i].x > x) continue;
int nx, ny;
int tx, ty;
nx = d[i].x;
ny = d[i].y;
int lo, up, mid;
lo = 0;
up = gs;
while (lo + 1 < up) {
mid = (lo + up) / 2;
if (d[i].va * d[mid].va > 1.0 + eps)
up = mid;
else
lo = mid;
}
for (int j = lo; j >= 0; j--) {
tx = d[j].x;
ty = d[j].y;
if (tx > y || d[i].va * d[j].va > 1.0 + eps)
break;
else {
if ((long long)tx * (long long)nx == (long long)ny * (long long)ty) {
q[t].x = nx;
q[t].y = tx;
t++;
} else
break;
}
}
}
sort(q, q + t, cmp);
return t;
}
int tree[150000];
int N;
void init() {
for (int i = 1; i <= N; i++) tree[i] = 0;
}
int read(int k) {
int sum = 0;
while (k) {
sum += tree[k];
k -= k & -k;
}
return sum;
}
void update(int k, int v) {
while (k <= N) {
tree[k] += v;
k += k & -k;
}
}
int n, m, w, i, x, y, po;
int main() {
while (~scanf("%d%d%d", &n, &m, &w)) {
int num = Cal(n, m);
N = n;
init();
po = n;
x = n + 1;
y = m + 1;
for (i = 0; i < num; i++) {
update(q[i].x, 1);
while (po >= 1 && read(po) >= w) {
if ((long long)x * (long long)y > (long long)q[i].y * (long long)po) {
x = po;
y = q[i].y;
}
po--;
}
}
if (x == n + 1 && y == m + 1)
puts("-1");
else
printf("%d %d\n", x, y);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int maxx, maxy, w, l, r, ans, ansl, ansr, cnt, sum;
map<double, int> t1, t2;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
int rev(int x) {
int res = 0;
while (x) {
res = res * 10 + x % 10;
x /= 10;
}
return res;
}
int main() {
maxx = read();
maxy = read();
w = read();
ans = 1e10;
for (int i = 1; i <= maxx; i++) t1[1.0 * i / rev(i)]++;
for (int i = 1; i <= maxy; i++) sum += t1[1.0 * rev(i) / i];
if (sum < w)
printf("%d\n", -1);
else {
l = maxx, r = 0;
while (l && r <= maxy) {
while (cnt < w && r <= maxy) {
r++;
t2[1.0 * rev(r) / r]++;
cnt += t1[1.0 * rev(r) / r];
}
if (cnt >= w && r * l < ans) {
ans = r * l;
ansl = l;
ansr = r;
}
cnt -= t2[1.0 * l / rev(l)];
t1[1.0 * l / rev(l)]--;
l--;
}
printf("%d %d\n", ansl, ansr);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int rev(int a) {
int b = 0;
while (a) {
b = b * 10 + a % 10;
a /= 10;
}
return b;
}
int gcd(int a, int b) {
while (b) {
int t = a % b;
a = b;
b = t;
}
return a;
}
int main() {
int mx, my, w;
scanf("%d%d%d", &mx, &my, &w);
multimap<pair<int, int>, pair<int, int> > cor;
for (int i = 1; i <= my; i++) {
int r = rev(i);
int d = gcd(i, r);
int a = i / d, b = r / d;
cor.insert(make_pair(make_pair(a, b), make_pair(i, r)));
}
static vector<int> list[110000];
int count = 0;
for (int i = 1; i <= mx; i++) {
int r = rev(i);
int d = gcd(i, r);
int a = i / d, b = r / d;
pair<int, int> t(b, a);
for (multimap<pair<int, int>, pair<int, int> >::iterator p =
cor.lower_bound(t);
p != cor.end() && p->first == t; p++) {
list[i].push_back(p->second.first);
count++;
}
}
if (count < w) {
puts("-1");
return 0;
}
priority_queue<int> ids;
int sy = my, sx = mx;
for (int i = 1; i <= mx; i++) {
for (vector<int>::iterator j = list[i].begin(); j != list[i].end(); j++) {
ids.push(*j);
}
while ((int)ids.size() > w) ids.pop();
if ((int)ids.size() >= w) {
int y = i;
int x = ids.top();
if ((long long)sy * (long long)sx > (long long)y * (long long)x) {
sy = y;
sx = x;
}
}
}
printf("%d %d\n", sy, sx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int n, int m) {
if (n == 0) return m;
return gcd(m % n, n);
}
int reverseNumber(int x) {
int temp = 0;
while (x) {
temp = 10 * temp + (x % 10);
x /= 10;
}
return temp;
}
pair<int, int> getNormalizedCount1(int x) {
int revX = reverseNumber(x);
int g = gcd(x, revX);
return make_pair(x / g, revX / g);
}
pair<int, int> getNormalizedCount2(int x) {
pair<int, int> pr = getNormalizedCount1(x);
return make_pair(pr.second, pr.first);
}
int main() {
int maxX, maxY, w;
scanf("%d%d%d", &maxX, &maxY, &w);
map<pair<int, int>, int> count1, count2;
long long int total = 0;
for (int i = 1; i <= maxY; ++i) {
count1[getNormalizedCount1(i)]++;
}
int curY = maxY, ans_x, ans_y;
long long int mx = ((long long int)maxY) * ((long long int)(maxX + 1));
long long int ans = mx;
for (int i = 1; i <= maxX; ++i) {
total += count1[getNormalizedCount2(i)];
++count2[getNormalizedCount2(i)];
while (curY > 0) {
int temp = count2[getNormalizedCount1(curY)];
if ((total - temp) < w) break;
total -= temp;
--count1[getNormalizedCount1(curY)];
--curY;
}
if (total >= w) {
long long int cur_ans = ((long long int)i) * ((long long int)curY);
if (cur_ans < ans) {
ans = cur_ans;
ans_x = i;
ans_y = curY;
}
}
}
if (ans == mx)
printf("-1\n");
else
printf("%d %d\n", ans_x, ans_y);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double a[100010], b[100010], rev[100010];
multimap<double, int> xmap, ymap;
multimap<double, int>::iterator xit[100010], yit[100010];
int mx, my, w;
int main(int argc, char** argv) {
cin >> mx >> my >> w;
for (int i = 1; i <= max(mx, my); i++) {
rev[i] = 0;
int k = i;
while (k) {
rev[i] = rev[i] * 10 + k % 10;
k /= 10;
}
a[i] = (double)i / rev[i];
b[i] = (double)rev[i] / i;
if (i <= mx) xit[i] = xmap.insert(make_pair(a[i], i));
}
int cnt = 0;
int rx, ry, rt = -1;
for (int i = 1, j = mx; i <= my; i++) {
cnt += xmap.count(b[i]);
yit[i] = ymap.insert(make_pair(b[i], i));
while (cnt >= w) {
if (rt == -1 || i * j < rt) {
rt = i * j;
rx = j;
ry = i;
}
cnt -= ymap.count(a[j]);
xmap.erase(xit[j]);
j -= 1;
}
}
if (rt == -1)
cout << rt << endl;
else
cout << rx << " " << ry << endl;
return (EXIT_SUCCESS);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5, mod = 1e6 + 3, inf = 0x3f3f3f3f;
template <class T>
T QuickMod(T a, T b, T c) {
T ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
b >>= 1;
a = (a * a) % c;
}
return ans;
}
template <class T>
T Gcd(T a, T b) {
return b != 0 ? Gcd(b, a % b) : a;
}
template <class T>
T Lcm(T a, T b) {
return a / Gcd(a, b) * b;
}
template <class T>
void outln(T x) {
cout << x << endl;
}
int mx, my, w, cnt;
map<double, long long> m, n;
int rev(int k) {
int a = 0;
while (k) {
a = a * 10 + k % 10;
k /= 10;
}
return a;
}
int main() {
cin >> mx >> my >> w;
for (int i = 1; i <= mx; i++) m[1.0 * i / rev(i)]++;
for (int i = 1; i <= my; i++) cnt += m[1.0 * rev(i) / i];
if (cnt < w) {
puts("-1");
return 0;
}
int dx = mx, dy = 1, cnt = m[1.0], x = mx, y = my;
double t;
n[1.0]++;
while (dx > 0 && dy <= my) {
if (cnt >= w) {
if (1ll * dx * dy < 1ll * x * y) {
x = dx;
y = dy;
}
t = 1.0 * dx / rev(dx);
cnt -= n[t];
m[t]--;
dx--;
} else {
dy++;
t = 1.0 * rev(dy) / dy;
cnt += m[t];
n[t]++;
}
}
cout << x << ' ' << y << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (b) {
int c = a % b;
a = b;
b = c;
}
return a;
}
pair<int, int> F(int n) {
int m = 0;
for (int i = n; i; i /= 10) m = m * 10 + i % 10;
int d = gcd(n, m);
return pair<int, int>(n / d, m / d);
}
const int N = 100000 + 10;
pair<int, int> a[N], b[N];
int main() {
int n, m, w;
scanf("%d %d %d", &n, &m, &w);
map<pair<int, int>, int> A, B;
for (int i = 1; i < N; ++i) {
a[i] = F(i);
b[i] = pair<int, int>(a[i].second, a[i].first);
}
int i = 1, j;
int cnt = 0;
for (j = 1; j <= m; ++j) B[a[j]]++;
for (i = 1; i <= n; ++i) {
A[a[i]]++;
cnt += B[b[i]];
if (cnt >= w) break;
}
if (cnt < w) {
puts("-1");
return 0;
}
j = m;
while (true) {
if (cnt - A[b[j]] < w) break;
cnt -= A[b[j]];
B[a[j]]--;
--j;
}
int ret = i * j;
int ret_i = i, ret_j = j;
for (++i; i <= n; ++i) {
A[a[i]]++;
cnt += B[b[i]];
while (true) {
if (cnt - A[b[j]] < w) break;
cnt -= A[b[j]];
B[a[j]]--;
--j;
}
if (i * j < ret) {
ret = i * j;
ret_i = i;
ret_j = j;
}
}
printf("%d %d\n", ret_i, ret_j);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int rev(int n) {
int ret = 0;
while (n != 0) {
ret = (10 * ret) + (n % 10);
n /= 10;
}
return ret;
}
int main() {
int mx, my, w;
int i, j, k, t;
int ax, ay;
vector<int> v;
map<pair<int, int>, vector<int> > mp;
scanf("%d%d%d", &mx, &my, &w);
for (i = 1; i <= my; i++) {
j = rev(i);
k = gcd(i, j);
mp[make_pair(i / k, j / k)].push_back(i);
}
vector<int> vec(my + 1, 0);
vector<vector<int> > vv;
vv.push_back(v);
for (i = 1; i <= mx; i++) {
j = rev(i);
k = gcd(i, j);
v = mp[make_pair(j / k, i / k)];
for (j = 0; j < v.size(); j++) vec[v[j]]++;
vv.push_back(v);
}
long long ans = -1;
for (i = mx, j = 0, k = 0; i > 0; i--) {
if (k < w && j < my) {
do {
j++;
k += vec[j];
} while (k < w && j < my);
}
if (k >= w && (ans == -1 || ans > (long long)i * j)) {
ans = (long long)i * j;
ax = i;
ay = j;
}
for (t = 0; t < vv[i].size(); t++) {
if (vv[i][t] <= j) k--;
vec[vv[i][t]]--;
}
}
if (ans == -1)
printf("-1\n");
else
printf("%d %d\n", ax, ay);
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...);
}
const int N = (int)1e5;
long long md = 998244353;
long long INF = (long long)9e18;
long long val[N], inv[N];
inline long long mul(long long a, long long b) {
return (long long)((long long)a * b % md);
}
inline int power(long long a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int rev(int x) {
int res = 0;
while (x) {
res *= 10;
res += x % 10;
x /= 10;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, w;
cin >> n >> m >> w;
for (int i = 1; i < N; i++) {
val[i] = (long long)i * power(rev(i), md - 2) % md,
inv[i] = power(val[i], md - 2);
}
map<int, int> cnt[2];
for (int i = 1; i <= m; i++) {
cnt[1][val[i]]++;
}
int j = m;
long long sum = 0;
long long res = INF;
long long x, y;
for (int i = 1; i <= n; i++) {
sum += cnt[1][inv[i]];
cnt[0][val[i]]++;
while (j && sum - cnt[0][inv[j]] >= w) {
cnt[1][val[j]]--;
sum -= cnt[0][inv[j]];
j--;
}
42;
if (sum >= w) {
res = min(res, (long long)i * j);
if (res == (long long)i * j) {
x = i;
y = j;
}
}
}
if (res == INF) {
cout << "-1" << '\n';
} else {
cout << x << " " << y << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const long long INF = 12345678987654321LL;
pair<int, int> r[MAXN];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int rev(int x) {
int y = 0;
while (x > 0) {
y = y * 10 + x % 10;
x /= 10;
}
return y;
}
pair<int, int> inv(const pair<int, int>& p) {
return pair<int, int>(p.second, p.first);
}
void init() {
for (int i = 1; i < MAXN; ++i) {
int t = rev(i);
int g = gcd(t, i);
r[i] = make_pair(t / g, i / g);
}
}
int main() {
int nx, ny, nw;
long long x, y, w;
map<pair<int, int>, int> mx, my;
init();
scanf("%d%d%d", &nx, &ny, &nw);
for (int j = 1; j <= ny; ++j) {
++my[r[j]];
}
x = y = -1;
w = INF;
for (long long i = 1, j = ny, k = 0; i <= nx; ++i) {
++mx[r[i]];
k += my[inv(r[i])];
while (j > 0 && k >= nw) {
if (w == INF || i * j < x * y) {
x = i;
y = j;
w = k;
}
--my[r[j]];
k -= mx[inv(r[j])];
--j;
if (k < nw) {
++j;
k += mx[inv(r[j])];
++my[r[j]];
break;
}
}
}
if (w < INF) {
printf("%d %d\n", (int)x, (int)y);
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
struct Tree {
int n;
int t[4 * 100001 + 1];
void build(int sz);
void build(int i, int l, int r);
void add(int pos, int val);
void add(int pos, int val, int i, int l, int r);
int get_kth(int k);
int get_kth(int k, int i, int l, int r);
};
void Tree::build(int sz) {
n = sz;
build(1, 0, n - 1);
}
void Tree::build(int i, int l, int r) {
if (l == r) {
t[i] = 0;
return;
}
int m = (l + r) / 2;
build(i * 2, l, m);
build(i * 2 + 1, m + 1, r);
t[i] = t[i * 2] + t[i * 2 + 1];
}
void Tree::add(int pos, int val) { add(pos, val, 1, 0, n - 1); }
void Tree::add(int pos, int val, int i, int l, int r) {
t[i] += val;
if (l == r) return;
int m = (l + r) / 2;
if (pos <= m)
add(pos, val, i * 2, l, m);
else
add(pos, val, i * 2 + 1, m + 1, r);
}
int Tree::get_kth(int k) { return get_kth(k, 1, 0, n - 1); }
int Tree::get_kth(int k, int i, int l, int r) {
assert(k >= 0 && k < t[i]);
if (l == r) return l;
int m = (l + r) / 2;
if (k < t[i * 2])
return get_kth(k, i * 2, l, m);
else
return get_kth(k - t[i * 2], i * 2 + 1, m + 1, r);
}
int rev(int x) {
char s[64];
int r = 0;
for (int i = (sprintf(s, "%d", x)) - 1; i >= 0; --i) r = r * 10 + s[i] - '0';
return r;
}
Tree t;
int maxx, maxy, w;
map<double, vector<int> > g;
void solution() {
cin >> maxx >> maxy >> w;
for (int i = 1; i <= maxy; i++) {
double ratio = rev(i) * 1. / i;
g[ratio].push_back(i);
}
t.build(maxy + 1);
int x = -1, y, into = 0;
for (int i = 1; i <= maxx; i++) {
double ratio = i * 1. / rev(i);
vector<int>& v = g[ratio];
for (int j = 0, _n = ((int)((v).size())); j < _n; ++j) t.add(v[j], +1);
into += (int)((v).size());
if (into < w) continue;
int val = t.get_kth(w - 1);
if (x == -1 || i * val < x * y) x = i, y = val;
}
if (x == -1)
puts("-1");
else
printf("%d %d\n", x, y);
}
int main() {
solution();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Rev[100001];
int maxX, maxY, W;
map<pair<int, int>, vector<int> > XSobreInv;
long long rev(int x) {
if (Rev[x] != -1) return Rev[x];
int y = 0;
while (x) {
y *= 10;
y += x % 10;
x /= 10;
}
return Rev[x] = y;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
pair<int, int> transforma(int x) {
int inv = rev(x);
int g = gcd(x, inv);
x /= g;
inv /= g;
if (inv == 0) x = 1;
return make_pair(x, inv);
}
int usei[100001];
int tenho(int x, int y) {
int q = 0;
pair<int, int> ok = transforma(x);
swap(ok.first, ok.second);
if (XSobreInv.count(ok)) {
for (vector<int>::iterator it = XSobreInv[ok].begin();
it != XSobreInv[ok].end(); it++) {
if (*it <= y) {
q++;
usei[*it]++;
} else {
break;
}
}
}
return q;
}
void atualiza(long long &X, long long &Y, long long x, long long y) {
if (x * y < X * Y) {
X = x;
Y = y;
}
}
int main() {
scanf("%d %d %d", &maxX, &maxY, &W);
memset(Rev, -1, sizeof(Rev));
XSobreInv.clear();
for (int i = 1; i < 100001; i++) {
int x = i;
pair<int, int> p = transforma(x);
XSobreInv[p].push_back(i);
}
memset(usei, 0, sizeof(usei));
int total = 0;
long long X = maxX + 1, Y = maxY + 1;
for (int x = 1; x <= maxX; x++) {
total += tenho(x, maxY);
if (total >= W) {
X = x;
Y = maxY;
break;
}
}
if (X > maxX) {
printf("-1\n");
return 0;
}
int xat = X;
for (int y = maxY; y >= 2; y--) {
total -= usei[y];
while (xat < maxX && total < W) {
total += tenho(++xat, y - 1);
}
if (total >= W) {
atualiza(X, Y, xat, y - 1);
} else {
break;
}
}
cout << X << " " << Y << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
pair<int, int> val[100000];
map<pair<int, int>, set<int> > C;
int rev(int a) {
int ans = 0;
while (a) ans = ans * 10 + a % 10, a /= 10;
return ans;
}
struct by_x {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
};
struct by_y {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
};
int main() {
int X, Y, W;
cin >> X >> Y >> W;
for (int i = (1); i <= (max(X, Y)); ++i) {
int r = rev(i);
int g = gcd(i, r);
val[i] = make_pair(i / g, r / g);
C[val[i]].insert(i);
}
vector<pair<int, int> > evt;
for (int a = (1); a <= (X); ++a) {
pair<int, int> p = val[a];
swap(p.first, p.second);
for (set<int>::iterator it = C[p].begin(); it != C[p].end(); it++) {
int b = (*it);
if (b > Y) continue;
evt.push_back(make_pair(a, b));
assert(a * (long long)b == rev(a) * (long long)rev(b));
}
}
int N = evt.size();
if (W > N) {
cout << -1 << endl;
return 0;
}
int bestx = X + 1;
int besty = Y + 1;
long long area = bestx * (long long)besty;
priority_queue<pair<int, int>, vector<pair<int, int> >, by_y> Q;
for (int i = 0; i < N; ++i) {
Q.push(evt[i]);
while (Q.size() > W) Q.pop();
if (Q.size() < W) continue;
int x = evt[i].first;
int y = Q.top().second;
if (x * (long long)y <= area) {
area = x * (long long)y;
bestx = x;
besty = y;
}
}
cout << bestx << " " << besty << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.