[20151018]SCZ训练

最新推荐文章于 2024-02-22 16:41:34 发布

Sakagami_Tomoyo

最新推荐文章于 2024-02-22 16:41:34 发布

阅读量674

点赞数

分类专栏：线段树日常训练

本文链接：https://blog.csdn.net/hbhcy98/article/details/49254115

版权

日常训练同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

线段树

5 篇文章 0 订阅

订阅专栏

Sequence

【题目简述】
Fiugou 想要在一个长度为 $N$ 的序列 A 中找到不同位置的三个数,以这三个数为三边长来构成一个三角形。但是它希望在满足条件下,这三个数的位置尽量靠前。具体地,设这三个数的为 $A_{i},A_{j},A_{k}$ , Fiugou 希望 $k$ 尽量小;当 $k$ 相等时,满足 $j$ 尽量小;当 $k,j$ 均相等时,满足尽量小。
但是这个序列中的数可能会发生变化。所以 Fiugou 给出了 $M$ 个操作,形式如下:
1 x y:将 $A_{x}$ 改为 $y$
2:查询最优的合法解,从小到大给出这三个数(而不是位置)。
【输入格式】
第一行一个整数 $N$ ,代表序列的长度。
第二行有 $N$ 个整数,代表初始序列。
第三行一个整数 $M$ ,代表操作的个数。
接下来 $M$ 行操作,两种操作格式如上所述。
【输出格式】
共 $M$ 行,每行三个数,从小到大给出。如果不存在,输出-1 -1 -1。
【样例输入】
6
7 1 3 4 5 1
3
2
1 3 5
2
【样例输出】
3 5 7
4 5 7
【数据范围】
对于10%的数据, $N<=10, M<=5$
对于30%的数据, $N<=100, M<=25$
对于50%的数据, $N<=1000, M<=1000$
对于100%的数据, $N<=100000, M<=1000$
对于100%的数据, $0<=Ai<=10^9, 1<=x<=N, 0<=y<=10^9$

Solution :
注意到即使是 $Fibnacci$ 数列在50项之后也超出 $10^9$ 了，所以 $50^3$ 枚举一下

Code :

/*************************************************************************
    > File Name: sequence.cpp
    > Author: Archer
 ************************************************************************/

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;

const int N = 111111;
int n, seq[N], m;

typedef long long ll;
typedef pair<int, int> PII;
#define REP(i, l, r) for (int i = l; i <= r; i++)
#define MP make_pair

inline int read(){
    int x = 0, f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar(); }
    return x * f;
}
inline void setIO(){
    freopen("sequence.in", "r", stdin);
    freopen("sequence.out", "w", stdout);
}
inline bool check(int x, int y, int z){
    return (seq[x] + seq[y] > seq[z] && seq[y] + seq[z] > seq[x] && seq[x] + seq[z] > seq[y]);
}
inline void solve(){
    REP(i, 3, min(n, 50)) REP(j, 2, i-1) REP(k, 1, j-1)
        if (check(i, j, k)){
            int _ = min(min(seq[i], seq[j]), seq[k]), __ = max(max(seq[i], seq[j]), seq[k]);
            printf("%d %d %d\n", _, seq[i] + seq[j] + seq[k] - _ - __, __);
            return;
        }
    printf("-1 -1 -1\n");
}
int main(){
    setIO();

    n = read();
    REP(i, 1, n) seq[i] = read();
    m = read();
    while (m--){
        int op = read();
        if (op == 2) solve();
        else{
            int x = read(), y = read();
            seq[x] = y;
        }
    }

    return 0;
}

登山

【题目简述】
$恶梦是一个登山爱好者,今天他来到了黄山。$
$俗话说的好,不走回头路。所以在黄山,你只能往前走,或者往上走。并且很显然的是,当你走到山脊的时候,你不能够往上走,你只能往前走一步再往上走。$
$抽象一点而言就是,你可以把黄山视为一个 N * N 格点图,恶梦从(0,0)开始出发,要走到(N,N)。当他走到位置(x,y)的时候,它可以往(x + 1,y),或(x,y+1)走。并且当他走到(x,x)的时候,由于他已经处在了山脊上,所以他不能够往(x,x+1)方向上走。$
$当恶梦兴致勃勃准备开始爬山的时候,他的同伴告诉他,黄山由于年久失修,有一些位置出现了大坑,不能走。恶梦觉得更刺激了,但他想先知道他能有多少种方式走到黄山顶。$
$由于这个数字很大,所以你只需要将答案对 10^9 + 7 取模输出即可。$
【输入格式】
$第一行包括两个整数 N,C,分别表示你可以把黄山视作一个 N * N 的格点图,并且黄山上面有 C 个位置出现了大坑。$
$接下来的 C 行,每行包括两个整数 X,Y,表示 X,Y 这个位置不能走。保证 X>=Y,也就是说(X,Y)必然在山上。$
$保证这 C 个点互不相同。$
【输出格式】
$输出只有一个整数 Ans,表示恶梦爬上山顶的路径数对 10^9+7 取模的值。$
【数据范围】
对于 30%的数据, $保证 N<=5000$
对于另外 20%的数据, $保证 C=0$
对于另外 20%的数据, $保证 C=1$
对于 100%的数据,保证 $N<=100000,C<=1000$
$保证对于(0,0),(N,N)不存在障碍点。$

Solution :
C比较小，这启示我们从障碍点入手。事实上也是这样的。我们将所有的障碍点以及 $(N,N)$ 视为关键点，先将所有的关键点按x坐标从小到大排序，设 $F_{i}$ 表示我们从 $(0,0)$ 走到第i个关键点，除当前点以外不经过任何关键点的方案数。我们也要用补集的思想，也就是说先计算出会经过其他关键点的方案数，设 $G_{i}$ 为这个方案数。假设一条这样的路径为 $(P_{1},P_{2},...P_{j},P_{i})$ ，其中 $P_{j}$ 是我们经过的第一个关键点。我们枚举这个 $P_{j}$ ，那么 $G_{i} = \sum_{j=1}^{i-1}F_{j}*Ways_{P_{j}->P_{i}}$ ， $P_{j}必须能走到P_{i}$ 。最后 $F_{i}=Ways_{(0,0)->P_{i}}-G_{i}$

Code :

/*************************************************************************
    > File Name: walk.cpp
    > Author: Archer
 ************************************************************************/
#include <bits/stdc++.h>
#define fe first
#define se second
using namespace std;
typedef pair<int,int> P;
const int MAXM = 1005,MAXN = 200015,Mo = int(1e9) + 7;
P Block[MAXM];
int Fc[MAXN],Rv[MAXN],F[MAXN],N,C;

int Quick(int a,int b){
    if (!b) return 1;
    int mid = Quick(a,b >> 1);
    if (b & 1) return mid * 1ll * mid % Mo * a % Mo;
    return mid * 1ll * mid % Mo;
}
int Getc(int n,int m){
    if (m > n) return 0;
    return Fc[n] * 1ll * Rv[m] % Mo * Rv[n - m] % Mo;
}
int Normal(int s,int t,int x,int y){
    if (x < s || y < t) return 0;
    return Getc(x + y - s - t,x - s);
}
int Walk(int s,int t,int x,int y){
    return (Normal(s,t,x,y) - Normal(s,t,y - 1,x + 1) + Mo) % Mo;
}
void setIO(){
    freopen("walk.in","r",stdin);
    freopen("walk.out","w",stdout);
}
int main(){
    setIO();
    scanf("%d%d", &N, &C);
    Fc[0] = 1;
    for(int i = 1;i <= N * 2 + 5;i ++) Fc[i] = Fc[i - 1] * 1ll * i % Mo;
    Rv[N * 2 + 5] = Quick(Fc[N * 2 + 5], Mo - 2);
    for(int i = N * 2 + 5;i;i --) Rv[i - 1] = Rv[i] * 1ll * i % Mo;
    for(int i = 1;i <= C;i ++) scanf("%d%d", &Block[i].fe, &Block[i].se);
    Block[++ C] = P(N,N);
    sort(Block + 1,Block + C + 1);
    for(int i = 1;i <= C;i ++)
    {
        F[i] = Walk(0,0,Block[i].fe,Block[i].se);
        for(int j = 1;j < i;j ++)
        if (Block[j].se <= Block[i].se)
            F[i] = (F[i] - F[j] * 1ll * Walk(Block[j].fe,Block[j].se,Block[i].fe,Block[i].se) % Mo + Mo) % Mo;
    }
    printf("%d\n", F[C]);
    return 0;
}

Melancholy

【题目简述】
$DX3906 星系,Melancholy 星上,我在勘测这里的地质情况。$
$我把这些天来已探测到的区域分为 N 组,并用二元组(D,V)对每一组进行标记:其中 D 为区域的相对距离,V 为内部地质元素的相对丰富程度。$
$在我的日程安排表上有 Q 项指派的计划。每项计划的形式是类似的,都是“对相对距离 D 在[L,R]之间的区域进行进一步的勘测,并在其中有次序地挑出 K 块区域的样本进行研究。”采集这 K 块的样品后,接下来在实验中,它们的研究价值即为这 K 块区域地质相对丰富程度 V 的乘积。$
$我对这 Q 项计划都进行了评估:一项计划的评估值 P 为所有可能选取情况的研究价值之和。$
$但是由于仪器的原因,在一次勘测中,这其中 V 最小的区域永远不会被选取。$
$现在我只想知道这 Q 项计划的评估值对 2^32 取模后的值,特殊地,如果没有 K 块区域可供选择,评估值为 0。$
【输入格式】
$第一行给出两个整数,区域数 N 与计划数 Q。$
$第二行给出 N 个整数,代表每一块区域的相对距离 D$ 。
$第三行给出 N 个整数,代表每一块区域的内部地质元素的相对丰富程度 V。$
$接下来的 Q 行,每一行 3 个整数,代表相对距离的限制 L,R,以及选取的块数 K。$
【输出格式】
$输出包括 Q 行,每一行一个整数,代表这项计划的评估值对 2^32 取模后的值。$
【数据范围】
$1,2,3 --K=1 1<=N,Q<=10^5$
$4,5,6 --1<=K<=2 1<=D,V<=10^9$
$7,8 ---1<=K<=3 1<=L<=R<=10^9$
9,10 $---1<=K<=6$
$数据保证所有区域的 D 与 V 互不相等。$
【样例输入输出】
样例输入
$5 3$
$5 4 7 2 6$
$1 4 5 3 2$
$6 7 1$
$2 6 2$
$1 8 3$
样例输出
$5$
$52$
$924$
【样例解释】
$第一次被勘测区域的 V 值有{2,5},而能够被选取只有{5}。$
$第二次被勘测区域的 V 值有{1,2,3,4},能够被选取的有{2,3,4},评估值为2!*(2*3+3*4+2*4)=52。$
$第三次被勘测区域的 V 值有{1,2,3,4,5},能够被选取的有{2,3,4,5},评估值为3!*(2*3*4+2*3*5+2*4*5+3*4*5)=924。$

Solution :
线段树维护不去掉min的答案，然后容斥原理。

Code :

/*************************************************************************
    > File Name: melancholy.cpp
    > Author: Archer
 ************************************************************************/

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;

typedef long long ll;
typedef unsigned int UI;
typedef pair<int, int> PII;
#define REP(i, l, r) for (int i = l; i <= r; i++)
#define MP make_pair
const int N = 111111;
int n, q;
struct node{int d, v; } blk[N];
struct Node{
    Node *lc, *rc; UI sum[10], mn; int l, r;
    void clear() { sum[0] = 1;}
    inline void merge(){
        REP(i, 1, 6) REP(j, 0, i) sum[i] += lc->sum[j] * rc->sum[i - j];
        mn = min(lc->mn, rc->mn);
    }
}pool[N << 4], *root, *tail = pool;
inline void setIO(){
    freopen("melancholy.in", "r", stdin);
    freopen("melancholy.out", "w", stdout);
}
inline int read(){
    int x = 0, f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar(); }
    return x * f;
}
inline void build(Node *(&rt), int l, int r){
    rt = tail++; rt->clear(); rt->l = l; rt->r = r;
    if (l == r){ rt->mn = rt->sum[1] = blk[l].v; return; }
    int mid = l+r >> 1;
    build(rt->lc, l, mid); build(rt->rc, mid + 1, r);
    rt->merge();
}
inline bool cmp(node x, node y) {return x.d < y.d; }
inline Node *merge(Node *t1, Node *t2){
    Node *ret = tail++; ret->lc = t1; ret->rc = t2;
    ret->merge(); ret->clear();
    return ret;
}
inline Node *query(Node *rt, int l, int r){
    if (l <= rt->l && rt->r <= r) { return rt; }
    int mid = rt->l+rt->r >> 1;
    if (r <= mid) return query(rt->lc, l, r);
    else if (l > mid) return query(rt->rc, l, r);
    else return merge(query(rt->lc, l, r), query(rt->rc, l, r));
}
inline int find(int x){
    int l = 0, r = n + 1;
    while (l + 1 < r){
        int mid = l+r >> 1;
        (blk[mid].d < x ? l : r) = mid;
    }
    return l;
}
int main(){
    setIO();

    n = read(); q = read();
    REP(i, 1, n) blk[i].d = read();
    REP(i, 1, n) blk[i].v = read(); 
    sort(blk + 1, blk + 1 + n, cmp);

    build(root, 1, n);

    while (q--){
        int L = read(), R = read(), k = read();
        int l = find(L) + 1, r = find(R + 1);
        if (l > r) {printf("0\n"); continue;}
        Node *info = query(root, l, r);
        info->clear(); 
        UI ans = info->sum[k], t = -info->mn;
        REP(i, 1, k) ans += t * info->sum[k - i], t *= -info->mn;
        REP(i, 1, k) ans *= i;
        printf("%u\n", ans);
    }
    return 0;
}