Jzoj P4237 Melancholy___线段树+动态规划

题目大意：

$n$个点，每个点有二个关键字$(a_i,b_i)$。
$Q$个询问，每个询问给出一组$(L,R,K)$。
在所有满足$L\le a_i\le R$的点去掉$b_i$最小的一个点，有多个只去掉其中一个，然后任选$K$个，将对应$b_i$相乘，累加乘积，不同顺序为不同的选择方案，问所有方案数的对应乘积的和对$2^{3}2$取模以后的结果是多少，如果点数不足$K$个则回答$0$。

$1\le n,Q\le 10^5,1\le L\le R\le 10^9,1\le k\le 6,1\le a_i,b_i\le 10^9$

分析：

这题对$pascal$选手貌似很不友好，因为$pascal$没有$unsigned$ $int$，要用常数比较大的$int64$还要取模一下，所以貌似很容易$T$呢
这题要怎么做的，貌似有人直接对$k$下手，暴力手推容斥，还有人莫队水过
我打的是线段树的做法，
将$n$个点按$a_i$为第一关键字升序排列，设升序序列为$c_i$，对应$b_i$也要注意跟着换位置
对于一个询问限制$[L,R]$以及选择个数$K$，
我们求出最大的满足限制$[L,R]$的在$c$中的区间$[x,y]$，
这个可以用二分，$lower$$bound$，$upper$$bound$求出，
那么我们可以用线段树去$O(logn)$的求出区间的最小值$min$,以及对应位置$pos$
接着我们对线段树的每个节点都建一个$f_i$，表示在其所控制的区间中按顺序依次选了$i$个数的方案总数的对应乘积的和是多少。
然后假如左区间依次选了$j$个数的方案对应的乘积有
$a1,a2,...,a_{x-1},a_x$, $f_j={\sum }_{i=1}^x{a}_i$
右区间依次选了$k$个数的方案对应的乘积有
$b1,b2,...,b_{y-1},b_y$, $f_k={\sum }_{i=1}^y{b}_i$
这$2$个$f_{[]}$是在不同的节点中，即$lson$和$rson$中，
然后他们对$father$中的$f_{[]}$的贡献，
就是
$f_j+=f_j$，前者在$father$中，后者在$lson$中
$f_k+=f_k$，前者在$father$中，后者在$rson$中

$f_{k+j}+=(a1b1+a1b2+,...,+a1b_y)+$
$(a2b1+a2b2+,...,+a2b_y)+,...,+(a_{x}b1+a_{x}b2+,...,+a_x{b}_y)$
等价于
$f_{k+j}+=(a1+a2+,...,a_{x-1},a_x)\ast (b1+b2+,...,b_{y-1}+b_y)$
即
$f_{k+j}+=f_j\ast f_k$
那么一个区间内的$f_{[]}$就可以在$O(k^2)$的时间内得到，
建这颗线段树就是$O(k^{2}nlogn)$的
然后我们一开始是得到了最小值的位置$pos$
那么我们就可以$O(logn)$的知道$[x,pos-1]$和$[pos+1,y]$的$f_{[]}$情况，
然后将这两者结合一下，
得到的$f_K$就是区间$[x,y]$除去最小的$b_i$以后依次选$K$个数的方案对应的乘积的和。
然后因为题目中规定顺序不同为不同的方案数，
所以一个长度为$K$的方案可以通过不同的排列进而有$K!$种方案，
所以答案为$f_K\ast K!$

代码：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <queue>
#include <cstring>
#include <algorithm>

#define lson(x) x * 2
#define rson(x) x * 2 + 1

#define N 100005

using namespace std;

typedef unsigned int usg;

const usg inf = 0x3f3f3f3f;

struct Node { usg total[7], minnum, minpos; }C[N*5], Answer;
struct Oier { usg d, v; }a[N];
usg b[N], n, Q, minnumpos;

void read(usg &x)
{
    usg f = 1; x = 0; char s = getchar();
	while (s < '0' || s > '9')   { if (s == '-') f = - 1;  s = getchar(); }
	while (s >= '0' && s <= '9') { x = x * 10 + (s - '0'); s = getchar(); }	
    x = x * f;
} 

bool cmp(Oier aa, Oier bb) 
{ 
    return aa.d < bb.d;
}

Node Update(Node x, Node y)
{
	Node z;
    for (usg i = 1; i <= 6; i++) z.total[i] = x.total[i] + y.total[i];
    for (usg i = 1; i <= 6; i++)
        for (usg j = 1; j < i; j++)
            z.total[i] += x.total[j] * y.total[i - j];
    return z; 
}

void Build(usg x, usg l, usg r)
{
    for (usg i = 1; i <= 6; i++) C[x].total[i] = 0;
    if (l == r)
    {
        C[x].total[1] = a[l].v;
        C[x].minnum = a[l].v;
        C[x].minpos = l;
        return;
    }
    usg mid = (l + r) >> 1;
    Build(lson(x), l, mid); 
	Build(rson(x), mid + 1, r);
    C[x] = Update(C[lson(x)], C[rson(x)]);
	C[x].minnum = min(C[lson(x)].minnum, C[rson(x)].minnum);
	if (C[x].minnum == C[lson(x)].minnum) C[x].minpos = C[lson(x)].minpos; else C[x].minpos = C[rson(x)].minpos;
}


void Get_minpos(usg x, usg l, usg r, usg L, usg R)
{
    if (L > R) return;
    if (L <= l && r <= R)
    {
        if (a[minnumpos].v > C[x].minnum) minnumpos = C[x].minpos; 
        return;
    }
    int mid = (l + r) >> 1;
    if (L <= mid) Get_minpos(lson(x), l, mid, L, R);
    if (mid + 1 <= R) Get_minpos(rson(x), mid + 1, r, L, R);
}

void Query(usg x, usg l, usg r, usg L, usg R)
{
     if (L > R) return;
     if (L <= l && r <= R)
     {
         Answer = Update(Answer, C[x]); 
         return;
    }
    int mid = (l + r) >> 1;
    if (L <= mid) Query(lson(x), l, mid, L, R);
    if (mid + 1 <= R) Query(rson(x), mid + 1, r, L, R);
}

void Work(usg num1, usg num2, usg k)
{
    usg L = lower_bound(b, b + n + 1, num1) - b;
    usg R = upper_bound(b, b + n + 1, num2) - b - 1;
    if (L > R || R - L < k) { printf("0\n"); return; }
	minnumpos = 0;
    Get_minpos(1, 1, n, L, R);
    for (usg i = 1; i <= 6; i++) Answer.total[i] = 0; 
    Query(1, 1, n, L, minnumpos - 1);
    Query(1, 1, n, minnumpos + 1, R);
    for (usg i = 1; i <= k; i++) Answer.total[k] *= i;
	printf("%u\n", Answer.total[k]);
}

int main()
{
    read(n); read(Q);
    for (usg i = 1; i <= n; i++) read(a[i].d);
    for (usg i = 1; i <= n; i++) read(a[i].v);
    sort(a + 1, a + n + 1, cmp);
    for (usg i = 1; i <= n; i++) b[i] = a[i].d;
	a[0].v = inf;
	Build(1, 1, n);    
    while (Q--)
    {
        usg L, R, k; 
		read(L); read(R); read(k);
        Work(L, R, k);
    }
}