代码模板

1.并查集操作：

int father[10086];
int find(int x){
    return father[x]=(father[x]==x?x:find(father[x]));//一般都是写这个模板，因为他快，不会超时！！！
}
void Union(int a,int b){
    int f1=find(a);
    int f2=find(b);
    if(f1<f2)swap(f1,f2);//意思是大的当小的父亲，有钦定的含义在里面，这是可以自定义的额
    father[f2]=f1;
}

 2.求解最大公约数：

inline int gcd(int a,int b){
    return b==0?a:gcd(b,a%b);//a一定是一直大于b的。。。
}

 3.

//priority_queue默认使用的是大顶堆：
priority_queue<int>pq;

如果想使用priority_queue的小顶堆的特性，那么可以采用的是：
priority_queue<int,vector<int>,greater<int>()>pq;

 4.优先队列，自定义大顶堆或者小顶堆：

那个排序大于是greater<>；所以大于是小顶堆

小于是less<>,所以小于是大顶堆，一定不能弄混了。

学习链接：

https://blog.csdn.net/c20182030/article/details/70757660?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

比较模板，以及习题：

787. K 站中转内最便宜的航班

// class Node{
// public:
//     Node(int _cost,int _name,int _dist):pay(_cost),name(_name),dist(_dist){}

//     int pay;
//     int name;
//     int dist;
// };
struct Node{
    int pay;
    int name;
    int dist;
};

struct cmp{
    //下面的含义是重载小于号的含义
    bool operator() (Node& a,Node& b){
        return a.pay>b.pay;
    }
    
};
struct edge{
    int to;
    int cost;
};
class Solution {
public:
//Djkstra算法，使用优先队列求解，首先写出Dijkstra算法的模板
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
        priority_queue<Node,vector<Node>,cmp>pq;//第一个参数是代价，第二个参数是到达结点位置。
        vector<edge>g[n+1];
        for(auto v:flights){
            edge e;
            e.to=v[1];
            e.cost=v[2];
            g[v[0]].push_back(e);
        }
        set<int>vis;
        vis.clear();
        pq.push({0,src,-1});
        while(!pq.empty()){
            auto x=pq.top();
            pq.pop();
            cout<<x.name<<" "<<vis.count(x.name)<<endl;
            //if(vis.count(x.name))continue;
            if(x.name==dst)return x.pay;
            //vis.insert(x.name);
            int n=g[x.name].size();
            for(int i=0;i<n;i++){
                edge v=g[x.name][i];
                if(x.dist<K){
                    pq.push({x.pay+v.cost,v.to,x.dist+1});
                }
                
            }
        }
        return -1;
    }
};

 Trie树模板

//Trie 树
#include<iostream>
#include<vector>
#include<string>
#include<cstring>
using namespace std;

struct Node{
    Node *child[26];
    //bool flag;
    Node(){//构造函数
        for(int i=0;i<26;i++){
            child[i]=nullptr;
        }
    }
};
void insert(Node *root,string word){
    Node *rt=root;//root是不能变化的，所以最初赋给一个新的值进行操作
    for(int i=word.length()-1;i>=0;i--){
        int to=word[i]-'a';
        if(rt->child[to]==nullptr){
            rt->child[to]=new Node();
        }
        rt=rt->child[to];
    }
}
void count(Node *root,int &res,int deep){
    bool flag=true;//这里涉及到递归的问题，所以需要首先设置一下，防止之后递归多加了。。。
    for(int i=0;i<26;i++){
        if(root->child[i]!=nullptr){
            count(root->child[i],res,deep+1);
            flag=false;//注意需要回溯，否则会出错。。。
        }
    }
    if(flag){
        res+=deep;//注意这里的deep需要最初多加一个，因为#也算是一部份
        //cout<<res<<endl;
    }
}

int main(){
    Node *root=new Node();
    int n;
    cin>>n;
    string s;
    vector<string>str;
    for(int i=0;i<n;i++){
        cin>>s;
        //str.push_back(s);
        insert(root,s);
    }
    int res=0;
    count(root,res,1);
    cout<<res<<endl;
    return 0;
}

 Trie基本操作：

leetcode题目：

208. 实现 Trie (前缀树)

class Trie {
private:
    bool is_str;
    Trie* next[26];
public:
    //bool is_str;//是否是一个完整的字符串
    /** Initialize your data structure here. */
    Trie() {
        for(int i=0;i<26;i++){
            next[i]=nullptr;
        }
        is_str=false;
    }
    ~Trie(){//析构函数
        for(int i=0;i<26;i++){
            if(next[i]==nullptr)continue;
            delete(next[i]);
            next[i]=nullptr;
        }
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        Trie *cur=this;//将根结点this赋给给node
        for(auto v:word){
            if(cur->next[v-'a']==nullptr){
                cur->next[v-'a']=new Trie();
            }
            cur=cur->next[v-'a'];
        }
        cur->is_str=true;//表示的是这个插入的字符串是完整的。
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        Trie *cur=this;
        for(auto v:word){
            if(cur->next[v-'a']==nullptr)return false;
            else cur=cur->next[v-'a'];
        }
        return cur->is_str;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        Trie *cur=this;
        for(auto v:prefix){
            if(cur->next[v-'a']==nullptr)return false;
            else cur=cur->next[v-'a'];
        }
        return true;
    }


};

 

 

最短路径算法：

743. 网络延迟时间

struct edge{
    int to;
    int cost;
};
typedef pair<int,int>P;

class Solution {
public:
//dijkstra算法，采用的是优先队列的小顶堆的特性，因为每一次更新会有一个结点的最短路径会最终的确定。那么下一次优先更新的是最小路径的结点。
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        priority_queue<P,vector<P>,greater<P>>pq;
        vector<edge>g[N+1];//数组中的形式是edge的格式
        memset(dist,0x3f,sizeof(dist));
        int n=times.size();
        for(int i=0;i<n;i++){
            edge e;
            e.to=times[i][1];
            e.cost=times[i][2];
            g[times[i][0]].push_back(e);
        }
        set<int>vis;
        pq.push({0,K});
        int res=0;
        while(!pq.empty()){
            auto x=pq.top();
            pq.pop();
            if(vis.count(x.second))continue;
            //vis[x.second]=true;
            vis.insert(x.second);
            res=max(x.first,res);
            //cout<<res<<endl;
            int n=g[x.second].size();
            for(int i=0;i<n;i++){
                edge v=g[x.second][i];
                if(vis.count(v.to))continue;
                pq.push({v.cost+x.first,v.to});
            }
        }
        return vis.size()==N?res:-1;
    }
};

 

快排手写代码：

void Quick_sort(int arr[],int start,int end){
    int i=start;
    int j=end;
    int val=arr[start];
    while(i<j){
        while(i<j&&arr[j]>=val)j--;
        if(i<j){
            arr[i]=arr[j];
            i++;
        }
        while(i<j&&arr[i]<=val)i++;
        if(i<j){
            arr[j]=arr[i];
            j--;
        }
    }
    arr[i]=val;
    Quick_sort(arr,start,i-1);
    Quick_sort(arr,i+1,end);
}

 二分查找模板：

1095. 山脉数组中查找目标值

class Solution {
public://三次二分查找，第一次找峰，第二次左边，第三次右边
    //不能使用暴力求解，因为get不能调用超过100次，所以只能采用二分查找的方法求解。。。。
    int findInMountainArray(int target, MountainArray &a) {
        //第一步找峰
        int lo=0;
        int hi=a.length()-1;
        while(lo<hi){
            int mid=(lo+hi)/2;
            if(a.get(mid)<a.get(mid+1)){
                lo=mid+1;
            }else{
                hi=mid;
            }
        }
        int peak=lo;
        cout<<peak<<endl;
        if(target>a.get(peak))return -1;
        int l0=0;
        hi=peak;
        
        while(l0<=hi){
            int mid=(l0+hi)/2;
            if(a.get(mid)==target)return mid;
            else if(a.get(mid)<target){
                l0=mid+1;
            }else{
                hi=mid-1;
            }
        }
        l0=peak;
        hi=a.length()-1;
        while(l0<=hi){
            int mid=(l0+hi)/2;
            if(a.get(mid)==target)return mid;
            else if(a.get(mid)<target){
                hi=mid-1;
            }else{
                l0=mid+1;
            }
        }
        return -1;
    }
};

 

 

KMP算法：

namespace KMP{
    vector<int>next;//存放的是next数组

    void build(const string &pattern){//构建next数组
        int n=pattern.length();
        next.resize(n+1);//多构建一个位,在模式串的末尾加上一个永远不能操作的位置，方便下面匹配的操作

        for(int i=0,j=next[0]=-1;i<n;next[++i]=++j){
            while(j!=-1&&pattern[j]!=pattern[i])j=next[j];
        }
    }
    vector<int>match(const string &pattern,const string &text){
        vector<int>res;//存放的是在text中符合条件的串的初始位置。。。
        int n=pattern.length(),m=text.length();
        build(pattern);
        for(int i=0,j=0;i<m;i++){
            while(j>0&&pattern[j]!=text[i])j=next[j];//kmp主操作
            if(pattern[j]==text[i])j++;
            if(j==n){//表示到达最后一个位置了,表示当前位置匹配成功了
                res.push_back(i-n+1);
                j=next[j];//表示j又变成0了。。。
            }
        }
    }
}

 

快速幂模板：

typedef double db;
typedef long long ll;
class Solution {
public:
    double myPow(double x, int n) {
        db ans=1.0;
        ll k=n;
        if(k<0){
            k=-k;
            x=1/x;
        }
        while(k){
            if(k&1)ans*=x;
            x*=x;
            k=k>>1;
        }
        return ans;
    }
};

 

最短路径相关的代码模板：

743. 网络延迟时间

Floyd:

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        int res=0;
        vector<vector<int>>edge(N+1,vector<int>(N+1,0x3f3f));
        for(int i=1;i<=N;i++){//注意这里是从1开始的，因为我们下标是结点的值，结点值最小是1
            edge[i][i]=0;
        }
        for(auto v:times){
            edge[v[0]][v[1]]=v[2];
        }
        for(int k=1;k<=N;k++){
            for(int i=1;i<=N;i++){
                for(int j=1;j<=N;j++){
                    edge[i][j]=min(edge[i][j],edge[i][k]+edge[k][j]);
                }
            }
        }
        for(int i=1;i<=N;i++){
            if(edge[K][i]==0x3f3f)return -1;//如果不能使所有结点收到信号那么返回的是-1.
            res=max(res,edge[K][i]);
        }
        return res;

    }
};

作者：zb121
链接：https://leetcode-cn.com/problems/network-delay-time/solution/cfloydspfa-by-zb121/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

SPFA:

class Solution {
public:
//SPFA解法
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        queue<int>que;
        vector<vector<int>>edge(N+1,vector<int>(N+1,INT_MAX));
        vector<int>dist(N+1,INT_MAX);//表示的是K点到其他结点的最短距离
        for(auto v:times){
            edge[v[0]][v[1]]=v[2];
        }
        que.push(K);
        dist[K]=0;
        //SPFA使用的是队列的方式存放中间结点，方便下一次更新
        while(!que.empty()){
            int x=que.front();
            que.pop();
            for(int i=1;i<=N;i++){//只要出现有边存在，同时边长度较小，那么更新边权值。同时将其放入队列中，下一次再更新一下，当没有边需要更新的时候，那么结束吧。。。
                if(edge[x][i]!=INT_MAX&&dist[x]+edge[x][i]<dist[i]){
                    dist[i]=dist[x]+edge[x][i];
                    que.push(i);
                }
            }
        }
        int ans=0;
        for(int i=1;i<=N;i++){
            if(dist[i]==INT_MAX)return -1;
            ans=max(ans,dist[i]);
        }
        return ans;
    }
};

作者：zb121
链接：https://leetcode-cn.com/problems/network-delay-time/solution/cfloydspfa-by-zb121/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Djkstra:

struct edge{
    int to;
    int cost;
};
typedef pair<int,int>P;

class Solution {
public:
//dijkstra算法，采用的是优先队列的小顶堆的特性，因为每一次更新会有一个结点的最短路径会最终的确定。那么下一次优先更新的是最小路径的结点。不需要每一次更新不同结点的距离。。。
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        priority_queue<P,vector<P>,greater<P>>pq;
        vector<edge>g[N+1];//数组中的形式是edge的格式
        int n=times.size();
        for(int i=0;i<n;i++){
            edge e;
            e.to=times[i][1];
            e.cost=times[i][2];
            g[times[i][0]].push_back(e);
        }
        set<int>vis;
        pq.push({0,K});
        int res=0;
        while(!pq.empty()){
            auto x=pq.top();
            pq.pop();
            if(vis.count(x.second))continue;
            vis.insert(x.second);
            res=max(x.first,res);
            int n=g[x.second].size();
            for(int i=0;i<n;i++){
                edge v=g[x.second][i];
                if(vis.count(v.to))continue;
                pq.push({v.cost+x.first,v.to});
            }
        }
        return vis.size()==N?res:-1;
    }
};

作者：zb121
链接：https://leetcode-cn.com/problems/network-delay-time/solution/cfloydspfa-by-zb121/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

 

求解最长回文子串的长度：Manacher算法：

//Mancher算法 ,O(n)时间复杂度解决，将奇数与偶数的回文串统一了起来！！！
//HDU 3068最长回文！

//核心思想：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstring>
#include<map>
#include<cstdio>
#include<vector>
using namespace std;
const int maxn=3e5;
char s[maxn],str[maxn];
int len1,len2,p[maxn],ans;//p[i]表示的是以i为中心的回文半径是多少。。。ans存放的是最终的结果。。。
void init(){//这是一个完成字符串翻倍的操作，加上#实现字符串翻倍的操作。。。
    str[0]='$';
    str[1]='#';
    for(int i=0;i<len1;i++){//len1是s的长度
        str[i*2+2]=s[i];
        str[i*2+3]='#';
    }
    len2=len1*2+2;//加上的2是额外的$以及*。。。
    str[len2]='*';
}
void manacher(){
    int id=0,mx=0;//mx是以id为中心的最长回文子串的右边界。。。
    for(int i=1;i<len2;i++){//这里下标是1，因为i-p[i]防止越界。。。
        if(mx>i)p[i]=min(p[2*id-i],mx-i);//这里的解释在C++程序员面试宝典上面有写，在P3.
        else p[i]=1;
        for(;str[i+p[i]]==str[i-p[i]];p[i]++);//暴力的匹配。。。
        if(p[i]+i>mx){//我的串加上我的回文半径大于mx，那么更新mx
            mx=p[i]+i;
            id=i;//更新id
        }
    }

}
int main(){
    while(cin>>s){
        //首先我们需要将string这个数组进行翻倍.init()函数完成这个功能
        len1=strlen(s);
        init();
        //下面就是进行manacher的操作了。。
        manacher();
        ans=0;
        for(int i=0;i<len2;i++){
            ans=max(ans,p[i]);
        }
        cout<<ans-1<<endl;//因为半径其实插入了字符，所以半径就是长度二倍，所以需要减一。。。
    }
    return 0;
}

 

C11特性，基本写代码模板：

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
struct Point{
    int a,b;
    Point(int a=0,int b=0):a(a),b(b){}
    bool operator<(const Point &rhs)const{//这样就不用再写cmp函数，重载小于运算符。
        return a<rhs.a;
    }
}
template <typename T1,typename T2,typename T3>//模板的使用
bool solve(const T1 &a,cosnt T2 &b,const T3 &c){

}

int main(){
    int n=100;
    Point ts[n];
    sort(ts,ts+n,[](const Point& t1,cosnt Point& t2){
        if(t1.a!=t2.a)return t1.a<t2.a;
        return t1.b<t2.b;
    });
    return 0;
}

 

 

背包问题：

 

//背包问题合集。
int 0-1(){//每一个物品只能被选择一次
    //0-1背包
    int n;//n表示的是有n件物品可以选择，每一件物品有其自己的重量以及价值。
    int m;//m表示的是背包的总容量。
    vector<int>dp(n,0);//dp表示的是可以在m容量的背包中装上最大的价值是多少。
    vector<int>weight(n);
    vector<int>value(n);
    for(int i=1;i<=n;i++){//i表示的是物品编号。
        for(int j=m;j>=weight[i];j--){//j表示的是容量，j从大到小就可以保证每一个物品只被选择一次。。。
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);//这个j是从大到小，而j-weight[i]就是更小的，所以之后一定无法转移到大的上面。。。
        }
    }
    return *max_element(dp.begin(),dp.end());
}

//完全背包
int Wanquan(){
    //完全背包，每一个物品可以被多次的选择。。。
    int n,m;
    vector<int>dp;
    vector<int>weight;
    vector<int>value;
    for(int i=1;i<=n;i++){
        for(int j=weight[i];j<=m;j++){
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);//这样同一件物品i就可以被多次的选择了。因为我当前的状态可以从之前的状态转移过来。这样转移的状态选的背包可能被多次的选择。
            //原因是j从小到大遍历的，所以之后的j-weight[i]可能是之前的状态转移的结果
        }
    }
    return *max_element(dp.begin(),dp.end());
}

//多重背包，是0-1背包与完全背包的结合。

int Duochong(){
    int n,m;
    vector<int>dp(n,0);
    vector<int>value;
    vector<int>weight;
    vector<int>num;//这个表示每一个物品的个数，这个个数不是1，当然也不是无限个，是有限制的，个数是给出来的。
    for(int i=1;i<=n;i++){
        for(int j=m;j>=weight[i];j--){//这样就可以保证，某一个物品是按照你的要求进行选择个数的，不会无缘无故的叠加之前的状态，从而不知道选择多少个物品。。
            for(int k=0;k<=num[i];k++){//此时选择的个数是k个物品
                dp[j]=max(dp[j],dp[j-k*weight[i]]+k*value[i]);
            }
        }
    }
    return *max_element(dp.begin(),dp.end());
}

 

 

线段树模板:

//树状数组主要处理的是一个数组中更新每一个区段数组的值，求每一个区段数组的和，或者某一段数组的最大值。。。
//线段树。。。


// const int maxn=1e6+5;
// typedef long long ll
// //vector<int>a(maxn,0);
// int n,q
// int sum[maxn<<2];
// int a[maxn];
// void push_up(int rt){
//     sum[rt]=sum[rt<<1]+sum[rt<<1|1];
// }
// void build(int l,int r,int rt){//首先建一颗线段树,rt表示的是当前的结点是多少。。。l,r是范围大小
//     sum[rt]=0;
//     if(l==r){
//         sum[rt]=a[l];
//     }
//     int mid=(l+r)>>1;
//     build(l,mid,rt<<1);
//     build(mid+1,r,rt<<1|1);
//     push_up(rt);//就是将两个叶子结点的值传上去。。。
// }
// void update(int pos,int val,int l,int r,int rt){//就是更新pos位置的结点值为val...l,r为范围，rt为当前的结点


// }

// int main(){

//     return 0;
// }




// const int maxn=1e5+5;
// int sum[maxn<<2];

// int a[maxn];//表示当前结点存在的数组中。。。

// void push_up(int rt){
//     sum[rt]=sum[rt<<1]+sum[rt<<1|1];
// }

// void build(int l,int r,int rt){//rt当前结点位置，就是当前的根。。。
//     sum[rt]=0;
//     if(l==r){
//         sum[rt]=a[l];//表示到达最底下的叶子结点
//         return;
//     }
//     int mid=(l+r)>>1;
//     build(l,mid,rt<<1);//找根结点的左儿子
//     build(mid+1,r,rt<<1|1);
//     push_up(rt);
// }

// //求解一个区间的sum值，写一个函数query
// int query(int L,int R,int l,int r,int rt){//我需要查询的区间是[L,R],我当前的区间是（l,r),当前的结点是rt
//     if(L<=l&&R>=r){
//         //这个含义是：我所递归到的区间，在我查询区间的里面，那么这个低估区间当前的结点的sum值直接返回，因为这个值一定是所需要的，不需要再往下做无用的查询了。。。
//         return sum[rt];
//     }
//     int ans=0;
//     int mid=(l+r)>>1;
//     if(L<=mid){
//         ans+=query(L,R,l,mid,rt<<1);
//     }
//     if(R>mid){
//         ans+=query(L,R,mid+1,r,rt<<1|1);
//     }
//     return ans;
// }

// void update(int L,int R,int val,int l,int r,int rt){//全部使用区间修改的方法,修改区间为[L,R]
//     if(L<=l&&R>=r){
//         sum[rt]+=val;
//         return;
//     }
//     int mid=(l+r)>>1;
//     if(L<=mid){
//         update(L,R,val,l,mid,rt<<1);
//     }
//     if(R>mid){
//         update(L,R,val,mid+1,r,rt<<1|1);
//     }
//     push_up(rt);
// }

// int main(){
//     int n,q;
//     cin>>n;
//     for(int i=1;i<=n;i++){
//         cin>>a[i];
//     }
//     build(1,n,1);
//     int m;
//     // int ans=query(1,n,1,n,1);
//     // cout<<ans<<endl;
//     cin>>m;
//     for(int i=0;i<m;i++){
//         int l,r,v;
//         cin>>l>>r>>v;
//         update(l,r,v,1,n,1);
//         cout<<"Ok"<<endl;
//         int ans=query(1,n,1,n,1);
//         cout<<ans<<endl;
//     }

// }
//线段树模板：
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;

const int maxn=1e5+10;
typedef long long ll;

int a[maxn];

struct node{
    int l,r;
    ll sum,lazy;//lazy的意思就是有的时候区间更改，只需要改需要修改的一段区间，eg.[1,3]只需修改范围为[1,3]的结点，下面的结点不需要修改，因为你之后不需要访问下面的结点内容的，下面的区间是不需要修改的。。。
    void update(ll x){
        sum+=1ll*(r-l+1)*x;
        lazy+=x;
    }
}tree[maxn<<2];

void push_up(int x){
    tree[x].sum=tree[x<<1].sum+tree[x<<1|1].sum;//做儿子和与右儿子的和。。。
}

void push_down(int x){
    int lazyval=tree[x].lazy;
    if(lazyval){
        tree[x<<1].update(lazyval);
        tree[x<<1|1].update(lazyval);
        tree[x].lazy=0;
    }
}

void build(int x,int l,int r){//x是当前结点的编号。。。l,r是区间范围
    tree[x].l=l;
    tree[x].r=r;
    tree[x].sum=tree[x].lazy=0;
    if(l==r){
        tree[x].sum=a[l];
        return ;
    }else{
        int mid=(l+r)>>1;
        build(x<<1,l,mid);
        build(x<<1|1,mid+1,r);
        push_up(x);
    }
}

void update(int x,int l,int r,ll val){//注意这里的l,r是需要更新的范围
    int L=tree[x].l,R=tree[x].r;//这个L，R是结点当前的[L，R]管辖的范围
    if(l<=L&&r>=R){//直接更新
        tree[x].update(val);
        return;
    }else{
        //先将信息传下去
        push_down(x);
        int mid=(L+R)>>1;
        if(mid>=l){
            update(x<<1,l,r,val);//注意这个是l,r表示的是需要查找的范围。。。这个需要查找的范围是不能够改变的。。。
        }
        if(r>mid){
            update(x<<1|1,l,r,val);
        }
        push_up(x);
    }
}

ll query(int x,int l,int r){
    int L=tree[x].l,R=tree[x].r;
    if(l<=L&&R<=r){//x的区间都是从到小的if
        return tree[x].sum;
    }else{
        push_down(x);//需要查询某一个区间先push_down一下，这一步一定要有，因为有肯能之前更新的时候，需要查询的这一段区间没有更新，但是现在需要查询这一段了，那么我们一定要先更新一下，然后再进行查询操作。。。
        ll ans=0;
        int mid=(L+R)>>1;
        if(mid>=l){
            ans+=query(x<<1,l,r);
        }
        if(mid<r){
            ans+=query(x<<1|1,l,r);
        }
        push_up(x);
        return ans;
    }
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    build(1,1,n);
    int m;
    scanf("%d",&m);
    for(int i=0;i<m;i++){
        int l,r,v;
        scanf("%d%d%d",&l,&r,&v);
        update(1,l,r,v);
        printf("%lld\n",query(1,l,r));
    }
    return 0;
}

 

 

石子合并：virtual judge搜一下题目/洛谷P1880

直线问题：

//直线问题：
#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<vector>
#include<cmath>
#include<map>
#include<cstdlib>
#include<sstream>
#include<set>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int>PII;
typedef pair<ll,ll>PLL;
#define make_pair mkp;

int dp1[400][400];//求解最小值的，，，，
int dp2[441][441];//求解最大值得。。。
int a[441];
int sum[441];
int main(){
    int n;
    //while(cin>>n){
    cin>>n;
        memset(dp1,0x3f,sizeof(dp1));
        memset(dp2,-1,sizeof(dp2));
        for(int i=1;i<=n;i++){
            cin>>a[i];
        }
        memset(sum,0,sizeof(sum));
        //sum[0]=a[0];
        for(int i=1;i<=n;i++){
            sum[i]=sum[i-1]+a[i];//求解前缀和。。。
            //cout<<sum[i]<<endl;
        }
        for(int i=1;i<=n;i++){
            dp1[i][i]=0;
            dp2[i][i]=0;
        }
        for(int len=1;len<n;len++){
            for(int i=1;i+len<=n;i++){
                int j=i+len;
                //dp1[i][j]=1e9;
                for(int k=i;k<j;k++){
                    dp1[i][j]=min(dp1[i][j],dp1[i][k]+dp1[k+1][j]+sum[j]-sum[i-1]);//当前以k为分割点进行分割求解。。。
                    dp2[i][j]=max(dp2[i][j],dp2[i][k]+dp2[k+1][j]+sum[j]-sum[i-1]);
                }
            }
        }
        cout<<dp1[1][n]<<endl;
        cout<<dp2[1][n]<<endl;
    //}


    return 0;
}

曲线问题：

//曲线问题石子合并
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<string>
#include<cstring>
#include<numeric>
#include<vector>
#include<map>
#include<queue>
#include<set>
#include<cmath>
using namespace std;
typedef long long ll;
typedef pair<int,int>PII;
typedef pair<ll,ll>PLL;

//这一题是石子合并问题的延伸版本。。。注意一定不要忘记去环的情况。。。

//注意与直线是类似的，只不过是将环展开就完事了。。。
int dp1[450][450];//求解最小值
int dp2[400][450];//求解最大值
int sum[450];//维护一个前缀和。。。
int a[450];
int main(){
    int n;
    //while(cin>>n){
        cin>>n;
        memset(dp1,0x3f,sizeof(dp1));
        memset(dp2,-1,sizeof(dp2));
        memset(sum,0,sizeof(sum));
        for(int i=1;i<=n;i++){
            cin>>a[i];
        }
        for(int i=1;i<=n;i++){
            a[i+n]=a[i];
        }
        for(int i=1;i<=n*2;i++){
            dp1[i][i]=0;
            dp2[i][i]=0;
            sum[i]=sum[i-1]+a[i];//求解前缀和。。。
        }
        for(int len=1;len<=n;len++){
            for(int i=1;i+len<=2*n;i++){
                int j=i+len;
                for(int k=i;k<j;k++){
                    dp1[i][j]=min(dp1[i][j],dp1[i][k]+dp1[k+1][j]+sum[j]-sum[i-1]);
                    dp2[i][j]=max(dp2[i][j],dp2[i][k]+dp2[k+1][j]+sum[j]-sum[i-1]);
                }
            }
        }
        int res1=1e9;
        int res2=-1;
        for(int i=1;i<=n;i++){
            res1=min(res1,dp1[i][i+n-1]);
            res2=max(res2,dp2[i][i+n-1]);
        }
        cout<<res1<<endl;
        //cout<<res2<<endl;
    //}
    return 0;
}