Crowded Cows（洛谷P3088）

$[USACO13NOV]Crowded Cows S$

传送门

思路

先看数据，

对于 $20$ %的数据：$1≤N≤100；$

对于 $40$ %的数据：$1≤N≤500；$

对于 $100$ %的数据：$1≤N≤50,000；1≤X_i,H_i≤1,000,000,000；1≤D≤1,000,000,000；$

题目所说的就是查找一个位置左边和右边的长度为 $d$ 的区间，那么我们可以这么查询最大

值，如果最大值比 $2 \times a_i$ 大，那么肯定就存在。

这不是线段树模板吗？（%树状数组 $dalao$ ）

• 先将数据离散化（将相距较远的数据距离缩短），例如

-9999 -1  3  44

可离散化成

1 2 3 4

• 对于 $a_i$ ， 线段树查找其左右 $d$ 区间中最大值的最小值，与 $2 \times a_i$ 比较
• 输出 $ans$

单调队列

这道题中并不关心有多少个超过两倍高度的，也不关心超过多少，所以想到维护区域内最高

的牛，与这头牛身高的两倍比较。可以用单调队列维护。

但是这只能解决一头牛左边有没有足够高的牛，所以还要从右到左再来一遍。

1. 首先每个元素肯定要按照位置排序，然后依次进队，判断如果队尾的数大小小于要进队的数，那就把队尾弹出，直到队尾的数大于等于要进队的数 这是为了维护单调性
2. 然后再判断如果队头的数位置的差值大于d，出队，直到差值小于d，此时队头的数为单调队列内的合法最大值

因此只要将要进队的数与目前的队头元素比较即可

这样维护了前面的，后面的反一下就好了

时间复杂度 ：因为每个元素最多进队出队一次，所以是 $O(n)$ 的

$AC code$

线段树

#include <bits/stdc++.h>
using namespace std;

const int maxn = 2e5 + 5;

int n, d;

struct abc
{-
	int id, h;
} a[maxn];

int b[maxn], tree[maxn << 2], ans;

inline bool comp(abc a, abc b)
{
	return a.id < b.id;
}

void update(int pos, int l, int r, int id, int val)
{
	if (l == r)
	{
		tree[pos] = val;
		return;
	}
	int mid = (l + r) >> 1;
	if(id<=mid)
	{
		update(pos << 1, l, mid, id, val);
	}
	else
	{
		update(pos << 1 | 1, mid + 1, r, id, val);
	}
	tree[pos] = max(tree[pos << 1], tree[pos << 1 | 1]);
}

int query(int pos, int l, int r, int left, int right)
{
	if (left <= l && r <= right)
	{
		return tree[pos];
	}
	int mid = (l + r) >> 1;
	int ans = 0;
	if(left<=mid)
	{
		ans = query(pos << 1, l, mid, left, right);
	}
	if(right>mid)
	{
		ans = max(ans, query(pos << 1 | 1, mid + 1, r, left, right));
	}
	return ans;
}

signed main()
{
	cin >> n >> d;

	for (int i = 1; i <= n; i++)
	{
		cin >> a[i].id >> a[i].h;
	}

	sort(a + 1, a + n + 1, comp);

	for (int i = 1; i <= n; i++)
	{
		update(1, 1, n, i, a[i].h);
		b[i] = a[i].id;
	}

	for (int i = 1; i <= n; i++)
	{

		int q = b[i], p = b[i];
		q -= d;
		q = max(q, 0);
		p += d;

		int a1 = lower_bound(b + 1, b + n + 1, q) - b;
		int a2 = upper_bound(b + 1, b + n + 1, p) - b - 1;

		int b1 = query(1, 1, n, a1, i), b2 = query(1, 1, n, i, a2);

		if (min(b1, b2) >= 2 * a[i].h)
		{
			ans++;
		}
	}

	cout << ans << endl;

	return 0;
}

单调队列

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, d, ans;
struct abc
{
	int id, h;
} a[maxn];
bool comp(abc a, abc b)
{
	return a.id < b.id;
}
bool b[maxn], c[maxn];
deque<abc> q;
signed main()
{
	cin >> n >> d;
	
	for (int i = 1; i <= n; i++)
		cin >> a[i].id >> a[i].h;
		
	sort(a + 1, a + n + 1, comp);
	
	for (int i = 1; i <= n; i++)
	{
		while (!q.empty() && q.back().h < a[i].h)
			q.pop_back();
		q.push_back(a[i]);
		while (!q.empty() && q.front().id < a[i].id - d)
			q.pop_front();
		if (q.front().h >= a[i].h * 2)
			b[i] = 1;
	}

	q.clear();

	for (int i = n; i >= 1; i--)
	{
		while (!q.empty() && q.back().h < a[i].h)
			q.pop_back();
		q.push_back(a[i]);
		while (!q.empty() && q.front().id > a[i].id + d)
			q.pop_front();
		if (q.front().h >= a[i].h * 2)
			c[i] = 1;
	}

	for (int i = 1; i <= n; i++)
	{
		if (b[i] && c[i])
			ans++;
	}

	cout << ans << endl;

	return 0;
}