树状数组专题

折叠

区间修改，区间查询，这一类题通常都可以使用线段树解决，但对于此题，树状数组同样可以，而且常数较小，代码简单。
思路：
考虑使用树状数组去维护差分数组，即对于$a_i$,我们使用树状数组去维护$|a_i-a_{i-1}|$的值。
对于修改，我们对一段区间进行修改的时候，能对结果产生影响的只有左右端点，因为绝对值之差相互抵消了。
所以我们考虑修改时，端点的影响即可。
对于$a_l$,若$a_{l-1}\le a_l$，那么我们在对$a_l$进行加一后，我们会发现，$|a_l-a_{l-1}|$的值同样会加一，所以我们正常给$a_l$加一即可。
反之，$a_{l-1}>a_l$,那么在给$a_l$加一的时候，$|a_l-a_{l-1}|$的值会减小，所以此时我们需要给该值减一。
对于$r,r+1$位置的分析同理。
同时，又因为查询需要输出$a_l$的值，所以我们再开一个树状数组去单独维护每个值的大小即可。

#include 

using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 1e9+7;
const int maxv = 4e6 + 5;
// #define endl "\n"

struct MIT
{
ll tr[N];
int lowbit(int x) {
    return x & (-x);
}

void add(int u, int v) {
    for (int i = u; i < N; i += lowbit(i)) {
        tr[i] += v;
    }
}

ll query(int x) {
    ll res = 0;

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

    return res;
}
};

MIT t1,t2;

void solve()
{
	int n,q;
	cin>>n>>q;
	vector<int> a(n+5);
	for(int i=1;i<=n;i++){
		cin>>a[i];
		t1.add(i,a[i]-a[i-1]);
		t2.add(i,abs(a[i]-a[i-1]));
	}
	while(q--){
		int op,l,r;
		cin>>op>>l>>r;
		if(op==1){
			cout<<t1.query(l)+t2.query(r)-t2.query(l)<<endl;
		}
		else{
			ll c1=t1.query(l-1),c2=t1.query(l);
			if(c2-c1>=0) t2.add(l,1);
			else t2.add(l,-1);
			c1=t1.query(r),c2=t1.query(r+1);
			if(c2-c1>0) t2.add(r+1,-1);
			else t2.add(r+1,1);
			t1.add(l,1),t1.add(r+1,-1);
		}
	}
}

int main()
{
    ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;

	while(t--){
		solve();
	}
   	system("pause");
    return 0;
}

Mex and Update

问题陈述

给你一个长度为 $N$ 的序列 $A=(A_1,A_2,\dots ,A_N)$。
请按给出的顺序回答下列 $Q$ 个问题。

$k$个查询按以下格式给出：

• 首先，将$A_{i_k}$改为$x_k$。这一改动将带入后续查询。
• 然后，打印$A$的$\mathrm{mex}$。
  • $A$的$\mathrm{mex}$是不包含在$A$中的最小非负整数。

可以说一道典题，收获不小。有两种思路：第一种就是set，第二种就是树状数组，两种方法接下来都会介绍。

set做法
我们使用set去记录序列中没有出现过的数，那么这样对于每次查询而言，我们输出set的第一个元素即可。同时，我们使用$cnt$数组去维护每个数在序列中的出现次数，然后每次修改时去$cnt$数组中对应删除或是添加。
对于删除操作，若该元素删去一次后变为 0 ，即代表这个数不存在于序列中了，所以需要放入 set ；
对于添加操作，若该元素添加后次数变为1，即代表该数第一次出现在序列中（即之前不存在于序列中，存在于set中），所以此时需要把这个数从set中删除即可。
时间复杂度：$qlogn$

#include 

using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 1e9+7;
const int maxv = 4e6 + 5;
// #define endl "\n"



void solve()
{
	int n,q;
	cin>>n>>q;
	set<int> s;
	map<int,int >mp;//不使用map，使用正常数组即可。
	vector<int> a(n+5);
	for(int i=1;i<=n;i++){
		cin>>a[i];
		mp[a[i]]++;
	}
	for(int i=0;i<=n;i++){
		if(!mp.count(i)) s.insert(i);
	}
	while(q--){
		int id,x;
		cin>>id>>x;
		if(mp[a[id]]){
			mp[a[id]]--;
			mp[x]++;
			if(mp[x]==1) s.erase(x);
			if(mp[a[id]]==0){
				s.insert(a[id]);
			}
			a[id]=x;
		}
		cout<<*s.begin()<<endl;
	}
	

}

int main()
{
    ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		solve();
	}
   	system("pause");
    return 0;
}

树状数组
思路：我们考虑将每个元素放入树状数组中，即将值域映射到下标，通过0/1去判断这个数是否存在。经过上述操作后，我们对于mex的判断为：因为树状数组返回的是$1-i$的前缀和，即对于第 i 个数，我们可以知道前面有多少个比 i 小的数，那么我们可以在树状数组上进行二分（前缀和保证了单调性），找到第一个下标大于其对应值的地方，即为mex。
时间复杂度：$q\times (logn{)}^2$
细节有点多，具体看代码注释。

#include 

using namespace std;
const int N = 4e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 1e9+7;
const int maxv = 4e6 + 5;
// #define endl "\n"

int n,q;

vector<int> a(N),b(N);

struct MIT
{
ll tr[N];
int lowbit(int x) {
    return x & (-x);
}

void add(int u, int v) {
    for (int i = u; i < N; i += lowbit(i)) {
        tr[i] += v;
    }
}

ll query(int x) {
    ll res = 0;

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

    return res;
}
};
MIT c;

int cal()//树状数组二分过程
{
	int l=1,r=n+1,ans=0;
	while(l<=r){
		int mid=(l+r)/2;
		if(c.query(mid)==mid){
			ans=mid;
			l=mid+1;
		}
		else r=mid-1;
	}
	return ans;
}

void solve()
{
	cin>>n>>q;
	for(int i=1;i<=n;i++) cin>>a[i],a[i]++;//把每个元素加1，因为树状数组不能为0
	for(int i=1;i<=n;i++){
		if(a[i]<=n+1){//如果当前数大于n,那么放入树状数组就没有意义了，因为mex只能为0-n之间
			if(b[a[i]]==0){//如果这个数没有出现过，我们就进行添加
				c.add(a[i],1);
			}
			b[a[i]]++;//记录该数的出现次数
		}
	}
	while(q--){
		ll id,x;
		cin>>id>>x;
		x++;
		if(a[id]<=n+1){//同理
			if(b[a[id]]==1) c.add(a[id],-1);
			//如果当前数的次数为1，即删一次为0，即我们修改后这个数不存在了，所以就需要把这个数从树状数组中删除
			b[a[id]]--;
		}
		if(x<=n+1){//同理
			if(b[x]==0) c.add(x,1);
			b[x]++;
		}
		a[id]=x;//把当前数的值修改为x
		cout<<cal()<<endl;
	}
	

}

int main()
{
    ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	//cin>>t;
	while(t--){
		solve();
	}
   	system("pause");
    return 0;
}

由于set的做法写的不是很好，导致set的运行时间比树状数组还长…

大风起兮

简化一下题意，给定一个数组，有$q$次操作，每次操作选择一个编号为$x$的元素删除，要求输出每次操作的中位数。

思路
考虑树状数组在这题中如何进行应用，我们同样把值域映射到下标，去统计对于第 i 个数，其前面有多少个比他小的数。然后运用二分去找值为$n/2$的下标即为所求。

因为值域很大所以需要进行离散化。

#include 

using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 1e9+7;
const int maxv = 4e6 + 5;
// #define endl "\n"

struct MIT
{
ll tr[N];
int lowbit(int x) {
    return x & (-x);
}

void add(int u, int v) {
    for (int i = u; i < N; i += lowbit(i)) {
        tr[i] += v;
    }
}

ll query(int x) {
    ll res = 0;

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

    return res;
}
};

int n,q;
int a[N];
MIT tr;

int cal(int x)
{
	int l=1,r=N,ans=0;
	while(l<=r){
		int mid=(l+r)/2;
		if(tr.query(mid)>=x){
			r=mid-1;
			ans=mid;
		}
		else l=mid+1;
	}
	return ans;
}

void solve()
{
	cin>>n;
	vector<int> b;
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
		b.push_back(a[i]);
	}
	b.push_back(0);
	sort(b.begin(),b.end());
	b.erase(unique(b.begin(),b.end()),b.end());//离散化不多说了
	for(int i=1;i<=n;i++){
		int t=lower_bound(b.begin(),b.end(),a[i])-b.begin();
		a[i]=t;
		tr.add(t,1);
	}
	int q;
	cin>>q;
	while(q--){
		int x;
		cin>>x;
		x=a[x];
		tr.add(x,-1);
		n--;
		if(n%2==0){
			double ans=(b[cal(n/2)]+b[cal(n/2+1)])*1.0/2;
			printf("%.1lf ",ans);
		}
		else{
			double ans=b[cal((n+1)/2)]*1.0;
			printf("%.1lf ",ans);
		}
	}
	//cout<
}

int main()
{
	int t;
	t=1;
	while(t--){
		solve();
	}
   	//system("pause");
    return 0;
}