text
stringlengths 49
983k
|
|---|
#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;
const int N = 1005;
int n, m, q, u, v, w, l, r, ans, par[N], col[N], mark[N];
vector<pair<int, pair<int, int> > > yal, edge[N * N];
vector<int> cmp[N];
void add(int x) {
for (int i = 0; i < edge[x].size(); i++) yal.push_back(edge[x][i]);
}
int Get_par(int u) {
if (par[u] < 0) return u;
return par[u] = Get_par(par[u]);
}
void query(int l, int r) {
r++;
for (l += m, r += m; l < r; l >>= 1, r >>= 1) {
if (l & 1) add(l++);
if (r & 1) add(--r);
}
}
void reset(int x) {
cmp[x].clear();
cmp[x].push_back(x);
}
void merge(int u, int v, int s) {
u = Get_par(u), v = Get_par(v);
if (par[u] > par[v]) swap(u, v);
for (int i = 0; i < cmp[v].size(); i++)
cmp[u].push_back(cmp[v][i]), col[cmp[v][i]] ^= s;
par[u] += par[v], par[v] = u;
}
void solve(int x) {
vector<pair<int, pair<int, int> > > vec;
for (int i = 0; i < edge[x].size(); i++)
par[edge[x][i].second.first] = par[edge[x][i].second.second] = -1,
reset(edge[x][i].second.first), reset(edge[x][i].second.second);
for (int i = 0; i < edge[x].size(); i++) {
u = edge[x][i].second.first, v = edge[x][i].second.second;
if (Get_par(u) == Get_par(v)) {
if (col[u] == col[v]) {
vec.push_back(edge[x][i]);
break;
}
} else
merge(u, v, col[u] == col[v]), vec.push_back(edge[x][i]);
}
edge[x].clear();
edge[x] = vec;
}
void merge_t(int u, int v, int an) {
int p1 = 0, p2 = 0;
while (p1 < edge[u].size() || p2 < edge[v].size()) {
if (p2 == edge[v].size() ||
(p1 < edge[u].size() && edge[u][p1].first > edge[v][p2].first))
edge[an].push_back(edge[u][p1++]);
else
edge[an].push_back(edge[v][p2++]);
}
}
void build() {
for (int i = m - 1; i >= 1; i--) {
merge_t(i * 2, i * 2 + 1, i);
solve(i);
}
}
void clear() {
ans = -1, yal.clear();
fill(col, col + N, 0);
fill(par, par + N, -1);
for (int i = 1; i < n + 1; i++) reset(i);
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
;
scanf("%d", &w);
;
edge[i + m].push_back(make_pair(w, make_pair(u, v)));
}
build();
for (int io = 0; io < q; io++) {
clear();
scanf("%d%d", &l, &r);
;
--l, --r;
query(l, r);
sort(yal.begin(), yal.end());
reverse(yal.begin(), yal.end());
for (int i = 0; i < yal.size(); i++) {
u = yal[i].second.first, v = yal[i].second.second;
if (Get_par(u) == Get_par(v)) {
if (col[u] == col[v]) {
ans = yal[i].first;
break;
}
} else
merge(u, v, col[u] == col[v]);
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int n, m, q;
pair<pair<int, int>, pair<int, int> > edges[maxn * maxn];
pair<int, int> par[maxn];
pair<int, int> getpar(int a) {
if (par[a].first == a) return par[a];
pair<int, int> p = getpar(par[a].first);
return par[a] = make_pair(p.first, p.second ^ par[a].second);
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &edges[i].second.first, &edges[i].second.second,
&edges[i].first.first);
edges[i].first.second = i;
}
sort(edges, edges + m);
reverse(edges, edges + m);
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--;
for (int j = 1; j <= n; j++) par[j] = make_pair(j, 0);
bool b = 0;
for (int j = 0; j < m; j++)
if (l <= edges[j].first.second && edges[j].first.second < r) {
pair<int, int> x = getpar(edges[j].second.first),
y = getpar(edges[j].second.second);
if (x.first == y.first) {
if (x.second == y.second) {
printf("%d\n", edges[j].first.first);
b = 1;
break;
}
} else {
par[x.first] = make_pair(y.first, x.second ^ y.second ^ 1);
}
}
if (!b) printf("-1\n");
}
}
|
#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];
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]];
b[0] = e[i].u;
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;
}
uu = p[b[0]];
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>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops, no-stack-protector")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const long long maxn = 1e6 + 530;
const long long mod = 998244353;
const long long base = 1e9;
long long par[maxn][2];
long long find_par(long long u, long long t) {
if (par[u][t] < 0) return u;
return par[u][t] = find_par(par[u][t], t);
}
void dsu(long long x, long long y, long long t) {
if (x == 0 || y == 0) return;
x = find_par(x, t);
y = find_par(y, t);
if (x == y) return;
if (par[x][t] > par[y][t]) swap(x, y);
par[x][t] += par[y][t];
par[y][t] = x;
}
struct tk {
long long x, y, w, pos;
};
long long nxt[maxn];
tk a[maxn];
bool lf(tk a, tk b) { return a.w > b.w; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.out", "w", stdout);
}
long long n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> a[i].x >> a[i].y >> a[i].w;
a[i].pos = i;
}
sort(a + 1, a + m + 1, lf);
while (q--) {
long long l, r;
cin >> l >> r;
for (int i = 1; i <= n; i++) {
par[i][0] = -1;
par[i][1] = -1;
nxt[i] = 0;
}
long long ans = -1;
for (int i = 1; i <= m; i++) {
if (a[i].pos > r || a[i].pos < l) continue;
long long x = a[i].x;
long long y = a[i].y;
long long x1 = find_par(x, 0);
long long y1 = find_par(y, 0);
if (x1 == y1) {
x = find_par(x, 1);
y = find_par(y, 1);
if (x == y) {
ans = a[i].w;
break;
}
} else {
dsu(x1, y1, 0);
dsu(x, nxt[y], 1);
dsu(y, nxt[x], 1);
nxt[x] = y;
nxt[y] = x;
}
}
cout << ans << "\n";
}
}
|
#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 (rand() % 2) {
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;
inline long long readint() {
long long a = 0;
char c = getchar(), f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -f;
for (; '0' <= c && c <= '9'; c = getchar())
a = (a << 3) + (a << 1) + (c ^ 48);
return a * f;
}
template <class T>
void getMax(T &a, const T &b) {
if (a < b) a = b;
}
const int MaxM = 1000005;
const int MaxN = 1005;
int n;
namespace UFS {
int fa[MaxN], val[MaxN];
void init() {
for (int i = 1; i <= n; ++i) fa[i] = i, val[i] = 0;
}
int find(int a) {
if (fa[a] == a) return a;
int root = find(fa[a]);
val[a] ^= val[fa[a]];
return fa[a] = root;
}
int combine(int a, int b) {
int x = find(a), y = find(b);
if (x == y)
if (val[a] ^ val[b])
return 1;
else
return 0;
fa[x] = y;
val[x] = val[a] ^ val[b] ^ 1;
return 2;
}
}; // namespace UFS
struct Edge {
int from, to, val;
Edge(int F = 0, int T = 0, int V = 0) { from = F, to = T, val = V; }
} e[MaxM];
void hebing(vector<int> &v, vector<int> &v1, vector<int> &v2) {
int p = 0, len1 = v1.size();
int q = 0, len2 = v2.size();
int len = len1 + len2;
v.resize(len);
while (p < len1 || q < len2) {
if (p < len1 && (q >= len2 || e[v1[p]].val > e[v2[q]].val))
v[p + q] = v1[p], ++p;
else
v[p + q] = v2[q], ++q;
}
UFS::init();
int delta = 0;
for (int i = 0, llb; i + delta < len; ++i) {
v[i] = v[i + delta];
llb = UFS::combine(e[v[i]].from, e[v[i]].to);
if (llb == 0) {
len = i + 1 + delta;
break;
}
if (llb == 1) ++delta, --i;
}
v.resize(len -= delta);
}
int m;
vector<int> v[MaxM << 1 | 1];
int __id(int l, int r) { return (l + r) | (l != r); }
void build(int l = 1, int r = m) {
if (l == r) {
v[__id(l, r)].resize(1);
v[__id(l, r)][0] = l;
return;
}
int t = (l + r) >> 1;
build(l, t), build(t + 1, r);
hebing(v[__id(l, r)], v[__id(l, t)], v[__id(t + 1, r)]);
}
void query(int ql, int qr, vector<int> &res, int l = 1, int r = m) {
if (ql <= l && r <= qr) {
res = v[__id(l, r)];
return;
}
int t = (l + r) >> 1;
if (qr <= t) return query(ql, qr, res, l, t);
if (t < ql) return query(ql, qr, res, t + 1, r);
vector<int> tmp[2];
query(ql, qr, tmp[0], l, t);
query(ql, qr, tmp[1], t + 1, r);
hebing(res, tmp[0], tmp[1]);
}
vector<int> res;
int main() {
n = readint(), m = readint();
int q = readint();
for (int i = 1; i <= m; ++i) {
e[i].from = readint();
e[i].to = readint();
e[i].val = readint();
}
build();
while (q--) {
int l = readint();
int r = readint();
query(l, r, res);
UFS::init();
bool notAny = true;
for (int i = 0, len = res.size(); i < len; ++i)
if (UFS::combine(e[res[i]].from, e[res[i]].to) == 0) notAny = false;
if (!notAny)
printf("%d\n", e[res.back()].val);
else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const M = 5e5 + 41;
int const N = 1e3 + 41;
int n, m, q, cost[M], from[M], to[M], par[N], sz[N], color[N];
vector<int> e[N];
pair<int, int> edges[M];
void clear() {
for (int i = 0; i < n; ++i) {
par[i] = i;
e[i].clear();
sz[i] = 1;
}
}
void dfs(int u, int p, int newCol, int newPar) {
color[u] = newCol;
par[u] = newPar;
for (int i = 0; i < e[u].size(); ++i) {
int to = e[u][i];
if (to == p) {
continue;
}
dfs(to, u, 1 - newCol, newPar);
}
}
void uni(int a, int b) {
if (sz[b] > sz[a]) {
swap(a, b);
}
sz[a] += sz[b];
dfs(b, b, 1 - color[a], par[a]);
}
int solve(int li, int ri) {
clear();
int a, b;
for (int i = m - 1; i >= 0; --i) {
if (edges[i].second >= li && edges[i].second <= ri) {
a = from[edges[i].second];
b = to[edges[i].second];
if (par[a] == par[b]) {
if (color[a] == color[b]) {
return edges[i].first;
}
} else {
uni(a, b);
e[a].push_back(b);
e[b].push_back(a);
}
}
}
return -1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
int f, s, c;
scanf("%d%d%d", &f, &s, &c);
--f;
--s;
from[i] = f;
to[i] = s;
cost[i] = c;
edges[i] = make_pair(c, i);
}
sort(edges, edges + m);
for (int i = 0; i < q; ++i) {
int li, ri;
scanf("%d%d", &li, &ri);
--li;
--ri;
printf("%d\n", solve(li, ri));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
const int M = 1e6 + 5;
struct DSU {
int fa[N];
int find(int x) { return (x == fa[x]) ? x : (fa[x] = find(fa[x])); }
void init(int n) {
for (int i = 0; i <= n; i++) fa[i] = i;
}
void joint(int u, int v) {
u = find(u), v = find(v);
if (u != v) fa[u] = v;
}
bool same(int u, int v) { return find(u) == find(v); }
};
struct Edge {
int id, u, v, w;
bool operator<(const Edge &o) const { return w > o.w; }
};
int n, m, q, l, r, u, v;
DSU dsu;
Edge e[M];
int solve() {
dsu.init(2 * n);
scanf("%d%d", &l, &r);
for (int i = 0; i < m; i++) {
if (e[i].id < l || e[i].id > r) continue;
u = e[i].u, v = e[i].v;
if (dsu.same(u, v)) {
return e[i].w;
} else {
dsu.joint(u, v + n);
dsu.joint(v, u + n);
}
}
return -1;
}
int main() {
while (scanf("%d%d%d", &n, &m, &q) == 3) {
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
e[i].id = i + 1;
}
sort(e, e + m);
for (int i = 0; i < q; i++) {
printf("%d\n", solve());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const nmax = 1000;
int const edgemax = nmax * (nmax - 1) / 2;
struct Edge {
int x;
int y;
int cost;
bool operator<(Edge const &a) const { return cost < a.cost; }
} v[1 + edgemax];
namespace Dsu {
vector<int> mult;
vector<int> sz;
vector<int> cost;
void initialize(int n) {
mult.resize(1 + n);
sz.resize(1 + n);
cost.resize(1 + n);
for (int i = 1; i <= n; i++) mult[i] = i;
for (int i = 1; i <= n; i++) sz[i] = 1;
for (int i = 1; i <= n; i++) cost[i] = 0;
}
int jump(int gala) {
if (gala != mult[gala]) {
int parent = mult[gala];
mult[gala] = jump(mult[gala]);
cost[gala] = cost[gala] ^ cost[parent];
}
return mult[gala];
}
int unite(int gala, int galb) {
jump(gala);
jump(galb);
if (mult[gala] == mult[galb]) {
if ((cost[gala] ^ cost[galb]) == 0)
return -1;
else
return 0;
} else {
int off = cost[gala] ^ cost[galb];
gala = jump(gala);
galb = jump(galb);
if (sz[galb] < sz[gala]) swap(gala, galb);
mult[gala] = galb;
cost[gala] = 1 ^ off;
sz[galb] += sz[gala];
return 1;
}
}
void cleartaint(vector<Edge> edges) {
for (int i = 0; i < edges.size(); i++) {
int x = edges[i].x;
int y = edges[i].y;
mult[x] = x;
mult[y] = y;
sz[x] = sz[y] = 1;
cost[x] = cost[y] = 0;
}
}
} // namespace Dsu
int n;
class SegmentTree {
private:
struct Node {
vector<Edge> edges;
Node operator+(Node a) {
Node result;
merge(edges.begin(), edges.end(), a.edges.begin(), a.edges.end(),
back_inserter(result.edges));
vector<Edge> real;
Dsu::cleartaint(result.edges);
for (int i = result.edges.size() - 1; 0 <= i; i--) {
Edge e = result.edges[i];
int verdict = Dsu::unite(e.x, e.y);
if (0 != verdict) real.push_back(e);
if (verdict == -1) break;
}
reverse(real.begin(), real.end());
result.edges = real;
return result;
}
};
vector<Node> aint;
public:
SegmentTree(int n_) { aint.resize(1 + 4 * n_); }
void build(int node, int from, int to) {
if (from < to) {
int mid = (from + to) / 2;
build(node * 2, from, mid);
build(node * 2 + 1, mid + 1, to);
aint[node] = aint[node * 2] + aint[node * 2 + 1];
} else
aint[node].edges.push_back(v[from]);
}
Node _query(int node, int from, int to, int x, int y) {
if (from == x && to == y)
return aint[node];
else {
int mid = (from + to) / 2;
if (x <= mid && y <= mid)
return _query(node * 2, from, mid, x, y);
else if (mid + 1 <= x && mid + 1 <= y)
return _query(node * 2 + 1, mid + 1, to, x, y);
else
return _query(node * 2, from, mid, x, mid) +
_query(node * 2 + 1, mid + 1, to, mid + 1, y);
}
}
int query(int node, int from, int to, int x, int y) {
Node result = _query(node, from, to, x, y);
Dsu::cleartaint(result.edges);
for (int i = result.edges.size() - 1; 0 <= i; i--) {
Edge e = result.edges[i];
if (Dsu::unite(e.x, e.y) == -1) return e.cost;
}
return -1;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) cin >> v[i].x >> v[i].y >> v[i].cost;
Dsu::initialize(n);
SegmentTree aint(m);
aint.build(1, 1, m);
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
cout << aint.query(1, 1, m, x, y) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = N * (N - 1) / 2;
struct Edge {
int u, v, w;
};
struct Node {
vector<Edge> e;
int ans = -1;
};
int p[N], vis[N], pass, change[N], sz[N];
int f(int u) { return u == p[u] ? u : f(p[u]); }
int get(int u) { return u == p[u] ? 0 : change[u] ^ get(p[u]); }
int n, m, q;
Node merge(const Node &a, const Node &b) {
Node ans;
ans.ans = max(a.ans, b.ans);
pass++;
auto init = [](int u) {
vis[u] = pass;
p[u] = u;
sz[u] = 1;
change[u] = 0;
};
bool over = false;
auto add = [&](Edge e) {
if (over) return;
if (vis[e.u] != pass) init(e.u);
if (vis[e.v] != pass) init(e.v);
int valu = get(e.u), valv = get(e.v);
int u = f(e.u), v = f(e.v);
if (u == v and valu == valv) {
over = true;
ans.ans = max(ans.ans, e.w);
return;
}
if (u != v) {
ans.e.push_back(e);
if (sz[u] < sz[v]) swap(u, v);
p[v] = u;
sz[u] += sz[v];
if (valu == valv) change[v] ^= 1;
}
};
size_t i = 0, j = 0;
while (!over and i < a.e.size() and j < b.e.size()) {
if (a.e[i].w > b.e[j].w) {
add(a.e[i++]);
} else {
add(b.e[j++]);
}
}
while (!over and i < a.e.size()) add(a.e[i++]);
while (!over and j < b.e.size()) add(b.e[j++]);
return ans;
}
Node st[2 * M];
Node query(int l, int r) {
Node ans;
for (l += m, r += m; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans = merge(ans, st[l++]);
if (r & 1) ans = merge(ans, st[--r]);
}
return ans;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; i++) {
Edge e;
scanf("%d %d %d", &e.u, &e.v, &e.w);
st[i + m].e.push_back(e);
}
for (int i = m - 1; i > 0; i--) {
st[i] = merge(st[2 * i], st[2 * i + 1]);
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", query(l - 1, r).ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 1e9 + 7;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int f[MAXN], num[MAXN];
struct enode {
int u, v, c, id;
} e[MAXN];
int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
signed main() {
int n = read(), m = read(), q = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read(), c = read();
e[i] = (enode){u, v, c, i};
}
sort(e + 1, e + m + 1, [&](enode x, enode y) { return x.c > y.c; });
while (q--) {
int l = read(), r = read(), flag = 0;
for (int i = 1; i <= n << 1; i++) f[i] = i, num[i] = 1;
for (int i = 1; i <= m; i++)
if (e[i].id >= l && e[i].id <= r) {
int x = find(e[i].u), y = find(e[i].v), xx = find(e[i].u + n),
yy = find(e[i].v + n);
if (x == y || xx == yy) {
printf("%d\n", e[i].c);
flag = 1;
break;
}
if (num[xx] > num[y])
f[y] = xx, num[xx] += num[y];
else
f[xx] = y, num[y] += num[xx];
if (num[yy] > num[x])
f[x] = yy, num[yy] += num[x];
else
f[yy] = x, num[x] += num[yy];
}
if (!flag) puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int fa[N], relation[N];
struct Edge {
int u, v, w, id;
bool operator<(const Edge &rhs) const { return w > rhs.w; }
} p[N];
int find(int x) {
if (x == fa[x]) return x;
int fx = find(fa[x]);
relation[x] ^= relation[fa[x]];
return fa[x] = fx;
}
bool Union(int u, int v) {
int fx = find(u), fy = find(v);
if (fx == fy) {
if (relation[u] == relation[v]) return false;
return true;
}
fa[fx] = fy;
relation[fx] = relation[u] ^ relation[v] ^ 1;
return true;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &p[i].u, &p[i].v, &p[i].w);
p[i].id = i;
}
sort(p + 1, p + 1 + m);
while (q--) {
int l, r, ret = -1;
scanf("%d%d", &l, &r);
for (int i = 1; i <= n; ++i) fa[i] = i, relation[i] = 0;
for (int i = 1; i <= m; ++i) {
if (p[i].id < l || p[i].id > r) continue;
if (!Union(p[i].u, p[i].v)) {
ret = p[i].w;
break;
}
}
printf("%d\n", ret);
}
return 0;
}
|
#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], col[1005];
int getfa(int u) {
if (u == fa[u]) return u;
int res = getfa(fa[u]);
col[u] ^= col[fa[u]];
fa[u] = res;
return res;
}
inline bool same(int u, int v) {
return getfa(u) == getfa(v) && col[u] == col[v];
}
inline void unite(int u, int v) {
int x = getfa(u), y = getfa(v);
if (x != y) {
col[x] = col[u] ^ col[v] ^ 1;
fa[x] = y;
}
}
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].idx = i;
arr[i].u--;
arr[i].v--;
}
sort(arr, arr + m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
l--;
for (int i = 0; i < n; i++) {
fa[i] = i;
col[i] = 0;
}
bool f = false;
for (int i = 0; i < m && !f; i++) {
if (arr[i].idx < l || arr[i].idx >= r) continue;
if (same(arr[i].u, arr[i].v)) {
printf("%d\n", arr[i].w);
f = true;
}
unite(arr[i].u, arr[i].v);
}
if (!f) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops, no-stack-protector")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int maxn = 1e6 + 530;
const int mod = 998244353;
const int base = 1e9;
int par[maxn][2];
int find_par(int u, int t) {
if (par[u][t] < 0) return u;
return par[u][t] = find_par(par[u][t], t);
}
void dsu(int x, int y, int t) {
if (x == 0 || y == 0) return;
x = find_par(x, t);
y = find_par(y, t);
if (x == y) return;
if (par[x][t] > par[y][t]) swap(x, y);
par[x][t] += par[y][t];
par[y][t] = x;
}
struct tk {
int x, y, w, pos;
};
int nxt[maxn];
tk a[maxn];
bool lf(tk a, tk b) { return a.w > b.w; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.out", "w", stdout);
}
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> a[i].x >> a[i].y >> a[i].w;
a[i].pos = i;
}
sort(a + 1, a + m + 1, lf);
while (q--) {
int l, r;
cin >> l >> r;
for (int i = 1; i <= n; i++) {
par[i][0] = -1;
par[i][1] = -1;
nxt[i] = 0;
}
int ans = -1;
for (int i = 1; i <= m; i++) {
if (a[i].pos > r || a[i].pos < l) continue;
int x = a[i].x;
int y = a[i].y;
int x1 = find_par(x, 0);
int y1 = find_par(y, 0);
if (x1 == y1) {
x = find_par(x, 1);
y = find_par(y, 1);
if (x == y) {
ans = a[i].w;
break;
}
} else {
dsu(x1, y1, 0);
dsu(x, nxt[y], 1);
dsu(y, nxt[x], 1);
nxt[x] = y;
nxt[y] = x;
}
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, w;
int id;
bool operator<(const Edge& o) const { return w > o.w; }
} edges[500000];
int n, m, q;
int r[1111];
int p[1111];
bool vis[1111];
void init() {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
p[i] = i;
r[i] = 0;
}
}
pair<int, int> Find(int u) {
if (u == p[u]) {
return make_pair(u, 0);
}
pair<int, int> pp = Find(p[u]);
r[u] = r[p[u]] ^ r[u];
p[u] = pp.first;
return make_pair(p[u], r[u]);
}
void Union(int u, int v, int relation) {
pair<int, int> fu = Find(u);
pair<int, int> fv = Find(v);
p[fu.first] = fv.first;
r[fu.first] = relation ^ r[u] ^ r[v];
}
int Relation(int u, int v) { return r[u] ^ r[v]; }
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &edges[i].u, &edges[i].v, &edges[i].w);
edges[i].id = i;
}
sort(edges + 1, edges + m + 1);
for (int i = 1; i <= q; i++) {
int ans = -1;
int l, r;
scanf("%d %d", &l, &r);
init();
for (int j = 1; j <= m; j++) {
if (edges[j].id < l || edges[j].id > r) {
continue;
}
int u = edges[j].u;
int v = edges[j].v;
if (vis[u] && vis[v]) {
if (Find(u).first != Find(v).first) {
Union(u, v, 1);
} else {
if (Relation(u, v) == 0) {
ans = edges[j].w;
break;
}
}
} else if (vis[u] && !vis[v]) {
Union(v, u, 1);
vis[v] = 1;
} else if (!vis[u] && vis[v]) {
Union(u, v, 1);
vis[u] = 1;
} else {
Union(u, v, 1);
vis[u] = vis[v] = 1;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct iii {
int first, second, T;
};
struct DS {
vector<int> p, c, r;
int n;
DS(int n) : n(n), p(n), c(n), r(n) { clear(); }
void clear() {
for (int i = 0; i < n; i++) p[i] = i, c[i] = 1, r[i] = 0;
}
pair<int, int> SetOf(int x) {
int y = 0;
while (p[x] != x) {
y += r[x];
x = p[x];
}
return {x, y % 2};
}
int Merge(int x, int y) {
pair<int, int> tx = SetOf(x);
pair<int, int> ty = SetOf(y);
if (tx.first == ty.first) {
if (tx.second != ty.second)
return 2;
else
return 1;
}
if (c[tx.first] > c[ty.first]) swap(tx, ty);
r[tx.first] = (tx.second + ty.second + 1) % 2;
p[tx.first] = ty.first;
c[ty.first] += c[tx.first];
return 0;
}
};
struct segment_tree {
vector<vector<iii>> st;
DS ds;
int n;
segment_tree(int n, int m, vector<iii> &e) : n(n), st(2 * n), ds(m) {
build(0, n, e);
}
inline int id(int b, int e) { return (b + e - 1) | (b != e - 1); }
void build(int l, int r, vector<iii> &e) {
int cur = id(l, r);
vector<iii> t;
for (int i = l; i < r; i++) t.push_back(e[i]);
sort(t.begin(), t.end(), [](iii x, iii y) { return x.T > y.T; });
ds.clear();
for (auto i : t) {
int x = ds.Merge(i.first, i.second);
if (x <= 1) st[cur].push_back(i);
if (x == 1) break;
}
if (l + 1 == r) return;
int mid = (l + r + 1) >> 1;
build(l, mid, e);
build(mid, r, e);
}
vector<iii> query(int l, int r, int li, int ri) {
int cur = id(l, r);
if (l >= ri || r <= li) return {};
if (li <= l && r <= ri) return st[cur];
int mid = (l + r + 1) >> 1;
vector<iii> ret;
for (auto i : query(l, mid, li, ri)) ret.push_back(i);
for (auto i : query(mid, r, li, ri)) ret.push_back(i);
return ret;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<iii> e(m);
for (auto &i : e) cin >> i.first >> i.second >> i.T, --i.first, --i.second;
DS ds(n);
segment_tree st(m, n, e);
while (q--) {
int l, r;
cin >> l >> r;
--l;
auto t = st.query(0, m, l, r);
sort(t.begin(), t.end(), [](iii x, iii y) { return x.T > y.T; });
int ans = -1;
for (auto i : t)
if (ds.Merge(i.first, i.second) == 1) {
ans = i.T;
break;
}
cout << ans << '\n';
ds.clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, w, id;
bool operator<(const edge& q) const { return w > q.w; }
} a[1001000];
int f[1010];
int e[1010];
int find(int a) {
if (f[a] == a) return a;
int fa = find(f[a]);
e[a] = (e[a] + e[f[a]]) & 1;
return f[a] = fa;
}
int main() {
int n, q, m;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w);
a[i].id = i + 1;
}
sort(a, a + m);
while (q--) {
for (int i = 0; i < 1010; i++) f[i] = i, e[i] = 0;
int l, r, ans = -1;
scanf("%d%d", &l, &r);
for (int i = 0; i < m; i++) {
if (a[i].id >= l && a[i].id <= r) {
int u = a[i].u, v = a[i].v;
int fu = find(u), fv = find(v);
if (fu == fv && (e[u] + e[v]) % 2 == 0) {
ans = a[i].w;
break;
}
if (fu != fv) {
f[fu] = fv;
e[fu] = (e[u] + e[v] + 1) & 1;
}
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 500010;
int aa[MAX], bb[MAX], cc[MAX];
int id[MAX];
int a[MAX], b[MAX], c[MAX];
inline bool cmp(int x, int y) { return cc[x] > cc[y]; }
const int N = 1010;
int color[N], comp[N], nc[N];
int nv[N][N];
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", aa + i, bb + i, cc + i);
aa[i]--;
bb[i]--;
id[i] = i;
}
sort(id, id + m, cmp);
for (int i = 0; i < m; i++) {
a[i] = aa[id[i]];
b[i] = bb[id[i]];
c[i] = cc[id[i]];
}
while (q--) {
int from, to;
scanf("%d %d", &from, &to);
for (int i = 0; i < n; i++) {
color[i] = 0;
comp[i] = i;
nc[i] = 1;
nv[i][0] = i;
}
from--;
to--;
int ans = -1;
for (int i = 0; i < m; i++) {
if (id[i] < from || id[i] > to) {
continue;
}
if (comp[a[i]] == comp[b[i]]) {
if (color[a[i]] == color[b[i]]) {
ans = c[i];
break;
}
} else {
int x = comp[a[i]];
int y = comp[b[i]];
if (nc[x] < nc[y]) {
swap(x, y);
}
int inv = (color[a[i]] == color[b[i]]);
for (int j = 0; j < nc[y]; j++) {
int ver = nv[y][j];
comp[ver] = x;
color[ver] ^= inv;
nv[x][nc[x]++] = ver;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
struct Node {
int u;
int v;
int w;
int id;
} s[1000010];
int fa[2010];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
bool merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return false;
fa[a] = b;
return true;
}
bool cmp(Node a, Node b) { return a.w > b.w; }
int main() {
int n = inp();
int m = inp();
int q = inp();
for (int i = 1; i <= m; i++) {
s[i].u = inp();
s[i].v = inp();
s[i].w = inp();
s[i].id = i;
}
std::sort(s + 1, s + m + 1, cmp);
while (q--) {
int l = inp();
int r = inp();
for (int i = 1; i <= (n << 1); i++) fa[i] = i;
bool flg = false;
for (int i = 1; i <= m; i++)
if (l <= s[i].id && s[i].id <= r) {
if (find(s[i].u) == find(s[i].v)) {
flg = true;
printf("%d\n", s[i].w);
break;
}
merge(s[i].u, s[i].v + n);
merge(s[i].u + n, s[i].v);
}
if (!flg) printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using LL = long long;
const int N = 1000 + 5;
int dsu[N << 1];
int n, m, nq;
int find(int x) { return dsu[x] == x ? x : dsu[x] = find(dsu[x]); }
struct Edge {
int u, v, w, id;
};
int main() {
scanf("%d%d%d", &n, &m, &nq);
std::vector<Edge> es;
for (int i = 0; i < m; ++i) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
a--;
b--;
es.push_back(Edge{a, b, w, i});
}
std::sort((es).begin(), (es).end(),
[](const Edge &a, const Edge &b) { return a.w > b.w; });
for (int i = 0; i < nq; ++i) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
std::iota(dsu, dsu + n + n, 0);
int result = -1;
for (int i = 0; i < m; ++i) {
Edge &e = es[i];
if (e.id < l || e.id > r) continue;
if (find(e.u << 1) == find(e.v << 1)) {
result = e.w;
break;
}
dsu[find(e.u << 1)] = find(e.v << 1 | 1);
dsu[find(e.u << 1 | 1)] = find(e.v << 1);
}
printf("%d\n", result);
}
}
|
#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), std::swap(a, b);
int p = (C[a] == C[b]);
C[x] ^= p;
sz[y] += sz[x];
dsu[x] = y;
find(a);
find(b);
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);
}
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>
#pragma warning(disable : 4996)
using namespace std;
int IT_MAX = 1 << 17;
const long long MOD = 1000000007;
const int INF = 1034567890;
const long long LL_INF = 1234567890123456789ll;
const double PI = acos(-1);
const long double ERR = 1E-10;
int r[1050][2];
int root(int x) {
if (r[x][0] == x) return r[x][0];
int t = r[x][0];
r[x][0] = root(r[x][0]);
r[x][1] ^= r[t][1];
return r[x][0];
}
pair<pair<int, int>, pair<int, int> > in[500050];
int main() {
int N, Q, M, i, j, t1, t2, t3, S, E;
scanf("%d %d %d", &N, &M, &Q);
for (i = 1; i <= M; i++) {
scanf("%d %d %d", &t1, &t2, &t3);
in[i] = make_pair(pair<int, int>(t3, i), pair<int, int>(t1, t2));
}
sort(in + 1, in + M + 1);
while (Q--) {
scanf("%d %d", &S, &E);
for (i = 1; i <= N; i++) r[i][0] = i, r[i][1] = 0;
for (i = M; i >= 1; i--) {
if (in[i].first.second < S || in[i].first.second > E) continue;
t1 = in[i].second.first;
t2 = in[i].second.second;
int u1 = root(t1);
int u2 = root(t2);
int u3 = r[t1][1] ^ r[t2][1] ^ 1;
if (u1 == u2 && u3 == 1) break;
r[u1][0] = u2;
r[u1][1] = u3;
}
if (i == 0)
printf("-1\n");
else
printf("%d\n", in[i].first.first);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
struct Edge {
int u, v, w, id;
Edge() {}
Edge(int a, int b, int c, int d) : u(a), v(b), w(c), id(d) {}
bool operator<(const Edge e) const { return w > e.w; }
} e[maxn * maxn];
int fa[maxn << 1];
int Find(int x) { return fa[x] == x ? fa[x] : (fa[x] = Find(fa[x])); }
void Merge(int a, int b) {
int x = Find(a);
int y = Find(b);
fa[x] = y;
}
int main() {
int n, m, q;
while (scanf("%d%d%d", &n, &m, &q) != EOF) {
int u, v, w;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &u, &v, &w);
e[i] = Edge(u, v, w, i + 1);
}
sort(e, e + m);
while (q--) {
int flag = 0;
for (int i = 1; i <= 2 * n; i++) fa[i] = i;
scanf("%d%d", &u, &v);
for (int i = 0; i < m; i++) {
if (e[i].id < u || e[i].id > v) continue;
if (Find(e[i].u) == Find(e[i].v)) {
printf("%d\n", e[i].w);
flag = 1;
break;
} else {
Merge(e[i].u, e[i].v + n);
Merge(e[i].v, e[i].u + n);
}
}
if (!flag) printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x + _y;
if (_ >= _mod) _ -= _mod;
return _;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x - _y;
if (_ < 0) _ += _mod;
return _;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x * _y;
if (_ >= _mod) _ %= _mod;
return _;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1ll;
long long _tmp = mypow(_a, _x / 2, _mod);
_tmp = mul(_tmp, _tmp, _mod);
if (_x & 1) _tmp = mul(_tmp, _a, _mod);
return _tmp;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0ll;
long long _tmp = mymul(_a, _x / 2, _mod);
_tmp = add(_tmp, _tmp, _mod);
if (_x & 1) _tmp = add(_tmp, _a, _mod);
return _tmp;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int __ = 1, _cs;
void build() {}
int n, m, q, p[1021 * 2];
int find_p(int x) { return x == p[x] ? x : p[x] = find_p(p[x]); }
void Union(int x, int y) { p[find_p(x)] = find_p(y); }
vector<pair<pair<int, int>, pair<int, int> > > v;
void init() {
n = getint();
m = getint();
q = getint();
for (int i = 1; i <= m; i++) {
int ui = getint();
int vi = getint();
int wi = getint();
v.push_back({{wi, i}, {ui, vi}});
}
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
}
void solve() {
while (q--) {
int li = getint();
int ri = getint();
int ans = -1;
for (int i = 1; i <= n + n; i++) p[i] = i;
for (size_t i = 0; i < v.size(); i++) {
if (v[i].first.second < li || v[i].first.second > ri) continue;
int ui = v[i].second.first, vi = v[i].second.second;
if (find_p(ui) == find_p(vi)) {
ans = v[i].first.first;
break;
}
Union(ui, vi + n);
Union(vi, ui + n);
}
printf("%d\n", ans);
}
}
int main() {
build();
while (__--) {
init();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1011, M = N * N / 2;
const int inf = 0x3f3f3f3f;
struct Edg {
int u, v, w, id;
void read() { scanf("%d%d%d", &u, &v, &w); }
bool operator<(const Edg& t) const { return w > t.w; }
} e[M];
int n, m;
int f[N], g[N];
inline int fa(int i) {
static int j;
return f[i] == i ? i : (j = fa(f[i]), g[i] ^= g[f[i]], f[i] = j);
}
int Solve(int l, int r) {
for (int i = 0; i <= n; ++i) {
f[i] = i;
g[i] = 0;
}
for (int i = 1; i <= m; ++i) {
Edg& x = e[i];
if (x.id > r || x.id < l) continue;
int u = fa(x.u), v = fa(x.v);
;
if (u == v) {
if (g[x.u] == g[x.v]) {
return x.w;
}
} else {
f[v] = u, g[v] = g[x.u] ^ g[x.v] ^ 1;
}
};
return -1;
}
int main() {
int T;
scanf("%d%d%d", &n, &m, &T);
for (int i = 1; i <= m; ++i) {
e[i].read();
e[i].id = i;
}
sort(e + 1, e + m + 1);
for (; T--;) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", Solve(l, r));
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long Rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void Rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
Rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int N = 1005, M = 500005;
struct Edge {
int u, v, w, id;
bool operator<(const Edge& x) const { return w > x.w; }
} E[M];
int n, m, q, Fa[N], Val[N], Dep[N];
int Find(int x) {
if (x == Fa[x]) return x;
int F = Find(Fa[x]);
Val[x] = Val[x] ^ Val[Fa[x]];
return Fa[x] = F;
}
int main() {
n = Rd(), m = Rd(), q = Rd();
for (int i = 1; i <= (int)m; i++)
E[i].u = Rd(), E[i].v = Rd(), E[i].w = Rd(), E[i].id = i;
sort(E + 1, E + m + 1);
while (q--) {
int l = Rd(), r = Rd();
for (int i = 1; i <= (int)n; i++) Fa[i] = i, Val[i] = 0, Dep[i] = 1;
int sign = 0;
for (int i = 1; i <= (int)m; i++) {
if (E[i].id > r || E[i].id < l) continue;
int Fu = Find(E[i].u), Fv = Find(E[i].v);
if (Fu != Fv) {
if (Dep[Fu] < Dep[Fv]) swap(Fu, Fv);
Fa[Fv] = Fu;
if (Dep[Fv] == Dep[Fu]) Dep[Fu]++;
Val[Fv] = Val[E[i].v] ^ Val[E[i].u] ^ 1;
} else {
if (Val[E[i].u] == Val[E[i].v]) {
Rt(E[i].w), putchar('\n');
sign = 1;
break;
}
}
}
if (!sign) puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct unionFind {
vector<int> u;
vector<int> us;
vector<int> ucol;
unionFind(int n) : u(n + 1), us(n + 1), ucol(n + 1) {
for (int i = 1; i <= n; i++) {
u[i] = i;
us[i] = 1;
ucol[i] = 0;
}
}
int get(int x) {
if (x == u[x]) return x;
int res = get(u[x]);
ucol[x] ^= ucol[u[x]];
u[x] = res;
return u[x];
}
void un(int a0, int b0) {
int a = get(a0);
int b = get(b0);
if (a != b) {
if (us[a] < us[b]) {
swap(a, b);
}
us[a] += us[b];
u[b] = a;
ucol[b] = ucol[a0] ^ ucol[b0] ^ 1;
}
}
};
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
vector<pair<int, int>> w(m);
vector<pair<int, int>> e(m);
for (int i = 0; i < m; ++i) {
scanf("%d %d %d", &e[i].first, &e[i].second, &w[i].first);
e[i].first--;
e[i].second--;
w[i].second = i;
}
sort(w.begin(), w.end(), greater<pair<int, int>>());
for (int qi = 0; qi < q; ++qi) {
int l, r;
scanf("%d %d", &l, &r);
l--;
unionFind u(n);
bool found = false;
for (auto x : w) {
if (x.second < l || x.second >= r) continue;
int a = e[x.second].first, b = e[x.second].second;
int ra = u.get(a + 1);
int rb = u.get(b + 1);
if (ra != rb) {
u.un(a + 1, b + 1);
} else {
if ((u.ucol[ra] ^ u.ucol[a + 1]) == (u.ucol[rb] ^ u.ucol[b + 1])) {
printf("%d\n", x.first);
found = true;
break;
}
}
}
if (!found) {
printf("-1\n");
}
}
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);
}
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;
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() {
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;
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;
const int N = 1005;
const int M = N * (N - 1) / 2;
struct Edge {
int u, v, w;
};
struct Node {
vector<Edge> e;
int ans = -1;
};
int p[N], vis[N], pass, change[N], sz[N];
int f(int u) { return u == p[u] ? u : f(p[u]); }
int get(int u) { return u == p[u] ? 0 : change[u] ^ get(p[u]); }
int n, m, q;
Node merge(const Node &a, const Node &b) {
Node ans;
ans.ans = max(a.ans, b.ans);
ans.e.reserve(max(a.e.size(), b.e.size()));
pass++;
auto init = [](int u) {
vis[u] = pass;
p[u] = u;
sz[u] = 1;
change[u] = 0;
};
bool over = false;
auto add = [&](Edge e) {
if (over) return;
if (vis[e.u] != pass) init(e.u);
if (vis[e.v] != pass) init(e.v);
int valu = get(e.u), valv = get(e.v);
int u = f(e.u), v = f(e.v);
if (u == v and valu == valv) {
over = true;
ans.ans = max(ans.ans, e.w);
return;
}
if (u != v) {
ans.e.push_back(e);
if (sz[u] < sz[v]) swap(u, v);
p[v] = u;
sz[u] += sz[v];
if (valu == valv) change[v] ^= 1;
}
};
size_t i = 0, j = 0;
while (!over and i < a.e.size() and j < b.e.size()) {
if (a.e[i].w > b.e[j].w) {
add(a.e[i++]);
} else {
add(b.e[j++]);
}
}
while (!over and i < a.e.size()) add(a.e[i++]);
while (!over and j < b.e.size()) add(b.e[j++]);
return ans;
}
Node st[2 * M];
Node query(int l, int r) {
Node ans;
for (l += m, r += m; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans = merge(ans, st[l++]);
if (r & 1) ans = merge(ans, st[--r]);
}
return ans;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; i++) {
Edge e;
scanf("%d %d %d", &e.u, &e.v, &e.w);
st[i + m].e.push_back(e);
}
for (int i = m - 1; i > 0; i--) {
st[i] = merge(st[2 * i], st[2 * i + 1]);
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", query(l - 1, r).ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
struct bian {
int from, to, w, i;
} b[2000000];
int cmp(const bian &a, const bian &b) {
if (a.w > b.w)
return 1;
else
return 0;
}
int l[10000], r[10000];
int father[10000], path[10000];
int findd(int x) {
if (father[x] == x) return x;
int t = father[x];
father[x] = findd(father[x]);
path[x] = (path[t] + path[x]) % 2;
return father[x];
}
int fx, fy;
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &b[i].from, &b[i].to, &b[i].w);
b[i].i = i;
}
sort(b + 1, b + m + 1, cmp);
for (int i = 1; i <= q; i++) scanf("%d%d", &l[i], &r[i]);
for (int i = 1; i <= q; i++) {
int ans = 0;
for (int j = 1; j <= n; j++) {
path[j] = 0;
father[j] = j;
}
for (int j = 1; j <= m; j++)
if (b[j].i <= r[i] && b[j].i >= l[i]) {
fx = findd(b[j].from);
fy = findd(b[j].to);
if (fx != fy) {
father[fx] = fy;
path[fx] = (1 + path[b[j].from] + path[b[j].to]) % 2;
} else if (path[b[j].from] == path[b[j].to]) {
cout << b[j].w << endl;
ans = 1;
break;
}
}
if (!ans) cout << -1 << endl;
;
}
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 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) {
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 (int i = 0; i < (m); ++i) {
Edge e = edge[i];
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(get(opp[u]), v);
} else {
opp[u] = v;
}
if (opp[v] != -1) {
merge(get(opp[v]), u);
} else {
opp[v] = u;
}
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1 << 20;
const long long second = 1 << 10;
long long n, m, q, v[N], u[N], w[N], par[N], f[second];
vector<long long> seg[N << 2], V;
bool CMP(long long i, long long j) { return w[i] > w[j]; }
long long Find(long long v) {
if (par[v] == v) return v;
long long p = Find(par[v]);
f[v] ^= f[par[v]];
par[v] = p;
return p;
}
long long Union(long long v, long long u) {
long long vv = Find(v), uu = Find(u);
if (vv == uu) {
if (f[v] == f[u]) return 0;
return 1;
}
par[vv] = uu;
f[vv] = f[v] == f[u];
return 2;
}
void build(int id = 1, int b = 0, int e = m) {
vector<long long> vec;
memset(f, 0, sizeof f);
iota(par, par + n + 1, 0);
for (int i = b; i < e; i++) vec.push_back(i);
sort(vec.begin(), vec.end(), CMP);
for (auto i : vec) {
long long x = Union(v[i], u[i]);
if (!x) {
seg[id].push_back(i);
break;
}
if (x == 1) continue;
seg[id].push_back(i);
}
if (e - b == 1) return;
build((id << 1), b, ((b + e) >> 1));
build(((id << 1) | 1), ((b + e) >> 1), e);
}
void get(int l, int r, int id = 1, int b = 0, int e = m) {
if (r <= b || e <= l) return;
if (l <= b && e <= r) {
for (auto i : seg[id]) V.push_back(i);
return;
}
get(l, r, (id << 1), b, ((b + e) >> 1));
get(l, r, ((id << 1) | 1), ((b + e) >> 1), e);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
cin >> v[i] >> u[i] >> w[i];
}
build();
while (q--) {
long long l, r;
cin >> l >> r;
l--;
memset(f, 0, sizeof f);
iota(par, par + n + 1, 0);
V.clear();
get(l, r);
long long ans = -1;
sort(V.begin(), V.end(), CMP);
for (auto i : V) {
long long x = Union(v[i], u[i]);
if (x == 0) {
ans = w[i];
break;
}
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
bool p = 0;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') p = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c ^ 48);
if (p) x = -x;
}
struct node {
int id, l, r, val;
} Hina[1000005], Aya[1000005];
int enemy[1005], f[1005], n, m, q, cnt;
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
bool cmp(node a, node b) { return a.val > b.val; }
int query(int L, int R) {
for (int i = 1; i <= n; ++i) f[i] = i;
memset(enemy, 0, sizeof(enemy));
cnt = 0;
for (int i = 1; i <= m; ++i) {
if (Hina[i].id >= L && Hina[i].id <= R) {
Aya[++cnt] = Hina[i];
}
}
for (int i = 1; i <= cnt; ++i) {
int u = Aya[i].l, v = Aya[i].r;
if (find(u) == find(v)) {
return Aya[i].val;
}
if (!enemy[u]) {
enemy[u] = v;
} else {
f[find(enemy[u])] = find(v);
}
if (!enemy[v]) {
enemy[v] = u;
} else {
f[find(enemy[v])] = find(u);
}
}
return -1;
}
int main() {
read(n), read(m), read(q);
for (int i = 1; i <= m; ++i) {
read(Hina[i].l), read(Hina[i].r), read(Hina[i].val);
Hina[i].id = i;
}
sort(Hina + 1, Hina + m + 1, cmp);
for (int i = 1, L, R; i <= q; ++i) {
read(L), read(R);
printf("%d\n", query(L, R));
}
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];
bool color[N];
int find(int x) {
if (p[x] < 0) return x;
int bef = p[x];
p[x] = find(p[x]);
color[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--) {
for (int i = 0; i < n; i++) {
p[i] = -1;
color[i] = 0;
}
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;
int edges[566456][3];
const int S = 1 << 19;
vector<int> tree[2 * S];
vector<int> out;
pair<int, bool> parent[1234];
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;
}
}
}
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]);
}
}
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 build(int l, int r, int node) {
vector<int> inds;
for (int i = l; i <= min(m - 1, r); ++i) inds.push_back(i);
calc(inds);
tree[node] = out;
if (l < r) {
int s = (l + r) / 2;
build(l, s, 2 * node);
build(s + 1, r, 2 * node + 1);
}
}
void zbieraj(int l, int r, int ll, int rr, int node, vector<int>& inds) {
if (r < ll || rr < l) {
return;
}
if (l <= ll && rr <= r) {
for (int ind : tree[node]) {
inds.push_back(ind);
}
return;
}
int ss = (ll + rr) / 2;
zbieraj(l, r, ll, ss, 2 * node, inds);
zbieraj(l, r, ss + 1, rr, 2 * node + 1, inds);
}
int query() {
int l, r;
scanf("%d%d", &l, &r);
--l;
--r;
vector<int> inds;
zbieraj(l, r, 0, S - 1, 1, inds);
return calc(inds);
}
int main() {
loda();
build(0, S - 1, 1);
for (int i = 0; i < q; ++i) {
printf("%d\n", query());
}
}
|
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 1010, M = 5e5 + 10, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n, m, q;
struct Edge {
int x, y, z, o;
bool operator<(const Edge &b) const { return z > b.z; }
} a[M];
int f[N], op[N];
int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
int solve(int l, int r) {
for (int i = 1; i <= n; ++i) f[i] = i, op[i] = -1;
for (int i = 1; i <= m; ++i)
if (a[i].o >= l && a[i].o <= r) {
int x = find(a[i].x);
int y = find(a[i].y);
if (x == y) return a[i].z;
if (op[x] == -1) op[x] = y;
if (op[y] == -1) op[y] = x;
op[x] = find(op[x]);
op[y] = find(op[y]);
f[x] = op[y];
f[y] = op[x];
}
return -1;
}
int main() {
while (~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].z);
a[i].o = i;
}
sort(a + 1, a + m + 1);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%d\n", solve(x, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct st {
bool bp;
int l[1005], cl[1005];
vector<tuple<int, int, int> > el;
void rst() {
bp = true;
el.clear();
for (int i = (0); i < (1000); i++) l[i] = i, cl[i] = 0;
}
int gl(int i) {
if (i == l[i])
return l[i];
else {
int nl = gl(l[i]);
cl[i] ^= cl[l[i]];
l[i] = nl;
return nl;
}
}
int gc(int i) {
gl(i);
return cl[i];
}
void adde(int i, int j, int w) {
if (!bp) return;
gl(i);
gl(j);
if (l[i] == l[j]) {
if (cl[i] ^ cl[j] ^ 1) {
bp = false;
el.emplace_back(w, i, j);
}
} else {
cl[l[j]] = 1 ^ cl[j] ^ cl[i];
l[l[j]] = l[i];
el.emplace_back(w, i, j);
}
}
};
st rt[4010];
int n, m, q;
tuple<int, int, int> t[600000];
long long eo[600000];
int cp[600000];
vector<int> sp;
int l[1005], r[1005];
int rtn;
void added(int i, int x, int y, int w) {
for (i += rtn; i > 0; i /= 2) {
rt[i].adde(x, y, w);
}
}
vector<tuple<int, int, int> > el;
st qus;
int qu(int i, int j) {
el.clear();
for (i += rtn, j += rtn; i < j; i /= 2, j /= 2) {
if (i & 1) {
el.insert(el.end(), rt[i].el.begin(), rt[i].el.end()), i++;
}
if (j & 1) {
j--;
el.insert(el.end(), rt[j].el.begin(), rt[j].el.end());
}
}
sort(el.begin(), el.end());
reverse(el.begin(), el.end());
qus.rst();
for (auto ed : el) {
int w, x, y;
tie(w, x, y) = ed;
qus.adde(x, y, w);
if (!qus.bp) return w;
}
return -1;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = (0); i < (m); i++) {
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
x--;
y--;
t[i] = make_tuple(x, y, w);
eo[i] = (1000000005 - w) * 1ll * m + i;
}
sort(eo, eo + m);
for (int i = (0); i < (m); i++) eo[i] %= m;
sp.push_back(0);
sp.push_back(m);
for (int i = (0); i < (q); i++) {
scanf("%d %d", l + i, r + i);
l[i]--;
sp.push_back(l[i]);
sp.push_back(r[i]);
}
sort(sp.begin(), sp.end());
sp.resize(unique(sp.begin(), sp.end()) - sp.begin());
for (int i = (0); i < (int(sp.size()) - 1); i++)
for (int j = sp[i]; j < sp[i + 1]; j++) cp[j] = i;
cp[m] = int(sp.size()) - 1;
rtn = int(sp.size());
for (int i = (0); i < (2 * rtn); i++) rt[i].rst();
for (int i = (0); i < (m); i++) {
int j = eo[i];
int x, y, w;
tie(x, y, w) = t[j];
added(cp[j], x, y, w);
}
for (int i = (0); i < (q); i++) {
printf("%d\n", qu(cp[l[i]], cp[r[i]]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
const int INF = 2000000000;
const ll LLINF = 9000000000000000000;
constexpr size_t NMAX = 1000;
constexpr size_t MMAX = 1000000;
constexpr size_t TMAX = 2000000;
template <class T>
struct resettable_vector {
vector<T> val, def;
vi time;
int cur = 0;
resettable_vector(int n, T d) {
val.assign(n, d);
def.assign(n, d);
time.assign(n, cur = 0);
}
T get(int i) { return time[i] == cur ? val[i] : def[i]; }
void set(int i, T v) {
val[i] = v;
time[i] = cur;
}
void set_default(int i, T v) { def[i] = v; }
void reset() { ++cur; }
};
struct AdvancedUnionFind {
int n, c;
bool bipartite = true;
resettable_vector<int> par, rank, size;
resettable_vector<bool> sign;
AdvancedUnionFind(int _n)
: n(_n), c(n), par(n, 0), rank(n, 0), size(n, 1), sign(n, false) {
for (int i = 0; i < n; ++i) par.set(i, i), par.set_default(i, i);
}
int find(int i) {
if (par.get(i) == i) return i;
int p = find(par.get(i));
if (par.get(i) != p && sign.get(par.get(i))) sign.set(i, !sign.get(i));
par.set(i, p);
return p;
}
bool same(int i, int j) { return find(i) == find(j); }
bool sign_of(int u, int pu = -1) {
if (pu == -1) pu = find(u);
bool su = sign.get(u);
if (u != pu && sign.get(pu)) su = !su;
return su;
}
bool merge(int i, int j, bool diff = true) {
int pi = find(i), pj = find(j);
if (pi == pj) {
bool si = sign_of(i, pi), sj = sign_of(j, pj);
if (si == sj && diff) bipartite = false;
if (si != sj && !diff) bipartite = false;
return bipartite;
}
c--;
if (rank.get(pi) > rank.get(pj)) swap(i, j), swap(pi, pj);
bool si = sign_of(i, pi), sj = sign_of(j, pj);
if ((si == sj && diff) || (si != sj && !diff)) sign.set(pi, !sign.get(pi));
par.set(pi, pj);
size.set(pj, size.get(pj) + size.get(pi));
if (rank.get(pi) == rank.get(pj)) rank.set(pj, rank.get(pj) + 1);
return bipartite;
}
void reset() {
par.reset();
rank.reset();
size.reset();
sign.reset();
bipartite = true;
c = n;
}
};
int n, m, q;
vector<pair<ii, ll>> E;
constexpr int SZ = 1e6;
vb sign;
AdvancedUnionFind uf(NMAX);
vector<pair<ll, vi>> ans(SZ, {-2LL, vi()});
map<ii, int> cache;
void combine_into(pair<ll, vi> &lv, pair<ll, vi> &rv, pair<ll, vi> &o) {
uf.reset();
size_t lx = 0, rx = 0;
while (lx < lv.second.size() || rx < rv.second.size()) {
int i = (lx < lv.second.size() ? lv.second[lx] : rv.second[rx]);
if (rx < rv.second.size() && E[i].second <= E[rv.second[rx]].second) {
i = rv.second[rx];
++rx;
} else
++lx;
int u = E[i].first.first, v = E[i].first.second;
int pu = uf.find(u), pv = uf.find(v);
if (pu == pv && uf.sign_of(u, pu) != uf.sign_of(v, pv)) continue;
o.second.push_back(i);
if (!uf.merge(u, v)) {
o.first = E[i].second;
break;
}
}
}
void ptup(pair<ll, vi> &v) {
cerr << "{" << v.first << ",";
for (ll w : v.second)
cerr << " ((" << E[w].first.first << "," << E[w].first.second << "),"
<< E[w].second << ")";
cerr << "}";
}
int solve(int l, int r) {
auto it = cache.find({l, r});
if (it != cache.end()) return it->second;
cache.insert({{l, r}, cache.size()});
int id = cache.size() - 1;
ans[id].first = -1LL;
int lid = solve(l, (l + r) / 2), rid = solve((l + r) / 2 + 1, r);
combine_into(ans[lid], ans[rid], ans[id]);
return id;
}
void accumulate(int l, int r, int L, int R, vi &res) {
if (r < L || R < l) return;
if (l <= L && R <= r)
res.push_back(solve(L, R));
else {
accumulate(l, r, L, (L + R) / 2, res);
accumulate(l, r, (L + R) / 2 + 1, R, res);
}
}
ll query(int l, int r) {
vi res;
accumulate(l, r, 0, m - 1, res);
vector<pair<ll, vi>> resa(2, {-1LL, vi()});
for (size_t i = 0; i < res.size(); ++i) {
resa[i & 1].second.clear();
combine_into(resa[(i & 1) ^ 1], ans[res[i]], resa[i & 1]);
}
return resa[(1 & res.size()) ^ 1].first;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
E.assign(m, {{-1, -1}, 0LL});
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
E[i] = {{u - 1, v - 1}, ll(w)};
ans[cache.size()] = {-1LL, vi{i}};
cache.insert({{i, i}, cache.size()});
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
cout << query(l - 1, r - 1) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace std {
template <class S, class T>
struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T>
struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v) h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v) os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v) os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int n, m, q;
vector<pair<pair<int, int>, pair<int, int>>> e;
int p[2000], height[2000];
inline int root(int x) { return x == p[x] ? x : (p[x] = root(p[x])); }
inline void merge(int a, int b) {
a = root(a);
b = root(b);
if (height[a] > height[b])
swap(a, b);
else if (height[a] == height[b])
height[a]++;
p[b] = a;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < (int)m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
e.emplace_back(make_pair(c, i), make_pair(a, b));
}
sort((e).begin(), (e).end());
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
l--;
int ans = -1;
for (int i = 0; i < (int)2 * n; i++) p[i] = i, height[i] = 0;
for (int i = (int)e.size() - 1; i >= 0; i--)
if (l <= e[i].first.second && e[i].first.second < r) {
int a = e[i].second.first, b = e[i].second.second;
int a0 = root(a * 2), b1 = root(b * 2 + 1);
if (a0 == b1) continue;
merge(b1, a0);
merge(b * 2, a * 2 + 1);
if (root(a * 2) == root(b * 2)) {
ans = e[i].first.first;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, Q, fa[500020], g[500020], p[500020];
vector<int> t, T[500020 << 2];
int read() {
int x = 0, k = 1;
char c;
c = getchar();
while (c < '0' || c > '9') {
if (c == '-') k = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * k;
}
struct edge {
int u, v, w;
} e[500020];
int find(int x) {
if (fa[x] == x) return x;
int t = fa[x];
fa[x] = find(fa[x]);
g[x] ^= g[t];
return fa[x];
}
vector<int> Merge(vector<int> a, vector<int> b) {
int cnt = 0;
vector<int> c;
for (int i = 0; i < a.size(); i++) {
int x = a[i];
fa[e[x].u] = e[x].u, fa[e[x].v] = e[x].v;
g[e[x].u] = g[e[x].v] = 0;
}
for (int i = 0; i < b.size(); i++) {
int x = b[i];
fa[e[x].u] = e[x].u, fa[e[x].v] = e[x].v;
g[e[x].u] = g[e[x].v] = 0;
}
for (int i = 0, j = 0; i < a.size() || j < b.size();) {
if (i < a.size() && (j == b.size() || e[a[i]].w > e[b[j]].w))
p[++cnt] = a[i], i++;
else
p[++cnt] = b[j], j++;
}
for (int i = 1; i <= cnt; i++) {
int x = e[p[i]].u, y = e[p[i]].v;
if (find(x) != find(y))
g[fa[x]] = g[x] ^ g[y] ^ 1, fa[fa[x]] = fa[y], c.push_back(p[i]);
else if (g[x] != g[y])
continue;
else {
c.push_back(p[i]);
break;
}
}
return c;
}
void Build(int p, int l, int r) {
if (l == r) {
T[p].push_back(l);
return;
}
int mid = (l + r) >> 1;
Build(p << 1, l, mid), Build(p << 1 | 1, mid + 1, r);
T[p] = Merge(T[p << 1], T[p << 1 | 1]);
}
vector<int> Query(int p, int l, int r, int L, int R) {
if (L <= l && R >= r) return T[p];
int mid = (l + r) >> 1;
if (R <= mid)
return Query(p << 1, l, mid, L, R);
else if (L > mid)
return Query(p << 1 | 1, mid + 1, r, L, R);
return Merge(Query(p << 1, l, mid, L, R),
Query(p << 1 | 1, mid + 1, r, L, R));
}
int main() {
n = read(), m = read(), Q = read();
for (int i = 1; i <= m; i++)
e[i].u = read(), e[i].v = read(), e[i].w = read();
Build(1, 1, m);
for (int i = 1; i <= Q; i++) {
int L = read(), R = read();
t = Query(1, 1, m, L, R);
for (int j = 0; j < t.size(); j++)
fa[e[t[j]].u] = e[t[j]].u, fa[e[t[j]].v] = e[t[j]].v;
int ans = -1;
for (int j = 0; j < t.size(); j++) {
int u = e[t[j]].u, v = e[t[j]].v;
if (find(u) == find(v)) {
ans = e[t[j]].w;
break;
}
fa[fa[u]] = fa[v];
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, pair<int, int> > E[1000000];
int p[1002], d[1002];
pair<int, int> find(int u, int cur) {
if (p[u] != u) {
pair<int, int> res = find(p[u], (cur + d[u]) % 2);
int pp = res.first;
int dd = res.second;
p[u] = pp;
d[u] = (cur + dd) % 2;
return make_pair(pp, dd);
} else {
return make_pair(u, cur);
}
}
int main() {
ios::sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> E[i].second.first >> E[i].second.second >> E[i].first.first;
E[i].first.second = i;
}
sort(E + 1, E + m + 1);
for (int i = 0; i < q; i++) {
for (int i = 1; i <= n; i++) {
p[i] = i;
d[i] = 0;
}
int l, r;
cin >> l >> r;
bool found = false;
int w = 12341234;
for (int j = m; j >= 1; j--) {
int ind = E[j].first.second;
if (ind < l || ind > r) continue;
w = E[j].first.first;
int u = E[j].second.first;
int v = E[j].second.second;
pair<int, int> res = find(u, 0);
int r = res.first;
int d1 = res.second;
res = find(v, 0);
int s = res.first;
int d2 = res.second;
if (r != s) {
p[s] = r;
d[s] = (d1 + d2 + 1) % 2;
} else if (d1 == d2) {
found = true;
break;
}
}
if (found) {
cout << w << endl;
} else {
cout << -1 << endl;
}
}
}
|
#include <bits/stdc++.h>
int n, m, q;
int uft[1010][2];
int uftf(int x) {
if (x == uft[x][0]) return x;
uftf(uft[x][0]);
uft[x][1] = uft[uft[x][0]][1] ^ uft[x][1];
uft[x][0] = uft[uft[x][0]][0];
return uft[x][0];
}
struct edge {
int a, b, c;
bool operator<(const edge& r) const { return c > r.c; }
};
struct edgeb {
int a, b, c;
bool operator<(const edgeb& r) const { return c < r.c; }
};
edge eg[501000];
struct itnod {
std::vector<edge>* a;
itnod operator+(itnod z) {
itnod res;
res.a = new std::vector<edge>;
int i, j;
edge t;
for (i = 1; i <= n; i++) {
uft[i][0] = i;
uft[i][1] = 0;
}
i = 0;
j = 0;
while (i < a->size() || j < z.a->size()) {
if (i != a->size() && (j == z.a->size() || (*(a))[i] < (*(z.a))[j])) {
t = (*a)[i];
i++;
} else {
t = (*z.a)[j];
j++;
}
if (uftf(t.a) != uftf(t.b)) {
uft[uft[t.a][0]][1] = 1 ^ uft[t.a][1] ^ uft[t.b][1];
uft[uft[t.a][0]][0] = uftf(t.b);
(*res.a).push_back(t);
} else {
if (uft[t.a][1] == uft[t.b][1]) {
(*res.a).push_back(t);
break;
}
}
}
return res;
}
};
const int bucketsz = 1 << 10;
const int itsz = 1 << 9;
itnod it[2 * itsz];
edge es[itsz][bucketsz];
int essz[itsz];
std::priority_queue<edgeb> pq;
itnod itcalc(int start, int end) {
start += itsz;
end += itsz;
itnod res;
res.a = new std::vector<edge>;
std::vector<edge>* pa = res.a;
while (start <= end) {
if (start % 2 == 1) {
res = res + it[start];
pa->clear();
free(pa);
pa = res.a;
start++;
}
if (end % 2 == 0) {
res = res + it[end];
pa->clear();
free(pa);
pa = res.a;
end--;
}
start /= 2;
end /= 2;
}
return res;
}
int main() {
int i, j, k;
int a, b;
edgeb t;
scanf("%d%d%d", &n, &m, &q);
for (i = 0; i < m; i++) {
scanf("%d%d%d", &eg[i].a, &eg[i].b, &eg[i].c);
}
for (i = 0; i < m; i++) {
es[i / bucketsz][essz[i / bucketsz]] = eg[i];
essz[i / bucketsz]++;
}
for (i = 0; i < itsz; i++) {
std::sort(es[i], es[i] + essz[i]);
}
for (i = itsz; i < 2 * itsz; i++) {
it[i].a = new std::vector<edge>;
for (j = 0; j < essz[i - itsz]; j++) {
it[i].a->push_back(es[i - itsz][j]);
}
}
for (i = itsz - 1; i > 0; i--) {
it[i] = it[i * 2] + it[i * 2 + 1];
}
for (k = 0; k < q; k++) {
scanf("%d%d", &a, &b);
a--;
b--;
itnod s = itcalc(a / bucketsz + 1, b / bucketsz - 1);
edge ta;
edgeb tb;
for (i = 0; i < s.a->size(); i++) {
ta = (*s.a)[i];
tb.a = ta.a;
tb.b = ta.b;
tb.c = ta.c;
pq.push(tb);
}
for (i = a; i <= b && i / bucketsz == a / bucketsz; i++) {
ta = eg[i];
tb.a = ta.a;
tb.b = ta.b;
tb.c = ta.c;
pq.push(tb);
}
if (i != b + 1) {
for (i = b; i / bucketsz == b / bucketsz; i--) {
ta = eg[i];
tb.a = ta.a;
tb.b = ta.b;
tb.c = ta.c;
pq.push(tb);
}
}
for (i = 1; i <= n; i++) {
uft[i][0] = i;
uft[i][1] = 0;
}
int ans = -1;
while (pq.size() > 0) {
t = pq.top();
pq.pop();
if (uftf(t.a) != uftf(t.b)) {
uft[uft[t.a][0]][1] = 1 ^ uft[t.a][1] ^ uft[t.b][1];
uft[uft[t.a][0]][0] = uftf(t.b);
} else {
if (uft[t.a][1] == uft[t.b][1]) {
ans = t.c;
break;
}
}
}
while (pq.size() > 0) {
pq.pop();
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cf[2000], tmpf[2000];
int N, M, Q;
int a[1000000], b[1000000], w[1000000];
int cid[1000000];
int find(int i) {
if (cf[i] == i) return i;
cf[i] = find(cf[i]);
return cf[i];
}
bool cmp(int x, int y) { return w[x] > w[y]; }
int l, r;
int main() {
scanf("%d %d %d", &N, &M, &Q);
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &a[i], &b[i], &w[i]);
a[i]--, b[i]--;
cid[i] = i;
}
sort(cid, cid + M, cmp);
int u, v;
for (int i = 0; i < Q; i++) {
scanf("%d %d", &l, &r);
l--, r--;
for (int i = 0; i < 2 * N; i++) cf[i] = i;
bool out = 0;
for (int j = 0; j < M; j++) {
if (l <= cid[j] && cid[j] <= r) {
u = a[cid[j]], v = b[cid[j]];
if (find(u) == find(v)) {
out = 1;
printf("%d\n", w[cid[j]]);
break;
}
cf[find(u)] = find(v + N);
cf[find(v)] = find(u + N);
}
}
if (out == 0) printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[25];
const int maxn = 1010;
const int maxm = 500010;
struct edge {
int x, y, v;
} e[maxm];
struct tree {
int lc, rc;
vector<int> v;
} t[maxm * 2];
vector<int> ans;
int f[maxn], w[maxn];
int n, m, q, rt, num, val;
int read() {
int x = 0, f = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = 1;
} while (ch < '0' || ch > '9');
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int cnt = 0;
while (x) {
buf[++cnt] = '0' + x % 10;
x /= 10;
}
for (int i = cnt; i >= 1; --i) putchar(buf[i]);
}
int find(int x) {
if (f[x] != x) {
val ^= w[x];
int tp = f[x];
f[x] = find(f[x]);
w[x] = w[x] ^ w[tp];
}
return f[x];
}
vector<int> merge(vector<int> a, vector<int> b) {
if (a.size() == 0) return b;
if (b.size() == 0) return a;
vector<int> tp;
tp.clear();
int i = 0, j = 0;
while (i <= a.size() - 1 && j <= b.size() - 1) {
if (e[a[i]].v > e[b[j]].v)
tp.push_back(a[i]), ++i;
else
tp.push_back(b[j]), ++j;
}
while (i <= a.size() - 1) tp.push_back(a[i]), ++i;
while (j <= b.size() - 1) tp.push_back(b[j]), ++j;
for (int i = 0; i <= tp.size() - 1; ++i) {
int x = e[tp[i]].x, y = e[tp[i]].y;
f[x] = x;
f[y] = y;
w[x] = w[y] = 0;
}
vector<int> v;
v.clear();
for (int i = 0; i <= tp.size() - 1; ++i) {
int x = e[tp[i]].x, y = e[tp[i]].y;
val = 0;
int tx = find(x), ty = find(y);
if (tx != ty) {
f[tx] = f[ty];
w[tx] = val ^ 1;
v.push_back(tp[i]);
} else {
if (!val) {
v.push_back(tp[i]);
break;
}
}
}
return v;
}
int build(int l, int r) {
int x = ++num;
if (l == r) {
t[x].v.push_back(l);
} else {
int mid = (l + r) >> 1;
t[x].lc = build(l, mid);
t[x].rc = build(mid + 1, r);
t[x].v = merge(t[t[x].lc].v, t[t[x].rc].v);
}
return x;
}
void query(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
ans = merge(ans, t[x].v);
return;
}
int mid = (l + r) >> 1;
if (ql <= mid) query(t[x].lc, l, mid, ql, qr);
if (mid + 1 <= qr) query(t[x].rc, mid + 1, r, ql, qr);
}
int main() {
n = read();
m = read();
q = read();
for (int i = 1; i <= m; ++i) {
e[i].x = read();
e[i].y = read();
e[i].v = read();
}
rt = build(1, m);
for (int i = 1; i <= q; ++i) {
int l = read(), r = read();
ans.clear();
query(rt, 1, m, l, r);
for (int j = 1; j <= n; ++j) f[j] = j, w[j] = 0;
int ANS = -1;
for (int j = 0; j <= ans.size() - 1; ++j) {
int x = e[ans[j]].x, y = e[ans[j]].y;
val = 0;
int tx = find(x), ty = find(y);
if (tx != ty)
f[tx] = f[ty], w[tx] = val ^ 1;
else {
if (val == 0) {
ANS = e[ans[j]].v;
break;
}
}
}
write(ANS);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 2002, M = (1 << 20), Q = 1001, S = 2 * M;
struct Edge {
int u, v, w;
Edge(int u = 0, int v = 0, int w = 0) : v(v), u(u), w(w) {}
bool operator<(const Edge &e) const { return w < e.w; }
};
struct Segment {
int l, r;
Segment(int l = 0, int r = 0) : l(l), r(r) {}
};
int n, m, q;
Edge es[M];
vector<Edge> seg[S];
Segment range[S];
int par[N], cost[N], PAP[N];
Segment merge(Segment l, Segment r) { return Segment(l.l, r.r); }
void clear(vector<Edge> &es) {
for (Edge e : es) {
par[e.v] = par[e.u] = -1;
cost[e.v] = cost[e.u] = 0;
PAP[e.v] = PAP[e.u] = 1;
}
}
int root(int v) {
if (par[v] == -1) return v;
int u = root(par[v]);
cost[v] ^= cost[par[v]];
return par[v] = u;
}
int parity(int v) {
root(v);
return cost[v];
}
int merge(Edge e) {
if (PAP[root(e.u)] > PAP[root(e.v)]) swap(e.u, e.v);
if (root(e.u) == root(e.v)) {
if (parity(e.u) == parity(e.v)) return 2;
return 0;
}
int u = root(e.u);
int v = root(e.v);
cost[u] ^= (parity(e.u) ^ 1 ^ parity(e.v));
par[u] = root(v);
PAP[v] += PAP[u];
return 1;
}
bool hasOddCycle;
vector<Edge> merge(vector<Edge> &a, vector<Edge> &b) {
vector<Edge> c;
merge(a.begin(), a.end(), b.begin(), b.end(), back_inserter(c));
clear(c);
vector<Edge> res;
for (int i = c.size() - 1; i >= 0; i--) {
int x = merge(c[i]);
if (x) res.push_back(c[i]);
if (x == 2) {
hasOddCycle = 1;
break;
}
}
reverse(res.begin(), res.end());
return res;
}
void make() {
for (int i = S - 1; i; i--) {
if (i >= M) {
range[i] = Segment(i - M, i - M + 1);
if (i - M < m) seg[i].push_back(es[i - M]);
} else {
range[i] = merge(range[i * 2], range[i * 2 + 1]);
seg[i] = merge(seg[i * 2], seg[i * 2 + 1]);
}
}
}
int solve(Segment s) {
vector<Edge> es;
hasOddCycle = 0;
for (int l = s.l + M, r = s.r + M; l < r; l /= 2, r /= 2) {
if (l % 2) es = merge(es, seg[l++]);
if (r % 2) es = merge(es, seg[--r]);
}
if (hasOddCycle) return es[0].w;
return -1;
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
es[i].u = in() - 1;
es[i].v = in() - 1;
es[i].w = in();
}
make();
while (q--) {
int l = in() - 1, r = in();
cout << solve(Segment(l, r)) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1011;
int fa[maxn * 2];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int n, m, q;
struct edge {
int u, v, w, id;
bool operator<(const edge &oth) const { return w > oth.w; }
} E[maxn * maxn / 2];
int getn() {
int r = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) r = r * 10 + c - '0', c = getchar();
return r;
}
int main() {
n = getn();
m = getn();
q = getn();
for (int i = 1; i <= m; i++) {
E[i].u = getn() - 1;
E[i].v = getn() - 1;
E[i].w = getn();
E[i].id = i;
}
sort(E + 1, E + 1 + m);
while (q--) {
int l = getn(), r = getn();
for (int i = 0; i <= n * 2; i++) fa[i] = i;
int ok = 0;
for (int i = 1; i <= m; i++)
if (l <= E[i].id && E[i].id <= r) {
if (find(E[i].u * 2) == find(E[i].v * 2)) {
ok = 1;
printf("%d\n", E[i].w);
break;
} else {
fa[find(E[i].u * 2)] = find(E[i].v * 2 + 1);
fa[find(E[i].u * 2 + 1)] = find(E[i].v * 2);
}
}
if (!ok) puts("-1");
}
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;
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, i;
bool operator<(const edge &rhs) const { return w < rhs.w; }
} arr[500100];
int n, m, q;
vector<edge> adj[1001];
int pa[1001], lz[1001], c[1001];
int find(int cur) {
int p = pa[cur];
while (p != pa[p]) {
c[cur] ^= lz[p];
lz[cur] ^= lz[p];
p = pa[p];
}
pa[cur] = p;
return p;
}
bool merge(int u, int v) {
int pu = find(u), pv = find(v);
if (pu == pv) {
return c[u] != c[v];
} else {
if (c[u] == c[v]) {
lz[pv] ^= 1, c[pv] ^= 1;
}
pa[pv] = pu;
return true;
}
}
int l, r, mw;
int main() {
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].i = i + 1;
}
sort(arr, arr + m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
for (int i = 1; i <= n; i++) pa[i] = i, c[i] = 0, lz[i] = 0;
int j = m - 1;
for (; j >= 0; j--)
if (arr[j].i >= l && arr[j].i <= r) {
if (!merge(arr[j].u, arr[j].v)) break;
}
if (j == -1)
puts("-1");
else
printf("%d\n", arr[j].w);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int edges[1010 * 1010][3];
int i, j, n, m, q;
int L, R;
map<pair<int, int>, int> ans;
bool color[1010];
int fa[1010], sum[1010];
struct Edge {
int a, b, w, id;
} ee[1010 * 1010];
bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second;
}
bool cmp2(const Edge& a, const Edge& b) { return a.w > b.w; }
int findfa(int a) {
if (a == fa[a]) return a;
int ans = findfa(fa[a]);
color[a] = color[a] ^ color[fa[a]];
return fa[a] = ans;
}
bool merge(int a, int b) {
int aa = findfa(a), bb = findfa(b);
if (aa == bb) {
if (color[a] == color[b]) return false;
return true;
}
if (sum[aa] > sum[bb]) {
swap(aa, bb);
}
fa[aa] = bb;
if (color[a] == color[b]) color[aa] = !color[aa];
sum[bb] += sum[aa];
return true;
}
int make() {
for (i = 1; i < (int)n + 1; ++i) {
fa[i] = i;
sum[i] = 1;
color[i] = 0;
}
int ans = -1;
for (i = 0; i < (int)m; ++i) {
if (ee[i].id >= L && ee[i].id <= R) {
if (!merge(ee[i].a, ee[i].b)) {
ans = ee[i].w;
return ans;
}
}
}
return ans;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (i = 0; i < (int)m; ++i) {
scanf("%d %d %d", &edges[i][0], &edges[i][1], &edges[i][2]);
ee[i].a = edges[i][0];
ee[i].b = edges[i][1];
ee[i].w = edges[i][2];
ee[i].id = i + 1;
}
sort(ee, ee + m, cmp2);
while (q--) {
scanf("%d %d", &L, &R);
if (!ans.count(make_pair(L, R))) {
ans[make_pair(L, R)] = make();
}
printf("%d\n", ans[make_pair(L, R)]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, Q;
inline int get() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
struct Edge {
int x, y, w, id;
friend bool operator<(const Edge &p, const Edge &q) { return p.w > q.w; }
} E[1000 * 500];
int fa[2010];
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
inline void uni(int x, int y) { fa[find(x)] = find(y); }
int main() {
n = get(), m = get(), Q = get();
for (int i = 1; i <= m; i++)
E[i].x = get(), E[i].y = get(), E[i].w = get(), E[i].id = i;
sort(E + 1, E + m + 1);
while (Q--) {
int l, r;
l = get(), r = get();
for (int i = 1; i <= n + n; i++) fa[i] = i;
int ans = -1;
for (int i = 1; i <= m; i++)
if (E[i].id >= l && E[i].id <= r) {
if (find(E[i].x) == find(E[i].y)) {
ans = E[i].w;
break;
}
uni(E[i].x, E[i].y + n);
uni(E[i].x + n, E[i].y);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
int fa[maxn * 2];
int n, m, q;
struct Edge {
int u, v, w, id;
friend bool operator<(const Edge n1, const Edge n2) { return n1.w > n2.w; }
} edge[maxn * maxn];
int findset(int x) { return fa[x] == x ? x : fa[x] = findset(fa[x]); }
void Union(int x, int y) {
int fx = findset(x);
int fy = findset(y);
if (fx != fy) {
fa[fx] = fy;
}
}
int main() {
cin >> 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--) {
bool flag = false;
int l, r;
scanf("%d%d", &l, &r);
for (int i = 1; i <= 2 * n; i++) fa[i] = i;
int ans = 0x3f3f3f3f;
for (int i = 1; i <= m; i++) {
if (edge[i].id < l || edge[i].id > r) continue;
int u = edge[i].u, v = edge[i].v;
int fu = findset(u), fv = findset(v);
if (fu != fv) {
Union(edge[i].u, edge[i].v + n);
Union(edge[i].u + n, edge[i].v);
} else {
printf("%d\n", edge[i].w);
flag = true;
break;
}
}
if (!flag) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = int(1e3) + 10;
const int M = (N * (N - 1)) / 2;
const int LOGM = 23;
int U[M], V[M], W[M], n, m, q, C[N], dsu[N], sz[N];
bool cmp(int a, int b) { return W[a] > W[b]; }
inline int Find(int x) {
if (x == dsu[x]) return x;
int p = Find(dsu[x]);
C[x] ^= C[dsu[x]];
return dsu[x] = p;
}
inline bool Union(int a, int b) {
int x = Find(a), y = Find(b);
if (x == y) return false;
if (sz[x] > sz[y]) swap(x, y), swap(a, b);
int p = (C[a] == C[b]);
C[x] ^= p;
sz[y] += sz[x];
dsu[x] = y;
Find(a);
Find(b);
return true;
}
struct tree {
vector<int> edges;
int ans;
tree() { edges.clear(); }
tree(int l, int r) {
for (int i = l; i <= r; i++) edges.push_back(i);
sort(edges.begin(), edges.end(), cmp);
}
tree(vector<int>& _edges) { edges = _edges; }
inline void build() {
ans = -1;
for (auto e : edges) {
C[U[e]] = C[V[e]] = 0;
dsu[U[e]] = U[e];
dsu[V[e]] = V[e];
sz[U[e]] = sz[V[e]] = 1;
}
vector<int> want;
for (auto e : edges)
if (Union(U[e], V[e]))
want.push_back(e);
else if (ans == -1 && C[U[e]] == C[V[e]])
ans = W[e], want.push_back(e);
edges = want;
}
};
tree ST[4 * M], null;
inline tree merge(tree& A, tree& B) {
vector<int> edges;
vector<int>&a = A.edges, &b = B.edges;
if (a.empty() || b.empty()) return (a.empty() ? B : A);
int i = 0, j = 0;
while (i < (int)(a.size()) && j < (int)(b.size()))
if (W[a[i]] > W[b[j]])
edges.push_back(a[i++]);
else
edges.push_back(b[j++]);
while (i < (int)(a.size())) edges.push_back(a[i++]);
while (j < (int)(b.size())) edges.push_back(b[j++]);
tree ret(edges);
ret.build();
return ret;
}
inline void build(int l = 1, int r = m + 1, int x = 1) {
if (l == r - 1) {
ST[x] = tree(l, l);
ST[x].build();
return;
}
int m = (l + r) / 2;
build(l, m, (x << 1));
build(m, r, (x << 1) | 1);
ST[x] = merge(ST[(x << 1)], ST[(x << 1) | 1]);
}
inline tree query(int L, int R, int l = 1, int r = m + 1, int x = 1) {
if (l >= L && r <= R) return ST[x];
if (l >= R || r <= L) return null;
int m = (l + r) / 2;
tree la = query(L, R, l, m, (x << 1));
tree ra = query(L, R, m, r, (x << 1) | 1);
return merge(la, ra);
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
for (int i = 1; i <= m; i++) scanf("%d %d %d", U + i, V + i, W + i);
build();
while (q--) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
printf("%d\n", query(l, r + 1).ans);
}
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];
inline int find_set(int v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find_set(parent[v]);
}
inline 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;
vector<pair<pair<int, int>, pair<int, int> > > edgeTotal;
int p[1111], len[1111], ran[1111];
bool cmp(const pair<pair<int, int>, pair<int, int> > &a,
const pair<pair<int, int>, pair<int, int> > &b) {
return a.first.first > b.first.first;
}
int find_set(int x) {
if (x == p[x]) return x;
int y = find_set(p[x]);
len[x] ^= len[p[x]];
return p[x] = y;
}
void merge_set(int x, int y) {
int px = find_set(x);
int py = find_set(y);
if (ran[px] > ran[py]) swap(px, py);
p[px] = py;
len[px] ^= len[x] ^ len[y] ^ 1;
if (ran[px] == ran[py]) ran[py]++;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
int a, b, w;
cin >> a >> b >> w;
edgeTotal.push_back(make_pair(make_pair(w, i), make_pair(a, b)));
}
sort(edgeTotal.begin(), edgeTotal.end(), cmp);
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
for (int j = 1; j <= n; j++) {
p[j] = j;
len[j] = 0;
ran[j] = 0;
}
int ans = -1;
for (int j = 0; j < edgeTotal.size(); j++) {
if (edgeTotal[j].first.second > r || edgeTotal[j].first.second < l)
continue;
int w = edgeTotal[j].first.first, a = edgeTotal[j].second.first,
b = edgeTotal[j].second.second;
if (find_set(a) != find_set(b)) {
merge_set(a, b);
} else {
if (abs(len[a] - len[b]) % 2 == 0) {
ans = w;
break;
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
T Angle(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T euclide(T a, T b, T& x, T& y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
void ia(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void pa(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T, class first>
inline T togglebit(T a, first i) {
T t = 1;
return (a ^ (t << i));
}
double DEG(double x) { return (180.0 * x) / (2.0 * acos(0.0)); }
double RAD(double x) { return (x * (double)2.0 * acos(0.0)) / (180.0); }
template <class T>
struct Vector {
T* ar;
int sz;
int cap;
Vector() {
cap = 1;
sz = 0;
ar = (T*)malloc(cap * sizeof(T));
}
Vector(int n) {
cap = n;
sz = n;
ar = (T*)calloc(cap, sizeof(T));
}
void push_back(T x) {
if (sz == cap) {
cap = cap + ((cap + 1) >> 1);
ar = (T*)realloc(ar, cap * sizeof(T));
}
ar[sz++] = x;
}
void clear() {
cap = 1;
sz = 0;
free(ar);
ar = (T*)malloc(cap * sizeof(T));
}
void sort(int l, int r) { std::sort(ar + l, ar + r + 1); }
T& operator[](int idx) { return ar[idx]; }
int size() { return sz; }
};
struct Edge {
int u, v, w, i;
Edge() {}
Edge(int _u, int _v, int _w, int _i) {
u = _u;
v = _v;
w = _w;
i = _i;
}
bool operator<(const Edge& p) const { return w < p.w; }
};
int par[1007], color[1007];
Vector<int> comp[1007];
Vector<Edge> e;
void Init(int n) {
for (int i = 0; i <= n; i++) {
par[i] = i;
color[i] = 0;
comp[i].clear();
comp[i].push_back(i);
}
}
int FindPar(int n) {
if (par[n] == n)
return n;
else
return par[n] = FindPar(par[n]);
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
e = Vector<Edge>(m + 2);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
e[i] = Edge(u, v, w, i);
}
e.sort(1, m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
Init(n);
int res = -1;
for (int i = m; i; i--) {
if (e[i].i < l || e[i].i > r) continue;
int u = par[e[i].u], v = par[e[i].v], w = e[i].w;
if (u != v) {
if (comp[u].size() < comp[v].size()) swap(u, v);
int f = (color[e[i].u] == color[e[i].v]);
for (int j = 0; j < comp[v].size(); j++) {
int x = comp[v][j];
color[x] ^= f;
comp[u].push_back(x);
par[x] = u;
}
comp[v].clear();
} else if (color[e[i].u] == color[e[i].v]) {
res = max(res, w);
break;
}
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void getre() {
int x = 0;
printf("%d\n", 1 / x);
}
void gettle() {
int res = 1;
while (1) res <<= 1;
printf("%d\n", res);
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
template <typename N>
inline int sgn(N a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
inline void gn(double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gs(char *s) { scanf("%s", s); }
inline void gc(char &c) {
while ((c = getchar()) > 126 || c < 33)
;
}
inline void pc(char c) { putchar(c); }
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double pi = 3.14159265358979323846264338327950288L;
const double eps = 1e-6;
int n, m, q;
int u[1111111], v[1111111], w[1111111];
int ord[1111111];
int tot;
int cmp(int i, int j) { return w[i] > w[j]; }
int cmp1(int i, int j) { return w[i] < w[j]; }
int val[1111111];
int fa[2222];
int gf(int x) { return x == fa[x] ? x : fa[x] = gf(fa[x]); }
map<pair<int, int>, int> mem;
int u2[1111111], v2[1111111];
int main() {
gn(n);
gn(m);
gn(q);
for (int i = (1), _ed = (m + 1); i < _ed; i++) {
gn(u[i]), gn(v[i]), gn(w[i]);
ord[i] = i;
}
sort(ord + 1, ord + 1 + m, cmp1);
for (int i = (1), _ed = (m + 1); i < _ed; i++) val[i] = w[ord[i]];
for (int i = (1), _ed = (m + 1); i < _ed; i++)
u2[i] = u[ord[i]], v2[i] = v[ord[i]];
while (q--) {
int l, r;
gn(l);
gn(r);
if (mem.count(make_pair(l, r))) {
printf("%d\n", mem[make_pair(l, r)]);
continue;
}
for (int i = (1), _ed = (2 * n + 1); i < _ed; i++) fa[i] = i;
int ans = -1;
for (int i = m; i >= 1; i--)
if (ord[i] >= l && ord[i] <= r) {
int uu = u2[i], vv = v2[i];
int a, b, c, d;
if ((a = gf(uu)) == (b = gf(vv)) ||
(c = gf(uu + n)) == (d = gf(vv + n))) {
ans = w[ord[i]];
break;
}
fa[a] = d;
fa[b] = c;
}
printf("%d\n", mem[make_pair(l, r)] = ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int f, t, w, id;
bool operator<(const Edge& r) const { return w < r.w; }
};
Edge es[1111111];
int dsu[1111];
int dr[1111];
int pl[1111];
int pr[1111];
void init(int n) {
for (int i = 0; i < n; i++) {
dsu[i] = i;
dr[i] = 0;
pl[i] = i;
pr[i] = -1;
}
}
int get(int x) { return dsu[x] == x ? x : dsu[x] = get(dsu[x]); }
void unite(int x, int y) {
x = get(x);
y = get(y);
if (x == y) {
return;
}
if (dr[x] < dr[y]) {
dsu[x] = y;
} else {
dsu[y] = x;
if (dr[x] == dr[y]) {
dr[x]++;
}
}
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
--x;
--y;
es[i] = Edge{x, y, z, i};
}
sort(es, es + m);
while (q-- > 0) {
init(n);
for (int i = 0; i < n; i++) {
pl[i] = i;
pr[i] = -1;
}
int l, r;
scanf("%d%d", &l, &r);
--l;
--r;
int res = -1;
for (int i = m - 1; i >= 0; i--) {
Edge& e = es[i];
if (e.id < l || e.id > r) {
continue;
}
int xx = get(e.f);
int yy = get(e.t);
if (xx == yy) {
res = e.w;
break;
}
if (pr[xx] != -1) {
unite(pr[xx], yy);
}
if (pr[yy] != -1) {
unite(pr[yy], xx);
}
pr[xx] = yy;
pr[yy] = xx;
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Q;
pair<pair<int, int>, pair<int, int> > E[1000005];
int par[2005];
int find_parent(int x) {
if (par[x] == x) return x;
return par[x] = find_parent(par[x]);
}
int go(int li, int ri) {
for (int i = 1; i <= 2 * N + 1; i++) par[i] = i;
for (int i = M - 1; i >= 0; i--)
if (li <= E[i].first.second && E[i].first.second <= ri) {
int a = E[i].second.first, b = E[i].second.second;
if (find_parent(2 * a) == find_parent(2 * b)) return E[i].first.first;
par[find_parent(2 * a)] = find_parent(2 * b + 1);
par[find_parent(2 * a + 1)] = find_parent(2 * b);
}
return -1;
}
int main() {
scanf("%d %d %d", &N, &M, &Q);
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &E[i].second.first, &E[i].second.second,
&E[i].first.first);
E[i].first.second = i + 1;
}
sort(E, E + M);
for (int i = 0, li, ri; i < Q; i++) {
scanf("%d %d", &li, &ri);
printf("%d\n", go(li, ri));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const int N = 1e3 + 1000, n_ = 2e3 + 3000;
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int n, m, q, par[n_];
vector<pair<pair<int, int>, pair<int, int> > > e;
void rm() {
for (int i = 0; i < n_; i++) {
par[i] = i;
}
}
int find(int u) { return par[u] = (par[u] == u ? u : find(par[u])); }
int merge(int u, int v) {
int fu = find(u), fv = find(v);
if (fv == fu) return 0;
par[fv] = find(u + N);
par[fu] = find(v + N);
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int u, v, w;
pair<pair<int, int>, pair<int, int> > tmp;
cin >> u >> v >> w;
u--, v--;
tmp.second.first = u, tmp.second.second = v, tmp.first.first = w,
tmp.first.second = i;
e.push_back(tmp);
}
sort((e).begin(), (e).end());
while (q--) {
int l, r, ans = -1;
cin >> l >> r;
l--;
rm();
for (int i = m - 1; i >= 0; i--) {
if (e[i].first.second >= l && e[i].first.second < r &&
!merge(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 int MAXN = 501 * 1001;
vector<pair<pair<int, int>, pair<int, int> > > yal;
int par[MAXN] = {}, col[MAXN] = {}, mark[MAXN] = {};
int root(int x) {
if (par[x] < 0) {
return x;
}
int p = root(par[x]);
col[x] ^= col[par[x]];
return par[x] = p;
}
int main() {
int n, q, m, l, r;
scanf("%d%d%d", &n, &m, &q);
int x, y, z;
for (int i = 0; i < m; i++)
scanf("%d%d%d", &x, &y, &z), yal.push_back({{z, i}, {x, y}});
sort(yal.rbegin(), yal.rend());
for (int i = 0; i < q; i++) {
scanf("%d%d", &l, &r);
for (int i = 1; i <= n; i++) par[i] = -1, col[i] = 0, mark[i] = 0;
bool f = 1;
for (int j = 0; j < m && f; j++) {
if (yal[j].first.second >= l - 1 && yal[j].first.second < r) {
x = yal[j].second.first, y = yal[j].second.second;
if (root(x) == root(y)) {
if (col[x] == col[y]) printf("%d\n", yal[j].first.first), f = 0;
} else {
bool ff = 0;
if (col[x] == col[y]) ff = 1;
x = root(x);
y = root(y);
if (par[y] < par[x]) swap(x, y);
par[x] += par[y];
if (ff) {
mark[y] = 1;
col[y] = 1;
}
par[y] = x;
}
}
}
if (f) puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = N * N;
int n, m, q;
struct Edge {
int u, v, w, id;
void read(int id) {
scanf("%d%d%d", &u, &v, &w);
u--;
v--;
this->id = id;
}
bool operator<(const Edge& c) const { return w > c.w; }
} e[M];
int parent[N * 2];
int find(int x) {
if (x == parent[x]) return x;
return parent[x] = find(parent[x]);
}
int gao(int l, int r) {
for (int i = 0; i < n * 2; i++) parent[i] = i;
for (int i = 1; i <= m; i++) {
if (e[i].id < l || e[i].id > r) continue;
int pu = find(e[i].u * 2), pv = find(e[i].v * 2 + 1);
if (pu != pv) {
parent[pu] = pv;
parent[find(e[i].u * 2 + 1)] = find(e[i].v * 2);
}
if (find(e[i].u * 2) == find(e[i].u * 2 + 1)) return e[i].w;
if (find(e[i].v * 2) == find(e[i].v * 2 + 1)) return e[i].w;
}
return -1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) e[i].read(i);
sort(e + 1, e + 1 + m);
int l, r;
while (q--) {
scanf("%d%d", &l, &r);
printf("%d\n", gao(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1005;
int parent[2 * M];
vector<pair<pair<int, int>, pair<int, int> > > edges;
void init() {
for (int i = 0; i < 2 * M; i++) parent[i] = i;
}
int find(int u) {
if (u == parent[u]) return u;
return parent[u] = find(parent[u]);
}
void un(int u, int v) {
u = find(u);
v = find(v);
parent[u] = v;
}
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
edges.push_back(make_pair(make_pair(c, i), make_pair(a, b)));
}
sort(edges.begin(), edges.end(),
greater<pair<pair<int, int>, pair<int, int> > >());
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
int ans = -1;
init();
for (int i = 0; i < edges.size(); i++) {
int c = edges[i].first.first;
int id = edges[i].first.second;
int u = edges[i].second.first;
int v = edges[i].second.second;
if (id < l || id > r) continue;
if (find(u) == find(v)) {
ans = c;
break;
}
un(u, v + n);
un(u + n, v);
}
printf("%d\n", ans);
}
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;
}
vector<trzy> Akt;
void solve() {
Akt.reserve(1000005);
sort(V.begin(), V.end());
for (int i = 0; i < q; i++) {
Akt.clear();
int first, b;
scanf("%d%d", &first, &b);
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 MAX_N = 1000 + 10;
const int MAX_M = 1000000 + 10;
int n, m, q;
vector<pair<int, int> > e1;
int M[MAX_M][3];
int mark[MAX_N];
int par[MAX_N];
int size[MAX_N];
int l, r;
int findPar(int u) {
if (par[u] == par[par[u]]) return par[u];
int parent = par[u];
par[u] = findPar(par[u]);
mark[u] *= mark[parent];
return par[u];
}
int findSet(int u) {
findPar(u);
if (u == par[u]) {
return mark[u];
}
return mark[u] * mark[par[u]];
}
void solve() {
for (int i = e1.size() - 1; i >= 0; i--)
if (e1[i].second <= r && e1[i].second >= l) {
int index = e1[i].second;
int u = M[index][0];
int v = M[index][1];
int w = e1[i].first;
int uPar = findPar(u);
int vPar = findPar(v);
if (uPar == vPar) {
if (findSet(u) == findSet(v)) {
cout << w << endl;
return;
}
} else {
if (size[uPar] > size[vPar]) {
if (findSet(u) == findSet(v)) {
mark[vPar] *= -1;
}
par[vPar] = uPar;
} else {
if (findSet(u) == findSet(v)) {
mark[uPar] *= -1;
}
par[uPar] = vPar;
}
}
}
cout << -1 << endl;
return;
}
void read() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &M[i][0], &M[i][1], &M[i][2]);
e1.push_back(pair<int, int>(M[i][2], i));
}
sort(e1.begin(), e1.end());
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
for (int j = 1; j <= n; j++) {
mark[j] = 1;
par[j] = j;
size[j] = 1;
}
solve();
}
}
int main() { read(); }
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
struct DSU {
int C[(1001)], G[(1001)];
vector<int> V[(1001)];
void con(int u, int v) {
int b = G[u] == G[v], x;
u = C[u], v = C[v];
if (V[u].size() < V[v].size()) swap(u, v);
while (!V[v].empty())
x = V[v].back(), V[v].pop_back(), G[x] ^= b, C[x] = u, V[u].push_back(x);
}
void ini(int N) {
for (int i(0); i < N; i++)
V[i].clear(), G[i] = 0, C[i] = i, V[i].push_back(i);
}
int gc(int u) { return C[u]; }
int gp(int u) { return G[u]; }
} D;
struct bs {
long long A[(7805)];
void clr() { (memset(A, 0, sizeof(A))); }
void tr(int H) {
for (int i(0); i < H >> 6; i++) A[i] = -1;
for (int k(H - (H & 63)); k < H; k++) ad(k);
}
bool is(bs &r) {
for (int i(0); i < (7805); i++)
if (A[i] & r.A[i]) return 1;
return 0;
}
void operator|=(bs &r) {
for (int i(0); i < (7805); i++) A[i] |= r.A[i];
}
void operator&=(bs &r) {
for (int i(0); i < (7805); i++) A[i] &= r.A[i];
}
void operator^=(bs &r) {
for (int i(0); i < (7805); i++) A[i] ^= r.A[i];
}
void ad(int u) { A[u >> 6] |= 1ull << (u & 63); }
void cg(int u) { A[u >> 6] ^= 1ull << (u & 63); }
bool ct(int v) { return (A[v >> 6] >> (v & 63)) & 1; }
int bt() {
int l(0);
for (int i(0); i < (7805); i++) l += __builtin_popcountll(A[i]);
return l;
}
int xt(int u) {
while (++u & 63)
if ((A[u >> 6] >> (u & 63)) & 1) return u;
while (u < (7805) << 6 && !A[u >> 6]) ++u;
if (u == (7805) << 6) return -1;
while (!ct(u)) ++u;
return u;
}
} Z;
int M, N, Q, a, b, O[(1001)], B[(499501)], E[(499501)], W[(499501)],
H[(499501)], I[(499501)];
struct MOQ {
int b, e, i;
bool operator<(const MOQ &r) const {
return b / (666) ^ r.b / (666) ? b / (666) < r.b / (666) : e < r.e;
}
};
struct MO {
MOQ T[(1001)];
int C[(1001)], L, b, e;
void CLR() { L = 0; }
void QY(int b, int e) {
T[L] = {min(b, e), max(b, e), L};
++L;
}
void GO(int *O) {
(memset(C, 0, sizeof(C))), st();
sort(T, T + L), b = T[0].b - 1, e = T[0].b - 1;
for (int i(0); i < L; i++) {
while (b >= T[i].b) add(b--);
while (e < T[i].e) add(++e);
while (b + 1 < T[i].b) del(++b);
while (e > T[i].e) del(e--);
O[T[i].i] = ans();
}
}
void add(int w) { Z.cg(I[w]); }
void del(int w) { Z.cg(I[w]); }
int ans() {
D.ini(N);
int J = -1, x, y;
while (666) {
J = Z.xt(J);
if (!~J) return -1;
x = B[H[J]], y = E[H[J]];
if (D.gc(x) == D.gc(y)) {
if (D.gp(x) == D.gp(y)) return W[H[J]];
continue;
}
D.con(x, y);
}
}
void st() { Z.clr(); }
} T;
bool cp(int a, int b) { return W[a] > W[b]; }
int main(void) {
scanf("%d%d%d", &N, &M, &Q), iota(H, H + M, 0), T.CLR();
for (int i(0); i < M; i++)
scanf("%d%d%d", B + i, E + i, W + i), --B[i], --E[i];
sort(H, H + M, cp);
for (int i(0); i < M; i++) I[H[i]] = i;
for (int i(0); i < Q; i++) scanf("%d%d", &a, &b), T.QY(--a, --b);
T.GO(O);
for (int i(0); i < Q; i++) printf("%d\n", O[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
const int INF = 2000000000;
const ll LLINF = 9000000000000000000;
constexpr size_t NMAX = 1000;
constexpr size_t MMAX = 1000000;
constexpr size_t TMAX = 2000000;
template <class T>
struct resettable_vector {
vector<T> val, def;
vi time;
int cur = 0;
resettable_vector(int n, T d) {
val.assign(n, d);
def.assign(n, d);
time.assign(n, cur = 0);
}
T get(int i) { return time[i] == cur ? val[i] : def[i]; }
void set(int i, T v) {
val[i] = v;
time[i] = cur;
}
void set_default(int i, T v) { def[i] = v; }
void reset() { ++cur; }
};
struct AdvancedUnionFind {
int n, c;
bool bipartite = true;
resettable_vector<int> par, rank, size;
resettable_vector<bool> sign;
AdvancedUnionFind(int _n)
: n(_n), c(n), par(n, 0), rank(n, 0), size(n, 1), sign(n, false) {
for (int i = 0; i < n; ++i) par.set(i, i), par.set_default(i, i);
}
int find(int i) {
if (par.get(i) == i) return i;
int p = find(par.get(i));
if (par.get(i) != p && sign.get(par.get(i))) sign.set(i, !sign.get(i));
par.set(i, p);
return p;
}
bool same(int i, int j) { return find(i) == find(j); }
bool sign_of(int u, int pu = -1) {
if (pu == -1) pu = find(u);
bool su = sign.get(u);
if (u != pu && sign.get(pu)) su = !su;
return su;
}
void merge(int i, int j, bool diff = true) {
int pi = find(i), pj = find(j);
if (pi == pj) {
bool si = sign_of(i, pi), sj = sign_of(j, pj);
if (si == sj && diff) bipartite = false;
if (si != sj && !diff) bipartite = false;
}
c--;
if (rank.get(pi) > rank.get(pj)) swap(i, j), swap(pi, pj);
bool si = sign_of(i, pi), sj = sign_of(j, pj);
if ((si == sj && diff) || (si != sj && !diff)) sign.set(pi, !sign.get(pi));
par.set(pi, pj);
size.set(pj, size.get(pj) + size.get(pi));
if (rank.get(pi) == rank.get(pj)) rank.set(pj, rank.get(pj) + 1);
}
void reset() {
par.reset();
rank.reset();
size.reset();
sign.reset();
bipartite = true;
c = n;
}
};
int n, m, q;
vector<pair<ii, ll>> E;
constexpr int SZ = 1e6;
vb sign;
AdvancedUnionFind uf(NMAX);
vector<pair<ll, vi>> ans(SZ, {-2LL, vi()});
map<ii, int> cache;
void combine_into(pair<ll, vi> &lv, pair<ll, vi> &rv, pair<ll, vi> &o) {
uf.reset();
size_t lx = 0, rx = 0;
while (lx < lv.second.size() || rx < rv.second.size()) {
int i = (lx < lv.second.size() ? lv.second[lx] : rv.second[rx]);
if (rx < rv.second.size() && E[i].second <= E[rv.second[rx]].second) {
i = rv.second[rx];
++rx;
} else
++lx;
int u = E[i].first.first, v = E[i].first.second;
int pu = uf.find(u), pv = uf.find(v);
if (pu == pv && uf.sign_of(u, pu) != uf.sign_of(v, pv)) continue;
o.second.push_back(i);
if (pu != pv)
uf.merge(u, v);
else {
o.first = E[i].second;
break;
}
}
}
void ptup(pair<ll, vi> &v) {
cerr << "{" << v.first << ",";
for (ll w : v.second)
cerr << " ((" << E[w].first.first << "," << E[w].first.second << "),"
<< E[w].second << ")";
cerr << "}";
}
int solve(int l, int r) {
auto it = cache.find({l, r});
if (it != cache.end()) return it->second;
cache.insert({{l, r}, cache.size()});
int id = cache.size() - 1;
ans[id].first = -1LL;
int lid = solve(l, (l + r) / 2), rid = solve((l + r) / 2 + 1, r);
combine_into(ans[lid], ans[rid], ans[id]);
return id;
}
void accumulate(int l, int r, int L, int R, vi &res) {
if (r < L || R < l) return;
if (l <= L && R <= r)
res.push_back(solve(L, R));
else {
accumulate(l, r, L, (L + R) / 2, res);
accumulate(l, r, (L + R) / 2 + 1, R, res);
}
}
ll query(int l, int r) {
vi res;
accumulate(l, r, 0, m - 1, res);
vector<pair<ll, vi>> resa(2, {-1LL, vi()});
for (size_t i = 0; i < res.size(); ++i) {
resa[i & 1].second.clear();
combine_into(resa[(i & 1) ^ 1], ans[res[i]], resa[i & 1]);
}
return resa[(1 & res.size()) ^ 1].first;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
E.assign(m, {{-1, -1}, 0LL});
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
E[i] = {{u - 1, v - 1}, ll(w)};
ans[cache.size()] = {-1LL, vi{i}};
cache.insert({{i, i}, cache.size()});
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
cout << query(l - 1, r - 1) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
const int INF = 2000000000;
const ll LLINF = 9000000000000000000;
constexpr size_t NMAX = 1000;
constexpr size_t MMAX = 1000000;
constexpr size_t TMAX = 2000000;
template <class T>
struct res_vector {
vector<T> v, d;
int time = 0;
vi t;
res_vector(int n, T _d) {
v.assign(n, _d);
d.assign(n, _d);
t.assign(n, 0);
}
T get(int i) { return t[i] == time ? v[i] : d[i]; }
void set(int i, T _v) {
t[i] = time;
v[i] = _v;
}
void setdef(int i, T _v) { d[i] = _v; }
void reset() { ++time; }
};
struct UnionFind {
bool consistent = true;
int n, c;
res_vector<int> par, rank, size;
res_vector<bool> sign;
UnionFind(int _n)
: n(_n), c(n), par(n, 0), rank(n, 0), size(n, 1), sign(n, false) {
for (int i = 0; i < n; ++i) par.set(i, i), par.setdef(i, i);
}
int find(int i) {
if (par.get(i) == i) return i;
int p = find(par.get(i));
if (par.get(i) != p && sign.get(par.get(i))) {
sign.set(i, !sign.get(i));
}
par.set(i, p);
return p;
}
bool same(int i, int j) { return find(i) == find(j); }
bool sign_of(int u, int pu) {
bool su = sign.get(u);
if (u != pu && sign.get(pu)) su = !su;
return su;
}
void reset() {
par.reset();
rank.reset();
size.reset();
sign.reset();
c = n;
}
void merge(int i, int j, bool diff = true) {
int pi = find(i), pj = find(j);
if (pi == pj) {
bool si = sign_of(i, pi), sj = sign_of(j, pj);
if (si == sj && diff) consistent = false;
if (si != sj && !diff) consistent = false;
}
c--;
if (rank.get(pi) > rank.get(pj)) swap(i, j), swap(pi, pj);
bool si = sign_of(i, pi), sj = sign_of(j, pj);
if ((si == sj && diff) || (si != sj && !diff)) {
sign.set(pi, !sign.get(pi));
}
par.set(pi, pj);
size.set(pj, size.get(pj) + size.get(pi));
if (rank.get(pi) == rank.get(pj)) rank.set(pj, rank.get(pj) + 1);
}
};
int n, m, q;
vector<pair<ii, ll>> E;
constexpr int SZ = 1e6;
vb sign;
UnionFind uf(NMAX);
vector<pair<ll, vi>> ans(SZ, {-2LL, vi()});
map<ii, int> cache;
void combine_into(pair<ll, vi> &lv, pair<ll, vi> &rv, pair<ll, vi> &o) {
uf.reset();
size_t lx = 0, rx = 0;
while (lx < lv.second.size() || rx < rv.second.size()) {
int i = (lx < lv.second.size() ? lv.second[lx] : rv.second[rx]);
if (rx < rv.second.size() && E[i].second <= E[rv.second[rx]].second) {
i = rv.second[rx];
++rx;
} else
++lx;
int u = E[i].first.first, v = E[i].first.second;
int pu = uf.find(u), pv = uf.find(v);
if (pu == pv && uf.sign_of(u, pu) != uf.sign_of(v, pv)) continue;
o.second.push_back(i);
if (pu != pv)
uf.merge(u, v);
else {
o.first = E[i].second;
break;
}
}
}
void ptup(pair<ll, vi> &v) {
cerr << "{" << v.first << ",";
for (ll w : v.second)
cerr << " ((" << E[w].first.first << "," << E[w].first.second << "),"
<< E[w].second << ")";
cerr << "}";
}
int solve(int l, int r) {
auto it = cache.find({l, r});
if (it != cache.end()) return it->second;
cache.insert({{l, r}, cache.size()});
int id = cache.size() - 1;
ans[id].first = -1LL;
int lid = solve(l, (l + r) / 2), rid = solve((l + r) / 2 + 1, r);
combine_into(ans[lid], ans[rid], ans[id]);
return id;
}
void accumulate(int l, int r, int L, int R, vi &res) {
if (r < L || R < l) return;
if (l <= L && R <= r)
res.push_back(solve(L, R));
else {
accumulate(l, r, L, (L + R) / 2, res);
accumulate(l, r, (L + R) / 2 + 1, R, res);
}
}
ll query(int l, int r) {
vi res;
accumulate(l, r, 0, m - 1, res);
vector<pair<ll, vi>> resa(2, {-1LL, vi()});
for (size_t i = 0; i < res.size(); ++i) {
resa[i & 1].second.clear();
combine_into(resa[(i & 1) ^ 1], ans[res[i]], resa[i & 1]);
}
return resa[(1 & res.size()) ^ 1].first;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
E.assign(m, {{-1, -1}, 0LL});
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
E[i] = {{u - 1, v - 1}, ll(w)};
ans[cache.size()] = {-1LL, vi{i}};
cache.insert({{i, i}, cache.size()});
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
cout << query(l - 1, r - 1) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010, d = 0;
int N, Q, M, uf[MAXN * 2];
void init() {
for (int i = 1; i <= 2 * N; ++i) {
uf[i] = -1;
}
}
int find(int n) {
if (uf[n] < 0) {
return n;
} else {
uf[n] = find(uf[n]);
return uf[n];
}
}
void merge(int a, int b) {
int pa = find(a);
int pb = find(b);
if (pa == pb) {
return;
} else if (uf[pa] == uf[pb]) {
uf[pa]--;
uf[pb] = pa;
} else if (uf[pa] < uf[pb]) {
uf[pb] = pa;
} else {
uf[pa] = pb;
}
}
pair<pair<int, int>, pair<int, int> > edges[MAXN * (MAXN - 1) / 2];
int counterpart[MAXN * 2];
void reset() {
init();
for (int i = 1; i <= 2 * N; ++i) {
counterpart[i] = -1;
}
}
void print_uf() {
for (int i = 1; i <= 2 * N; ++i) {
printf("\t%d belongs to group %d with counterpart %d\n", i, find(i),
counterpart[find(i)]);
}
}
int main() {
scanf("%d %d %d", &N, &M, &Q);
for (int i = 0; i < M; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
edges[i] = make_pair(make_pair(c, i + 1), make_pair(a, b));
}
sort(edges, edges + M);
for (int i = 0; i < Q; ++i) {
int l, r;
scanf("%d %d", &l, &r);
reset();
int answer = -1;
for (int j = M - 1; j >= 0; --j) {
if (edges[j].first.second < l or edges[j].first.second > r) {
continue;
}
int a = edges[j].second.first;
int b = edges[j].second.second;
int pa = find(a);
int pb = find(b);
if (counterpart[pa] < 0) {
counterpart[pa] = N + pa;
counterpart[N + pa] = pa;
}
if (counterpart[pb] < 0) {
counterpart[pb] = N + pb;
counterpart[N + pb] = pb;
}
if (pb == pa) {
answer = edges[j].first.first;
break;
} else {
merge(pb, counterpart[pa]);
merge(pa, counterpart[pb]);
}
}
printf("%d\n", answer);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int id[510000];
int st[510000], en[510000], w[510000], f[1100], pos[1100];
bool cmp(int i, int j) { return w[i] < w[j]; }
int Fa(int x) {
if (f[x] == x) return x;
return f[x] = Fa(f[x]);
}
int n, m;
vector<int> root[1100];
int calc(int L, int R) {
for (int i = 1; i <= n; i++)
f[i] = i, pos[i] = 0, root[i].clear(), root[i].push_back(i);
;
for (int i = m; i; i--) {
int j = id[i];
if (j < L || j > R) continue;
int x = st[j];
int y = en[j];
int in = (pos[x] == pos[y]);
int xx = Fa(x);
int yy = Fa(y);
if (xx == yy) {
if (pos[x] == pos[y]) return w[j];
continue;
}
x = xx;
y = yy;
if (root[x].size() < root[y].size()) swap(x, y);
for (int k = 0; k < root[y].size(); k++) {
int aa = root[y][k];
root[x].push_back(aa);
pos[aa] ^= in;
}
root[y].clear();
f[y] = x;
}
return -1;
}
int main() {
int L, R, Q;
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &st[i], &en[i], &w[i]);
}
for (int i = 1; i <= m; i++) id[i] = i;
sort(id + 1, id + m + 1, cmp);
int cnt = 0;
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &L, &R);
printf("%d\n", calc(L, R));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, M = (1 << 20) + 105, S = 1e4 + 4, B = 505, mod = 0;
int n, res[M], m, q, fr[M], to[M], ln[M];
pair<int, int> sr[M];
struct dsu {
int par[N], h[N], dead;
vector<int> comp[N];
dsu(int x = 0) {
for (int i = 0; i < N; ++i) par[i] = i, comp[i].push_back(i), h[i] = 0;
dead = 0;
}
bool add(int e) {
int u = fr[e], v = to[e];
if (par[u] == par[v] && (h[u] ^ h[v]) == 0) {
dead = 1;
return 0;
}
if (par[u] != par[v]) {
if (comp[par[u]].size() > comp[par[v]].size()) swap(u, v);
int c = h[u], pp = par[u];
for (int x : comp[pp]) {
par[x] = par[v];
h[x] = (c ^ h[v] ^ h[x] ^ 1);
comp[par[v]].push_back(x);
}
comp[pp].clear();
return 1;
}
return 0;
}
};
vector<int> contain[M];
int ql[N], qr[N];
dsu qd[N], block[B];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(res, -1, sizeof res);
cin >> n >> m >> q;
for (int i = 0; i < B; ++i) block[i] = dsu();
for (int i = 0; i < m; ++i) {
cin >> fr[i] >> to[i] >> ln[i];
fr[i]--;
to[i]--;
sr[i] = make_pair(ln[i], i);
}
for (int i = 0; i < q; ++i) {
qd[i] = dsu();
cin >> ql[i] >> qr[i];
ql[i]--;
for (int j = ql[i]; j < min(qr[i], ((ql[i] - 1) / S + 1) * S); ++j)
if (j < m) contain[j].push_back(i);
for (int j = max((qr[i] / S) * S, ql[i]); j < qr[i]; ++j)
if (j < m) contain[j].push_back(i);
}
sort(sr, sr + m);
reverse(sr, sr + m);
for (int pp = 0; pp < m; ++pp) {
int e = sr[pp].second;
for (auto x : contain[e])
if (!qd[x].dead) {
qd[x].add(e);
if (qd[x].dead) res[x] = sr[pp].first;
}
int bl = e / S;
if (!block[bl].dead) {
int flag = block[bl].add(e);
flag |= block[bl].dead;
if (flag) {
int xl = bl * S, xr = (bl + 1) * S;
for (int x = 0; x < q; ++x)
if (!qd[x].dead) {
if (ql[x] <= xl && xr <= qr[x]) {
qd[x].add(e);
if (qd[x].dead) res[x] = sr[pp].first;
}
}
}
}
}
for (int i = 0; i < q; ++i) cout << res[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e5 + 4;
const int inf = (int)1e9 + 7;
const long double eps = 1e-7;
const int K = 12;
const int M = 1001;
struct edge {
int a, b, w, n;
edge() { a = 0, b = 0, w = 0, n = 0; }
edge(int a, int b, int w, int n) : a(a), b(b), w(w), n(n) {}
bool operator<(const edge &a) const { return w > a.w; }
};
edge e[N];
pair<int, int> p[M];
int sz[M];
void make_set(int v) {
p[v] = make_pair(v, 0);
sz[v] = 1;
}
inline pair<int, int> find(int v) {
if (p[v].first == v) {
return make_pair(v, 0);
}
int s = p[v].second;
p[v] = find(p[v].first);
p[v].second ^= s;
return p[v];
}
bool unite(int v, int u) {
int a = find(v).first;
int b = find(u).first;
if (a == b) {
return p[v].second ^ p[u].second;
}
if (sz[a] > sz[b]) {
swap(a, b);
}
sz[b] += sz[a];
p[a] = make_pair(b, p[v].second ^ p[u].second ^ 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", &e[i].a, &e[i].b, &e[i].w);
--e[i].a, --e[i].b;
e[i].n = i + 1;
}
sort(e, e + m);
for (int i = 0; i < q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
bool f = 0;
for (int j = 0; j < n; ++j) {
make_set(j);
}
for (int j = 0; j < m; ++j) {
if (e[j].n >= l && e[j].n <= r) {
if (!unite(e[j].a, e[j].b)) {
printf("%d\n", e[j].w);
f = 1;
break;
}
}
}
if (!f) {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000, M = N * (N - 1) / 2;
int dsu[N * 2];
int find(int i) { return dsu[i] < 0 ? i : (dsu[i] = find(dsu[i])); }
bool join(int i, int j) {
i = find(i);
j = find(j);
if (i == j) return false;
if (dsu[i] > dsu[j])
dsu[i] = j;
else {
if (dsu[i] == dsu[j]) dsu[i]--;
dsu[j] = i;
}
return true;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
static int ii[M], jj[M], ww[M], hh[M];
for (int h = 0; h < m; h++) {
int i, j, w;
scanf("%d%d%d", &i, &j, &w), i--, j--;
ii[h] = i;
jj[h] = j;
ww[h] = w;
hh[h] = h;
}
sort(hh, hh + m, [](int a, int b) { return ww[a] > ww[b]; });
while (q-- > 0) {
int l, r;
scanf("%d%d", &l, &r), l--, r--;
fill_n(dsu, n * 2, -1);
int w = -1;
for (int 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;
if (join(i0, j1) && !join(i1, j0)) {
w = ww[h_];
break;
}
}
}
printf("%d\n", w);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1111;
int p[NMAX << 1];
int rnk[NMAX << 1];
int find(int u) { return p[u] == u ? u : p[u] = find(p[u]); }
void uni(int u, int v) {
u = find(u), v = find(v);
if (u == v) return;
if (rnk[v] < rnk[u]) swap(v, u);
p[u] = v;
rnk[v] = max(rnk[v], rnk[u] + 1);
}
struct edge {
int w, a, b, x;
const bool operator<(const edge& other) const { return w > other.w; }
};
int main() {
int N, M, Q;
scanf("%d%d%d", &N, &M, &Q);
vector<edge> v;
for (int i = 1; i <= M; i++) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
v.push_back({w, a, b, i});
}
sort(v.begin(), v.end());
while (Q--) {
int l, r;
scanf("%d%d", &l, &r);
for (int i = 1; i <= 2 * N; i++) p[i] = i, rnk[i] = 0;
bool ok = false;
for (int i = 0; i < M; i++) {
const auto& e = v[i];
if (l <= e.x && e.x <= r) {
if (find(e.a) == find(e.b)) {
printf("%d\n", e.w);
ok = true;
break;
}
uni(e.a, e.b + N);
uni(e.b, e.a + N);
}
}
if (!ok) printf("-1\n");
}
}
|
#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);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
const int maxm = 1e6 + 5;
int ufs[maxn], n, m;
struct edg {
int u, v, w;
int id;
edg(int u = 0, int v = 0, int w = 0, int id = 0) : u(u), v(v), w(w), id(id) {}
};
bool cmp(edg a1, edg b1) { return a1.w > b1.w; }
edg a[maxm];
int q;
inline void init() {
for (int i = 1; i <= n * 2; i++) {
ufs[i] = i;
}
}
int find(int u) {
if (ufs[u] == u) return u;
return ufs[u] = find(ufs[u]);
}
void join(int u, int v) { ufs[find(u)] = find(v); }
void debug() {
cout << "print edg" << endl;
for (int i = 1; i <= m; i++) {
cout << a[i].u << ' ' << a[i].v << ' ' << a[i].w << ' ' << a[i].id << endl;
}
cout << "print edg end" << endl;
}
void printu() {
cout << "print ufs" << endl;
for (int i = 1; i <= n * 2; i++) {
cout << ufs[i] << ' ';
}
cout << endl;
}
int main() {
cin >> 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, cmp);
while (q--) {
int l, r;
init();
int ans = -1;
scanf("%d%d", &l, &r);
for (int i = 1; i <= m; i++) {
if (a[i].id >= l && a[i].id <= r) {
int u = a[i].u, v = a[i].v;
if (find(u) == find(v)) {
ans = a[i].w;
break;
} else {
join(u + n, v);
join(u, v + n);
}
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct road {
int start, end, len, id;
} rd[500005];
int fa[2005];
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;
}
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> rd[i].start >> rd[i].end >> rd[i].len;
rd[i].id = i;
}
sort(rd + 1, rd + 1 + m, cmp);
while (q--) {
int ans = -1, l, r;
cin >> l >> r;
for (int i = 1; i <= n * 2; i++) {
fa[i] = i;
}
for (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);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, M = 1e6 + 10;
struct edge {
int u, v, w, ind;
};
int n, m, comp[N], col[N];
vector<int> nodes[N];
edge e[M];
void init() {
for (int i = 0; i < (int)(n); i++) {
comp[i] = i;
col[i] = 0;
nodes[i] = vector<int>{i};
}
}
void merge(int x, int y) {
int a = comp[x], b = comp[y];
if (((int)(nodes[a]).size()) < ((int)(nodes[y]).size())) {
swap(x, y);
swap(a, b);
}
bool inv = col[x] == col[y];
for (auto u : nodes[b]) {
nodes[a].push_back(u);
col[u] ^= inv;
comp[u] = a;
}
nodes[b].clear();
}
int main() {
int q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < (int)(m); i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
u--;
v--;
e[i] = (edge){u, v, w, i + 1};
}
sort(e, e + m, [](edge x, edge y) { return x.w > y.w; });
while (q--) {
init();
int l, r;
scanf("%d %d", &l, &r);
int ans = -1;
for (int i = 0; i < (int)(m); i++)
if (l <= e[i].ind && e[i].ind <= r) {
int u = e[i].u, v = e[i].v;
if (comp[u] == comp[v]) {
if (col[u] == col[v]) {
ans = e[i].w;
break;
}
} else
merge(u, v);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int read() {
int MisakaMikoto;
scanf("%d", &MisakaMikoto);
return MisakaMikoto;
}
int fa[N * 2];
int find(int x) {
if (fa[x] != x) return fa[x] = find(fa[x]);
return x;
}
int cnt;
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;
}
} e[N * N];
bool cmp(edge a, edge b) { return a.w > b.w; }
int n, m, q;
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= m; ++i) {
int u = read(), v = read(), w = read();
e[++cnt] = edge(u, v, w, i);
}
sort(e + 1, e + 1 + cnt, cmp);
while (q--) {
int l = read(), r = read(), ans = -1;
for (int i = 1; i <= n * 2; i++) fa[i] = i;
for (int i = 1; i <= m; i++)
if (e[i].id >= l && e[i].id <= r) {
if (find(e[i].u) == find(e[i].v)) {
ans = e[i].w;
break;
} else {
fa[find(e[i].u + n)] = find(e[i].v);
fa[find(e[i].u)] = find(e[i].v + n);
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
const int N = 1000 + 10;
const int MAXN = 1e9 + 8;
using namespace std;
int n, m, q;
int l, r;
bool sign = false;
struct Node {
int u, v, d, t;
} f[N * N / 2];
bool cmp(Node A, Node B) { return A.d > B.d; }
void init() {
scanf("%d %d %d", &n, &m, &q);
int u, v, d;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &f[i].u, &f[i].v, &f[i].d);
f[i].t = i;
}
sort(f + 1, f + m + 1, cmp);
}
int fa[N * 2];
int findx(int x) { return x == fa[x] ? x : fa[x] = findx(fa[x]); }
void solve() {
for (int i = 1; i <= n * 2 + 1; i++) {
fa[i] = i;
}
int u, v, lu, lv, ru, rv;
for (int i = 1; i <= m; i++)
if (f[i].t >= l && f[i].t <= r) {
u = f[i].u, v = f[i].v;
lu = (u << 1), lv = (v << 1), ru = (u << 1 | 1), rv = (v << 1 | 1);
if (findx(lu) == findx(lv) || findx(ru) == findx(rv)) {
printf("%d\n", f[i].d);
return;
}
if (fa[lu] != fa[rv]) fa[fa[lu]] = fa[rv];
if (fa[ru] != fa[lv]) fa[fa[ru]] = fa[lv];
}
printf("-1\n");
}
void work() {
for (int i = 1; i <= q; i++) {
cin >> l >> r;
solve();
}
}
int main() {
init();
work();
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;
struct edge {
int u, v, w;
edge() { u = 0, v = 0, w = 0; }
const bool operator<(const edge &rhs) const { return rhs.w < w; }
};
edge 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;
}
pair<vector<edge>, int> getrange(vector<edge> a, vector<edge> b) {
vector<edge> te(sz(a) + sz(b));
merge(a.begin(), a.end(), b.begin(), b.end(), te.begin());
for (auto x : te) dsu[x.u] = {{x.u, 1}, 1}, dsu[x.v] = {{x.v, 1}, 1};
vector<edge> fin;
for (auto x : te) {
if (uni(x.u, x.v))
fin.push_back(x);
else if (sameasparent(x.u) == sameasparent(x.v)) {
fin.push_back(x);
return {fin, x.w};
}
}
return {fin, -1};
}
struct seg {
pair<vector<edge>, int> t[MAXN];
void mt(int ind, int le, int ri) {
if (le == ri) {
t[ind] = {{edges[le]}, -1};
return;
}
int mid = (le + ri) / 2;
int left = ind + 1, right = ind + (mid - le + 1) * 2;
mt(left, le, mid), mt(right, mid + 1, ri);
t[ind] = getrange(t[left].first, t[right].first);
}
pair<vector<edge>, int> query(int ind, int le, int ri, int l, int r) {
if (l > ri || r < le) return {{}, -1};
if (le >= l && ri <= r) return t[ind];
int mid = (le + ri) / 2;
int left = ind + 1, right = ind + (mid - le + 1) * 2;
return getrange(query(left, le, mid, l, r).first,
query(right, mid + 1, ri, l, r).first);
}
} tree;
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].u >> edges[i].v >> edges[i].w;
tree.mt(0, 1, m);
int l, r;
while (q--) {
cin >> l >> r;
printf("%d\n", tree.query(0, 1, m, l, r).second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000 * 1000 * 1000;
const long long inf64 = 1ll * inf * inf;
struct DSU {
int n;
vector<int> par, color, h;
DSU() { n = 0; }
DSU(int nn) {
n = nn;
par.resize(n + 1);
color.resize(n + 1);
h.resize(n + 1);
for (int i = 1; i <= n; i++) {
par[i] = i;
color[i] = h[i] = 0;
}
}
int find(int x) {
if (x == par[x])
return x;
else {
int t = find(par[x]);
color[x] ^= color[par[x]];
return par[x] = t;
}
}
int parity(int x) {
find(x);
return color[x];
}
int add_edge(int x, int y) {
int px = find(x);
int py = find(y);
if (px == py) {
if (parity(x) == parity(y))
return 2;
else
return 0;
}
if (h[px] < h[py]) {
swap(px, py);
swap(x, y);
}
color[py] ^= (parity(x) ^ parity(y) ^ 1);
if (h[py] == h[px]) h[px]++;
par[py] = px;
return 1;
}
};
int n, m, q;
struct edge {
int u, v, id, w;
static int EdgeCount;
edge() { u = v = id = w = 0; }
void read() {
scanf("%d %d %d", &u, &v, &w);
id = EdgeCount++;
}
void print() { printf("#%d {%d %d} [%d]\n", id, u, v, w); }
bool operator<(const edge& b) const {
return make_tuple(w, u, v, id) < make_tuple(b.w, b.u, b.v, b.id);
}
bool operator>(const edge& b) const {
return make_tuple(w, u, v, id) > make_tuple(b.w, b.u, b.v, b.id);
}
bool operator==(const edge& b) const {
return make_tuple(w, u, v, id) == make_tuple(b.w, b.u, b.v, b.id);
}
};
int edge ::EdgeCount = 1;
int RESULT;
void upd(vector<edge>& l) {
vector<edge> res;
DSU dsu(n);
RESULT = -1;
for (auto _e : l) {
int type = dsu.add_edge(_e.u, _e.v);
if (type) res.push_back(_e);
if (type == 2) {
RESULT = _e.w;
break;
}
}
l = res;
}
vector<edge> merge(const vector<edge>& l, const vector<edge>& r) {
int left_size = (int)l.size();
int right_size = (int)r.size();
int left_cur = 0, right_cur = 0;
vector<edge> res;
while (left_cur < left_size && right_cur < right_size) {
if (l[left_cur] > r[right_cur])
res.push_back(l[left_cur++]);
else
res.push_back(r[right_cur++]);
}
while (left_cur < left_size) res.push_back(l[left_cur++]);
while (right_cur < right_size) res.push_back(r[right_cur++]);
upd(res);
return res;
}
vector<vector<edge> > st;
vector<edge> e;
void build(int v, int tl, int tr) {
if (tl == tr) {
st[v].push_back(e[tl]);
} else {
int tm = (tl + tr) / 2;
build(v << 1, tl, tm);
build(v << 1 | 1, tm + 1, tr);
st[v] = merge(st[v << 1], st[v << 1 | 1]);
}
}
vector<edge> get(int v, int tl, int tr, int l, int r) {
if (l <= tl && tr <= r)
return st[v];
else {
int tm = (tl + tr) / 2;
if (l <= tm) {
if (r > tm)
return merge(get(v << 1, tl, tm, l, r),
get(v << 1 | 1, tm + 1, tr, l, r));
else
return get(v << 1, tl, tm, l, r);
} else
return get(v << 1 | 1, tm + 1, tr, l, r);
}
}
bool solve() {
scanf("%d %d %d", &n, &m, &q);
e.resize(m + 1);
for (int i = 1; i <= m; i++) e[i].read();
st.resize(4 * m);
build(1, 1, m);
for (int l, r; q > 0; q--) {
scanf("%d %d", &l, &r);
auto tmp = get(1, 1, m, l, r);
upd(tmp);
printf("%d\n", RESULT);
}
return true;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct str {
int a, b, len;
} edge[1010 * 1010], sing[1010 * 1010];
vector<str> Edge[501000 << 2];
int n, m, Q;
int top, ans;
int re[1010], fa[1010];
bool cmp(const str &a, const str &b) { return (a.len > b.len); }
int find(int a) {
if (a == fa[a]) return a;
int f = fa[a];
fa[a] = find(f);
re[a] ^= re[f];
return fa[a];
}
void build(int u, int L, int R) {
int n = 0;
for (int i = L; i <= R; i++) sing[++n] = edge[i];
sort(sing + 1, sing + n + 1, cmp);
for (int i = 1; i <= n; i++) {
int a = sing[i].a, b = sing[i].b;
if (find(a) != find(b)) {
re[fa[a]] = re[a] ^ re[b] ^ 1;
fa[fa[a]] = fa[b];
Edge[u].push_back(sing[i]);
} else if (re[a] == re[b]) {
Edge[u].push_back(sing[i]);
break;
}
}
for (int i = 1; i <= n; i++) {
int a = sing[i].a, b = sing[i].b;
re[a] = 0;
re[b] = 0;
fa[a] = a;
fa[b] = b;
}
if (L < R) {
build((u << 1), L, ((L + R) >> 1));
build((u << 1 | 1), (((L + R) >> 1) + 1), R);
}
return;
}
void proc(int u, int L, int R, int l, int r) {
if (L == l && R == r) {
for (int i = 0; i < (int)Edge[u].size(); i++) sing[++top] = Edge[u][i];
return;
}
if (r < (((L + R) >> 1) + 1))
proc((u << 1), L, ((L + R) >> 1), l, r);
else if (l > ((L + R) >> 1))
proc((u << 1 | 1), (((L + R) >> 1) + 1), R, l, r);
else {
proc((u << 1), L, ((L + R) >> 1), l, ((L + R) >> 1));
proc((u << 1 | 1), (((L + R) >> 1) + 1), R, (((L + R) >> 1) + 1), r);
}
return;
}
int main() {
scanf("%d %d %d", &n, &m, &Q);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &edge[i].a, &edge[i].b, &edge[i].len);
}
for (int i = 1; i <= n; i++) fa[i] = i;
build(1, 1, m);
for (; Q; Q--) {
int l, r;
for (int i = 1; i <= n; i++) re[i] = 0, fa[i] = i;
scanf("%d %d", &l, &r);
top = 0;
proc(1, 1, m, l, r);
sort(sing + 1, sing + top + 1, cmp);
ans = -1;
for (int i = 1; i <= top; i++) {
int a = sing[i].a, b = sing[i].b;
if (find(a) != find(b)) {
re[fa[a]] = re[a] ^ re[b] ^ 1;
fa[fa[a]] = fa[b];
} else if (re[a] == re[b]) {
ans = sing[i].len;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> edge[1000000];
pair<int, int> vert[1000000];
int parity[1001];
int par[1001];
vector<int> group[1001];
int m;
void merge(int u, int v) {
int x = parity[u] == parity[v];
u = par[u];
v = par[v];
if (group[u].size() < group[v].size()) swap(u, v);
while (!group[v].empty()) {
int cur = group[v].back();
group[v].pop_back();
par[cur] = u;
parity[cur] ^= x;
group[u].push_back(cur);
}
}
int solve(int l, int r) {
for (int i = m - 1; i >= 0; i--) {
int j = edge[i].second;
if (j > r || j < l) continue;
int u = vert[j].first;
int v = vert[j].second;
if (par[u] == par[v]) {
if (parity[u] == parity[v]) return edge[i].first;
continue;
}
merge(u, v);
}
return -1;
}
int main(int argc, char const *argv[]) {
int n, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
edge[i] = make_pair(w, i);
vert[i] = make_pair(u, v);
}
sort(edge, edge + m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
for (int i = 1; i <= n; i++) {
parity[i] = -1;
par[i] = i;
group[i].clear();
group[i].push_back(i);
}
int ans = solve(l, r);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ui64 = unsigned long long;
using i64 = long long;
using ui32 = unsigned int;
using Double = long double;
template <class T>
inline T Abs(const T& x) {
return x < 0 ? -x : x;
}
template <class T>
inline T Sqr(const T& x) {
return x * x;
}
template <class T>
void Print(const T& x);
template <>
void Print<ui64>(const ui64& x) {
printf("%" PRIu64, x);
}
template <>
void Print<i64>(const i64& x) {
printf("%" PRId64, x);
}
template <>
void Print<ui32>(const ui32& x) {
printf("%" PRIu32, x);
}
template <>
void Print<int>(const int& x) {
printf("%" PRId32, x);
}
template <>
void Print<float>(const float& x) {
printf("%.15f", x);
}
template <>
void Print<double>(const double& x) {
printf("%.15lf", x);
}
template <>
void Print<Double>(const Double& x) {
Print<double>(x);
}
template <>
void Print<string>(const string& s) {
printf("%s", s.c_str());
}
template <class T>
T Read();
template <>
ui64 Read<ui64>() {
ui64 x;
scanf("%" SCNu64, &x);
return x;
}
template <>
i64 Read<i64>() {
i64 x;
scanf("%" SCNd64, &x);
return x;
}
template <>
ui32 Read<ui32>() {
ui32 x;
scanf("%" SCNu32, &x);
return x;
}
template <>
int Read<int>() {
int x;
scanf("%" SCNd32, &x);
return x;
}
template <>
float Read<float>() {
float x;
scanf("%f", &x);
return x;
}
template <>
double Read<double>() {
double x;
scanf("%lf", &x);
return x;
}
template <>
Double Read<Double>() {
return Read<double>();
}
template <>
string Read<string>() {
static char buf[int(1e7 + 1)];
scanf("%s", buf);
return string(buf);
}
template <class T>
void ReadLine(T& x);
template <class T, class... Args>
void ReadLine(T& x, Args&... args);
template <class T>
void PrintLine(const T& x);
template <class T, class... Args>
void PrintLine(const T& x, Args... args);
template <class T>
void PrintVector(const vector<T>& x, char delimiter = ' ');
template <class T>
vector<T> ReadVector(size_t size);
const int maxm = 500 * 1001;
struct TEdge {
int U;
int V;
int W;
};
int main() {
int n, m, q;
ReadLine(n, m, q);
vector<TEdge> edges;
vector<int> idx(m);
for (int i = 0; i < m; ++i) {
int u = Read<int>() - 1;
int v = Read<int>() - 1;
int w = Read<int>();
edges.push_back({u, v, w});
idx[i] = i;
}
sort(idx.begin(), idx.end(),
[&](int lhs, int rhs) { return edges[lhs].W > edges[rhs].W; });
for (; q; --q) {
int l = Read<int>() - 1;
int r = Read<int>() - 1;
vector<int> color(n, 1);
vector<int> comp(n, 0);
for (int i = 0; i < n; ++i) {
comp[i] = i;
}
int ans = -1;
for (int id : idx) {
if (id > r || id < l) {
continue;
}
int u = edges[id].U, v = edges[id].V;
if (comp[u] == comp[v]) {
if (color[u] == color[v]) {
ans = edges[id].W;
break;
}
} else {
int mask = (color[u] == color[v] ? 3 : 0);
int curComp = comp[v];
for (int i = 0; i < n; ++i) {
if (comp[i] == curComp) {
comp[i] = comp[u];
color[i] ^= mask;
}
}
}
}
PrintLine(ans);
}
return 0;
}
template <class T>
void ReadLine(T& x) {
x = Read<T>();
}
template <class T, class... Args>
void ReadLine(T& x, Args&... args) {
x = Read<T>();
ReadLine(args...);
}
template <class T>
void PrintLine(const T& x) {
Print(x);
printf("\n");
}
template <class T, class... Args>
void PrintLine(const T& x, Args... args) {
Print(x);
printf(" ");
PrintLine(args...);
}
template <class T>
void PrintVector(const vector<T>& x, char delimiter) {
for (size_t i = 0; i < x.size(); ++i) {
Print(x[i]);
if (i + 1 < x.size()) {
printf("%c", delimiter);
}
}
printf("\n");
}
template <class T>
vector<T> ReadVector(size_t size) {
vector<T> res(size);
for (size_t i = 0; i < size; ++i) {
res[i] = Read<T>();
}
return res;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
struct UnionFind {
vector<int> data;
void init(int n) { data.assign(n, -1); }
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
struct Edge {
int i;
int u, v;
};
int main() {
int n;
int m;
int q;
while (~scanf("%d%d%d", &n, &m, &q)) {
vector<pair<int, int> > weights(m), pairs(m);
for (int(i) = 0; (i) < (int)(m); ++(i)) {
int u;
int v;
int w;
scanf("%d%d%d", &u, &v, &w), --u, --v;
weights[i] = make_pair(w, i);
pairs[i] = make_pair(u, v);
}
sort(weights.begin(), weights.end());
vector<Edge> edges(m);
for (int(i) = 0; (i) < (int)(m); ++(i)) {
int ei = weights[m - 1 - i].second;
edges[i] = Edge{ei, pairs[ei].first, pairs[ei].second};
}
vector<vector<int> > ccs(n);
vector<int> root(n), color(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) ccs[i].reserve(n);
for (int(ii) = 0; (ii) < (int)(q); ++(ii)) {
int l;
int r;
scanf("%d%d", &l, &r), --l;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
ccs[i].assign(1, i);
root[i] = i;
color[i] = 0;
}
int ans = -1;
for (int(ix) = 0; (ix) < (int)(m); ++(ix)) {
const Edge &e = edges[ix];
if (e.i < l || r <= e.i) continue;
bool samecol = color[e.u] == color[e.v];
int x = root[e.u], y = root[e.v];
if (x != y) {
vector<int> &v = ccs[x], &w = ccs[y];
if (v.size() < w.size()) {
swap(x, y);
v.swap(w);
}
for (int a : w) {
root[a] = x;
color[a] ^= samecol ? 1 : 0;
}
v.insert(v.end(), w.begin(), w.end());
w.clear();
ccs[x].swap(v);
} else if (samecol) {
ans = weights[m - 1 - ix].first;
break;
}
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[1000009], pr[1000009], ap[1000009], par[1002], color[1002];
pair<int, pair<int, int> > NOW[1000009];
vector<int> vec[1002];
pair<pair<int, int>, pair<int, int> > NOWW[1000009];
int get_parent(int r) {
if (par[r] != r) par[r] = get_parent(par[r]);
return par[r];
}
int main() {
int i, j, k, l, m, n, q, ind = 0, low, high, mid, left, right, ans, pos, flag,
u, v, jor, par_u, par_v, z, x, node;
cin >> n >> m >> q;
pos = 0;
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &ar[i], &pr[i], &ap[i]);
NOWW[++pos] = make_pair(make_pair(ap[i], i), make_pair(ar[i], pr[i]));
}
sort(NOWW + 1, NOWW + 1 + pos);
reverse(NOWW + 1, NOWW + 1 + pos);
while (q--) {
cin >> left >> right;
pos = 0;
for (i = 1; i <= m; i++) {
if (NOWW[i].first.second >= left && NOWW[i].first.second <= right)
NOW[++pos] =
make_pair(NOWW[i].first.first,
make_pair(NOWW[i].second.first, NOWW[i].second.second));
}
for (i = 1; i <= n; i++) {
par[i] = i;
color[i] = 0;
vec[i].clear();
vec[i].push_back(i);
}
flag = 0;
for (i = 1; i <= pos; i++) {
u = NOW[i].second.first;
v = NOW[i].second.second;
jor = (color[u] == color[v]);
par_u = get_parent(u);
par_v = get_parent(v);
if (par_u == par_v) {
if (jor == 1) {
ans = NOW[i].first;
flag = 1;
break;
}
} else {
z = vec[par_u].size();
x = vec[par_v].size();
if (z > x) {
for (j = 0; j < x; j++) {
node = vec[par_v][j];
vec[par_u].push_back(node);
color[node] ^= jor;
}
par[par_v] = par_u;
} else {
for (j = 0; j < z; j++) {
node = vec[par_u][j];
vec[par_v].push_back(node);
color[node] ^= jor;
}
par[par_u] = par_v;
}
}
}
if (flag == 0) ans = -1;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, l, r, ans;
int fa[1005], w[1005];
struct Node {
int x, y, w, id;
} f[1000005];
bool cmp(Node a, Node b) { return a.w > b.w; }
int find1(int x) {
if (fa[x] == x) return x;
int fx = find1(fa[x]);
w[x] = w[x] ^ w[fa[x]];
fa[x] = fx;
return fx;
}
bool union1(int x, int y) {
int fx = find1(x);
int fy = find1(y);
if (fx == fy) {
if (w[x] == w[y])
return false;
else
return true;
}
fa[fx] = fy;
w[fx] = w[x] ^ w[y] ^ 1;
return true;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &f[i].x, &f[i].y, &f[i].w);
f[i].id = i;
}
sort(f + 1, f + m + 1, cmp);
while (q--) {
ans = -1;
scanf("%d%d", &l, &r);
for (int i = 1; i <= n; ++i) fa[i] = i, w[i] = 0;
for (int i = 1; i <= m; ++i) {
if (f[i].id >= l && f[i].id <= r) {
if (!union1(f[i].x, f[i].y)) {
ans = f[i].w;
break;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m, q;
struct EDGE {
int s, e, v, idx;
EDGE() {}
EDGE(int s, int e, int v, int idx) : s(s), e(e), v(v), idx(idx) {}
bool operator<(const EDGE &p) const { return v > p.v; }
} edge[2000000];
EDGE a[2000000];
int ai;
int u[3000];
int find(int x) { return u[x] == x ? x : u[x] = find(u[x]); }
int main() {
int i, j, k, l;
cin >> n >> m >> q;
for (i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z), x--, y--;
edge[i] = EDGE(x, y, z, i);
}
sort(edge, edge + m);
for (i = 0; i < q; i++) {
int x, y;
scanf("%d%d", &x, &y), x--, y--;
ai = 0;
for (j = 0; j < n * 2; j++) u[j] = j;
int ans = -1;
for (j = 0; j < m; j++)
if (edge[j].idx >= x && edge[j].idx <= y) {
int x1 = find(edge[j].s * 2), y2 = find(edge[j].e * 2 + 1);
if (x1 != y2) u[x1] = y2;
int y1 = find(edge[j].e * 2), x2 = find(edge[j].s * 2 + 1);
if (y1 != x2) u[y1] = x2;
if (find(edge[j].s * 2) == find(edge[j].s * 2 + 1) ||
find(edge[j].e * 2) == find(edge[j].e * 2 + 1)) {
ans = edge[j].v;
break;
}
}
printf("%d\n", ans);
}
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 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) {
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(get(opp[u]), v);
} else {
opp[u] = v;
}
if (opp[v] != -1) {
merge(get(opp[v]), u);
} else {
opp[v] = u;
}
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read(long long num = 0, char c = 0) {
while (c > '9' || c < '0') c = getchar();
while (c >= '0' && c <= '9') num = num * 10 + c - 48, c = getchar();
return num;
}
struct node {
int x, y, val, num;
void in() { x = read(), y = read(), val = read(); }
} p[500010];
int f[2005], n, m, q, l, r;
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
bool cmp(node a, node b) { return a.val > b.val; }
int work() {
for (register int i = 1; i <= m; ++i) {
if (p[i].num >= l && p[i].num <= r) {
if (find(p[i].x) == find(p[i].y)) {
return p[i].val;
} else {
f[find(p[i].x + n)] = f[find(p[i].y)];
f[find(p[i].y + n)] = f[find(p[i].x)];
}
}
}
return -1;
}
int main() {
n = read(), m = read(), q = read();
for (register int i = 1; i <= m; ++i) p[i].in(), p[i].num = i;
sort(p + 1, p + 1 + m, cmp);
for (register int i = 1; i <= q; ++i) {
l = read(), r = read();
for (register int i = 1; i <= 2 * n; ++i) f[i] = i;
printf("%d\n", work());
}
return 0;
}
|
#include <bits/stdc++.h>
struct edge {
int u, v, id, w;
bool operator<(edge const &x) const { return w > x.w; }
} p[1000010];
int n, m, q, f[2010];
int find(int x) {
while (x != f[x]) x = f[x] = f[f[x]];
return x;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &p[i].u, &p[i].v, &p[i].w), p[i].id = i;
std::sort(p + 1, p + m + 1);
while (q--) {
for (int i = 1; i <= n * 2; i++) f[i] = i;
int l, r, ans = -1;
scanf("%d%d", &l, &r);
for (int i = 1; i <= m; i++)
if (p[i].id <= r && p[i].id >= l) {
int u = find(p[i].u), v = find(p[i].v);
if (u == v) {
ans = p[i].w;
break;
} else {
int fu = find(p[i].u + n), fv = find(p[i].v + n);
f[fv] = u;
f[fu] = v;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int flag, n, q, m, rl[1010], fa[1010];
struct data {
int u, v, w, id;
bool operator<(const data &rhs) const { return w < rhs.w; }
} ed[1001000];
void Init() {
flag = 0;
for (int i = 1; i <= n; i++) fa[i] = i, rl[i] = 0;
}
int find(int k) {
if (fa[k] == k) return k;
int f = find(fa[k]);
rl[k] ^= rl[fa[k]];
return fa[k] = f;
}
bool Unite(int x, int y) {
int fx = find(x), fy = find(y);
if (fx == fy && rl[x] == rl[y]) return 0;
if (fx != fy) {
fa[fx] = fy;
rl[fx] = rl[x] ^ rl[y] ^ 1;
}
return 1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &ed[i].u, &ed[i].v, &ed[i].w), ed[i].id = i;
sort(ed + 1, ed + m + 1);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
Init();
for (int i = m; i >= 1; i--)
if (ed[i].id >= l && ed[i].id <= r)
if (!Unite(ed[i].u, ed[i].v)) {
flag = 1;
printf("%d\n", ed[i].w);
break;
}
if (!flag) puts("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010, MAXM = 500000;
struct edge {
int u, v, w;
int id;
void read(int i) {
scanf("%d %d %d", &u, &v, &w);
u--;
v--;
id = i;
}
};
bool operator<(edge e1, edge e2) { return e1.w < e2.w; }
int N, M, Q;
edge E[MAXM];
struct union_find {
int par[MAXN];
void reset() {
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 x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return false;
}
par[x] = y;
return true;
}
} uf;
int col[MAXN];
vector<int> adj[MAXN];
void dfs(int x, int c) {
if (col[x] != -1) {
return;
}
col[x] = c;
for (int t : adj[x]) {
dfs(t, !c);
}
}
int main() {
scanf("%d %d %d", &N, &M, &Q);
for (int i = 0; i < M; i++) {
E[i].read(i);
}
sort(E, E + M);
for (int qi = 0; qi < Q; qi++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
uf.reset();
memset(col, -1, sizeof(col));
for (int i = 0; i < N; i++) {
adj[i].clear();
}
for (int i = M - 1; i >= 0; i--) {
if (E[i].id < x || E[i].id >= y) {
continue;
}
int u = E[i].u, v = E[i].v;
if (!uf.merge(u, v)) {
continue;
}
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < N; i++) {
dfs(i, 0);
}
int ans = -1;
for (int i = M - 1; i >= 0; i--) {
if (E[i].id < x || E[i].id >= y) {
continue;
}
if (col[E[i].u] == col[E[i].v]) {
ans = E[i].w;
break;
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int p[1000], r[1000], col[1000];
int getp(int v) {
if (p[v] == v) return v;
int pr = getp(p[v]);
col[v] ^= col[p[v]];
p[v] = pr;
return p[v];
}
void join(int a, int b, int d) {
if (r[a] > r[b])
swap(a, b);
else if (r[a] == r[b])
++r[b];
p[a] = b;
col[a] = 1 ^ d;
}
int main() {
int n, m, Q;
scanf("%d%d%d", &n, &m, &Q);
vector<array<int, 4>> v(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &v[i][1], &v[i][2], &v[i][0]);
--v[i][1];
--v[i][2];
v[i][3] = i + 1;
}
sort(v.rbegin(), v.rend());
for (int test = 0; test < Q; ++test) {
int L, R;
scanf("%d%d", &L, &R);
memset(r, 0, sizeof(r));
memset(col, 0, sizeof(col));
for (int i = 0; i < n; ++i) p[i] = i;
int ans = -1;
for (int i = 0; i < v.size(); ++i)
if (v[i][3] >= L && v[i][3] <= R) {
int a = getp(v[i][1]), b = getp(v[i][2]);
if (a != b) {
join(a, b, col[v[i][1]] ^ col[v[i][2]]);
} else {
if (col[v[i][1]] == col[v[i][2]]) {
ans = v[i][0];
break;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
T Angle(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T euclide(T a, T b, T& x, T& y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
void ia(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void pa(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T, class first>
inline T togglebit(T a, first i) {
T t = 1;
return (a ^ (t << i));
}
double DEG(double x) { return (180.0 * x) / (2.0 * acos(0.0)); }
double RAD(double x) { return (x * (double)2.0 * acos(0.0)) / (180.0); }
template <class T>
struct Vector {
T* ar;
int sz;
int cap;
Vector() {
cap = 1;
sz = 0;
ar = (T*)malloc(cap * sizeof(T));
}
Vector(int n) {
cap = n;
sz = n;
ar = (T*)calloc(cap, sizeof(T));
}
void push_back(T x) {
if (sz == cap) {
cap = cap + ((cap + 1) >> 1);
ar = (T*)realloc(ar, cap * sizeof(T));
}
ar[sz++] = x;
}
void clear() {
cap = 1;
sz = 0;
free(ar);
ar = (T*)malloc(cap * sizeof(T));
}
void sort(int l, int r) { std::sort(ar + l, ar + r + 1); }
T& operator[](int idx) { return ar[idx]; }
int size() { return sz; }
};
struct Edge {
int u, v, w, i;
Edge() {}
Edge(int _u, int _v, int _w, int _i) {
u = _u;
v = _v;
w = _w;
i = _i;
}
bool operator<(const Edge& p) const { return w < p.w; }
};
int par[1007], color[1007];
Vector<int> comp[1007];
Vector<Edge> e;
void Init(int n) {
for (int i = 0; i <= n; i++) {
par[i] = i;
color[i] = 0;
comp[i].clear();
comp[i].push_back(i);
}
}
int FindPar(int n) {
if (par[n] == n)
return n;
else
return par[n] = FindPar(par[n]);
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
e = Vector<Edge>(m + 2);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
e[i] = Edge(u, v, w, i);
}
e.sort(1, m);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
Init(n);
int res = -1;
for (int i = m; i; i--) {
if (e[i].i < l || e[i].i > r) continue;
int u = FindPar(e[i].u), v = FindPar(e[i].v), w = e[i].w;
if (u != v) {
if (comp[u].size() < comp[v].size()) swap(u, v);
int f = (color[e[i].u] == color[e[i].v]);
for (int j = 0; j < comp[v].size(); j++) {
int x = comp[v][j];
color[x] ^= f;
comp[u].push_back(x);
par[x] = u;
}
comp[v].clear();
} else if (color[e[i].u] == color[e[i].v]) {
res = max(res, w);
break;
}
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int N = 1000;
struct union_find_tree {
vector<int> parent;
vector<int> height;
vector<int> group_size;
vector<bool> diff;
void init1(int uf_n) {
parent.resize(uf_n);
height.resize(uf_n);
group_size.resize(uf_n);
diff.resize(uf_n);
}
void init(int uf_n) {
for (int i = 0; i < uf_n; i++) {
parent[i] = i;
height[i] = 0;
group_size[i] = 0;
diff[i] = false;
}
}
pair<int, bool> get_root(int now) {
if (parent[now] == now) return pair<int, bool>(parent[now], diff[now]);
pair<int, bool> op = get_root(parent[now]);
diff[now] = diff[now] ^ diff[parent[now]];
parent[now] = parent[parent[now]];
return pair<int, bool>(parent[now], diff[now]);
}
void merge(int v1, int v2) {
pair<int, bool> p1 = get_root(v1), p2 = get_root(v2);
v1 = p1.first, v2 = p2.first;
bool di = p1.second ^ p2.second;
if (height[v1] < height[v2]) swap(v1, v2);
parent[v2] = v1;
group_size[v1] += group_size[v2];
diff[v2] = !di;
if (height[v1] == height[v2]) height[v1]++;
}
} uf_tree;
int n, m, q;
pair<pair<int, int>, pair<int, int> > road[N * N + 5];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int v1, v2, r;
scanf("%d %d %d", &v1, &v2, &r);
road[i] = pair<pair<int, int>, pair<int, int> >(pair<int, int>(r, i),
pair<int, int>(v1, v2));
}
uf_tree.init1(n + 2);
sort(road + 1, road + m + 1);
for (int i = 0; i < q; i++) {
int l, r, j;
scanf("%d %d", &l, &r);
uf_tree.init(n + 2);
for (j = m; j >= 1; j--) {
if (road[j].first.second < l || road[j].first.second > r) continue;
int v1 = road[j].second.first, v2 = road[j].second.second;
pair<int, bool> p1 = uf_tree.get_root(v1), p2 = uf_tree.get_root(v2);
if (p1.first != p2.first)
uf_tree.merge(v1, v2);
else if (p1.second == p2.second) {
printf("%d\n", road[j].first.first);
break;
}
}
if (j == 0) printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int id[600000], a[600000], b[600000], c[600000];
bool cmp(int i, int j) { return c[i] > c[j]; }
int adj[1010][1010], deg[1010], col[1010], root[1010];
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", a + i, b + i, c + i);
id[i] = i;
}
sort(id, id + m, cmp);
int L, R;
while (q--) {
scanf("%d %d", &L, &R);
L--;
R--;
for (int i = 1; i <= n; i++) {
root[i] = i;
col[i] = deg[i] = 0;
adj[i][deg[i]++] = i;
}
int ans = -1;
for (int ii = 0; ii < m; ii++) {
int i = id[ii];
if (i > R || i < L) continue;
int x = root[a[i]], y = root[b[i]];
if (x == y) {
if (col[a[i]] == col[b[i]]) {
ans = c[i];
break;
}
} else {
if (deg[x] > deg[y]) swap(x, y);
int inv = (col[a[i]] == col[b[i]]);
for (int j = 0; j < deg[x]; j++) {
int z = adj[x][j];
adj[y][deg[y]++] = z;
root[z] = y;
col[z] ^= inv;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rread(T& num) {
num = 0;
T f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') num = num * 10 + ch - '0', ch = getchar();
num *= f;
}
inline int getgcd(int x, int y) {
if (!x) return y;
return getgcd(y % x, x);
}
inline long long getlcm(int x, int y) {
return (long long)x / getgcd(x, y) * y;
}
inline long long getgcd(long long x, long long y) {
if (!x) return y;
return getgcd(y % x, x);
}
inline long long getlcm(long long x, long long y) {
return x / getgcd(x, y) * y;
}
inline int power(int x, int k, int p) {
int res = 1;
for (; k; k >>= 1, x = (long long)x * x % p)
if (k & 1) res = (long long)res * x % p;
return res;
}
inline long long power(long long x, long long k, long long p) {
long long res = 1;
for (; k; k >>= 1, x = x * x % p)
if (k & 1) res = res * x % p;
return res;
}
const double pi = acos(-1);
inline void judge() { freopen("input.txt", "r", stdin); }
const int maxm = 1e6 + 5;
const int maxn = 2e3 + 5;
int n, m, q;
int fa[maxn], rk[maxn];
struct edge {
int x, y, z, id;
} e[maxm];
inline bool cmp(edge a, edge b) { return a.z > b.z; }
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rk[x] == rk[y])
rk[y]++;
else if (rk[x] > rk[y])
swap(rk[x], rk[y]);
fa[x] = y;
}
int main() {
rread(n);
rread(m);
rread(q);
for (int(i) = (1); (i) <= (m); (i)++)
rread(e[i].x), rread(e[i].y), rread(e[i].z), e[i].id = i;
sort(e + 1, e + m + 1, cmp);
while (q--) {
int l, r;
rread(l);
rread(r);
bool flag = 0;
for (int(i) = (1); (i) <= (n * 2); (i)++) fa[i] = i, rk[i] = 0;
for (int(i) = (1); (i) <= (m); (i)++)
if (e[i].id >= l && e[i].id <= r) {
merge((2 * e[i].x - 1), (2 * e[i].y));
merge((2 * e[i].x), (2 * e[i].y - 1));
if (find((2 * e[i].x - 1)) == find((2 * e[i].x)) ||
find((2 * e[i].y - 1)) == find((2 * e[i].y))) {
printf("%d\n", e[i].z);
flag = 1;
}
if (flag) break;
}
if (!flag) puts("-1");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.