BZOJ 2038: [2009国家集训队]小Z的袜子【莫队算法裸题】

作为一个生活散漫的人，小Z每天早上都要耗费很久从一堆五颜六色的袜子中找出一双来穿。

终于有一天，小Z再也无法忍受这恼人的找袜子过程，于是他决定听天由命。

具体来说，小Z把这N只袜子从1到N编号，然后从编号L到R的袜子中随机选出两只来穿。

尽管小Z并不在意两只袜子是不是完整的一双，甚至不在意两只袜子是否一左一右，他却很在意袜子的颜色，毕竟穿两只不同色的袜子会很尴尬。

你的任务便是告诉小Z，他有多大的概率抽到两只颜色相同的袜子。

当然，小Z希望这个概率尽量高，所以他可能会询问多个(L,R)以方便自己选择。

输入格式

第一行包含两个正整数N和M，N为袜子的数量，M为小Z所提的询问的数量。

接下来一行包含N个正整数\(C_i\)，其中\(C_i\)表示第i只袜子的颜色，相同的颜色用相同的数字表示。

再接下来M行，每行两个正整数L，R表示一个询问。

输出格式

包含M行，对于每个询问在一行中输出分数A/B表示从该询问的区间[L,R]中随机抽出两只袜子颜色相同的概率。

若该概率为0则输出0/1，否则输出的A/B必须为最简分数。

输入样例：

6 4
1 2 3 3 3 2
2 6
1 3
3 5
1 6

输出样例：

2/5
0/1
1/1
4/15

第一次接触莫队算法

kuangbin大佬的分析：莫队算法可以解决一类不修改、离线查询问题。

写了个直接分段解决的办法。把1~n分成sqrt(n)段。unit = sqrt(n)m个查询先按照第几个块排序，再按照 R排序。然后直接求解。

学习笔记：

对于一个区间的概率，就是每种颜色选2个相同的方案数的和/总的选择方案数

化简之后，就是区间内 (每种颜色的数量^2的和-区间长度)/（区间长度*区间长度减1)

问题变为快速求一个区间内每种颜色数量的平方的和

线段树？可以每种颜色单独维护平方，但是会被卡

所以用到了莫队算法

使用范围：

可离线且在得到区间[l,r]的答案后，能在O(1)或O(log2n)得到区间[l,r+1]或[l−1,r]的答案

其实就是找一个数据结构支持插入、删除时维护当前答案。

这样的话，如果已知[l,r]的答案，要求[l’,r’]的答案，我们很容易通过|l – l’|+|r – r’|次转移内求得。

抽象成平面上的点，我们要按一定顺序计算每个值，那开销就为曼哈顿距离的和。曼哈顿距离最小生成树

这里通常用分块解决

n个数分块

按区间排序，以左端点所在块内为第一关键字，右端点为第二关键字，进行排序，

复杂度分析是这样的：

1、\(i\)与\(i+1\)在同一块内，r单调递增，所以r是O(n)的。由于有\(n^{0.5}\)块,所以这一部分时间复杂度是\(n^{1.5}\)。

2、i与i+1跨越一块，r最多变化n，由于有\(n^{0.5}\)块,所以这一部分时间复杂度是\(n^{1.5}\)。

3、i与i+1在同一块内时l变化不超过\(n^{0.5}\)，跨越一块也不会超过\(n^{0.5}\)，由于有m次询问（和n同级），所以时间复杂度是\(n^{1.5}\).

于是就是\(O(n^{1.5})\)了

AC代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 50050;
const int minn = 50050;
struct Query {
    int L, R, id;
}node[maxn];

ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }

struct Ans {
    ll a, b;
    //分数简化操作
    void reduce() {
        ll d = gcd(a, b);
        a /= d, b /= d;
    }
}ans[maxn];
int a[maxn], num[maxn], n, m, unit;

//把1~n分成sqrt(n)段,unit=sqrt(n)m个查询先按照第几个块排序,再按照R排序,分块处理
bool cmp(Query a, Query b) {
    if (a.L / unit != b.L / unit)
        return a.L / unit < b.L / unit;
    else return a.R < b.R;
}

void solve() {
    ll tmp = 0;
    memset(num, false, sizeof num);
    int L = 1, R = 0;
    //莫队算法核心部分
    for (int i = 0; i < m; ++i) {
        while (R < node[i].R) {
            R++;
            tmp -= (ll)num[a[R]] * num[a[R]];
            num[a[R]]++;
            tmp += (ll)num[a[R]] * num[a[R]];
        }
        while (R > node[i].R) {
            tmp -= (ll)num[a[R]] * num[a[R]];
            num[a[R]]--;
            tmp += (ll)num[a[R]] * num[a[R]];
            R--;
        }
        while (L < node[i].L)
        {
            tmp -= (ll)num[a[L]] * num[a[L]];
            num[a[L]]--;
            tmp += (ll)num[a[L]] * num[a[L]];
            L++;
        }
        while (L > node[i].L)
        {
            L--;
            tmp -= (ll)num[a[L]] * num[a[L]];
            num[a[L]]++;
            tmp += (ll)num[a[L]] * num[a[L]];
        }
        ans[node[i].id].a = tmp - (R - L + 1);
        ans[node[i].id].b = (ll)(R - L + 1) * (R - L);
        ans[node[i].id].reduce();
    }
}

int main() {
    //freopen("in.txt", "r", stdin);
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    while (cin >> n >> m) {
        for (int i = 1; i <= n; ++i)cin >> a[i];
        for (int i = 0; i < m; ++i) {
            node[i].id = i;
            cin >> node[i].L >> node[i].R;
        }
        unit = (int)sqrt(n);
        sort(node, node + m, cmp);
        solve();
        for (int i = 0; i < m; i++)
            printf("%lld/%lld\n", ans[i].a, ans[i].b);
    }
}