某道巨恶心的线段树

最新推荐文章于 2025-02-18 17:45:17 发布
最新推荐文章于 2025-02-18 17:45:17 发布
阅读量42 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/ZlycerQan/p/7678856.html
本文介绍了一种基于线段树的数据结构实现，能够高效地处理区间修改与查询操作，适用于离散数值的动态更新场景。该实现支持两种类型的区间操作：区间加法更新与区间奇偶性反转，并能快速查询指定区间内特定项的系数。

 

 10.24 Updata

考场上写出来了233333

 

#include <iostream>
#include <cstdio>
#define rg register
#define Max 100005
inline void read (int &n)
{
    rg char c = getchar (); bool temp = false;
    for (n = 0; !isdigit (c); c = getchar ()) if (c == '-') temp = true;
    for (; isdigit (c); n = n * 10 + c - '0', c = getchar ());
    if (temp) n = -n;
}
typedef long long LL; int a[Max]; LL C[Max][11];
#define mo 1000000007
struct SD 
{ SD *L, *R; int l, r, m; LL f[11], t1; bool t2; void D (); void U (); } 
*null = new SD, pool[Max << 2], *Ta = pool;
inline LL Inc (LL &x, LL y) { for (x += y; x >= mo; x -= mo); }
void Updata (SD *&n, int l, int r, int c)
{
    rg int Len = r - l + 1, i, j; static LL _f[11]; LL t, p;
    for (i = 0; i <= 10; ++ i) _f[i] = n->f[i];
    for (i = 1; i <= 10; ++ i)
        for (t = 1, j = n->f[i] = 0; j <= i; ++ j)
        {
            p = _f[i - j] * C[Len - i + j][j] % mo * t % mo;
            Inc (n->f[i], p), t = t * c % mo;
        }
}
void SD :: D ()
{
    if (t1)
    {
        if (L->t2) L->t1 = (L->t1 + mo - t1) % mo;
        else L->t1 = (L->t1 + t1) % mo;
        if (R->t2) R->t1 = (R->t1 + mo - t1) % mo;
        else R->t1 = (R->t1 + t1) % mo;
        Updata (L, l, m, t1), Updata (R, m + 1, r, t1); t1 = 0;    
    }
    if (t2)
    {
        L->t2 ^= 1, R->t2 ^= 1; rg int i; t2 = false;
        for (i = 1; i <= 10; i += 2) 
            L->f[i] = mo - L->f[i], R->f[i] = mo - R->f[i];
    }
}
void SD :: U ()
{
    f[0] = 1; rg int i, j;
    for (i = 1; i <= 10; ++ i)
        for (j = f[i] = 0; j <= i; ++ j)
            Inc (f[i], L->f[j] * R->f[i - j] % mo);
}
class SegmentTree
{
    private : SD *Root, *Limit;
        
        SD *New (int x, int y)
        {
            ++ Ta, Ta->l = x, Ta->r = y, Ta->m = x + y >> 1;
            for (rg int i = 0; i <= 10; ++ i) Ta->f[i] = 0;
            Ta->L = null, Ta->R = null, Ta->t1 = Ta->t2 = 0; return Ta;
        }
        SD *Q (SD *&n, int l, int r)
        {
            if (l <= n->l && n->r <= r) return n; 
            n->D (); SD *p = ++ Ta; p->L = p->R = null;
            if (r <= n->m) return Q (n->L, l, r); if (l > n->m) return Q (n->R, l, r);
            p->L = Q (n->L, l, r), p->R = Q (n->R, l, r); 
            return p->U (), p;
        }
        void Modi1 (SD *&n, int l, int r, int c)
        {
            if (l <= n->l && n->r <= r)
            {
                if (n->t2) n->t1 = (n->t1 + mo - c) % mo;
                else Inc (n->t1, c);
                Updata (n, n->l, n->r, c); return ;
            }
            n->D ();
            if (l <= n->m) Modi1 (n->L, l, r, c); if (r > n->m) Modi1 (n->R, l, r, c); n->U ();
        } 
        void Build (SD *&n, int l, int r)
        {
            n = New (l, r);
            if (l == r) 
            { n->f[0] = 1, n->f[1] = (a[l] % mo + mo) % mo;  return ; } 
            Build (n->L, l, n->m), Build (n->R, n->m + 1, r), n->U (); 
        }
        void Modi2 (SD *&n, int l, int r)
        {
            if (l <= n->l && n->r <= r)
            {
                for (rg int i = 1; i <= 10; i += 2) n->f[i] = mo - n->f[i];
                n->t2 ^= 1; return ;
            }
            n->D ();
            if (l <= n->m) Modi2 (n->L, l, r); if (r > n->m) Modi2 (n->R, l, r); n->U ();
        }
        
    public :
        
        void Build (int l, int r) { Build (Root, l, r); Limit = ++ Ta; return ;}
        int Q (int l, int r, int k) 
        { SD *c = Q (Root, l, r); return Ta = Limit, c->f[k] % mo; }
        void Modi1 (int l, int r, int c) { Modi1 (Root, l, r, c); return ; }
        void Modi2 (int l, int r) { Modi2 (Root, l, r); return ; }
} T;
std :: string Name = "game", _I = ".in", _O = ".out";
int main (int argc, char *argv[])
{
    freopen ((Name + _I).c_str (), "r", stdin);
    freopen ((Name + _O).c_str (), "w", stdout);
    int N, M, t, x, y, z; read (N), read (M); rg int i, j;
    null->L = null->R = null; null->l = null->r = null->t1 = null->t2 = null->m = 0;
    for (i = 0; i <= 10; ++ i) null->f[i] = 0;
    for (i = C[0][0] = 1; i <= N; ++ i)
        for (C[i][0] = j = 1; j <= 10; ++ j)
            C[i][j] += C[i - 1][j - 1] + C[i - 1][j], C[i][j] %= mo;
    for (i = 1; i <= N; ++ i) read (a[i]);
    for (T.Build (1, N), i = 1; i <= M; ++ i)
    {
        read (t), read (x), read (y);
        if (t == 1) { read (z), z = (z % mo + mo) % mo, T.Modi1 (x, y, z); }
        else if (t == 2) T.Modi2 (x, y);
        else read (z), printf ("%d\n", T.Q (x, y, z));
    }
    return 0;
}

 

 

 

 

/*
        莫Copy
        还未调出来
*/
#define DEBUG for (int q = 0; q <= 10; ++ q) std :: cout << n->f[q] << " "; puts ("");
#include <iostream>
#include <cstdio>
#define rg register
#define Max 100005
inline void read (int &n)
{
    rg char c = getchar (); bool temp = false;
    for (n = 0; !isdigit (c); c = getchar ()) if (c == '-') temp = true;
    for (; isdigit (c); n = n * 10 + c - '0', c = getchar ());
    if (temp) n = -n;
}
typedef long long LL; int a[Max]; LL C[Max][11];
#define mo 1000000007
struct SD 
{ SD *L, *R; int l, r, m; LL f[11], t1; bool t2; void D (); void U (); } 
*null = new SD, pool[Max << 2], *Ta = pool;
inline LL Inc (LL &x, LL y) { for (x += y; x >= mo; x -= mo); }
void Updata (SD *&n, int l, int r, int c)
{
    rg int Len = r - l + 1, i, j; static LL _f[11]; LL t, p;
    for (i = 0; i <= 10; ++ i) _f[i] = n->f[i];
    for (i = 1; i <= 10; ++ i)
        for (t = 1, j = n->f[i] = 0; j <= i; ++ j)
        {
            p = _f[i - j] * C[Len - i + j][j] % mo * t % mo;
            Inc (n->f[i], p), t = t * c % mo;
        }
}
void SD :: D ()
{
    if (t1)
    {
        if (L->t2) L->t1 = (L->t1 + mo - t1) % mo;
        else L->t1 = (L->t1 + t1) % mo;
        if (R->t2) R->t1 = (R->t1 + mo - t1) % mo;
        else R->t1 = (R->t1 + t1) % mo;
        Updata (L, l, m, t1), Updata (R, m + 1, r, t1); t1 = 0;    
    }
    if (t2)
    {
        L->t2 ^= 1, R->t2 ^= 1; rg int i; t2 = false;
        for (i = 1; i <= 10; ++ i) 
            L->f[i] = mo - L->f[i], R->f[i] = mo - R->f[i];
    }
}
void SD :: U ()
{
    f[0] = 1; rg int i, j;
    for (i = 1; i <= 10; ++ i)
        for (j = f[i] = 0; j <= i; ++ j)
            Inc (f[i], L->f[j] * R->f[i - j] % mo);
}
class SegmentTree
{
    private : SD *Root, *Limit;
        
        SD *New (int x, int y)
        {
            ++ Ta, Ta->l = x, Ta->r = y, Ta->m = x + y >> 1;
            for (rg int i = 0; i <= 10; ++ i) Ta->f[i] = 0;
            Ta->L = null, Ta->R = null, Ta->t1 = Ta->t2 = 0; return Ta;
        }
        void Build (SD *&n, int l, int r)
        {
            n = New (l, r);
            if (l == r) 
            { n->f[0] = 1, n->f[1] = (a[l] % mo + mo) % mo;  return ; } 
            Build (n->L, l, n->m), Build (n->R, n->m + 1, r), n->U (); 
        }
        SD *Q (SD *&n, int l, int r)
        {
            if (l <= n->l && n->r <= r) return n; 
            n->D (); SD *p = ++ Ta; p->L = p->R = null;
            if (r <= n->m) return Q (n->L, l, r); if (l > n->m) return Q (n->R, l, r);
            p->L = Q (n->L, l, r), p->R = Q (n->R, l, r); 
            return p->U (), p;
        }
        void Modi1 (SD *&n, int l, int r, int c)
        {
            if (l <= n->l && n->r <= r)
            {
                if (n->t2) n->t1 = (n->t1 + mo - c) % mo;
                else Inc (n->t1, c);
                Updata (n, n->l, n->r, c); return ;
            }
            n->D ();
            if (l <= n->m) Modi1 (n->L, l, r, c); if (r > n->m) Modi1 (n->R, l, r, c); n->U ();
        }
        void Modi2 (SD *&n, int l, int r)
        {
            if (l <= n->l && n->r <= r)
            {
                for (rg int i = 1; i <= 10; i += 2) n->f[i] = mo - n->f[i];
                n->t2 ^= 1; return ;
            }
            n->D ();
            if (l <= n->m) Modi2 (n->L, l, r); if (r > n->m) Modi2 (n->R, l, r); n->U ();
        }
        
    public :
        
        void Build (int l, int r) { Build (Root, l, r); Limit = ++ Ta; return ;}
        int Q (int l, int r, int k) 
        { SD *c = Q (Root, l, r); return Ta = Limit, c->f[k] % mo; }
        void Modi1 (int l, int r, int c) { Modi1 (Root, l, r, c); return ; }
        void Modi2 (int l, int r) { Modi2 (Root, l, r); return ; }
} T;
std :: string Name = "game", _I = ".in", _O = ".out";
int main (int argc, char *argv[])
{
    freopen ((Name + _I).c_str (), "r", stdin);
    freopen ((Name + _O).c_str (), "w", stdout);
    int N, M, t, x, y, z; read (N), read (M); rg int i, j;
    null->L = null->R = null; null->l = null->r = null->t1 = null->t2 = null->m = 0;
    for (i = 0; i <= 10; ++ i) null->f[i] = 0;
    for (i = C[0][0] = 1; i <= N; ++ i)
        for (C[i][0] = j = 1; j <= 10; ++ j)
            C[i][j] += C[i - 1][j - 1] + C[i - 1][j], C[i][j] %= mo;
    for (i = 1; i <= N; ++ i) read (a[i]);
    for (T.Build (1, N), i = 1; i <= M; ++ i)
    {
        read (t), read (x), read (y);
        if (t == 1) { read (z), z = (z % mo + mo) % mo, T.Modi1 (x, y, z); }
        else if (t == 2) T.Modi2 (x, y);
        else read (z), printf ("%d\n", T.Q (x, y, z));
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/ZlycerQan/p/7678856.html

【算法】线段树详解
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
线段树入门
Tsingcheng_liu的博客
08-29 324
线段树入门（Segment Tree) 开学要给萌新们讲课，懒得写PPT于是跑来写博客。 线段树引入 题目描述： 已知一个数列，你需要进行下面两种操作： 1.将某区间每一个数加上x 2.求出某区间每一个数的和 输入格式： 第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。 第二行包含N个用空格分隔的整数，其中第i个...
线段树合集整理
zjy_code的博客
08-11 353
作为oier刷题是碰见的大数据结构的集合 作者水平有限，如有不足欢迎批评指正 会随时更新其中的题目
线段树
antRain的博客
08-31 203
线段树线段树区间修改(加)+ 区间查询区间修改(加+乘）+区间查询静态区间第K小参考博客 线段树 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 区间...
线段树之进阶
Oveln
05-23 694
前记 哦看了上次的blog感觉自己是个傻子 讲不清楚阿西吧 不管了 这次的目标是 ·线段树区间修改 ·一些杂题 那么就开始吧 区间修改 先把原来的题面修改一下 如题，已知一个数列，你需要进行下面两种操作： 1.将某个数修改成x 2.求出某区间每一个数的和 3.将某个区间的数全部加上x N&lt;=100000，M&lt;=100000 上次...
入门-线段树
君只见独不见的专栏
04-11 327
题目描述 老师想知道从某某同学到某某同学当中，分数最高的是多少。 现在请你编程模拟老师的询问。当然，老师有时候需要更新某位同学的成绩。 输入 输入包含多组测试数据。 每组输入第一行是两个正整数N和M（0<N<=30000,0<M<5000），分表代表学生的数目和操作的数目。 学生ID编号从1编到N。 第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学...
Hdu 2795 线段树的运用
Mr_13的博客
09-09 912
线段树
线段树专题
far away
08-16 843
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1166 敌兵布阵 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 97473    Accepted Submi
线段树1——您的不二选择
Pt.ll的博客
02-18 778
线段树
线段树，数据结构的选择与算法效率
11-22
- **查询操作**：可以通过线段树快速查询某一段超元线段是否属于轮廓的一部分。 - **更新操作**：当添加新的矩形时，可以通过更新线段树来反映新增矩形对轮廓的影响。 - **优势**：利用线段树进行管理，可以在O(log ...
线段树，从入门到入坑（完整版）
luhaoren2009的博客
07-08 586
今年初的时候学线段树，凑了一篇博客（其实就是一堆题的题解），连线段树是什么都没讲明白，所以重新写了一篇。
ACM竞赛算法之线段树
Boss_Xie的博客
01-12 1162
线段树是一个很重要的数据结构，而且在算法竞赛中用处也十分巨大，但很多人往往认为线段树是一个算法，可以完成某些功能，但是实际上完全可以把它看成是一个容器，用来执行的操作可以按照需求修改 首先思考如下问题： 思考一、现在如果有一个长度为n的序列，有m次操作，操作中包含区间求和，某点修改，并且n和m特别大 思考二、现在给你一个长度为n的序列，有m次操作，操作中仅包含求区间内最大值或最小值的问题
线段树与后算法：竞赛中的高效数据结构对比
而后一种算法则更偏向于针对某一类特定问题的优化，不具有线段树那样通用的性质。 总结来说，在ACM竞赛中，选择线段树还是其他算法取决于具体问题的特性。如果问题需要频繁进行区间操作并且区间范围可能动态变化，...
springboot智能在线预约挂号系统【附万字论文+PPT+包部署+录制讲解视频】.zip
09-05
标题SpringBoot智能在线预约挂号系统研究AI更换标题第1章引言介绍智能在线预约挂号系统的研究背景、意义、国内外研究现状及论文创新点。1.1研究背景与意义阐述智能在线预约挂号系统对提升医疗服务效率的重要性。1.2国内外研究现状分析国内外智能在线预约挂号系统的研究与应用情况。1.3研究方法及创新点概述本文采用的技术路线、研究方法及主要创新点。第2章相关理论总结智能在线预约挂号系统相关理论，包括系统架构、开发技术等。2.1系统架构设计理论介绍系统架构设计的基本原则和常用方法。2.2SpringBoot开发框架理论阐述SpringBoot框架的特点、优势及其在系统开发中的应用。2.3数据库设计与管理理论介绍数据库设计原则、数据模型及数据库管理系统。2.4网络安全与数据保护理论讨论网络安全威胁、数据保护技术及其在系统中的应用。第3章SpringBoot智能在线预约挂号系统设计详细介绍系统的设计方案，包括功能模块划分、数据库设计等。3.1系统功能模块设计划分系统功能模块，如用户管理、挂号管理、医生排班等。3.2数据库设计与实现设计数据库表结构，确定字段类型、主键及外键关系。3.3用户界面设计设计用户友好的界面，提升用户体验。3.4系统安全设计阐述系统安全策略，包括用户认证、数据加密等。第4章系统实现与测试介绍系统的实现过程，包括编码、测试及优化等。4.1系统编码实现采用SpringBoot框架进行系统编码实现。4.2系统测试方法介绍系统测试的方法、步骤及测试用例设计。4.3系统性能测试与分析对系统进行性能测试，分析测试结果并提出优化建议。4.4系统优化与改进根据测试结果对系统进行优化和改进，提升系统性能。第5章研究结果呈现系统实现后的效果，包括功能实现、性能提升等。5.1系统功能实现效果展示系统各功能模块的实现效果，如挂号成功界面等。5.2系统性能提升效果对比优化前后的系统性能
基于机器学习方法的信用风险评估体系构建与实现
09-05
在金融行业中，对信用风险的判断是核心环节之一，其结果对机构的信贷政策和风险控制策略有直接影响。本文将围绕如何借助机器学习方法，尤其是Sklearn工具包，建立用于判断信用状况的预测系统。文中将涵盖逻辑回归、支持向量机等常见方法，并通过实际操作流程进行说明。 一、机器学习基本概念 机器学习属于人工智能的子领域，其基本理念是通过数据自动学习规律，而非依赖人工设定规则。在信贷分析中，该技术可用于挖掘历史数据中的潜在规律，进而对未来的信用表现进行预测。 二、Sklearn工具包概述 Sklearn（Scikit-learn）是Python语言中广泛使用的机器学习模块，提供多种数据处理和建模功能。它简化了数据清洗、特征提取、模型构建、验证与优化等流程，是数据科学项目中的常用工具。 三、逻辑回归模型 逻辑回归是一种常用于分类任务的线性模型，特别适用于二类问题。在信用评估中，该模型可用于判断借款人是否可能违约。其通过逻辑函数将输出映射为0到1之间的概率值，从而表示违约的可能性。 四、支持向量机模型 支持向量机是一种用于监督学习的算法，适用于数据维度高、样本量小的情况。在信用分析中，该方法能够通过寻找最佳分割面，区分违约与非违约客户。通过选用不同核函数，可应对复杂的非线性关系，提升预测精度。 五、数据预处理步骤 在建模前，需对原始数据进行清理与转换，包括处理缺失值、识别异常点、标准化数值、筛选有效特征等。对于信用评分，常见的输入变量包括收入水平、负债比例、信用历史记录、职业稳定性等。预处理有助于减少噪声干扰，增强模型的适应性。 六、模型构建与验证 借助Sklearn，可以将数据集划分为训练集和测试集，并通过交叉验证调整参数以提升模型性能。常用评估指标包括准确率、召回率、F1值以及AUC-ROC曲线。在处理不平衡数据时，更应关注模型的召回率与特异性。 七、集成学习方法 为提升模型预测能力，可采用集成策略，如结合多个模型的预测结果。这有助于降低单一模型的偏差与方差，增强整体预测的稳定性与准确性。 综上，基于机器学习的信用评估系统可通过Sklearn中的多种算法，结合合理的数据处理与模型优化，实现对借款人信用状况的精准判断。在实际应用中，需持续调整模型以适应市场变化，保障预测结果的长期有效性。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
橙色s（）_Orange's一个操作系统的实现(随书光盘).zip
09-05
橙色s（）_Orange's一个操作系统的实现(随书光盘).zip
perl-Hash-Flatten-1.19-26.el8.tar.gz
最新发布
09-05
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
jackson-dataformat-smile-2.20.0.jar中文-英文对照文档.zip
09-05
1、压缩文件中包含： 中文-英文对照文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文-英文对照文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
Source code for common plots in various languages_libraries_
09-05
Source code for common plots in various languages_libraries_ R (base, ggplot2, rCharts) Python (matplotlib, seaborn, ggplot, bokeh, vincent), MATLAB, and Julia (Gadfly).zip
线段树经典题目解析与代码实现
在给出的文件信息中，“几道经典线段树题目及代码”可能意味着该文件包含对线段树实现的代码示例以及一些关于线段树应用的习题。在解决这些习题的过程中，可以加深对线段树结构、操作和实现的理解。通过实际编码和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值