Jzoj P4237 Melancholy___线段树+动态规划

版权声明：欢迎借鉴，谢绝抄搬。 https://blog.csdn.net/Gx_Man_VIP/article/details/86682679

题目大意：

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

$1≤n,Q≤10^5,1≤L≤R≤10^9,1≤k≤6,1≤a_i,b_i≤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_xb1+a_xb2+,...,+a_xb_y)$
等价于
$f_{k+j}+=(a1+a2+,...,a_{x-1},a_x)*(b1+b2+,...,b_{y-1}+b_{y})$
即
$f_{k+j}+=f_{j}*f_{k}$
那么一个区间内的 $f_{[]}$就可以在 $O(k^2)$的时间内得到，
建这颗线段树就是 $O(k^2nlogn)$的
然后我们一开始是得到了最小值的位置 $pos$
那么我们就可以 $O(logn)$的知道 $[x,pos-1]$和 $[pos+1,y]$的 $f_{[]}$情况，
然后将这两者结合一下，
得到的 $f_{K}$就是区间 $[x,y]$除去最小的 $b_i$以后依次选 $K$个数的方案对应的乘积的和。
然后因为题目中规定顺序不同为不同的方案数，
所以一个长度为 $K$的方案可以通过不同的排列进而有 $K!$种方案，
所以答案为 $f_{K}*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);
    }
}