BZOJ.2527. [Poi2011]Meteors【整体二分】

传送门
$M$个位置形成环，题目告诉这$M$个位置隶属于哪个国家
有$K$个区间，形如 { l , r , k } \{l,r,k\} {l,r,k}的三元组，表示$l$~$r$位置区间加$k$（区间依次出现）
再给出$N$个国家的需求，求每个国家在第几个区间出现加完后，刚好所有隶属于他位置的综合大于等于需求

分析

如果对于一个国家来说
我们可以通过二分答案来确定，如果当前二分区间为$[l,r]$
将$[l,mid]$内的区间全部加

• 如果加完后还不满足，说明需要更多的区间加，因此左端点$l$变为$mid+1$
• 如果加完后满足了，说明可行解存在于$[l,mid]$中，暂时记录答案为$mid$，(因为$mid$一定是可行解，当前就是检测的$mid$)，并且将右端点$r$变为$mid-1$
  大概就是这样（$check$为检测将$[l,mid]$区间数组中的区间加完之后，是否满足需求）

while(l <= r) {
	int mid = l + ((r-l)>>1);
	if (check(mid)) {
		ans = mid;
		l = mid + 1;
	} else {
		r = mid - 1;
	}
}

对于单次二分复杂度
由于是从$[1,K]$开始二分的，假设最差二分$logK$次
${\sum }_{i=1}^{logK}K/(2^i)$，复杂度接近$K$
我们要进行$N$个国家的的答案计算，总复杂度就是为$N\ast K$

继续分析假设我们目前只有两个国家$A$和$B$
从区间$[1,K]$开始

• 如果当前的$mid$不满足$A$，$A$需要往左边搜索区间为$[mid+1,r]$
• 如果也不满足$B$，$B$也要往左边搜索，区间为$[mid+1,r]$
• 如果不满足$A$，满足$B$，$A$往左$[mid+1,r]$，$B$往右$[l,mid-1]$
• …

这里我们能发现，我们只要做一次的区间加，就能判断两个的情况
也就是说，对于判断区间的查询，我们只需要进行单次二分的$check$ 就能将这些查询分为左右两部分，且左右两部分的判断区间也能确定，递归求解就能解决全部查询

由于最多进行${\sum }_{i=0}^{logK}{2}^i=2\ast K-1$ 次$check$(记为$M$)，每次判断是否满足，用树状数组维护，只需要$logM$查询判断(环状为$2M$，这里记为M)，总的时间复杂度为 $KlogM$加上常数，复杂度可行

以下为代码
通过测试
$div$就是整体二分，针对于上面那种二分过程中记录答案的二分写法

//BZ2527 
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define int long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("7.in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;

vector<int>vec[MAX_N];
int arr[MAX_N];

struct Star {
	int l, r, k;
}star[MAX_N];

int ans[MAX_N];
struct Qr {
	int id, need;
}qr[MAX_N], tmp[MAX_N];
int tr[MAX_N];
inline int lowbit(int x) {
	return x & -x;
}

inline void add(int x, int k) {
	while (x <= 2*M) {
		tr[x] += k;
		x += lowbit(x);
	}
}

inline int ask(int x) {
	int res = 0;
	while (x) {
		res += tr[x];
		x -= lowbit(x);
	}
	return res;
}

int calc(int pos, int need) {
	int cnt = 0;
	for (auto x : vec[pos]) {
		cnt += ask(x) + ask(x+M);
		if (cnt >= need) return need;
	}
	return cnt;
}

void div(int l, int r, int x, int y) {
	if (l > r) {
		return;
	}
	int mid = l + ((r-l)>>1);
	for (int i = l; i <= mid; ++i) {
		add(star[i].l, star[i].k);
		add(star[i].r+1, -star[i].k);
	}
	int lx = x;
	int rx = y;
	for (int i = x; i <= y; ++i) {
		int cnt = calc(qr[i].id, qr[i].need);
		if (cnt >= qr[i].need) {
			ans[qr[i].id] = mid;
			tmp[lx++] = qr[i];
		} else {
			qr[i].need -= cnt;
			tmp[rx--] = qr[i];
		}
	}
	for (int i = x; i <= y; ++i) {
		qr[i] = tmp[i];
	}
	for (int i = l; i <= mid; ++i) {
		add(star[i].l, -star[i].k);
		add(star[i].r+1, star[i].k);
	}
	div(l, mid-1, x, lx-1);
	div(mid+1, r, lx, y);
}

void solve(){
	sc("%lld%lld", &N, &M);
	int x;
	for (int i = 1; i <= M; ++i) {
		sc("%lld", &x);
		vec[x].push_back(i);
	}
	for (int i = 1; i <= N; ++i) {
		qr[i].id = i;
		sc("%lld", &qr[i].need);
	}
	sc("%lld", &K);
	for (int i = 1; i <= K; ++i) {
		sc("%lld%lld%lld", &star[i].l, &star[i].r, &star[i].k);
		if (star[i].l>star[i].r) star[i].r += M;
	}
	div(1, K, 1, N);
	for (int i = 1; i <= N; ++i) {
		if (ans[i]) pr("%lld\n", ans[i]);
		else puts("NIE");
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}