結果
| 問題 | No.529 帰省ラッシュ |
| ユーザー |
 tonegawa
|
| 提出日時 | 2020-05-13 08:10:43 |
| 言語 | C++14 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 5,984 bytes |
| コンパイル時間 | 2,181 ms |
| コンパイル使用メモリ | 138,684 KB |
| 実行使用メモリ | 83,996 KB |
| 最終ジャッジ日時 | 2024-09-14 15:24:13 |
| 合計ジャッジ時間 | 19,030 ms |
|
ジャッジサーバーID （参考情報） |
judge5 / judge2 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | WA | - |
| testcase_01 | AC | 53 ms
43,008 KB |
| testcase_02 | AC | 53 ms
43,008 KB |
| testcase_03 | AC | 53 ms
43,008 KB |
| testcase_04 | WA | - |
| testcase_05 | WA | - |
| testcase_06 | WA | - |
| testcase_07 | WA | - |
| testcase_08 | WA | - |
| testcase_09 | WA | - |
| testcase_10 | WA | - |
| testcase_11 | WA | - |
| testcase_12 | WA | - |
| testcase_13 | WA | - |
| testcase_14 | AC | 923 ms
83,996 KB |
| testcase_15 | WA | - |
| testcase_16 | WA | - |
| testcase_17 | WA | - |
| testcase_18 | WA | - |
| testcase_19 | WA | - |
ソースコード
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#define vll vector<ll>
#define vvvl vector<vvl>
#define vvl vector<vector<ll>>
#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));
#define re(c, b) for(ll c=0;c<b;c++)
#define all(obj) (obj).begin(), (obj).end()
typedef long long int ll;
typedef long double ld;
using namespace std;
//二重辺連結成分分解
struct Graph{
int MAX_V;
vector<set<ll>> G;
vector<set<ll>> rG;
vector<bool> used;
vector<int> cmp;
vector<int> vs;
Graph(ll V){
MAX_V = V;
G = vector<set<ll>>(MAX_V+1);
rG = vector<set<ll>>(MAX_V+1);
used.resize(MAX_V+1, false);
cmp.resize(MAX_V+1, 0);
}
void add_edge(int from, int to){
G[from].insert(to);
G[to].insert(from);
rG[from].insert(to);
rG[to].insert(from);
}
void dfs(int v){
used[v] = true;
for(auto to:G[v]) {
ll a = v, b = to;
G[b].erase(a);
rG[a].erase(b);
if(!used[to]) dfs(to);
}
vs.push_back(v);
}
void rdfs(int v, int k){
used[v] = true;
cmp[v] = k;
for(auto to:rG[v]) {
if(!used[to]) rdfs(to, k);
}
}
int scc(int V){
for(int i=0;i<MAX_V;i++) used[i] = false;
vs.clear();
for(int i=0;i<MAX_V;i++) if(!used[i]) dfs(i);
for(int i=0;i<MAX_V;i++) used[i] = false;
int k = 0;
for(int i=vs.size()-1;i>=0;i--) if(!used[vs[i]]) rdfs(vs[i], k++);
return k;
}
//変換後の頂点->辺群
vvl build(ll n){
vvl ret = VV(MAX_V+1, 0, 0, ll);
vector<set<ll>> T(MAX_V+1);
scc(n);
for(int i=0;i<=n;i++){
for(auto to:G[i]){
T[cmp[i]].insert(cmp[to]);
T[cmp[to]].insert(cmp[i]);
}
}
for(int i=0;i<=n;i++){
for(auto to:T[i]){
ret[i].push_back(to);
}
}
return ret;
}
};
template< typename G >
struct HeavyLightDecomposition {
G &g;
vector< int > sz, in, out, head, rev, par;
HeavyLightDecomposition(G &g) :
g(g), sz(200001), in(200001), out(200001), head(200001), rev(200001), par(200001) {}
void dfs_sz(int idx, int p) {
par[idx] = p;
sz[idx] = 1;
if(g[idx].size() && g[idx][0] == p) swap(g[idx][0], g[idx].back());
for(auto &to : g[idx]) {
if(to == p) continue;
dfs_sz(to, idx);
sz[idx] += sz[to];
if(sz[g[idx][0]] < sz[to]) swap(g[idx][0], to);
}
}
void dfs_hld(int idx, int par, int ×) {
in[idx] = times++;
rev[in[idx]] = idx;
for(auto &to : g[idx]) {
if(to == par) continue;
head[to] = (g[idx][0] == to ? head[idx] : to);
dfs_hld(to, idx, times);
}
out[idx] = times;
}
void build() {
dfs_sz(0, -1);
int t = 0;
dfs_hld(0, -1, t);
}
int la(int v, int k) {
while(1) {
int u = head[v];
if(in[v] - k >= in[u]) return rev[in[v] - k];
k -= in[v] - in[u] + 1;
v = par[u];
}
}
int lca(int u, int v) {
for(;; v = par[head[v]]) {
if(in[u] > in[v]) swap(u, v);
if(head[u] == head[v]) return u;
}
}
template< typename T, typename Q, typename F >
T query(int u, int v, const T &ti, const Q &q, const F &f, bool edge = false) {
T l = ti, r = ti;
for(;; v = par[head[v]]) {
if(in[u] > in[v]) swap(u, v), swap(l, r);
if(head[u] == head[v]) break;
l = f(q(in[head[v]], in[v] + 1), l);
}
return f(f(q(in[u] + edge, in[v] + 1), l), r);
// return {f(q(in[u] + edge, in[v] + 1), l), r};
}
template< typename Q >
void add(int u, int v, const Q &q, bool edge = false) {
for(;; v = par[head[v]]) {
if(in[u] > in[v]) swap(u, v);
if(head[u] == head[v]) break;
q(in[head[v]], in[v] + 1);
}
q(in[u] + edge, in[v] + 1);
}
};
//-------------------------------------------------------------------
//-------------------------------------------------------------------
struct segtree{
ll M=1, INF = 1000000000000000000;
vector<vll> dat;
vector<ll> INIT;
segtree(ll N, ll num){
INIT = vll{num, -1};
while(M<N) M*=2;
dat.resize(M*2-1, vll{num, -1});
}
void update(vll x, ll k, ll l=0, ll r=-1){
if(r==-1) r = M;
k+=M-1;
dat[k][0] = x[0], dat[k][1] = x[1];
while(k>0) {
k = (k-1)/2;
if(dat[k*2+2][1]>dat[k*2+1][1]){
dat[k][0] = dat[k*2+2][0], dat[k][1] = dat[k*2+2][1];
}else{
dat[k][0] = dat[k*2+1][0], dat[k][1] = dat[k*2+1][1];
}
}
}
vll query(ll a, ll b=-1, ll k=0, ll l=0, ll r=-1){
if(r==-1) r = M;
if(b==-1) b = M;
if(r<=a || b<=l) return INIT;
if(a<=l && r<=b) return dat[k];
vll A = query(a, b, k*2+1, l, (l+r)/2);
vll B = query(a, b, k*2+2, (l+r)/2, r);
return max(A, B);
}
};
//-------------------------------------------------------------------
#include <queue>
int main(int argc, char const *argv[]) {
ll a, b, c, n, m, q;std::cin >> n >> m >> q;
Graph scc(n+1);
re(i, m){
scanf("%lld %lld", &a, &b);
scc.add_edge(a, b);
}
vvl G = scc.build(n);
HeavyLightDecomposition<vvl> hld(G);
hld.build();
segtree seg(200001, -1);
vector<priority_queue<ll>> max_cost(200001);
re(i, q){
scanf("%lld %lld %lld", &a, &b, &c);
if(a==1){
b = scc.cmp[b];
max_cost[b].push(c);
ll MAX = max_cost[b].top();
hld.add(b, b, [&](ll x, ll y){seg.update(vll{MAX, b}, x);});
}else{
b = scc.cmp[b];
c = scc.cmp[c];
vll q = hld.query(b, c, vll{-1, -1},
[&](ll x, ll y){return seg.query(x, y);},
[&](vll x, vll y){return max(x, y);}
);
printf("%lld\n", q[0]);
if(q[0]!=-1) {
max_cost[q[1]].pop();
ll MAX = (!max_cost[q[1]].empty()?max_cost[q[1]].top():-1);
hld.add(q[1], q[1], [&](ll x, ll y){seg.update(vll{MAX, q[1]}, x);});
}
}
}
return 0;
}