20200803 专题：LCT

最新推荐文章于 2023-06-24 00:46:52 发布
最新推荐文章于 2023-06-24 00:46:52 发布
阅读量123 收藏
点赞数
分类专栏： 专题 # 动态树（LCT）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongkongreporter/article/details/107766731
版权

总览：

用 splay 动态维护树的信息
支持加边断边，换根等操作
可以维护连通性

板子：

struct LCT {
  int ch[2], f;
  int rev;
} tr[A];

#define ls(x) tr[x].ch[0]
#define rs(x) tr[x].ch[1]
inline int isroot(int x) { return ls(tr[x].f) != x && rs(tr[x].f) != x; }
inline void pushup(int x) {
  //
  return;
}
inline void reverse(int x) {
  if (x) swap(ls(x), rs(x)), tr[x].rev ^= 1;
}
inline void pushdown(int x) {
  if (tr[x].rev) reverse(ls(x)), reverse(rs(x))，tr[x].rev ^= 1;
}
inline void rotate(int x) {
  int y = tr[x].f, z = tr[y].f;
  int k = (rs(y) == x);
  if (z && !isroot(y)) tr[z].ch[rs(z) == y] = x;
  tr[x].f = z, tr[y].ch[k] = tr[x].ch[k ^ 1];
  tr[tr[x].ch[k ^ 1]].f = y;
  tr[x].ch[k ^ 1] = y, tr[y].f = x;
  pushup(y);
  return;
}
int st[A], top;
inline void pushpath(int x) {
  top = 0;
  st[++top] = x;
  for (int i = x; !isroot(i); i = tr[i].f) st[++top] = tr[i].f;
  for (int i = top; i; i--) pushdown(st[i]);
  return;
}
inline void splay(int x) {
  pushpath(x);
  while (!isroot(x)) {
    int y = tr[x].f, z = tr[y].f;
    if (!isroot(y)) {
      if ((rs(y) == x) == (rs(z) == y))
        rotate(y);
      else
        rotate(x);
    }
    rotate(x);
  }
  pushup(x);
  return;
}
inline void access(int x) {
  for (int y = 0; x; y = x, x = tr[x].f) splay(x), rs(x) = y, pushup(x);
}
inline int findroot(int x) {
  access(x), splay(x);
  while (ls(x)) pushdown(x), x = ls(x);
  return x;
}
inline void makeroot(int x) { access(x), splay(x), reverse(x); }
inline void split(int x, int y) { makeroot(x), access(y), splay(y); }
inline void link(int x, int y) {
  makeroot(x);
  if (findroot(y) != x) tr[x].f = y;
}
inline void cut(int x, int y) {
  makeroot(x);
  if (findroot(y) == x && tr[x].f == y && ls(y) == x) tr[x].f = 0, ls(y) = 0;
  pushup(y);
}
#undef ls
#undef rs

splay 后 pushdown，改变儿子后 pushup

T1 P2147 [SDOI2008]洞穴勘测

思路：
LCT 维护连通性板子

代码：

#include <bits/stdc++.h>
using namespace std;
#define re register
namespace IO {
inline char ch() {
  static char buf[1 << 21], *p1 = buf, *p2 = buf;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
inline int in() {
  int s = 0, f = 1;
  char x;
  for (x = getchar(); x < '0' || x > '9'; x = getchar())
    if (x == '-') f = -1;
  for (; x >= '0' && x <= '9'; x = getchar()) s = (s * 10) + (x & 15);
  return f == 1 ? s : -s;
}
}  // namespace IO
using namespace IO;

const int A = 4e5 + 5;
int n, m;
struct LCT {
  int ch[2], f, rev;
  LCT() { ch[0] = ch[1] = f = rev = 0; }
} tr[A];

#define ls(x) tr[x].ch[0]
#define rs(x) tr[x].ch[1]
inline int isroot(int x) {
  return !(tr[x].f && (ls(tr[x].f) == x || rs(tr[x].f) == x));
}
inline void reverse(int x) {
  if (x) {
    swap(ls(x), rs(x));
    tr[x].rev ^= 1;
  }
  return;
}
inline void pushdown(int x) {
  if (tr[x].rev) {
    reverse(ls(x));
    reverse(rs(x));
    tr[x].rev ^= 1;
  }
  return;
}
inline void rotate(int x) {
  int y = tr[x].f, z = tr[y].f;
  int k = (rs(y) == x);
  if (!isroot(y)) tr[z].ch[rs(z) == y] = x;
  tr[x].f = z;
  tr[y].ch[k] = tr[x].ch[k ^ 1];
  if (tr[x].ch[k ^ 1]) tr[tr[x].ch[k ^ 1]].f = y;
  tr[x].ch[k ^ 1] = y, tr[y].f = x;
  return;
}
int st[A], top;
inline void pushpath(int x) {
  top = 0;
  st[++top] = x;
  for (int i = x; !isroot(i); i = tr[i].f) st[++top] = tr[i].f;
  for (int i = top; i; i--) pushdown(st[i]);
  return;
}
inline void splay(int x) {
  pushpath(x);
  while (!isroot(x)) {
    int y = tr[x].f, z = tr[y].f;
    if (!isroot(y)) {
      if ((rs(y) == x) == (rs(z) == y))
        rotate(y);
      else
        rotate(x);
    }
    rotate(x);
  }
  return;
}
inline void access(int x) {
  for (int y = 0; x; y = x, x = tr[x].f) splay(x), rs(x) = y;
  return;
}
inline int findroot(int x) {
  access(x), splay(x), pushdown(x);
  while (ls(x)) x = ls(x), pushdown(x);
  return x;
}
inline void makeroot(int x) {
  access(x), splay(x), reverse(x);
  return;
}
inline void split(int x, int y) {
  makeroot(x), access(y), splay(y);
  return;
}
inline void link(int x, int y) {
  makeroot(x);
  if (findroot(y) != x) tr[x].f = y;
  return;
}
inline void cut(int x, int y) {
  makeroot(x);
  if (findroot(y) == x && tr[x].f == y && ls(y) == x) tr[x].f = 0, ls(y) = 0;
  return;
}
#undef ls
#undef rs

signed main() {
  n = in(), m = in();
  while (m--) {
    char x = getchar();
    while (x != 'Q' && x != 'C' && x != 'D') x = getchar();
    if (x == 'Q') {
      int u = in(), v = in();
      makeroot(u);
      puts(findroot(v) == u ? "Yes" : "No");
    } else if (x == 'C') {
      int u = in(), v = in();
      link(u, v);
    } else {
      int u = in(), v = in();
      cut(u, v);
    }
  }
  return 0;
}

T2 P3690 【模板】Link Cut Tree （动态树）

思路：板子

代码：

#include <bits/stdc++.h>
using namespace std;
#define re register
namespace IO {
inline char ch() {
  static char buf[1 << 21], *p1 = buf, *p2 = buf;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
inline int in() {
  int s = 0, f = 1;
  char x;
  for (x = ch(); x < '0' || x > '9'; x = ch())
    if (x == '-') f = -1;
  for (; x >= '0' && x <= '9'; x = ch()) s = (s * 10) + (x & 15);
  return f == 1 ? s : -s;
}
}  // namespace IO
using namespace IO;

const int A = 3e5 + 5;
int n, m;
struct LCT {
  int ch[2], f, rev;
  int val, sum;
} tr[A];

#define ls(x) tr[x].ch[0]
#define rs(x) tr[x].ch[1]
inline int isroot(int x) { return !(ls(tr[x].f) == x || rs(tr[x].f) == x); }

inline void pushup(int x) {
  tr[x].sum = tr[ls(x)].sum ^ tr[rs(x)].sum ^ tr[x].val;
  return;
}

inline void reverse(int x) {
  if (x) {
    swap(ls(x), rs(x));
    tr[x].rev ^= 1;
  }
  return;
}

inline void pushdown(int x) {
  if (tr[x].rev) {
    reverse(ls(x)), reverse(rs(x));
    tr[x].rev ^= 1;
  }
  return;
}

inline void rotate(int x) {
  int y = tr[x].f, z = tr[y].f;
  int k = (rs(y) == x);
  if (!isroot(y)) tr[z].ch[rs(z) == y] = x;
  tr[x].f = z, tr[y].ch[k] = tr[x].ch[k ^ 1];
  tr[tr[x].ch[k ^ 1]].f = y;
  tr[x].ch[k ^ 1] = y, tr[y].f = x;
  pushup(y), pushup(x);
  return;
}

int st[A], top;
inline void pushpath(int x) {
  top = 0;
  st[++top] = x;
  for (int i = x; !isroot(i); i = tr[i].f) st[++top] = tr[i].f;
  for (int i = top; i; i--) pushdown(st[i]);
  return;
}

inline void splay(int x) {
  pushpath(x);
  while (!isroot(x)) {
    int y = tr[x].f, z = tr[y].f;
    if (!isroot(y)) {
      if ((rs(y) == x) == (rs(z) == y))
        rotate(y);
      else
        rotate(x);
    }
    rotate(x);
  }
  pushup(x);
  return;
}

inline void access(int x) {
  for (int y = 0; x; y = x, x = tr[x].f) splay(x), rs(x) = y, pushup(x);
  return;
}

inline int findroot(int x) {
  access(x), splay(x);
  while (ls(x)) pushdown(x), x = ls(x);
  return x;
}

inline void makeroot(int x) {
  access(x), splay(x), reverse(x);
  return;
}

inline void split(int x, int y) {
  makeroot(x), access(y), splay(y);
  return;
}

inline void link(int x, int y) {
  makeroot(x);
  if (findroot(y) != x) tr[x].f = y;
  return;
}

inline void cut(int x, int y) {
  makeroot(x);
  if (findroot(y) == x && tr[x].f == y && ls(y) == x) tr[x].f = 0, ls(y) = 0;
  pushup(y);
  return;
}
#undef ls
#undef rs

signed main() {
  n = in(), m = in();
  for (int i = 1; i <= n; i++) tr[i].val = in();
  while (m--) {
    int opt = in();
    if (opt == 0) {
      int u = in(), v = in();
      split(u, v);
      printf("%d\n", tr[v].sum);
    } else if (opt == 1) {
      int u = in(), v = in();
      link(u, v);
    } else if (opt == 2) {
      int u = in(), v = in();
      cut(u, v);
    } else {
      int u = in(), v = in();
      splay(u);
      tr[u].val = v;
    }
  }
  return 0;
}

T3 P2387 [NOI2014]魔法森林

思路：
考虑类似最小生成树的做法，加边动态维护
先将边按一种边权排序
依次加边维护另一种边权的最小生成树
每次更新答案
可以用 LCT 维护最小生成树
如果成环就找到环上边权最大的边比较大小
需要将边化作点，如果加入边，就将这个点和两端点相连

代码：

#include <bits/stdc++.h>
using namespace std;
namespace IO {
char _buf[1 << 21], *_p1 = _buf, *_p2 = _buf;
#define ch()                                                               \
  (_p1 == _p2 &&                                                           \
           (_p2 = (_p1 = buf) + fread(buf, 1, 1 << 21, stdin), _p1 == _p2) \
       ? EOF                                                               \
       : *_p1++)
inline int in() {
  int s = 0, f = 1;
  char x = getchar();
  while (x < '0' || x > '9') {
    x = getchar();
    if (x == '-') f = -1;
  }
  while (x >= '0' && x <= '9') {
    s = (s * 10) + (x & 15);
    x = getchar();
  }
  return f == 1 ? s : -s;
}
char _buf_[1 << 21];
int _p1_ = -1;
inline void flush() {
  fwrite(_buf_, 1, _p1_ + 1, stdout);
  _p1_ = -1;
}
inline void pc(char x) {
  if (_p1_ == (1 << 21) - 1) flush();
  _buf_[++_p1_] = x;
}
inline void out(int x) {
  if (!x) {
    pc('0');
    return;
  }
  if (x < 0) {
    pc('-');
    x = -x;
  }
  char k[20];
  int tot = 0;
  while (x) {
    k[++tot] = (x % 10) | 48;
    x /= 10;
  }
  for (int i = tot; i; i--) pc(k[i]);
  return;
}
inline void out(string x) {
  int len = x.size();
  for (int i = 0; i < len; i++) pc(x[i]);
}
}  // namespace IO
using namespace IO;

const int A = 2e5 + 5;
const int INF = 1e9;
int n, m;
struct Road {
  int x, y, a, b;
} p[A];
inline bool cmp(Road u, Road v) { return u.b < v.b; }
inline int d(int x) { return x + n; }

int f[A];
inline int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
inline void merge(int x, int y) {
  int xx = find(x), yy = find(y);
  if (xx != yy) f[xx] = yy;
  return;
}

struct LCT {
  int ch[2], f;
  int rev, val, pos;
} tr[A];

#define ls(x) tr[x].ch[0]
#define rs(x) tr[x].ch[1]
#define max(x) tr[tr[x].pos].val
inline int isroot(int x) { return ls(tr[x].f) != x && rs(tr[x].f) != x; }
inline void pushup(int x) {
  tr[x].pos = x;
  if (ls(x) && max(ls(x)) > max(x))
    tr[x].pos = tr[ls(x)].pos;
  if (rs(x) && max(rs(x)) > max(x))
    tr[x].pos = tr[rs(x)].pos;
  return;
}
inline void reverse(int x) {
  if (x) {
    swap(ls(x), rs(x));
    tr[x].rev ^= 1;
  }
}
inline void pushdown(int x) {
  if (tr[x].rev) {
    reverse(ls(x)), reverse(rs(x));
    tr[x].rev ^= 1;
  }
  return;
}
inline void rotate(int x) {
  int y = tr[x].f, z = tr[y].f;
  int k = (rs(y) == x);
  if (!isroot(y)) tr[z].ch[rs(z) == y] = x;
  tr[x].f = z, tr[y].ch[k] = tr[x].ch[k ^ 1];
  tr[tr[x].ch[k ^ 1]].f = y;
  tr[x].ch[k ^ 1] = y, tr[y].f = x;
  pushup(y), pushup(x);
  return;
}
int st[A], top;
inline void pushpath(int x) {
  top = 0;
  st[++top] = x;
  for (int i = x; !isroot(i); i = tr[i].f) st[++top] = tr[i].f;
  for (int i = top; i; i--) pushdown(st[i]);
  return;
}
inline void splay(int x) {
  pushpath(x);
  while (!isroot(x)) {
    int y = tr[x].f, z = tr[y].f;
    if (!isroot(y)) {
      if ((rs(y) == x) == (rs(z) == y))
        rotate(y);
      else
        rotate(x);
    }
    rotate(x);
  }
  pushup(x);
  return;
}
inline void access(int x) {
  for (int y = 0; x; y = x, x = tr[x].f) splay(x), rs(x) = y, pushup(x);
}
inline int findroot(int x) {
  access(x), splay(x);
  while (ls(x)) pushdown(x), x = ls(x);
  pushdown(x);
  return x;
}
inline void makeroot(int x) { access(x), splay(x), reverse(x); }
inline void split(int x, int y) { makeroot(x), access(y), splay(y); }
inline void link(int x, int y) {
  makeroot(x);
  if (findroot(y) != x) tr[x].f = y;
  return;
}
inline void cut(int x, int y) {
  makeroot(x);
  if (findroot(y) == x && tr[x].f == y && ls(y) == x) tr[x].f = 0, ls(y) = 0;
  pushup(y);
  return;
}
inline int qurey(int x, int y) {
  split(x, y);
  return tr[y].pos;
}
#undef ls
#undef rs
#define max

int ans = INF;

signed main() {
  n = in(), m = in();
  for (int i = 1; i <= m; i++)
    p[i].x = in(), p[i].y = in(), p[i].a = in(), p[i].b = in();
  sort(p + 1, p + 1 + m, cmp);
  for (int i = 1; i <= n + m; i++) f[i] = i, tr[i].pos = i;
  for (int i = 1; i <= m; i++) tr[d(i)].val = p[i].a;
  for (int i = 1; i <= m; i++) {
    int x = p[i].x, y = p[i].y, pos = 0;
    if (find(x) == find(y)) {
      int w = qurey(x, y);
      if (tr[w].val > p[i].a)
        cut(p[w - n].x, w), cut(w, p[w - n].y);
      else
        pos = 1;
    } else {
      merge(x, y);
    }
    if (!pos) link(x, d(i)), link(d(i), y);
    if (find(1) == find(n)) ans = min(ans, p[i].b + tr[qurey(1, n)].val);
  }
  if (ans == INF)
    out(-1);
  else
    out(ans);
  pc('\n');
  flush();
  return 0;
}
ハルカナソラヘ
关注
专栏目录
专题总结:LCT
Deep_Kevin的娱乐空间
09-02 168
正题 这几天做了十几道LCT的题,板子打了二十几遍,快要吐了. 呕心沥血总结出了大概几种套路的方法: 简单的路径修改,询问 这种只要记好tag,每次splay记得下放就好了 复杂的单点修改,路径,子树询问 就类似[SHOI2014]三叉神经树,shi.这两道题,就是要你维护子树上的信息,这时候要注意在acs的时候考虑变化右儿子的影响,如果有取出一条链这种操作,或者换根,并且信息是沿着深度传递的,也就是说在splay里面是有左...
专题学习——LCT
romiqi
10-07 216
等下发树剖的学习笔记 LCT（link—cut—tree） 是解决一类动态树问题的数据结构 主要是给一个有根树的森林，然后有动态插入边，删除边，询问等操作 保证时刻是一个森林 LCT维护子树信息比较麻烦，这里暂时不提 一、实边和虚边： LCT 会将儿子划分为虚、实两种儿子， 相应的边称为虚边或实边，且任意时刻一个节点最多只会有一个实儿子（可能没有）。由于树的形态会改变，因此 LCT 不是严格的划分...
专题总结：动态树 LCT（Link cut tree）
NOI2015的专栏
02-01 1106
HUST开的一套动态树专题，全是经典题：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=25242#overview 先说一下什么是动态树。动态树可以维护一个动态的森林，支持树的合并（两棵合并成一棵），分离（把某个点和它父亲点分开），动态LCA，树上的点权和边权维护、查询（单点或者树上的一条路径），换根。 这里首先
计算物理专题：薛定谔方程的有限元解法
最新发布
Chandler_river的博客
06-24 615
计算物理专题：薛定谔方程的有限元解法
数据结构专题——动态树
m0_52766855的博客
06-09 1664
顾名思义，动态树是动态的，动态树维护了若干无序的有根树（实际上是无根的，操作过程中拓扑序不变）组成的森林.动态树，支持树上的节点到根节点的操作（树链剖分能够维护的信息），同时动态树能够高效的实现换根、加减边、森林中树的合并分裂（这是树剖无法高效实现的），这里介绍的均为 LCT(Link−Cut Trees)LCT(Link-Cut\ Trees)LCT(Link−Cut Trees).树链剖分一般指轻重链剖分，通过把树划分不同的链，然后在线段树上维护树上的信息；这里的 LCTLCTLCT 是虚实链剖分，每个
专题总结：数据结构
Deep_Kevin的娱乐空间
08-04 324
正题 今天讲的是数据结构 树状数组 树状数组在竞赛中是一种主要用来实现以下操作的数据结构。 维护一个长度为 n 的数组，要求支持 2 种操作。 1. 更改一个位置的权值 2. 询问前缀和 两种操作的时间复杂度均为 O(log n) 原理就不多说了 树状数组支持的操作确实被线段树完全包...
SPLAY，LCT学习笔记（四）
lleozhang的博客
09-18 360
前三篇好像变成了SPLAY专题... 这一篇正式开始LCT！ 其实LCT就是基于SPLAY的伸展操作维护树（森林）连通性的一个数据结构 核心操作有很多，我们以一道题为例： 例：bzoj 2049 洞穴勘测 要求：加边和删边，询问连通性 其实如果没有删边，裸跑并查集似乎就可以搞定 但由于存在删边，并查集思想受阻，我们要考虑更高级的数据结构 于是LCT横空出世！ LCT的核心思想：多...
SPLAY，LCT学习笔记（一）
lleozhang的博客
09-15 404
写了两周数据结构，感觉要死掉了，赶紧总结一下，要不都没学明白。 SPLAY专题： 例：NOI2005 维修数列 典型的SPLAY问题，而且综合了SPLAY常见的所有操作，特别适合新手入门学习（比如我这种蒟蒻） 题目要求很多，我们一步一步来分析 首先，区间翻转是SPLAY一个很基础的操作，我们以他为基础分析这个SPLAY 例：luogu文艺平衡树 题目：读入一个序列，进行多次区间翻转操...
回溯法专题
远行的博客
04-12 114
枚举，排列，组合问题都可以用回溯法来求解，它也是一个通用的求解问题的算法 比如给你数组1，2，3，输出该数组所有可能的全排列
北京市北京大学附属中学2014届高三物理一轮复习专题训练电磁波
08-05
7. **电压与电流图像**：第11题描述了电路中电压随时间的变化，t=0时刻断开开关，电容器开始放电，电容器电压下降，电流增大，直到t=LCT/2时电流最大；t=LCT时，电容器电压降为零，电流方向反转。 8. **麦克斯韦...
ArcGIS api for JavaScript 制作统计专题图
qq_32368213的博客
03-16 9898
声明：本方法并不是本人原创，原创应该为《Web GIS从基础到开发实践（基于ArcGIS API for JavaScript）》一书的作者刘光，曾敬文，曾庆丰三位老师。本人只是在学习过程中根据自己的需求，对三位老师的程序进行了修改，记录了自己在学习的过程以及收获。在此特别感谢三位老师的启发。
【专题小结】数据结构
Conan_c
02-26 1850
动态树小结
分块算法总结&专题训练
Plozia 的小窝
12-12 442
1.概述 分块，被称为优雅的暴力，实质上分块就是一种暴力算法。但是分块因其优美性与可扩展性，使得很多题目往往用分块做更简洁。而分块的最重要的一句话就是：大块维护，小块朴素。 分块被称为暴力是因为其时间复杂度是 O(nn)O(n\sqrt n)O(nn​) ，如果卡常不当就可能会被卡掉，或者直接卡成 O(n2)O(n^2)O(n2)。 莫队算法也是基于分块的（有兴趣了解莫队的可以看一看我的 这篇博文），并且很多用线段树、树套树等算法做的题目往往用分块可以吊打 std。因此，分块还是很重要的一种算法。 接下来通
BZOJ3153 Sone1 （Toptree）
BIT_shenyunhan的博客
03-07 3141
上周看Lytning（鄙校一队某大佬）开了一个LCT的专题，里面有这个题，正好我也没怎么写过LCT维护子树的题，就决定拿这个题开刀。先来说说LCT维护子树的大致思路，LCT里的轻边在Splay里都是只有儿子指向父亲但是父亲不指向儿子的虚边，如果维护的是树链，只用维护Splay里的实边，但是维护子树的话只要把每个节点的虚边也维护一下就行了。我之前只写过不带修改的子树维护，不带修改只要把虚子树信息向上...
20200903 专题：值域分块
hongkongreporter
09-03 1089
总览： 做了一道毒瘤题 带插区间k小 并且树套树常数过大，过不去 （毒瘤出题人毒瘤卡常） 于是就学习了新科技：值域分块 实质是分块套分块，先给序列分块，再在每个块中给值域分块 （分块用链表实现好方便 具体题目具体分析 T1 P4278 带插入区间K小值 思路： bzoj一个点平均15s，luogu一个点1s…… 先对序列分块，方便取出 [l,r][l,r][l,r] 再对值域分块，方便查询 kkk 小 要 O(1)O(1)O(1) 查询 [l,r][l,r][l,r] 中值在 [vall,valr][val
20200212 专题：后缀自动机（SAM）
hongkongreporter
02-12 404
总览： OI WiKi（详细介绍） 后缀自动机可视化 概述： 能解决的问题： 检查字符串是否出现 不同子串个数 所有不同子串的总长度 字典序第 kk 大子串 最小循环移位 出现次数 第一次出现的位置 所有出现的位置 最短的没有出现的字符串 两个字符串的最长公共子串 多个字符串间的最长公共子串 时间和空间复杂度都是线性的！ 对于长度为nnn的字符串，最多2n−12n-12n−1个节点和3n−43n...
生成函数学习笔记
hongkongreporter
01-04 396
文章目录生成函数学习笔记前置知识导数理解简单函数复杂函数四则运算复合函数反函数积分泰勒展开常用函数的泰勒展开式莱布尼茨公式广义二项式定理普通生成函数（ogf）数列 转 ogf形式幂级数常见ogf指数生成函数（egf）题目[BZOJ3028 食物](https://darkbzoj.tk/problem/3028)DescriptionSolutionCode 生成函数学习笔记 前置知识 导数 理解 对函数进行拟合 简单函数 f(x)f(x)f(x) f′(x)f'(x)f′(x) ccc 0
20200804 专题：仙人掌（圆方树）
hongkongreporter
08-04 396
总览： 无向仙人掌图的定义： 任意一条边至多只出现在一条简单回路的无向连通图称为仙人掌。 处理方法： 建立圆方树 圆方树的建点： 原图中的点都是圆点 对于每个点双连通分量，新建一个方点，这个方点和环上其它圆点连成菊花图 对于不在环上的两个圆点，保留原图中的边 根据仙人掌的性质，易证不存在相邻的两个方点 边 (u,v)(u,v)(u,v) 权值的确定： 若 u,vu,vu,v 都是圆点，则权值为原图中边权 若 uuu 为方点，则权值为 vvv 到 uuu 父亲的最短路 感性理解： 对于图中每一个
20200912 专题：最小乘积生成树
hongkongreporter
09-13 325
总览： 给出一个 nnn 个点 mmm 条边的无向图，第 iii 条边有两个权值 ai,bia_i,b_iai​,bi​，求该图的一棵生成树 TTT ，使得 ∑ai×∑bi\sum a_i\times \sum b_i∑ai​×∑bi​ 最小 对于每一棵生成树，视作一个二维平面上的点，(∑ai,∑bi)(\sum a_i,\sum b_i)(∑ai​,∑bi​) 使得 ∑ai×∑bi\sum a_i\times \sum b_i∑ai​×∑bi​ 最小就是让点所在的反比例函数最靠近坐标轴 于是先求出与 xx
动态树问题：LCT与Splay应用
其中，Link-Cut-Tree (LCT) 是解决这类问题的关键技术，由传奇算法学家Tarjan提出，用于处理树的动态更新，而不同于一般的动态树概念。 LCT 建立在Splay树的基础上，但并非简单的套用Splay树的模板。Splay树本身是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值