分块九题

最新推荐文章于 2020-10-28 14:41:02 发布
最新推荐文章于 2020-10-28 14:41:02 发布
阅读量224 收藏 1
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45916935/article/details/108653716
版权

爆肝一天，终于写完了

分块入门

由于后半部分参考了dalao的博客，于是码风较前边有点区别

第一题

区间修改单点查询

讲真这题可以用CDQ分治写，而且通俗易懂，但这篇讲的是分块，所以我们只是贴一下代码：

CDQ分治版：

#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
const int N = 1000010;
struct nod
{
    ll x , y;
    int id;
} p[N] , tmp[N];
ll ans[N] , num[N] , tot;
int n , m ;
ll a[N];
int c;
void solve(int l , int r)
{
    if(l >= r) return;
    int mid = (l + r) >> 1 , i = l , j = mid + 1 , k = 0 , sum = 0;
    solve(l , mid) ; solve(mid + 1 , r);
    while(i <= mid && j <= r)
    {
        if(p[i].x <= p[j].x)
        {
            if(!p[i].id)
                sum += p[i].y;
            tmp[k++] = p[i++];
        }
        else
        {
            if(p[j].id)
                ans[p[j].id] += sum;
            tmp[k++] = p[j++];
        }
    }
    while(i <= mid) tmp[k++] = p[i++];
    while(j <= r)
    {
        if(p[j].id)
            ans[p[j].id] += sum;
        tmp[k++] = p[j++];
    }
    for(int i = 0 ; i < k ; i++) p[l + i] = tmp[i];
}
int main()
{
    scanf("%d%d" , &n , &m);
    for(int i = 1 ; i <= n ; i++) cin >> a[i];
    int cnt = 0;
    for(int i = 1 , l , r , d ; i <= m ; i++)
    {
        cin >> c;
        if(c == 1)
        {
            cin >> l >> r >> d;
            p[++cnt].x = l ; p[cnt].y = d ; p[cnt].id = 0;
            p[++cnt].x = r + 1 ; p[cnt].y = -d ; p[cnt].id = 0;
        }
        else
        {
            cin >> l;
            p[++cnt].x = l ; p[cnt].id = ++tot ; num[tot] = l;
        }
    }
    solve(1 , cnt);
    for(int i = 1 ; i <= tot ; i++) printf("%d\n" , ans[i] + a[num[i]]);
    return 0;
}

回到正题，这题用对于每一块维护一个延迟标记(add)，如果是在修改时覆盖了整一个块，那我们就只对标记进行修改，块内的值我们暂时不处理

对于区间两侧不完整的块我们暴力修改内部，不更新相应的延迟标记

code:

#include<iostream>
#include<cstdio>
#include<cmath> 
using namespace std;
const int N = 50010;
struct block
{
	int l , r , add;
} q[N];
int n , LEN;
int a[N] , belong[N];
int main()
{
	scanf("%d" , &n);
	LEN = sqrt(n);
	int cnt = 0;
	for(int L = 1 , R ; L <= n ; L++)
	{
		R = L + LEN - 1;
		q[++cnt].l = L , q[cnt].r = R;
		q[cnt].add = 0;
		L = R;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		scanf("%d" , &a[i]);
		belong[i] = (i - 1) / LEN + 1;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		int opt , L , R , c;
		scanf("%d%d%d%d" , &opt , &L , &R , &c);
		R = min(R , n);
		if(opt == 0)
		{
			if(belong[L] == belong[R])
			{
				for(int i = L ; i <= R ; i++) a[i] += c; continue;
			} 
			int k = belong[L];
			for(int i = L ; i <= q[k].r ; i++) a[i] += c;
			k = belong[R];
			for(int i = q[k].l ; i <= R ; i++) a[i] += c;
			for(int i = belong[L] + 1 ; i <= belong[R] - 1 ; i++) q[i].add += c;
		}
		else
			printf("%d\n" , a[R] + q[belong[R]].add);
	}
	return 0;
}

第二题

区间修改+区间内小于某个数的个数

由小于二字想到块内二分，观察数据范围发现可行

对于每个块维护块内有序数组a以及原来的数组num（当时写的时候脑抽还多写了一个data来存一开始的数据，其实是不需要的），由于是区间加法，我们仿照上一题添加一个延迟标记

对于查询，两侧不完整的块暴力枚举判断即可，而对于完整的块，我们对块内元素二分（注意要减去这个块上的延迟标记），最后得到的下标即为我们找到的个数

对于修改，两侧不完整的块枚举处理完后还要维护相应块内的有序数组，而中间完整的则直接更新延迟标记即可

code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
const int N = 100010 , M = 1010;
struct block
{
	int l , r , add;
	ll a[M] , len;
	ll num[M];
	int find(int x)
	{
		int L = 1 , R = len , mid , best = -1;
		while(L <= R)
		{
			mid = (L + R) >> 1;
			if(a[mid] < x)
			{
				best = mid;
				L = mid + 1;
			}else R = mid - 1;
		}return best;
	}
	void iint()
	{
		for(int i = 1 ; i <= len ; i++) a[i] = num[i];
		sort(a + 1 , a + len + 1);
	}
} q[N];
int LEN;
ll data[N] , bel[N] , n;
int main()
{
	scanf("%d" , &n);
	LEN = sqrt(n);
	int cnt = 0;
	for(int L = 1 , R ; L <= n ; L++)
	{
		R = L + LEN - 1;
		q[++cnt].l = L , q[cnt].r = R;
		q[cnt].add = q[cnt].len = 0;
		L = R; 
	}
	for(int i = 1 ; i <= n ; i++)
	{
		scanf("%lld" , &data[i]);
		bel[i] = (i - 1) / LEN + 1;
		q[bel[i]].num[++q[bel[i]].len] = data[i];
	}
	for(int i = 1 ; i <= cnt ; i++) q[i].iint();
	for(int i = 1 ; i <= n ; i++)
	{
		ll opt , L , R , c;
		scanf("%lld%lld%lld%lld" , &opt , &L , &R , &c);
		if(opt == 0)
		{
			if(bel[L] == bel[R])
			{
				int k1 = (L - 1) % LEN + 1 , k2 = (R - 1) % LEN + 1;
				for(int i = k1 ; i <= k2 ; i++)
					q[bel[L]].num[i] += c;
				q[bel[L]].iint();
				continue;
			}
			int k1 = (L - 1) % LEN + 1 , k2 = (R - 1) % LEN + 1;
			for(int i = k1 ; i <= LEN ; i++)
				q[bel[L]].num[i] += c;
			for(int i = 1 ; i <= k2 ; i++)
				q[bel[R]].num[i] += c;
			for(int i = bel[L] + 1 ; i <= bel[R] - 1 ; i++) q[i].add += c;
			q[bel[L]].iint() ; q[bel[R]].iint();
		}
		else
		{
			c = c * c;
			int k1 = (L - 1) % LEN + 1 , k2 = (R - 1) % LEN + 1 ;
			ll res = 0;
			if(bel[L] == bel[R])
			{
				for(int i = k1 ; i <= k2 ; i++) if(q[bel[L]].num[i] + q[bel[L]].add < c) res++;
				printf("%lld\n" , res);
				continue;
			}
			for(int i = k1 ; i <= LEN ; i++) if(q[bel[L]].num[i] + q[bel[L]].add < c) res++;
			for(int i = 1 ; i <= k2 ; i++) if(q[bel[R]].num[i] + q[bel[R]].add < c) res++;
			for(int i = bel[L] + 1 ; i <= bel[R] - 1 ; i++)
			{
				int x = q[i].find(c - q[i].add);
				if(x > 0) res += x;
			}
			printf("%lld\n" , res);
		}
	}
	return 0;
}

第三题

区间修改+查前驱

差前驱等价于求最大的小于某个数的元素

于是仿照第二题的做法即可

对于查询，不完整的块枚举更新，完整的则二分（还是要注意减去延迟标记）

修改几乎更第二题一样

code:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
const int N = 100010 , M = 350;
struct block
{
	int l , r , add;
	ll a[M];
	ll num[M] , len;
	ll find(int x)
	{
		int l = 1 , r = len , mid , best = 0;
		while(l <= r)
		{
			mid = (l + r) >> 1;
			if(a[mid] < x)
			{
				best = mid;
				l = mid + 1;
			}else r = mid - 1;
		}return a[best];
	}
	void iint()
	{
		for(int i = 1 ; i <= len ; i++) a[i] = num[i];
		sort(a + 1 , a + len + 1);
	}
} q[N]; 
int n , LEN , bel[N];

void updata(int L , int R , ll c)
{
	int k1 = (L - 1) % LEN + 1 , k2 = (R - 1) % LEN + 1;
	if(bel[L] == bel[R])
	{
		for(int i = k1 ; i <= k2 ; i++) q[bel[L]].num[i] += c;
		q[bel[L]].iint() ; return;
	}
	for(int i = k1 ; i <= LEN ; i++) q[bel[L]].num[i] += c;
	for(int i = 1 ; i <= k2 ; i++) q[bel[R]].num[i] += c;
	for(int i = bel[L] + 1 ; i < bel[R] ; i++) q[i].add += c;
	q[bel[L]].iint() ; q[bel[R]].iint();
}
void query(int L , int R , ll c)
{
	int k1 = (L - 1) % LEN + 1 , k2 = (R - 1) % LEN + 1 ;
	ll ans = -1;
	if(bel[L] == bel[R])
	{
		for(int i = k1 ; i <= k2 ; i++)
			if(q[bel[L]].num[i] + q[bel[L]].add < c)
				ans = max(ans , q[bel[L]].num[i] + q[bel[L]].add);
		printf("%lld\n" , ans); return;
	}
	for(int i = k1 ; i <= LEN ; i++)
		if(q[bel[L]].num[i] + q[bel[L]].add < c) ans = max(ans , q[bel[L]].num[i] + q[bel[L]].add);
	for(int i = 1 ; i <= k2 ; i++)
		if(q[bel[R]].num[i] + q[bel[R]].add < c) ans = max(ans , q[bel[R]].num[i] + q[bel[R]].add);
	for(int i = bel[L] + 1 ; i < bel[R] ; i++)
	{
		ll res = q[i].find(c - q[i].add);
		if(res < c - q[i].add) ans = max(ans , res + q[i].add);
	}
	printf("%lld\n" , ans); return;
}
int main()
{
	scanf("%d" , &n);
	LEN = sqrt(n);
	int cnt = 0;
	for(int L = 1 , R ; L <= n ; L++)
	{
		R = min(L + LEN - 1 , n);
		q[++cnt].l = L , q[cnt].r = R;
		q[cnt].add = q[cnt].len = 0;
		q[cnt].a[0] = -1;
		L = R;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		ll x;
		scanf("%lld" , &x);
		bel[i] = (i - 1) / LEN + 1;
		q[bel[i]].num[++q[bel[i]].len] = x;
	}
	for(int i = 1 ; i <= cnt ; i++) q[i].iint();
	for(int i = 1 ; i <= n ; i++)
	{
		ll opt , L , R , c;
		scanf("%lld%lld%lld%lld" , &opt , &L , &R , &c);
		if(opt == 0)
			updata(L , R , c);
		else
			query(L , R , c);
	}
	return 0;
}

第四题

仿照第一题延迟标记，维护多一个块内的元素和

对于查询，不完整的标记下放，完整的直接塞元素和跟标记（记得乘块长）

code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
typedef long long ll;
const int N = 50010 , M = 310;
struct block
{
	int l , r;
	ll sum , add;
} q[N];
int n , LEN , bel[N];
ll a[N];
void updata(int L , int R , ll c)
{
	if(bel[L] == bel[R])
	{
		for(int i = L ; i <= R ; i++) a[i] += c;
		q[bel[L]].sum += c * (R - L + 1);
		return;
	}
	for(int i = L ; i <= q[bel[L]].r ; i++) a[i] += c;
	q[bel[L]].sum += c * (q[bel[L]].r - L + 1);
	for(int i = q[bel[R]].l ; i <= R ; i++) a[i] += c;
	q[bel[R]].sum += c * (R - q[bel[R]].l + 1);
	for(int i = bel[L] + 1 ; i < bel[R] ; i++) q[i].add += c;
}
void query(int L , int R , ll c)
{
	ll ans = 0;
	if(bel[L] == bel[R])
	{
		for(int i = L ; i <= R ; i++) ans = (ans + a[i] + q[bel[L]].add) % c;
		printf("%lld\n" , ans) ; return;
	}
	for(int i = L ; i <= q[bel[L]].r ; i++) ans = (ans + a[i] + q[bel[L]].add) % c;
	for(int i = q[bel[R]].l ; i <= R ; i++) ans = (ans + a[i] + q[bel[R]].add) % c;
	for(int i = bel[L] + 1 ; i < bel[R] ; i++)
		ans = (ans + q[i].sum + q[i].add * (q[i].r - q[i].l + 1)) % c;
	printf("%lld\n" , ans) ; return;
}
int main()
{
	scanf("%d" , &n);
	LEN = sqrt(n);
	int cnt = 0;
	for(int L = 1 , R ; L <= n ; L++)
	{
		R = L + LEN - 1; q[++cnt].l = L , q[cnt].r = min(R , n);
		q[cnt].add = q[cnt].sum = 0;
		L = R;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		scanf("%lld" , &a[i]);
		bel[i] = (i - 1) / LEN + 1;
		q[bel[i]].sum += a[i];
	}
	for(int i = 1 ; i <= n ; i++)
	{
		int opt , L , R;
		ll c;
		scanf("%d%d%d%lld" , &opt , &L , &R , &c);
		if(opt == 0)
			updata(L , R , c);
		else
			query(L , R , c + 1);
	}
	return 0;
}

第五题

区间元素开方+区间求和

仿照第四题

有个性质：

当x = 0或1时，对x开方还是x

于是再加多一个标记，若块内元素都是0和1时，修改操作直接跳过即可

修改则暴力枚举开方，再维护块内元素和

code：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
typedef long long ll;
const int N = 60010;
int a[N];
int bel[N] , n , LEN ;
struct block
{
	int l , r;
	int op ;
	int sum;
	bool check()
	{
		for(int i = l ; i <= r ; i++)
			if(a[i] > 1) return false;
		return true;
	}
} q[N];

void updata(int L , int R)
{
	if(bel[L] == bel[R])
	{
		if(q[bel[L]].op == 1) return;
		for(int i = L ; i <= R ; i++)
		{
			if(a[i] < 0) continue;
			q[bel[L]].sum -= a[i];
			a[i] = floor(sqrt(a[i]));
			q[bel[L]].sum += a[i];
		} 
		if(q[bel[L]].check()) q[bel[L]].op = 1;
		return;
	}
	if(!q[bel[L]].op)
	{
				
		for(int i = L ; i <= q[bel[L]].r ; i++)
		{
			if(a[i] < 0) continue;
			q[bel[L]].sum -= a[i]; a[i] = floor(sqrt(a[i]));
			q[bel[L]].sum += a[i];
		}
		if(q[bel[L]].check()) q[bel[L]].op = 1;
	}
	if(!q[bel[R]].op)
	{
		for(int i = q[bel[R]].l ; i <= R ; i++)
		{
			if(a[i] < 0) continue;
			q[bel[R]].sum -= a[i] ; a[i] = floor(sqrt(a[i]));
			q[bel[R]].sum += a[i];
		}
		if(q[bel[R]].check()) q[bel[R]].op = 1;
	}
	for(int i = bel[L] + 1 ; i < bel[R] ; i++)
	{
		if(q[i].op) continue;
		for(int j = q[i].l ; j <= q[i].r ; j++)
		{
			if(a[j] < 0) continue;
			q[i].sum -= a[j] ; a[j] = floor(sqrt(a[j]));
			q[i].sum += a[j];
		}if(q[i].check()) q[i].op = 1;
	}
}
void query(int L , int R)
{
	int ans = 0;
	if(bel[L] == bel[R])
	{
		for(int i = L ; i <= R ; i++) ans += a[i];
		printf("%d\n" , ans); return;
	}
	for(int i = L ; i <= q[bel[L]].r ; i++) ans += a[i];
	for(int i = q[bel[R]].l ; i <= R ; i++) ans += a[i];
	for(int i = bel[L] + 1 ; i < bel[R] ; i++)
		ans += q[i].sum;
	printf("%d\n" , ans);return;
}
int main()
{
//	freopen("a1.in" , "r" , stdin);
//	freopen("ans.out" , "w" , stdout); 
	scanf("%d" , &n);
	LEN = sqrt(n);
	int cnt = 0;
	for(int L = 1 , R ; L <= n ; L++)
	{
		R = min(L + LEN - 1 , n);
		q[++cnt].l = L , q[cnt].r = R ; 
		q[cnt].sum = q[cnt].op = 0;
		L = R;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		scanf("%d" , &a[i]);
		bel[i] = (i - 1) / LEN + 1;
		q[bel[i]].sum += a[i];
	}
	for(int i = 1 ; i <= n ; i++)
	{
		int opt , L , R , c;
		scanf("%d%d%d%d" , &opt , &L , &R , &c);
		if(opt == 0)
			updata(L , R);
		else 
			query(L , R);
	}
	return 0;
}

第六题

动态数组vector+分块重构

当某个块太长或者怎样怎样（随便啦~）时就重构

讲白了就是把数据拷贝一份，更新下块长，最后再一个个塞回去就行了

code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
typedef long long ll;
const int N = 100010 , M = 500010;
int a[M] ;
vector<int> v[N];
int LEN , n , m;

void build(int n)
{
	LEN = sqrt(n);
	m = (n - 1) / LEN + 1;
	for(int i = 1 ; i <= n ; i++) scanf("%d" , &a[i]);
	for(int i = 1 ; i <= n ; i++) v[(i - 1) / LEN + 1].push_back(a[i]);
}
pair<int , int> query(int b)
{
	int x = 1;
	while(b > v[x].size())
	{
		b -= v[x].size() ; x++;
	}
	return make_pair(x , b - 1);
}
void rebuild()
{
	int top = 0;
	for(int i = 1 ; i <= m ; i++)
	{
		for(vector<int> :: iterator it = v[i].begin() ; it != v[i].end() ; it++)
			a[++top] = *it;
		v[i].clear();
	}
	LEN = sqrt(top);
	for(int i = 1 ; i <= top ; i++)
		v[(i - 1) / LEN + 1].push_back(a[i]);
	m = (n - 1) / LEN + 1;
}
void Insert(int a , int b)
{
	pair<int , int> t = query(a);
	v[t.first].insert(v[t.first].begin() + t.second , b);
	
	if(v[t.first].size() > 20 * LEN) rebuild();
}

int main()
{
	scanf("%d" , &n);
	build(n);
	for(int i = 1 ; i <= n ; i++)
	{
		int opt , L , R , c;
		scanf("%d%d%d%d" , &opt , &L , &R , &c);
		if(opt == 0)
			Insert(L , R);
		else 
		{
			pair<int , int> t = query(R);
			printf("%d\n" , v[t.first][t.second]);
		}
	}
	return 0;
}

第七题

仿照第四题做法，只不过乘法跟加法分开成两个标记

由于a * c = ac，(a + m) * c = ac + mc

因此我们在进行乘法操作时是需要修改加法的标记的

对于不完整的块则需要将标记下放，再赋初值上去

code:

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 100010 , MOD = 10007;
struct block
{
	int l , r;
	int sum , mx;
} q[N];
int n , LEN;
int bel[N] , a[N];

void reset(int L)
{
	for(int i = q[bel[L]].l ; i <= q[bel[L]].r ; i++) a[i] = (a[i] * q[bel[L]].mx + q[bel[L]].sum) % MOD;
	q[bel[L]].sum = 0 , q[bel[L]].mx = 1;
}
void updata(int L , int R , int c , int opt)
{
	reset(L);
	for(int i = L ; i <= min(q[bel[L]].r , R) ; i++)
	{
		if(opt == 0)
			a[i] = (a[i] + c) % MOD;
		else a[i] = (a[i] * c) % MOD;
	}
	if(bel[L] != bel[R])
	{
		reset(R);
		for(int i = q[bel[R]].l ; i <= R ; i++)
			if(opt == 0) a[i] = (a[i] + c) % MOD;
			else a[i] = (a[i] * c) % MOD;
	}
	for(int i = bel[L] + 1 ; i < bel[R] ; i++)
		if(opt == 0)
			q[i].sum = (q[i].sum + c) % MOD;
		else
		{
			q[i].sum = (q[i].sum * c) % MOD;
			q[i].mx = (q[i].mx * c) % MOD;
		}
}
int main()
{
	scanf("%d" , &n);
	LEN = sqrt(n);
	int cnt = 0;
	for(int L = 1 , R ; L <= n ; L++)
	{
		R = L + LEN - 1;
		q[++cnt].l = L , q[cnt].r = min(R , n);
		q[cnt].sum = 0;
		q[cnt].mx = 1;
		L = R;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		scanf("%d" , &a[i]);
		bel[i] = (i - 1) / LEN + 1;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		int opt , L , R , c;
		scanf("%d%d%d%d" , &opt , &L , &R , &c);
		if(opt == 0 || opt == 1) updata(L , R , c , opt); 
		else printf("%d\n" , (a[R] * q[bel[R]].mx + q[bel[R]].sum) % MOD);
	}
	return 0;
}

第八题

仿照第五题，块内都是一个值时打标记，查询的时候直接用就行了

code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int N = 100010;
int a[N] , n , LEN;
int bel[N];
struct block
{
	int l , r;
	int id;
	bool check()
	{
		for(int i = l + 1 ; i <= r ; i++)
			if(a[i] != a[l]) return false;
		return true;
	}
} q[N];
void reset(int L)
{
	if(q[bel[L]].id == -1) return;
	else
	{
		for(int i = q[bel[L]].l ; i <= q[bel[L]].r ; i++)
			a[i] = q[bel[L]].id;
	}
	q[bel[L]].id = -1;
}
void query(int L , int R , int c)
{
	int res = 0;
	reset(L);
	for(int i = L ; i <= min(q[bel[L]].r , R) ; i++)
	{
		if(a[i] == c) res++;
		a[i] = c;
	}
	if(bel[L] != bel[R])
	{
		reset(R);
		for(int i = q[bel[R]].l ; i <= R ; i++)
		{
			if(a[i] == c) res++;
			a[i] = c;
		}
	}
	for(int i = bel[L] + 1 ; i < bel[R] ; i++)
	{
		if(q[i].id == -1)
		{
			for(int j = q[i].l ; j <= q[i].r ; j++)
			{
				if(a[j] == c) res++;
				a[j] = c;
			}
		}
		else if(q[i].id == c) res += LEN;
		q[i].id = c;
	}
	printf("%d\n" , res);
}
int main()
{
	scanf("%d" , &n);
	LEN = sqrt(n);
	int cnt = 0;
	for(int L = 1 , R ; L <= n ; L++)
	{
		R = L + LEN - 1;
		q[++cnt].l = L , q[cnt].r = min(R , n);
		q[cnt].id = -1; L = R;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		scanf("%d" , &a[i]);
		bel[i] = (i - 1) / LEN + 1;
	}
	for(int i = 1 ; i <= n ; i++)
	{
		int L , R , c;
		scanf("%d%d%d" , &L , &R , &c);
		query(L , R , c);
	}
	return 0;
}

第九题

仿照《进阶指南》里蒲公英的做法，用vector存每个值的下标再二分即可，（除开可以用离线做法做以外，题都一毛一样的）

code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath>
#include<map>
using namespace std;
const int N = 100010;
int n , LEN ;
int bel[N] , a[N] , val[N];
int MAX[2020][2020];
int num[N];
vector<int> v[N];
map<int , int> mp;
bool visit[N];

void iint(int x)
{
	int count = 0 , maxn1 = 0;
	memset(num , 0 , sizeof num);
	for(int i = (x - 1) * LEN + 1 ; i <= n ; i++)
	{
		num[a[i]]++;
		if(num[a[i]] > count || (num[a[i]] == count && val[a[i]] < val[maxn1]))
		{
			count = num[a[i]];
			maxn1 = a[i];
		}
		MAX[x][bel[i]] = maxn1;
	}
	
}
int er(int x , int l , int r)
{
	return upper_bound(v[x].begin() , v[x].end() , r) - lower_bound(v[x].begin() , v[x].end() , l);
}
int solve(int l , int r)
{
	int ans = MAX[bel[l] + 1][bel[r] - 1] , count = 0;
	memset(visit , 0 , sizeof visit);
	count = er(ans , l , r);
	for(int i = l ; i <= min(bel[l] * LEN , r) ; i++)
	{
		if(visit[a[i]] == 0)
		{
			visit[a[i]] = 1;
			int res = er(a[i] , l , r);
			if(res > count || (res == count && val[a[i]] < val[ans])) count = res , ans = a[i];
		}
	}
	if(bel[l] != bel[r])
	{
		for(int i = (bel[r] - 1) * LEN + 1 ; i <= r ; i++)
		{
			if(visit[a[i]] == 0)
			{
				visit[a[i]] = 1;
				int res = er(a[i] , l , r);
				if(res > count || (res == count && val[a[i]] < val[ans])) count = res , ans = a[i];
			}
		}
	}
	return val[ans];
}
int main()
{
	scanf("%d" , &n);
	LEN = 80;
	int cnt = 0 , cnt1 = 0;
	for(int i = 1 ; i <= n ; i++)
	{	
		scanf("%d" , &a[i]);
		if(mp[a[i]] == 0)
		{
			mp[a[i]] = ++cnt;
			val[cnt] = a[i];
		}
		a[i] = mp[a[i]]; 
		v[a[i]].push_back(i);
		bel[i] = (i - 1) / LEN + 1;
	}
	for(int i = 1 ; i <= bel[n] ; i++) iint(i);
	for(int i = 1 ; i <= n ; i++)
	{
		int L , R;
		scanf("%d%d" , &L , &R);
		printf("%d\n" , solve(L , R));
	}
	return 0;
}

蒲公英点这里，改一改就能交

Mongo_w
关注
专栏目录
分块入门 9题
J_lxj 的博客
02-25 590
分块的9题是跟着黄学长的博客写的，算是真正的入门了吧。 例题1：给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 题解By hzwer: 这是一道能用许多数据结构优化的经典题，可以用于不同数据结构训练。数列分块就是把数列中每m个元素打包起来，达到优化算法的目的。以此题为例，如果我们把每m个元素分为一块，共有n/m块，每次区间加的操作会涉及O(n/m)个整块，以及区间两侧两个不完整的...
分块算法详解
justin666888的博客
07-29 1120
分块算法详解
分块入门 LibreOJ分块九题
aoy29758的博客
07-23 324
推荐hzwer大佬的博客：http://hzwer.com/8053.html 初步学习体验就是，分块作为一种复杂度看上去并不优秀实际效率却很优秀的数据结构，在解决某些用其他如线段树等log数据结构非常麻烦的问题时非常好写好用，以后搭配莫队简直是解决大部分区间问题的强力算法 分块本身其实还是挺简单的，这套题总结了一些分块/数据结构的经典问题，很全面，能由浅入深地学习分块的基本使用，分...
[LOJ] 分块九题 9
Memories Do Not Open
04-16 294
区间众数。占坑。
分块9题【参考hzw】
CH_Vaniteux的博客
02-01 464
1 给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 嗯 分块板子啦 贴下主要部分的代码 struct Block{ int size, cnt, pos[N]; int atag[N]; inline int query(int x){ return a[x] + atag[pos[x]]; } inline void add(int x, int y, int d...
[LOJ] 分块九题 5
weixin_33858485的博客
04-12 118
区间开平方，区间查询。 lazy标记改为区间是否全是1或者0，这样的区间是没有更新价值的。 //Stay foolish,stay hungry,stay young,stay simple #include<iostream> #include<cmath> #include<cstdio> #include<cct...
九年级语文上学期期末考试试题(扫描版) 北师大版 试题.doc
11-10
3. 考试结构：试卷分为选择题和非选择题，共分为几个部分，如“一”、“二”、“三”、“五”和“六”，这显示了考试的分块结构，可能是按照基础知识、阅读理解、作文等不同能力进行划分。 4. 语文能力测试：试题...
数据结构第九章查找习题及答案.doc
09-25
5. **分块查找**：数据分为若干块，每块内数据不一定有序，但块间通过索引块（包含每块的最大或最小值）来保持有序，以提高查找效率。 6. **二叉查找树**：其查找效率与树的高度有关，高度越高，查找效率越低。呈单...
数据结构第九章--查找-习题及答案.docx
10-25
"数据结构第九章--查找" 本章主要讲解了查找的相关知识点，包括顺序查找、二分查找、分块查找、二叉查找树、哈希查找等。 1. 顺序查找：在具有n个记录的连续顺序文件中采用顺序查找法查找一个记录，其平均查找长度...
LOJ分块9题
qq_45342177的博客
10-10 285
众所周知分块是一种非常优秀的暴力算法 T1 把我吊打（我生气了所以不想写这道题的题解） #include <cstdio> #include <iostream> #include <algorithm> #include <cmath> #include <cstring> #define ll long long using nam...
[分块]数列分块入门1-9 待补充....
知与谁i的博客
03-03 736
一、数列分块入门1[区间修改，单点查询] 题目链接：https://loj.ac/problem/6277 【分析】把n分成n/k+(n%k ? 1 : 0)个块，其中k=sqrt(n)，也就是每个块的大小为k，当区间[l,r]内包含某个块的全部时，给该块做个标记即可，其余部分暴力更新，时间复杂度为O(k)； 【知识点】区间修改，单点查询 代码实现1：   #include &lt;...
[分块] 分块练习九例
Antimonysbguy的博客
10-28 247
LOJ 6277~6285 T1 Block1 区间加，单点查 #include<bits/stdc++.h> using namespace std; #define in Read() int in{ int i=0,f=1;char ch=0; while(!isdigit(ch)&&ch!='-') ch=getchar(); if(ch=='-') ch=getchar(),f=-1; while(isdigit(ch)) i=(i<<3)+(i&l
数列分块入门1 – 9 by hzwer
剑锋OI SharpSwordOI
04-11 1040
数列分块入门1 – 9 by hzwer 本文非原创，原创地址http://hzwer.com/8053.html - 可能涉及的几个词语解释： 区间：数列中连续一段的元素 区间操作：将某个区间[a,b]的所有元素进行某种改动的操作 块：我们将数列划分成若干个不相交的区间，每个区间称为一个块 整块：在一个区间操作时，完整包含于区间的块 不完整的块：在一个区间操作时，只有部分包含于区间的块...
归并排序求逆序对数
weixin_30633949的博客
06-17 54
Codevs /* 作者:thmyl 题目:p1688 求逆序对 */ #include<iostream> using namespace std; long long n,a[1000000],tot,temp[10000000]; void sor(int l,int r) { if(l==r)return ; int mid=(l+r...
基于C语言的Dao编程语言设计源码
最新发布
09-28
该项目是一款名为Dao的编程语言设计源码，采用C语言为主要开发语言，并辅以C、C++、Shell和CSS等语言。项目文件共计225个，其中包含126个Dao源文件、39个C源文件、36个C头文件、9个C++源文件、3个文本文件、2个Vim配置文件、1个ChangeLog文件、1个daomake工具文件、1个README文件、1个配置文件。这个项目旨在构建一个高效、可扩展的编程语言环境。
如何自定义数据集进行目标检测_keras-yolo3.zip
09-28
如何自定义数据集进行目标检测_keras-yolo3
基于JavaScript及多语言融合的勤工俭学平台设计源码
09-28
本项目是一款基于JavaScript及多语言融合的勤工俭学平台设计源码，共计367个文件，涵盖231个Java源代码文件、27个XML配置文件、23个JavaScript文件、19个CSS文件、8个PNG图像文件以及少量其他类型文件。该平台旨在为勤工俭学活动提供高效便捷的解决方案，支持多种语言的交互，满足不同用户的需求。
初始化对LoRA微调动态的影响研究
09-28
内容概要：研究了低秩适应（Low Rank Adaptation, LoRA）方法下不同随机初始化设置的效果与动态特性。论文主要发现，在初始化矩阵B为零、矩阵A随机时，模型通常可以使用更大的学习率并取得较好的效果，但这种情况下会出现内部不稳定现象。然而当A被初始化为零而B随机时，则不具备上述优势。通过理论和大量实验证明，初始化选择A而非B将导致更好的优化结果与训练稳定性。 适合人群：机器学习、神经网络的研究员、深度学习领域的科研学者。 使用场景及目标：在大规模语义模型的参数调整过程中选择恰当的初始化配置，从而提升效率以及性能。对于LoRA微调任务来说，在有限算力条件下高效地利用少量新增训练参数进行自适座行动。 其他说明：文中提出的结论有助于未来改进基于小样本学习的任务，同时指出了目前两种初始化方式均存在缺陷，提示可能需要进一步的研究来解决这些问题。尽管当前方法表现优于默认的LoRA初始化，但仍有一定局限性和潜在改进方向。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值