【无标题】

树状数组

树状数组介绍：

​ 树状数组是把一个数组向上构造森林的方法，可以在单点修改与查询的时间复杂度是logn

a数组是原来的数组，而t数组是转化之后的树状数组。（注意，原数组与树状数组的下标都是从1开始的）

其代码如下所示：

#include<bits/stdc++.h>
using namespace std;
const int N;//N是原数组的大小
int n;
int tr[N];

int lowbit(int x){
    return x&-x;
}//寻找最后一个下标的位置

void add(int x,int v){
    for(int i=x;i<=n;i+= lowbit(i))
        tr[i]+=v;
}//单点修改，把原数组下标为x的值增加v

int query(int x){
    int res=0;
    for(int i=x;i;i-= lowbit(i)){
        res+=tr[i];
    }
    return res;
}//查询和，查询下标为1到下标为x的值
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        int x;
        cin>>x;
        add(i,x);
    }//初始化
}

例题1：多次单点修改查询：P3374 【模板】树状数组 1 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

//经过分析，如果每次修改值的时候查询值的时间复杂度非常高，但是使用树状数组的时候时间复杂度会大幅度降低，于是使用树状数组比较好点
#include<bits/stdc++.h>
using namespace std;
const int N = 5e5;
int n,m;
int tr[N+1];
int lowbit(int x){
    return x&-x;
}//寻找最后一个下标的位置

void add(int x,int v){
    for(int i=x;i<=n;i+= lowbit(i))
        tr[i]+=v;
}//单点修改，把原数组下标为x的值增加v

int query(int x) {
    int res = 0;
    for (int i = x; i > 0; i -= lowbit(i)) {
        res += tr[i];
    }
    return res;
}//查询和，查询下标为1到下标为x的值

int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        int x;
        cin>>x;
        add(i,x);
    }//初始化
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        if(a==1){
            add(b,c);
        }else{
            cout<<query(c)-query(b-1)<<endl;//类似于前缀和求区间和
        }
    }
}

进一步思考，我们知道差分和是单点值的查询，比如a={0,1,2,3,4},di={0,1,1,1,1},那么如果要求第3个值的大小只需要在差分数组中的前三个元素加一起就行了。

那么如果把原数组的差分数组存入树状数组中，就可以查询单点值，并且也是高效的，因为query本身就是对区间和进行查询，如果不规定开始那么就是从开头进行查询数组的和，于是可以直接求解单点值。

例题2：差分树状数组多次修改区间查询单点值：P3368 【模板】树状数组 2 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include<bits/stdc++.h>
using namespace std;
const int N = 500010;
int n,m;
int tr[N];
int lowbit(int x){
    return x&-x;
}//寻找最后一个下标的位置

void add(int x,int v){
    for(int i=x;i<=n;i+= lowbit(i))
        tr[i]+=v;
}//单点修改，把原数组下标为x的值增加v

int query(int x) {
    int res = 0;
    for (int i = x; i > 0; i -= lowbit(i)) {
        res += tr[i];
    }
    return res;
}//查询和，查询下标为1到下标为x的值

int main(){
    cin>>n>>m;
    vector<int> v(n+1),pre(n+2);
    for(int i=1;i<=n;i++)cin>>v[i];
    for(int i=1;i<=n;i++){
        pre[i]=v[i]-v[i-1];
    }
    for(int i=1;i<=n;i++){
        add(i,pre[i]);
    }//初始化
    while(m--){
        int x;
        cin>>x;
        if(x==1){
            int a,b,c;
            cin>>a>>b>>c;
            add(a,c);
            add(b+1,-c);
        }
        else{
            int a;
            cin>>a;
            cout<<query(a)<<endl;
        }
    }
}

除此之外，树状数组在计算排列中逆序对个数的时候也很有用，但注意，只能计算排列中的逆序对（逆序对的定义是i<j&&a[i]>a[j]这是一组逆序对）

3715. 最少交换次数 - AcWing题库

这是一道求逆序对个数的的题目，十分简单可以想到暴力的方法，遍历两边数组来判断逆序对个数，时间复杂度是O(n^2)，如果用树状数组就可以把复杂度优化到O(nlog2n)来判断，那么就可以大大1降低时间复杂度。代码如下

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define pq priority_queue<int>
#define rep(i,a,n) for(int i=a;i<n;i++)
#define debug1(x) cout<<x<<endl;
#define debug2(a,b) cout<<a<<" "<<b<<endl;
const int INF = 0x3f3f3f3f;//无穷大
const int inf = 0xc0c0c0c0;//无穷小
const int MOD = 1;
const int N = 1e5;

int n;
int tr[N],ans[N];
int lowbit(int x){
    return x&-x;
}
void add(int x,int v){
    for(int i=x;i<=n;i+= lowbit(i))
        tr[i]+=v;
}

int query(int x){
    int res=0;
    for(int i=x;i;i-= lowbit(i)){
        res+=tr[i];
    }
    return res;
}

void ChiefNing()
{
    cin>>n;
    int sum=0;
    for(int i=0;i<n;i++){
        int x;
        cin>>x;
        ans[x]=query(n)- query(x);//这里相当于算x之前有多少个比他大的数，当然不包括x，所以不用x-1。
        sum+=ans[x];//这里计算逆序对个数，并且要注意，逆序对个数是交换的最小次数。
        add(x,1);//当x计算完之后需要在树状数组中的x加上1从而完成任务
    }
    for(int i=1;i<=n;i++){
        cout<<ans[i]<<" ";
    }
    cout<<endl<<sum<<endl;
}

signed main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

        ChiefNing();
    return 0;
}

之后补充一道codeforces的逆序对题目（一道1600分的，如果不会算法思路非常好想，但是暴力过不了）

Problem - D - Codeforces

直接附上代码

#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
const int N = 1e5;
int n;
int tr1[N];
int lowbit(int x){
    return x&-x;
}
void add1(int x,int v){
    for(int i=x;i<=n;i+= lowbit(i))
        tr1[i]+=v;
}
 
int query1(int x){
    int res=0;
    for(int i=x;i;i-= lowbit(i)){
        res+=tr1[i];
    }
    return res;
}
 
void ChiefNing()
{
    cin>>n;
    vector<int> a(n),b(n),c(n),d(n);
    for(int i=0;i<n;i++){
        cin>>a[i];
        c[i]=a[i];
    }
    for(int i=0;i<n;i++){
        cin>>b[i];
        d[i]=b[i];
    }
    //只需要分析l l+1 p p+1交换之后是否可以完成所需即可
    //所以只需要判断两者操作次数和是否是偶数，什么意思呢？相当于如果一个是奇数，另一个是偶数，那么必不能相互抵消，如果同为奇数或者偶数，次数小的那一方可以完成2n次来完成自我交换。
    sort(c.begin(),c.end());
    sort(d.begin(),d.end());
    for(int i=0;i<n;i++){
        if(d[i]!=c[i]){
            cout<<"NO"<<endl;
            return ;
        }
    }
    map<int,int> mp;
    mp[c[0]]=1;
    for(int i=1;i<n;i++){
        mp[c[i]]=mp[c[i-1]]+1;
    }
    for(int i=0;i<n;i++){
        a[i]=mp[a[i]];
        b[i]=mp[b[i]];
    }//把原数组转化为一个排列
    int s1=0,s2=0;
     //之后就是和上面的板子题一模一样的方法了
    memset(tr1,0,sizeof(tr1));
    for(int i=0;i<n;i++){
        s1+=(query1(n)-query1(a[i]));
        add1(a[i],1);
    }
     
    memset(tr1,0,sizeof(tr1));
    for(int i=0;i<n;i++){
        s2+=(query1(n)-query1(b[i]));
        add1(b[i],1);
    }
    int s=s1+s2;
    if(s%2==0)cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
     
}
 
int main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int _;
    cin>>_;
    while(_--)
        ChiefNing();
    return 0;
}