牛客练习赛61 [口胡]

好憨批一场牛客

A 题大概是个小模拟，告辞。

B 题大概也是个小模拟，告辞。

C 题随便并查集一下然后搜索。

D 题随便算一下 1~i 的距离和 i~n 的距离，最后O1查询就完了。

E 题显然可以二分，哈希然后记录上一个出现的位置就完了。

F 题随便搞个点分树，变成 (log) 层，然后随便修改一下。

// powered by c++11
// by Isaunoya
#include <bits/stdc++.h>

#define rep(i, x, y) for (register int i = (x); i <= (y); ++i)
#define Rep(i, x, y) for (register int i = (x); i >= (y); --i)

using namespace std;
using db = double;
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;

#define pii pair<int, int>
#define fir first
#define sec second

template <class T>

void cmax(T& x, const T& y) {
  if (x < y) x = y;
}

template <class T>

void cmin(T& x, const T& y) {
  if (x > y) x = y;
}

#define all(v) v.begin(), v.end()
#define sz(v) ((int)v.size())
#define pb emplace_back

template <class T>

void sort(vector<T>& v) {
  sort(all(v));
}

template <class T>

void reverse(vector<T>& v) {
  reverse(all(v));
}

template <class T>

void unique(vector<T>& v) {
  sort(all(v)), v.erase(unique(all(v)), v.end());
}

void reverse(string& s) { reverse(s.begin(), s.end()); }

const int io_size = 1 << 23 | 233;
const int io_limit = 1 << 22;
struct io_in {
  char ch;
#ifndef __WIN64
  char getchar() {
    static char buf[io_size], *p1 = buf, *p2 = buf;

    return (p1 == p2) && (p2 = (p1 = buf) + fread(buf, 1, io_size, stdin), p1 == p2) ? EOF : *p1++;
  }
#endif
  io_in& operator>>(char& c) {
    for (c = getchar(); isspace(c); c = getchar())
      ;

    return *this;
  }
  io_in& operator>>(string& s) {
    for (s.clear(); isspace(ch = getchar());)
      ;

    if (!~ch) return *this;

    for (s = ch; !isspace(ch = getchar()) && ~ch; s += ch)
      ;

    return *this;
  }

  io_in& operator>>(char* str) {
    char* cur = str;
    while (*cur) *cur++ = 0;

    for (cur = str; isspace(ch = getchar());)
      ;
    if (!~ch) return *this;

    for (*cur = ch; !isspace(ch = getchar()) && ~ch; *++cur = ch)
      ;

    return *++cur = 0, *this;
  }

  template <class T>

  void read(T& x) {
    bool f = 0;
    while ((ch = getchar()) < 48 && ~ch) f ^= (ch == 45);

    x = ~ch ? (ch ^ 48) : 0;
    while ((ch = getchar()) > 47) x = x * 10 + (ch ^ 48);
    x = f ? -x : x;
  }

  io_in& operator>>(int& x) { return read(x), *this; }

  io_in& operator>>(ll& x) { return read(x), *this; }

  io_in& operator>>(uint& x) { return read(x), *this; }

  io_in& operator>>(ull& x) { return read(x), *this; }

  io_in& operator>>(db& x) {
    read(x);
    bool f = x < 0;
    x = f ? -x : x;
    if (ch ^ '.') return *this;

    double d = 0.1;
    while ((ch = getchar()) > 47) x += d * (ch ^ 48), d *= .1;
    return x = f ? -x : x, *this;
  }
} in;

struct io_out {
  char buf[io_size], *s = buf;
  int pw[233], st[233];

  io_out() {
    set(7);
    rep(i, pw[0] = 1, 9) pw[i] = pw[i - 1] * 10;
  }

  ~io_out() { flush(); }

  void io_chk() {
    if (s - buf > io_limit) flush();
  }

  void flush() { fwrite(buf, 1, s - buf, stdout), fflush(stdout), s = buf; }

  io_out& operator<<(char c) { return *s++ = c, *this; }

  io_out& operator<<(string str) {
    for (char c : str) *s++ = c;
    return io_chk(), *this;
  }

  io_out& operator<<(char* str) {
    char* cur = str;
    while (*cur) *s++ = *cur++;
    return io_chk(), *this;
  }

  template <class T>

  void write(T x) {
    if (x < 0) *s++ = '-', x = -x;

    do {
      st[++st[0]] = x % 10, x /= 10;
    } while (x);

    while (st[0]) *s++ = st[st[0]--] ^ 48;
  }

  io_out& operator<<(int x) { return write(x), io_chk(), *this; }

  io_out& operator<<(ll x) { return write(x), io_chk(), *this; }

  io_out& operator<<(uint x) { return write(x), io_chk(), *this; }

  io_out& operator<<(ull x) { return write(x), io_chk(), *this; }

  int len, lft, rig;

  void set(int _length) { len = _length; }

  io_out& operator<<(db x) {
    bool f = x < 0;
    x = f ? -x : x, lft = x, rig = 1. * (x - lft) * pw[len];
    return write(f ? -lft : lft), *s++ = '.', write(rig), io_chk(), *this;
  }
} out;
#define int long long

template <int sz, int mod>

struct math_t {
  math_t() {
    fac.resize(sz + 1), ifac.resize(sz + 1);
    rep(i, fac[0] = 1, sz) fac[i] = fac[i - 1] * i % mod;

    ifac[sz] = inv(fac[sz]);
    Rep(i, sz - 1, 0) ifac[i] = ifac[i + 1] * (i + 1) % mod;
  }

  vector<int> fac, ifac;

  int qpow(int x, int y) {
    int ans = 1;
    for (; y; y >>= 1, x = x * x % mod)
      if (y & 1) ans = ans * x % mod;
    return ans;
  }

  int inv(int x) { return qpow(x, mod - 2); }

  int C(int n, int m) {
    if (n < 0 || m < 0 || n < m) return 0;
    return fac[n] * ifac[m] % mod * ifac[n - m] % mod;
  }
};

int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
int lcm(int x, int y) { return x * y / gcd(x, y); }

int n, m;
const int maxn = 1e5 + 51;
int rt[maxn];

struct SMT {
  int val[maxn << 7], ls[maxn << 7], rs[maxn << 7], cnt;

  SMT() { cnt = 0, memset(val, 0x3f, sizeof(val)); }

  void upd(int& p, int l, int r, int x, int v) {
    if (!p) p = ++cnt;
    if (l == r) {
      cmin(val[p], v);
      return;
    }
    int mid = l + r >> 1;
    if (x <= mid)
      upd(ls[p], l, mid, x, v);
    else
      upd(rs[p], mid + 1, r, x, v);
    val[p] = min(val[ls[p]], val[rs[p]]);
  }

  int qry(int p, int a, int b, int l, int r) {
    if (!p) return 1e18;
    if (a <= l && r <= b) return val[p];
    int mid = l + r >> 1, ans = 1e18;
    if (a <= mid) ans = min(ans, qry(ls[p], a, b, l, mid));
    if (b > mid) ans = min(ans, qry(rs[p], a, b, mid + 1, r));
    return ans;
  }
} smt;

struct edge {
  int v, nxt, w;
} e[maxn << 1];
int cnt = 0, head[maxn];
void add(int u, int v, int w) {
  e[++cnt] = { v, head[u], w }, head[u] = cnt;
  e[++cnt] = { u, head[v], w }, head[v] = cnt;
}

struct Tree {
  int f[maxn][22], fa[maxn], dep[maxn], len[maxn];

  void dfs(int u) {
    dep[u] = dep[fa[u]] + 1;
    for (int i = head[u]; i; i = e[i].nxt) {
      int v = e[i].v;
      if (v ^ fa[u]) {
        fa[v] = u, len[v] = len[u] + e[i].w;
        dfs(v);
      }
    }
  }

  void solve() {
    dfs(1);
    for (int i = 1; i <= n; i++) f[i][0] = fa[i];
    for (int j = 1; j <= 20; j++) {
      for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
    }
  }

  int lca(int x, int y) {
    if (dep[x] < dep[y]) x ^= y ^= x ^= y;
    for (int i = 20; ~i; i--)
      if (dep[f[x][i]] >= dep[y]) x = f[x][i];
    if (x == y) return x;
    for (int i = 20; ~i; i--)
      if (f[x][i] ^ f[y][i]) x = f[x][i], y = f[y][i];
    return f[x][0];
  }

  int dis(int x, int y) { return len[x] + len[y] - (len[lca(x, y)] << 1); }
} tr;

struct NewTree {
  int sz[maxn], mx[maxn], vis[maxn], fa[maxn];
  vector<int> g[maxn];
  int rt, tot;

  NewTree() { mx[rt = 0] = 1e9; }

  void getrt(int u, int fa) {
    sz[u] = 1, mx[u] = 0;
    for (int i = head[u]; i; i = e[i].nxt) {
      int v = e[i].v;
      if (v ^ fa && !vis[v]) {
        getrt(v, u);
        sz[u] += sz[v], cmax(mx[u], sz[v]);
      }
    }
    cmax(mx[u], tot - sz[u]);
    if (mx[u] < mx[rt]) {
      rt = u;
    }
  }

  void solve(int u) {
    vis[u] = 1;
    const int now = tot;
    for (int i = head[u]; i; i = e[i].nxt) {
      int v = e[i].v;
      if (!vis[v]) {
        rt = 0, tot = (sz[v] > sz[u]) ? (now - sz[u]) : sz[v];
        getrt(v, u), g[u].pb(rt), fa[rt] = u, solve(rt);
      }
    }
  }

  void upd(int x, int val) {
    int now = x;
    while (x) {
      smt.upd(::rt[x], 1, maxn, val, tr.dis(now, x));
      x = fa[x];
    }
  }

  int qry(int x, int l, int r) {
    int now = x, ans = 1e18;
    while (x) {
      ans = min(ans, tr.dis(now, x) + smt.qry(::rt[x], l, r, 1, maxn));
      x = fa[x];
    }
    return ans;
  }
} nt;

int a[maxn];
signed main() {
  // code begin.
  in >> n >> m;
  for (int i = 1; i <= n; i++) { in >> a[i]; }
  for (int i = 2; i <= n; i++) {
    int u, v, w;
    in >> u >> v >> w;
    add(u, v, w);
  }
  tr.solve(), nt.tot = n, nt.getrt(1, 0), nt.solve(nt.rt);
  for (int i = 1; i <= n; i++) { nt.upd(i, a[i]); }
  while (m--) {
    int op;
    in >> op;
    if (op == 1) {
      int x, val;
      in >> x >> val;
      nt.upd(x, val);
    } else {
      int x, l, r;
      in >> x >> l >> r;
      int ans = nt.qry(x, l, r) << 1;
      if (ans > 1e18) ans = -1;
      out << ans << '
';
    }
  }
  return 0;
  // code end.
}