路径

【题目描述】

给定一个n个点每个点度数不超过2的无向图，支持两种操作

1.加入一条边[l,r],保证加入后图依然满足每个点度不超过2

2.求长度在[l,r]之间的不经过重复点的路径有多少条

    注意:这里的路径长度定义为经过的点数而不是边数

【输入】

第一行三个正整数n,m,q表示点数,初始边数和操作数

接下来m行每行两个整数u,v表示u到v有一条边

接下来q行，每行三个整数op l r

【输出】

对于每个op=2输出答案

【样例】

path1.in	path1.out
8 5 8 1 2 2 3 4 5 5 6 7 8 2 2 3 1 4 6 2 3 3 2 1 2 1 1 7 2 3 5 1 3 8 2 1 8	7 4 14 9 34
path2.in	path2.out
4 0 5 1 1 2 1 2 3 1 3 4 1 4 1 2 1 4	16

大样例见下发文件path3.in/out,path4.in/out

【数据范围及约定】

对于100%的数据 1≤n,m,q≤500000 1≤l≤r≤n

性质1:没有修改操作

性质2:任意时刻一个联通块内任意两点之间路径唯一

性质3:任意时刻一个联通块内的点编号连续

下表给出了各测试点的数据规模和约定

编号	n,m	q	性质1	性质2	性质3
1	300	300	有	无	无
2			无	有
3				无
4	5000	2000
5
6		5000	有
7			无	有
8				无
9	100000	100000	有		有
10			无	有
11				无
12					无
13	200000		有
14			无		有
15		200000	有		无
16			无	有	有
17				无
18
19					无
20	500000	500000

意思就是说只有简单环和链。

两条链合并，就是加两个等差数列和区间加法。

合并成环，就是加一个等差数列。

#include <bits/stdc++.h>
using namespace std;
#define M 500010
#define LL long long
inline int read() {
    char ch = getchar(); int x = 0, f = 1;
    while(ch < '0' || ch > '9') {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}
int fa[M], sz[M];
bool vis[M];
LL q[M * 4], A1[4 * M], D[4 * M];
inline int Find(int x) {
    return fa[x] == x ? x : fa[x] = Find(fa[x]);
}
inline void update(int l, int r, int o, LL a1, LL d) {
    int len = r - l + 1;
    q[o] += (1ll * (a1 + a1 + 1ll * (len - 1) * d) * len / 2ll);
    A1[o] += a1; D[o] += d;
}
inline void pushdown(int l, int mid, int r, int o) {
    LL a1 = A1[o], d = D[o];
    if(a1 != 0 || d != 0) {
        update(l, mid, 2 * o, a1, d);
        update(mid + 1, r, 2 * o + 1, a1 + 1ll * (mid - l + 1) * d, d);
        A1[o] = D[o] = 0;
    }
}
inline void Add(int l, int r, int o, int x, int y, LL a1, LL d) {
    if(x <= l && r <= y) {
        update(l, r, o, a1, d);
        return;
    }
    int mid = (l + r) / 2;
    pushdown(l, mid, r, o);
    int Lnum = 0;
    if(x <= mid) Lnum = min(mid, y) - x + 1;
    if(x <= mid) Add(l, mid, 2 * o, x, min(mid, y), a1, d);
    if(y > mid) Add(mid + 1, r, 2 * o + 1, max(mid + 1, x), y, a1 + d * Lnum, d);
    q[o] = q[2 * o] + q[2 * o + 1];
}
inline LL query(int l, int r, int o, int x, int y) {
    if(x <= l && r <= y) {
        return q[o];
    }
    int mid = (l + r) / 2;
    LL ret = 0;
    pushdown(l, mid, r, o);
    if(x <= mid) ret += query(l, mid, 2 * o, x, y);
    if(y > mid) ret += query(mid + 1, r, 2 * o + 1, x, y);
    return ret;
}
int main() {
    int n = read(), m = read(), q = read();
    for(int i = 1; i <= n; ++ i) {
        fa[i] = i; sz[i] = 1;
    }
    Add(1, n, 1, 1, 1, n, 0);
    for(int tt = 1; tt <= m + q; ++ tt) {
        int op = 1, l, r;
        if(tt > m) op = read();
        l = read(), r = read();
        if(op == 1) {
            if(l == r) continue;
            if(Find(l) != Find(r)) {
                int p = Find(l), q = Find(r);
                int x = sz[p], y = sz[q];
                if(sz[p] > sz[q]) swap(p, q);
                fa[p] = q; sz[q] += sz[p];
                if(2 <= min(x, y) + 1) {
                    Add(1, n, 1, 2, min(x, y) + 1, 1, 1);
                }
                if(min(x, y) + 2 <= max(x, y) + 1) {
                    Add(1, n, 1, min(x, y) + 2, max(x, y) + 1, min(x, y), 0);
                }
                if(max(x, y) + 2 <= x + y) {
                    Add(1, n, 1, max(x, y) + 2, x + y, min(x, y) - 1, -1);
                }
            }
            else {
                int x = sz[Find(l)];
                vis[Find(l)] = 1;
                if(2 <= x) {
                    Add(1, n, 1, 2, x, 1, 1);
                }
            }
        }
        else {
            LL res = query(1, n, 1, l, r);
            printf("%lld
", res);
        }
    }
}