結果

問題 No.1442 I-wate Shortest Path Problem
ユーザー saxofone111saxofone111
提出日時 2021-03-26 22:36:50
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 732 ms / 3,000 ms
コード長 5,943 bytes
コンパイル時間 2,657 ms
コンパイル使用メモリ 220,712 KB
実行使用メモリ 43,116 KB
最終ジャッジ日時 2024-05-06 16:23:44
合計ジャッジ時間 13,881 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 2 ms
5,376 KB
testcase_02 AC 12 ms
5,376 KB
testcase_03 AC 188 ms
5,376 KB
testcase_04 AC 15 ms
5,376 KB
testcase_05 AC 9 ms
5,376 KB
testcase_06 AC 185 ms
5,376 KB
testcase_07 AC 9 ms
5,376 KB
testcase_08 AC 176 ms
5,376 KB
testcase_09 AC 21 ms
5,376 KB
testcase_10 AC 205 ms
5,376 KB
testcase_11 AC 202 ms
5,376 KB
testcase_12 AC 512 ms
34,696 KB
testcase_13 AC 349 ms
24,196 KB
testcase_14 AC 469 ms
30,944 KB
testcase_15 AC 416 ms
26,944 KB
testcase_16 AC 505 ms
29,372 KB
testcase_17 AC 670 ms
34,232 KB
testcase_18 AC 732 ms
34,368 KB
testcase_19 AC 588 ms
33,044 KB
testcase_20 AC 656 ms
34,248 KB
testcase_21 AC 704 ms
34,376 KB
testcase_22 AC 375 ms
32,364 KB
testcase_23 AC 604 ms
43,116 KB
testcase_24 AC 343 ms
23,824 KB
testcase_25 AC 530 ms
34,108 KB
testcase_26 AC 350 ms
30,456 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include "bits/stdc++.h"

#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
#define fi first
#define se second

using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};

struct dijkstra{
  ll N;
  llvec d;
  vector<vector<edge>> e;
  dijkstra(ll n){
    N = n;
    //d = llvec(N, 1e18);
    e = vector<vector<edge>>(N);
  }

  void add_edge(ll from, ll to, ll cost){
    e[from].push_back({to, cost});
  }

  void run(ll start){
    priority_queue<P, vector<P>, greater<P>> que;
    que.push({0, start});
    d = llvec(N, 1e18);
    d[start]=0;
    while(!que.empty()){
      P q = que.top();que.pop();
      ll dc = q.first;
      ll x = q.second;
      if(dc>d[x]){
        continue;
      }else{
        for(auto ip: e[x]){
          if(d[ip.x]<=d[x]+ip.c){
            continue;
          }else{
            d[ip.x]= d[x]+ip.c;
            que.push({d[ip.x], ip.x});
          }
        }
      }
    }
  }  
};

/*
  struct segment_tree{
  ll N;
  llvec v;
  ll init=5e18;//initial value
  ll f(ll a, ll b){ //function
  return min(a, b);
  }
  segment_tree(ll n){
  N=1;
  while(N<n){
  N*=2;
  }
  v = llvec(2*N-1, init);
  }
  
  void set(ll i, ll val){
  i += N-1;
  v[i] = val;
  while(i>0){
  i = (i-1)/2;
  v[i] = f(v[i*2+1], v[i*2+2]);
  }
  }
  void add(ll i, ll val){
  i += N-1;
  v[i] += val;
  while(i>0){
  i = (i-1)/2;
  v[i] = f(v[i*2+1], v[i*2+2]);
  }
  }

  ll get(ll L, ll R){// L <= i < R
  L += N-1;
  R += N-1;
  ll vl = init;
  ll vr = init;
  while(L<R){
  if(L%2==0){
  vl = f(vl, v[L]);
  L++;
  }
  if(R%2==0){
  vr = f(vr, v[R-1]);
  R--;
  }
  R=(R-1)/2;
  L=(L-1)/2;
  }
  return f(vl, vr);
  }

  ll operator[](ll i){
  return v[i+N-1];
  }
  
  };*/


template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
  int ceil_pow2(int n) {
    int x = 0;
    while ((1U << x) < (unsigned int)(n)) x++;
    return x;
  }
  segtree() : segtree(0) {}
  segtree(int n) : segtree(std::vector<S>(n, e())) {}
  segtree(const std::vector<S>& v) : _n(int(v.size())) {
    log = ceil_pow2(_n);
    size = 1 << log;
    d = std::vector<S>(2 * size, e());
    for (int i = 0; i < _n; i++) d[size + i] = v[i];
    for (int i = size - 1; i >= 1; i--) {
      update(i);
    }
  }

  void set(int p, S x) {
    assert(0 <= p && p < _n);
    p += size;
    d[p] = x;
    for (int i = 1; i <= log; i++) update(p >> i);
  }

  S get(int p) {
    assert(0 <= p && p < _n);
    return d[p + size];
  }

  S prod(int l, int r) {
    assert(0 <= l && l <= r && r <= _n);
    S sml = e(), smr = e();
    l += size;
    r += size;

    while (l < r) {
      if (l & 1) sml = op(sml, d[l++]);
      if (r & 1) smr = op(d[--r], smr);
      l >>= 1;
      r >>= 1;
    }
    return op(sml, smr);
  }

  S all_prod() { return d[1]; }

  template <bool (*f)(S)> int max_right(int l) {
    return max_right(l, [](S x) { return f(x); });
  }
  template <class F> int max_right(int l, F f) {
    assert(0 <= l && l <= _n);
    assert(f(e()));
    if (l == _n) return _n;
    l += size;
    S sm = e();
    do {
      while (l % 2 == 0) l >>= 1;
      if (!f(op(sm, d[l]))) {
        while (l < size) {
          l = (2 * l);
          if (f(op(sm, d[l]))) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - size;
      }
      sm = op(sm, d[l]);
      l++;
    } while ((l & -l) != l);
    return _n;
  }

  template <bool (*f)(S)> int min_left(int r) {
    return min_left(r, [](S x) { return f(x); });
  }
  template <class F> int min_left(int r, F f) {
    assert(0 <= r && r <= _n);
    assert(f(e()));
    if (r == 0) return 0;
    r += size;
    S sm = e();
    do {
      r--;
      while (r > 1 && (r % 2)) r >>= 1;
      if (!f(op(d[r], sm))) {
        while (r < size) {
          r = (2 * r + 1);
          if (f(op(d[r], sm))) {
            sm = op(d[r], sm);
            r--;
          }
        }
        return r + 1 - size;
      }
      sm = op(d[r], sm);
    } while ((r & -r) != r);
    return 0;
  }

private:
  int _n, size, log;
  std::vector<S> d;

  void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

using S = ll;
S op(S a, S b){
  return min(a, b);
}
S ed(){
  return 1e18;
}

//segtree<S, op, e> sg(vector<S> a)

vector<S> s;
vector<ll> in;
vector<vector<edge>> e;

void dfs(ll from, ll to, ll c){
  in[to] = s.size();  
  s.push_back(c);
  for(auto ie: e[to]){
    if(ie.x==from)continue;
    dfs(to, ie.x, c+ie.c);
    s.push_back(c);
  }
  return;
}

/**************************************
** A main function starts from here  **
***************************************/
int main(){
  ll N, K;
  cin >> N >> K;
  dijkstra dijk(N+K);
  e = vector<vector<edge>>(N);

  rep(i, N-1){
    ll a, b, c;
    cin >> a >> b >> c;
    a--;b--;
    e[a].push_back({b, c});
    e[b].push_back({a, c});
    dijk.add_edge(a, b, c);
    dijk.add_edge(b, a, c);
  }
  
  in = llvec(N, 0);
  dfs(-1, 0, 0);
  
  segtree<S, op, ed> sg(s);
  
  llvec p;
  
  rep(i, K){
    ll M, dd;
    cin >> M >> dd;
    rep(j, M){
      ll x;
      cin >> x;
      x--;
      dijk.add_edge(N+i, x, dd);
      dijk.add_edge(x, N+i, 0);
    }
    p.push_back(dd);
  }

  vector<llvec> d(K);

  rep(i, K){
    dijk.run(N+i);
    d[i] = dijk.d;
  }

  ll Q;
  cin >> Q;

  while(Q--){
    ll u, v;
    cin >> u >> v;
    u--;v--;
    
    ll from = min(in[u], in[v]);
    ll to = max(in[u], in[v])+1;
    ll ans = s[in[u]] + s[in[v]] - 2*sg.prod(from, to);
    
    rep(i, K){
      ans = min(ans, d[i][u] + d[i][v]-p[i]);
    }
    cout << ans << endl;
  }
  
  return 0;
}
0