bzoj-2038 小Z的袜子 hose

题意：

给出一个长度为n的序列，每次询问一个区间[l,r]；

查询在这个区间中取出两个数恰好相等的概率；

每个数大小在[0,n]内，概率用既约分数表示；

题解：

考虑一个区间的答案，显然是合法方案数/取数的所有可能；

也就是 ∑C[同种数字个数][2]/C[r-l+1][2]；

但是这个东西对一次询问的处理复杂度是O(r-l+1)的；

那么考虑上莫队算法，处理这样的区间问题；

很容易发现每次修改边界可以做到O(1)完成；

void update(int x,int op)
{
    now-=C[s[a[x]]][2];
    s[a[x]]+=op;
    now+=C[s[a[x]]][2];
}

C[i][j]是组合数，s[x]是当前区间x的数量，now是当前答案；

然后将询问排序处理，第一关键字左端点所在块，第二关键字右端点；

当块的大小为√n时，可以证明复杂度不会超过O(n√n)；

然后每个区间转移到下一个区间就是有复杂度保证的暴力咯；

码量似乎不算太巨大，思想也比较简单，很神的暴力算法；

代码：

#include<math.h>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 51000
using namespace std;
struct query
{
    int pos,l,r,no;
}Q[N];
int a[N],s[N],ans_up[N],ans_do[N],C[N][3],now;
bool cmp(query a,query b)
{
    if(a.pos==b.pos)
    return a.r<b.r;
    return a.pos<b.pos;
}
int gcd(int a,int b)
{
    if(!a||!b)  return a?a:b;
    int t=a%b;
    while(t)
    {
        a=b,b=t;
        t=a%b;
    }
    return b;
}
void update(int x,int op)
{
    now-=C[s[a[x]]][2];
    s[a[x]]+=op;
    now+=C[s[a[x]]][2];
}
int main()
{
    int n,m,k,i,j,l,r;
    scanf("%d%d",&n,&m);
    int bk=sqrt(n);
    for(i=1;i<=n;i++)
        scanf("%d",a+i);
    for(i=0;i<=n;i++)
    {
        C[i][0]=1;
        for(j=1;j<=2;j++)
            C[i][j]=C[i-1][j]+C[i-1][j-1];
    }
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&Q[i].l,&Q[i].r);
        Q[i].no=i,Q[i].pos=Q[i].l/bk;
    }
    sort(Q+1,Q+m+1,cmp);
    l=0,r=0,now=0,s[50001]=1,a[0]=50001;
    for(i=1;i<=m;i++)
    {
        while(l<Q[i].l)  update(l++,-1);
        while(l>Q[i].l)  update(--l, 1);
        while(r<Q[i].r)  update(++r, 1);
        while(r>Q[i].r)  update(r--,-1);
        ans_up[Q[i].no]=now;
        ans_do[Q[i].no]=C[r-l+1][2];
    }
    for(i=1;i<=m;i++)
    {
        k=gcd(ans_up[i],ans_do[i]);
        printf("%d/%d\n",ans_up[i]/k,ans_do[i]/k);
    }
    return 0;
}