初识莫队——小Z的袜子

以前一直觉得莫队是多么高大上的一种算法，然而仔细看了下发现其实并不复杂，实质上就是技巧性的暴力美学。

在我看来莫队是一种分块排序后降低复杂度的算法，当答案可以通过左右端点一个一个移动维护出来的时候就可以使用莫队了。

比如给你4个区间

(1, 2)

(99, 100)

(3, 4)

(101, 102)

如果你是傻傻的按照给定的顺序去移动左右端点，那就是先计算出(1,2)区间的值，然后左端点先从1移动到99，右端点从2移动到100，计算完(99,100)区间内的值，又哼哧哼哧的左端点从99移回3，右端点从100移回4，计算完(3,4)后又移动到(101,102)，显然这样实在是太蠢了。

正常人都应该想到，那我把计算顺序改成(1,2)(3,4)(99,100)(101,102)不就行了，但是因为区间是二维的，简单的排序似乎是行不通的(通过lhs或者rhs来排序似乎都不太好)

莫队为我们提供了一个排序方法，假设有Q个询问，区间范围是1~N，那么可以对左端点分块，分成根号N块，这样就先把不同块的左端点排好序了，接下来同一块的询问根据右端点排序，这样就形成了一个（比较科学）的序列，可以使左右端点移动的距离变小，变相减小了复杂度。

实际上莫队就是一个科学的二维数组排序方法嘛

然后对于这道题因为是求概率，每次如果都维护一个分数很困难，所以选择每次维护分子和分母，这样这个概率公式就很好求了，分母只与区间长度有关，分子就是（每种袜子数目*（每种袜子数目-1））然后求和，化简后发现只要求（每种袜子数目）的平方的和就可以了，最后求一下gcd把分数表示成最简形式

#include <iostream>
#include <string.h>
#include <cstdio>
#include <vector>
#include <map>
#include <math.h>
#include <string>
#include <algorithm>
#include <time.h>

#define SIGMA_SIZE 26
#define lson rt<<1
#define rson rt<<1|1
#define lowbit(x) (x&-x)
#define goe(i, a, b) for(int i=a; i<=b; i++)
#define go(i, a, b) for(int i = a; i < b; i++);
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;
inline LL LMax(LL a,LL b)      { return a>b?a:b; }
inline LL LMin(LL a,LL b)      { return a>b?b:a; }
inline LL lgcd( LL a, LL b ) { return b==0?a:lgcd(b,a%b); }
inline LL llcm( LL a, LL b ) { return a/lgcd(a,b)*b; }  //a*b = gcd*lcm
inline int Max(int a,int b)    { return a>b?a:b; }
inline int Min(int a,int b)       { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const LL INF = 0x3f3f3f3f3f3f3f3f;
const LL mod  = 1000000007;
const double eps = 1e-8;
const int inf  = 0x3f3f3f3f;
const int maxk = 5e4+5;
const int maxn = 3e4+5;

int belong[maxk], wazi[maxk];
int N, M, unit;
LL ans, cnt[maxk], fina[maxk], finb[maxk];
struct query {
    int lhs, rhs, id;
    LL a, b;    //分子和分母
}q[maxk];

bool cmp(const query& a, const query& b)
{
    if (belong[a.lhs] == belong[b.lhs]) return a.rhs < b.rhs;
    return a.lhs < b.lhs;
}

void revise( int x, int d )
{    
    //ans先减去以前的贡献再加上现在的贡献
    ans -= cnt[wazi[x]]*cnt[wazi[x]];
    cnt[wazi[x]] += d;
    ans += cnt[wazi[x]]*cnt[wazi[x]];
}

void read()
{
    scanf("%d %d", &N, &M); unit = sqrt(N);

    
    goe(i, 1, N) { scanf("%d", &wazi[i]); belong[i] = i/unit+1; }
    goe(i, 1, M) { scanf("%d %d", &q[i].lhs, &q[i].rhs); q[i].id = i; }
    sort(q+1, q+1+M, cmp);
    
}


int main()
{
    read();

    int l = 1, r = 0;
    ans = 0;

    goe(i, 1, M)
    {
        //如果是减操作，则先要执行revise，
        //注意顺序
        while(l < q[i].lhs) { revise(l, -1); l++; }
        while(l > q[i].lhs) { l--; revise(l, 1); }
        while(r < q[i].rhs) { r++; revise(r, 1); }
        while(r > q[i].rhs) { revise(r, -1); r--; }

        if ( q[i].lhs == q[i].rhs ) { q[i].a = 0; q[i].b = 1; continue; }
        q[i].a = ans - (q[i].rhs - q[i].lhs + 1);
        q[i].b = (LL)1*(q[i].rhs - q[i].lhs)*(q[i].rhs - q[i].lhs + 1);

        LL Gcd = lgcd(q[i].a, q[i].b);
        q[i].a /= Gcd;
        q[i].b /= Gcd;
    }

    goe(i, 1, M)
    {
        fina[q[i].id] = q[i].a;
        finb[q[i].id] = q[i].b;
    }

    goe(i, 1, M)
        printf("%lld/%lld
", fina[i], finb[i]);

    return 0;
}

待修改的莫队，这就有点难受了，原先的二维区间变成了三维，加了一个时间维度(怎么感觉怪怪的)，大意就是原先每个结构体多存储一个了时间变量，修改操作也通过时间变量储存，并且通过change这一数据结构将一系列修改的数据存储下来(即能通过时间确定修改的值，就像能操纵时间，随时可以通过时间还原原来的序列或者变化成修改后的序列)，然后就是在原始莫队的基础上加上一个时间维度的移动，不得不说这个算法真是朴素而美妙...

HYSBZ 2120 数颜色---模板题

#include <iostream>
#include <string.h>
#include <cstdio>
#include <vector>
#include <map>
#include <math.h>
#include <string>
#include <algorithm>
#include <time.h>

#define SIGMA_SIZE 26
#define lson rt<<1
#define rson rt<<1|1
#define lowbit(x) (x&-x)
#define foe(i, a, b) for(int i=a; i<=b; i++)
#define fo(i, a, b) for(int i = a; i < b; i++);
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;
inline LL LMax(LL a,LL b)      { return a>b?a:b; }
inline LL LMin(LL a,LL b)      { return a>b?b:a; }
inline LL lgcd( LL a, LL b ) { return b==0?a:lgcd(b,a%b); }
inline LL llcm( LL a, LL b ) { return a/lgcd(a,b)*b; }  //a*b = gcd*lcm
inline int Max(int a,int b)    { return a>b?a:b; }
inline int Min(int a,int b)       { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const LL INF = 0x3f3f3f3f3f3f3f3f;
const LL mod  = 1000000007;
const double eps = 1e-8;
const int inf  = 0x3f3f3f3f;
const int maxk = 1e6+5;
const int maxn = 1e4+5;


int belong[maxn], num[maxn], now[maxn], fin[maxn];
int N, Q, unit, l, r;
int t, T, Time, ans;
int cnt[maxk];

struct query {
    int lhs, rhs, tim, id;
    query() {}
    query(int l, int r, int t, int i)
        : lhs(l), rhs(r), tim(t), id(i) {}

}q[maxn];

// pos表示修改的位置，new表示修改后的值，Old表示修改前的值
struct change {
    int pos, New, Old;
    change() {}
    change(int p, int n, int o)
        : pos(p), New(n), Old(o) {}
}c[maxn];

bool cmp(const query& a, const query& b)
{
    if (belong[a.lhs != b.lhs]) return a.lhs < b.lhs;
    if (belong[a.rhs != b.rhs]) return a.rhs < b.rhs;
    return a.tim < b.tim;
}

void read()
{
    //最优分块策略不再是根号
    scanf("%d %d", &N, &Q); unit = pow((double)N, (double)0.666666);
    foe(i, 1, N) { scanf("%d", &num[i]); now[i] = num[i]; belong[i] = i/unit+1; }

    char str[2];
    int x, y; t = T = 0;
    foe(i, 1, Q)
    {
        scanf("%s %d %d", str, &x, &y);
        if (str[0] == 'Q') q[++t] = query(x, y, T, t);
        if (str[0] == 'R') { c[++T] = change(x, y, now[x]); now[x] = y; }
    }
    sort(q+1, q+t+1, cmp);
}

void revise(int x, int d)
{
    cnt[x] += d;
    if (d > 0)
        ans += (cnt[x] == 1);        //只有从0加到1才会增加一种颜色数量
    if (d < 0)
        ans -= (cnt[x] == 0);
}

void reviseT(int x, int d)
{
    if ( x >= l && x <= r )
    {
        revise(d, 1);
        revise(num[x], -1);
    }
    num[x] = d;
}

int main()
{
    read();

    l = 1; r = 0; Time = 0;
    foe(i, 1, t)
    {
        //若修改时间小于tim，则要添加新的修改
        while(Time < q[i].tim) { Time++; reviseT(c[Time].pos, c[Time].New); }
        //若time大于tim，则还原老修改
        while(Time > q[i].tim) { reviseT(c[Time].pos, c[Time].Old); Time--; }

        while(l < q[i].lhs) { revise(num[l], -1); l++; }
        while(l > q[i].lhs) { l--; revise(num[l], 1); }
        while(r < q[i].rhs) { r++; revise(num[r], 1); }
        while(r > q[i].rhs) { revise(num[r], -1); r--; }

        fin[q[i].id] = ans;

    }

    foe(i, 1, t)
        printf("%d
", fin[i]);

    return 0;
}