「Codeforces 827D」Best Edge Weight

给定一个点数为 $n$，边数为 $m$，权值不超过 $10^9$ 的带权连通图，没有自环与重边。
现在要求对于每一条边求出，这条边的边权最大为多少时，它还能出现在所有可能的最小生成树上，如果对于任意边权都出现，则输出 $-1$。
($2 \le n \le 2\times 10^5, n - 1 ≤ m ≤ 2\times 10^5$)

由于偷懒，我只写了 $O(n\log^2 n)$ 的做法。

分 $2$ 种情况考虑：

• 一条边 $e(u,v)$ 不在任意的最小生成树上：
  
  • 则一定要使 $w_e$ 小于最小生成树的上 $u$ 到 $v$ 的路径上的最大权值。
  • 证明：考虑 $\mathrm{Kruskal}$ 的计算过程，先将边按照边权排序，如果 $w_e$ 要在最小生成树上，那么只需要令其在 $u,v$ 各自所在联通块被连接在一起前，加入 $e(u,v)$ 即可，所以只要使 $w_e$ 小于最小生成树的上 $u$ 到 $v$ 的路径上的最大权值。
  • 一条边 $e(u,v)$ 在其中一个最小生成树上：
    
    • 则其权值等于不在最小生成树上的边 $e'(u',v')$，且 $u',v'$ 的路径经过边 $e(u,v)$ 的权值 $w_{e'} - 1$；
    • 证明：由前一个证明可知，$e(u,v)$ 在最小生成树，只需要满足 $e'(u',v')$ 的权值都比它大即可。

  所以有了上述想法，我们就能自然而然想出一个非常 simple 且 naive 的做法。

  只需要任意的求出一个最小生成树，用树链剖分线段树维护树上两点间路径的区间查询和区间取 $\min$ 即可，$O(n \log^2 n)$。

  复杂度更低的做法（杂谈）：

  1. 树上两点间路径的区间查询和区间取 $\min$，可以用 $\mathrm{LCT}$ 维护，$O(n\log n)$；
  2. 树上两点间路径的区间查询和区间取 $\min$，两个操作在本题中是各自独立的，所以区间查询可以用树上倍增，$O(n\log n)$；
  3. 而区间取 $\min$ 呢，方法应该很多，暂时想到一个离线所有的操作，然后在树上打标记，用可并堆来维护最小值，在 $u,v$ 处 push，做到 LCA$_{u,v}$ 时pop ，$O(n \log n)$；
  4. 欢迎踊跃发言。

  #include <cstdio>
  #include <cstring>
  #include <algorithm>
  #define R register
  #define Min(_A, _B) (_A < _B ? _A : _B)
  #define Max(_A, _B) (_A > _B ? _A : _B)
  template <class TT>  void Swap(R TT &A, R TT &B){ R TT t = A; A = B; B = t; }
  int F()
  {
      R int x; R char ch;
      while(ch = getchar(), ch < '0'|| ch > '9'); x = ch - '0';
      while(ch = getchar(), ch >= '0' && ch <= '9') x = ch - '0' + x * 10;
      return x;
  }
  const int Size = 200010, Inf = 2147483647;
  int n, m, Point[Size], Next[Size << 1], To[Size << 1], W1[Size << 1], W2[Size << 1], q;
  struct Edge{ int u, v, c, Ans; } e[Size], *p[Size];
  void Add(R Edge *t)
  {
      Next[++q] = Point[t->u]; Point[t->u] = q; To[q] = t->v; W1[q] = t->c, W2[q] = t - e;
      Next[++q] = Point[t->v]; Point[t->v] = q; To[q] = t->u; W1[q] = t->c, W2[q] = t - e;
  }
  bool cmp(R Edge *i, R Edge *j){ return i->c < j->c; }
  int Sum[Size], Most[Size], dfn[Size], dfn_index, Pre[Size], A[Size], Who[Size];
  int fa[Size], dep[Size], last[Size];
  int Find(R int now){ return last[now] == now ? now : last[now] = Find(last[now]); }
  void DFS1(R int u, R int from)
  {
      Sum[u] = 1;
      dep[u] = dep[fa[u] = from] + 1;
      for(R int j = Point[u]; j; j = Next[j])
          if(To[j] != from)
          {
              DFS1(To[j], u);
              Sum[u] += Sum[To[j]];
              if(Sum[Most[u]] < Sum[To[j]]) Most[u] = To[j];
          }
  }
  void DFS2(R int u, R int from, R int Grand, R int j)
  {
      A[dfn[u] = ++dfn_index] = W1[j]; Who[u] = W2[j];
      Pre[u] = Grand;
      for(R int j = Point[u]; j; j = Next[j]) if(Most[u] == To[j]) 
          DFS2(Most[u], u, Grand, j);
      for(R int j = Point[u]; j; j = Next[j])
          if(To[j] != from && To[j] != Most[u])
              DFS2(To[j], u, To[j], j);
  }
  int S0[1 << 19], Lazy[1 << 19], S1[1 << 19];
  void Pushdown(R int node)
  {
      if(Lazy[node] < Inf)
      {
          Lazy[node << 1] = Min(Lazy[node << 1], Lazy[node]);
          Lazy[node << 1 | 1] = Min(Lazy[node << 1 | 1], Lazy[node]);
          S0[node << 1] = Min(S0[node << 1], Lazy[node]);
          S0[node << 1 | 1] = Min(S0[node << 1 | 1], Lazy[node]);
          Lazy[node] = Inf;
      }
  }
  void Modify0(R int node, R int begin, R int end, R int l, R int r, R int val)
  {
      if(l <= begin && end <= r)
      {
          S0[node] = Min(S0[node], val);
          Lazy[node] = Min(Lazy[node], val);
          return ;
      }
      Pushdown(node);
      R int mid = begin + end >> 1;
      if(l <= mid) Modify0(node << 1, begin, mid, l, r, val);
      if(r > mid) Modify0(node << 1 | 1, mid + 1, end, l, r, val);
  }
  int Query0(R int node, R int begin, R int end, R int l, R int r)
  {
      if(l > r) return S0[node];
      if(l <= begin && end <= r) return S0[node];
      Pushdown(node);
      R int mid = begin + end >> 1, t1 = Inf, t2 = Inf;
      if(l <= mid) t1 = Query0(node << 1, begin, mid, l, r);
      if(r > mid) t2 = Query0(node << 1 | 1, mid + 1, end, l, r);
      return Min(t1, t2);
  }
  int Query1(R int node, R int begin, R int end, R int l, R int r)
  {
      if(l > r) return S1[node];
      if(l <= begin && end <= r) return S1[node];
      R int mid = begin + end >> 1, t1 = 0, t2 = 0;
      if(l <= mid) t1 = Query1(node << 1, begin, mid, l, r);
      if(r > mid) t2 = Query1(node << 1 | 1, mid + 1, end, l, r);
      return Max(t1, t2);
  }
  void Build1(R int node, R int begin, R int end)
  {
      if(begin == end)
      {
          S1[node] = A[begin];
          return ;
      }
      R int mid = begin + end >> 1;
      Build1(node << 1, begin, mid);
      Build1(node << 1 | 1, mid + 1, end);
      S1[node] = Max(S1[node << 1], S1[node << 1 | 1]);
  }
  void Build0(R int node, R int begin, R int end)
  {
      S0[node] = Lazy[node] = Inf;
      if(begin == end) return ;
      R int mid = begin + end >> 1;
      Build0(node << 1, begin, mid);
      Build0(node << 1 | 1, mid + 1, end);
  }
  void Work(R Edge *i)
  {
      R int A = i->u, B = i->v;
      while(Pre[A] != Pre[B])
      {
          if(dep[Pre[A]] < dep[Pre[B]]) Swap(A, B);
          Modify0(1, 1, n, dfn[Pre[A]], dfn[A], i->c);
          R int t = Query1(1, 1, n, dfn[Pre[A]], dfn[A]);
          i->Ans = Max(i->Ans, t);
          A = fa[Pre[A]];
      }
      if(A == B) return ;
      if(dep[A] < dep[B]) Swap(A, B);
      Modify0(1, 1, n, dfn[B] + 1, dfn[A], i->c);
      R int t = Query1(1, 1, n, dfn[B] + 1, dfn[A]);
      i->Ans = Max(i->Ans, t);
  }
  int main()
  {
      scanf("%d %d", &n, &m);
      for(R int i = 1; i <= m; i++) e[i] = (Edge){F(), F(), F(), -1};
      for(R int i = 1; i <= m; i++){ last[i] = i; p[i] = e + i; }
      std::sort(p + 1, p + 1 + m, cmp);
      for(R int i = 1; i <= m; i++)
      {
          R int X = Find(p[i]->u), Y = Find(p[i]->v);
          if(X != Y){ last[X] = Y; Add(p[i]); }
      }
      DFS1(1, 0); DFS2(1, 0, 0, 0);
      Build0(1, 1, n); Build1(1, 1, n);
      for(R int i = 1; i <= n; i++) last[i] = i;
      for(R int i = 1; i <= m; i++)
      {
          R int X = Find(p[i]->u), Y = Find(p[i]->v);
          if(X != Y) last[X] = Y;
          else Work(p[i]);
      }
      for(R int i = 1; i <= n; i++) e[Who[i]].Ans = Query0(1, 1, n, dfn[i], dfn[i]);
      for(R Edge *i = e + 1; i <= e + m; i++)
          if(i->Ans == Inf) printf("-1 ");
          else printf("%d ", i->Ans - 1);
      return 0;
  }