Algorithm Fenwick树的实现

#include <bits/stdc++.h>

using namespace std;

vector <long long int> update(int x,long long int val,vector <long long int> b,int n)
{
    b[x]+=(val);
    x+=(x&-x);
    while(x<=n)
    {
        b[x]+=(val);
        x+=(x&-x);
    }
    return b;
}

long long int getsum(int i,int j,vector <long long int> b)
{
    i=i-1;
    long long int sum1=b[i];
    i-=(i&-i);
    while(i>0)
    {
        sum1+=(b[i]);
        i-=(i&-i);
    }
    long long int sum2=b[j];
    j-=(j&-j);
    while(j>0)
    {
        sum2+=b[j];
        j-=(j&-j);
    }
    return(sum2-sum1);
}

int main()
{
    int n,q;
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin>>n>>q;
    vector <int> h(n);
    for(int i=0;i<n;i++)
    {
        cin>>h[i];
    }
    vector <long long int> a(n);
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    vector <int> Pl(n,-1);
    vector <int> Pr(n,-1);
    stack <int> s;
    s.push(0);
    for(int i = 1; i < n; i++)
    {
    
        if (s.empty())
        { 
            s.push(i);
            continue; 
        } 
        while (s.empty() == false && h[s.top()] < h[i]) 
        {          
            Pl[s.top()] = i;
            s.pop(); 
        }
        s.push(i); 
    }
    while(s.empty()==false)
    {
        s.pop();
    }
    
    s.push(n-1);
    // iterate for rest of the elements 
    for(int i = n-2; i >= 0; i--)
    {
        if (s.empty())
        { 
            s.push(i);
            continue; 
        }
        while (s.empty() == false && h[s.top()] < h[i]) 
        {          
            Pr[s.top()] = i;
            s.pop(); 
        } 
        s.push(i); 
    }
    while(s.empty()==false)
    {
        s.pop();
    }
    vector <pair <int,int>> timel(n);
    vector <int> arrayl;
    s.push(0);
    int t = 1;
    timel[0].first = t;
    t++;
    arrayl.push_back(0);
    arrayl.push_back(a[0]);
    int i = 1;
    while(i<n)
    {
        if(s.empty())
        {
            s.push(i);
            timel[i].first = t;
            t++;
            arrayl.push_back(a[i]);
            i++;
            if(i==n)
                break;
        }
        if(h[i]<h[s.top()])
        {
            s.push(i);
            timel[i].first = t;
            t++;
            arrayl.push_back(a[i]);
            i++;
        }
        else
        {
            timel[s.top()].second = t;
            t++;
            arrayl.push_back(-a[s.top()]);
            s.pop();
        }
    }
    while(s.empty()==false)
    {
        timel[s.top()].second = t;
        t++;
        arrayl.push_back(-a[s.top()]);
        s.pop();
    }
    vector <pair <int,int>> timer(n);
    vector <int> arrayr;
    s.push(n-1);
    t = 1;
    timer[n-1].first = t;
    t++;
    arrayr.push_back(0);
    arrayr.push_back(a[n-1]);
    i = n-2;
    while(i>=0)
    {
        if(s.empty())
        {
            s.push(i);
            timer[i].first = t;
            t++;
            arrayr.push_back(a[i]);
            i--;
            if(i==0)
                break;
        }
        if(h[i]<h[s.top()])
        {
            s.push(i);
            timer[i].first = t;
            t++;
            arrayr.push_back(a[i]);
            i--;
        }
        else
        {
            timer[s.top()].second = t;
            t++;
            arrayr.push_back(-a[s.top()]);
            s.pop();
        }
    }
    while(s.empty()==false)
    {
        timer[s.top()].second = t;
        t++;
        arrayr.push_back(-a[s.top()]);
        s.pop();
    }
    vector <long long int> bitr(arrayr.size(),0);
    vector <long long int> bitl(arrayl.size(),0);
    for(int i=1;i<arrayl.size();i++)
    {
        bitl = update(i,arrayl[i],bitl, arrayl.size()-1);
        bitr = update(i,arrayr[i],bitr, arrayr.size()-1);
    }
    for(int i=0;i<q;i++)
    {
        int type;
        cin>>type;
        if(type==2)
        {
            int s,d;
            cin>>s>>d;
            s--;
            d--;
            int x = s;
            int y = d;
            if(s>d)
            {
                while (Pl[x] != Pl[y])
                {
                    if (x < y)
                        x = Pl[x];
                    else
                        y = Pl[y];
                }
                if(x != s)
                {
                    cout<<-1<<endl;
                }
                else
                {
                    long long int ans = getsum(timer[s].first,timer[d].first,bitr);
                    cout<<ans<<endl;
                }
            }
            else
            {
                while (Pr[x] != Pr[y])
                {
                    if (x > y)
                        x = Pr[x];
                    else
                        y = Pr[y];
                }
                if(y != s)
                {
                    cout<<-1<<endl;
                }
                else
                {
                    long long int ans = getsum(timel[s].first,timel[d].first,bitl);
                    cout<<ans<<endl;
                }
            }
        }
        else
        {
            int s,k;
            cin>>s>>k;
            long long int val = k-a[s-1];
            bitl = update(timel[s-1].first,val,bitl,arrayl.size()-1);
            bitl = update(timel[s-1].second,-val,bitl,arrayl.size()-1);
            bitr = update(timer[s-1].first,val,bitr,arrayr.size()-1);
            bitr = update(timer[s-1].second,-val,bitr,arrayr.size()-1);
            a[s-1] = k;
        }
    }
    return 0;
}

#包括
使用名称空间std；
向量更新（整数x，长整数val，向量b，整数n）
{
b[x]+=（val）；
x+=（x&-x）；
while（x0）
{
sum1+=（b[i]）；
i-=（i&-i）；
}
长整型sum2=b[j]；
j-=（j&-j）；
而（j>0）
{
sum2+=b[j]；
j-=（j&-j）；
}
返回（sum2-sum1）；
}
int main（）
{
int n，q；
ios_base:：与_stdio同步（false）；
cin.tie（空）；
cin>>n>>q；
向量h（n）；
对于（int i=0；i>h[i]；
}
向量a（n）；
对于（int i=0；i>a[i]；
}
向量Pl（n，-1）；
载体Pr（n，-1）；
堆栈s；
s、 推（0）；
对于（int i=1；i=0；i--）
{
如果（s.empty（））
{ 
s、 推（i）；
继续；
}
而（s.empty（）==false&&h[s.top（）]虽然（iin update中，您正在逐个副本传递整个树，并返回另一个副本-->浪费大量时间，而不是按引用传递树并生成函数void@Photon：我尝试过这样做，但仍然没有解决问题。在更新中，您正在逐个副本传递整个树并返回另一个副本-->浪费大量时间，而不是按引用传递树并生成函数在…上void@Photon当前位置我尝试过这样做，但仍然没有解决问题。