#557235 (C++17) No.1197 モンスターショー

提出ソース

結果

問題	No.1197 モンスターショー
ユーザー	SHIJOU
提出日時	2020-09-23 14:49:12
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	248 ms / 3,000 ms
コード長	3,714 bytes
コンパイル時間	2,438 ms
コンパイル使用メモリ	220,952 KB
実行使用メモリ	14,720 KB
最終ジャッジ日時	2024-06-27 22:40:13
合計ジャッジ時間	9,809 ms
ジャッジサーバーID （参考情報）	judge2 / judge1

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 6,812 KB
testcase_01	AC	2 ms 6,940 KB
testcase_02	AC	2 ms 6,940 KB
testcase_03	AC	2 ms 6,940 KB
testcase_04	AC	2 ms 6,940 KB
testcase_05	AC	2 ms 6,944 KB
testcase_06	AC	2 ms 6,940 KB
testcase_07	AC	51 ms 12,160 KB
testcase_08	AC	80 ms 8,320 KB
testcase_09	AC	102 ms 11,776 KB
testcase_10	AC	142 ms 11,520 KB
testcase_11	AC	90 ms 6,944 KB
testcase_12	AC	73 ms 6,944 KB
testcase_13	AC	47 ms 8,832 KB
testcase_14	AC	139 ms 9,088 KB
testcase_15	AC	104 ms 6,940 KB
testcase_16	AC	152 ms 13,184 KB
testcase_17	AC	168 ms 13,440 KB
testcase_18	AC	67 ms 6,940 KB
testcase_19	AC	141 ms 11,520 KB
testcase_20	AC	33 ms 6,940 KB
testcase_21	AC	99 ms 6,944 KB
testcase_22	AC	12 ms 6,940 KB
testcase_23	AC	152 ms 9,472 KB
testcase_24	AC	112 ms 9,472 KB
testcase_25	AC	71 ms 7,424 KB
testcase_26	AC	133 ms 7,680 KB
testcase_27	AC	158 ms 12,672 KB
testcase_28	AC	110 ms 8,192 KB
testcase_29	AC	90 ms 9,216 KB
testcase_30	AC	76 ms 10,112 KB
testcase_31	AC	67 ms 8,576 KB
testcase_32	AC	65 ms 6,940 KB
testcase_33	AC	42 ms 7,296 KB
testcase_34	AC	248 ms 14,208 KB
testcase_35	AC	242 ms 14,112 KB
testcase_36	AC	237 ms 14,080 KB
testcase_37	AC	235 ms 14,080 KB
testcase_38	AC	233 ms 14,208 KB
testcase_39	AC	246 ms 14,080 KB
testcase_40	AC	142 ms 14,720 KB
testcase_41	AC	2 ms 6,944 KB
testcase_42	AC	2 ms 6,944 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <bits/stdc++.h>
using namespace std;

struct HLD {
  using Graph = vector<vector<int>>;
  using F = function<void(int, int)>;
  Graph G;
  vector<int> parent, heavy, depth, root, ids, sub, type, inv;
  int _n;
  HLD() {}
  HLD(int n):G(n), parent(n, -1), heavy(n, -1), depth(n), root(n, -1), ids(n), _n(n), sub(n, 1), type(n), inv(n) {}

  void add(int i, int j) {
    G[i].emplace_back(j);
    G[j].emplace_back(i);
  }
  void init(vector<int> roots = vector<int>(1, 0)) {
    int group = 0;
    int pos = 0;
    for(int rt:roots) {
      dfs(rt);
      bfs(rt, group++, pos);
    }
  }
  void dfs(int rt) {
    stack<pair<int, int>> st;
    st.emplace(rt, 0);
    while(!st.empty()) {
      int v = st.top().first;
      int &siz = st.top().second;
      if(siz < int(G[v].size())) {
        int u = G[v][siz++];
        if(u == parent[v]) continue;
        parent[u] = v;
        depth[u] = depth[v]+1;
        st.emplace(u, 0);
      }
      else {
        st.pop();
        int maxSubtree = 0;
        for(int u:G[v]) {
          if(u == parent[v]) continue;
          sub[v] += sub[u];
          if(maxSubtree < sub[u]) maxSubtree = sub[u], heavy[v] = u;
        }
      }
    }
  }
  void bfs(int rt, int group, int &pos) {
    queue<int> que({rt});
    while(!que.empty()) {
      int v = que.front();
      que.pop();
      for(int u = v; u != -1; u = heavy[u]) {
        type[u] = group;
        ids[u] = pos++;
        inv[ids[u]] = u;
        root[u] = v;
        for(int w:G[u]) {
          if(w != parent[u] and w != heavy[u]) que.emplace(w);
        }
      }
    }
  }
  void for_each(int u, int v, const F &f, bool edge = false) {
		assert(type[u] == type[v]);
    while(true) {
      if(ids[u] > ids[v]) swap(u, v);
      if(root[u] == root[v]) {
				if(edge) {
					if(u != v) f(ids[u]+1, ids[v]+1);
				}
        else f(ids[u], ids[v]+1);
        break;
      }
      f(ids[root[v]], ids[v]+1);
      v = parent[root[v]];
    }
  }
  int lca(int u, int v) {
    while(true) {
      if(ids[u] > ids[v]) swap(u, v);
      if(root[u] == root[v]) return u;
      v = parent[root[v]];
    }
  }
  int dis(int u, int v) {
    return depth[u] + depth[v] - (depth[lca(u, v)]<<1);
  }
	const int &operator[](int i) const {return ids[i];}
};

#define N 100100

int n, k, q;
int c[N];
long long ans;
long long bit1[N], bit2[N];
void add(int i, long long x, long long *bit) {
	while(i <= n) {
		bit[i] += x;
		i += i&-i;
	}
}
long long sum(int i, long long *bit) {
	long long res = 0;
	while(i) {
		res += bit[i];
		i &= i-1;
	}
	return res;
}
void add_p(int l, int r, long long x) {
	add(l, x, bit1);
	add(r, -x, bit1);
	add(l, -(l-1)*x, bit2);
	add(r, (r-1)*x, bit2);
}
long long get(int i) {
	long long res = 0;
	res += sum(i, bit2);
	res += sum(i, bit1)*i;
	return res;
}

int main() {
	scanf("%d%d%d", &n, &k, &q);
	HLD hld(n);
	for(int i = 0; i < k; i++) {
		scanf("%d", c+i);
		c[i]--;
	}
	for(int i = 0; i < n-1; i++) {
		int a, b;
		scanf("%d%d", &a, &b);
		a--; b--;
		hld.add(a, b);
	}
	hld.init();
	for(int i = 0; i < k; i++) {
		int _ = c[i];
		add_p(2, n+1, 1);
		hld.for_each(0, _, [](int i, int j)->void {add_p(i+1, j+1, -2);}, true);
		ans += hld.dis(0, _);
	}
	while(q--) {
		int type;
		scanf("%d", &type);
		if(type == 1) {
			int p, d;
			scanf("%d%d", &p, &d);
			p--; d--;
			hld.for_each(0, c[p], [](int i, int j)->void {add_p(i+1, j+1, 2);}, true);
			hld.for_each(0, d, [](int i, int j)->void {add_p(i+1, j+1, -2);}, true);
			ans += hld.dis(0, d) - hld.dis(c[p], 0);
			c[p] = d;
		}
		else {
			int e;
			scanf("%d", &e);
			e--;
			long long res = ans;
			hld.for_each(0, e, [&res](int i, int j)->void {res += get(j)-get(i);}, true);
			printf("%lld\n", res);
		}
	}
}

yukicoder

結果

テストケース

ソースコード