P3722 [AH2017/HNOI2017] 影魔 题解
题目链接：影魔
首先，考虑 \(n^2\) 枚举是很好思考的，贡献类的题大多数是从 \(n^2\) 的暴力思考 有效贡献点 的特征。
考虑本题问的两种贡献与什么有关，顺便说说我自己的思考吧。一开始简单扫了一眼以为是偏序问题计数，结果发现还有个区间询问限制，那么我们先解决区间询问限制：不带修？那就扫描线离线。再考虑是不是可差性问题？并不能写成：\(Ans[0,r]-Ans[0,l-1]\) 的答案。ok，显然跟逆序对这种差不多，并不是很好直接分，那就不分了，我已经有预感，一定是一个类似二维数点的东西，这个时候该回到题目了。
第一个询问：
\(l<s<r,\max{k_s} <\max{k_l,k_r}\)，说的是一个满足贡献的对 \((l,r)\) 它们之间 如果存在数，则不能大于两个端点。\(ok\)，这里特判一下无 \(s\) 的相邻数的情况先全部加上，即任意一个询问 \([l,r]\)，会有 \(r-l\) 个相邻对，然后它们的贡献皆为 \(p_1\)，其实题目要问的也即为满足的对数，再乘上 \(p_1\) 或者 \(p_2\)。一个区间上任意数小于端点，转化为区间最大数小于端点数，常规套路。
第二个询问：
区间最大数介于两个端点数之间。
区间最大数？这玩意有意思，常规的关于贡献简化，我们一般都是改变枚举对象去实现更好地简化计数，只要你注意到了如果枚举两个端点的组合这个复杂度板上钉钉的是 \(n^2\)，我们需要换一种枚举：枚举这个区间最大数是 who ？这个枚举则是 \(n\) 个事，考虑每个数作为区间最大数的贡献分析即可。
对于一个数 \(k_i\) 作为区间最大数来说，第一种贡献显然只有一个，记录：
\(L[i]\) 为 \(i\) 左侧第一个比自身大的数，\(R[i]\) 为右侧第一个比自身大的数。那么显然对于 \(i\) 来说，\((L[i],R[i])\) 是它影响的唯一答案，一旦超出这个范围以后，它不再是区间最大值。当然，前提是二者皆存在的情况下。so？这个直接单调栈，单调队列啥的预处理，这样一来所有有贡献第一种的 \((L,R)\) 就预处理出来了，询问 \(l \le L,R \le r\) 的数量，二维数点随便做。
第二个贡献，一定有一个端点是最大值：
其实图就长这样，\(i\) 为当前枚举的区间最大值，它到两个点 \(L\) 或者 \(R\) 范围内的数都比 \(i\) 处小，而第二种贡献需要一个点作为 \(>k_i=\max k_s\)，显然可以选择 \(L\) 或者 \(R\)，以选择 \(R\) 为例，那么左端点：\(l \in [L+1,i-1]\) 皆可选择，因为要满足 \(k_{l}<\max k_s=k_i <k_R\)，也就是说对于一个端点来说，有一段满足的所有端点。本质也是二维数点，只是需要区改，这个扫描线离线下来，由于有左右之分，分左右扫就好了。
区改可以考虑差分树状数组，也可以线段树相当于修改一段区间 \(+1\)，查询 \(\le x,\ge x\) 的和。
参照代码
#include <bits/stdc++.h>
// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
#define isPbdsFile
#ifdef isPbdsFile
#include <bits/extc++.h>
#else
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>
#endif
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef __int128 i128;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
template <typename T>
int disc(T* a, int n)
{
return unique(a + 1, a + n + 1) - (a + 1);
}
template <typename T>
T lowBit(T x)
{
return x & -x;
}
template <typename T>
T Rand(T l, T r)
{
static mt19937 Rand(time(nullptr));
uniform_int_distribution<T> dis(l, r);
return dis(Rand);
}
template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
return (a % b + b) % b;
}
template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
a %= c;
T1 ans = 1;
for (; b; b >>= 1, (a *= a) %= c)if (b & 1)(ans *= a) %= c;
return modt(ans, c);
}
template <typename T>
void read(T& x)
{
x = 0;
T sign = 1;
char ch = getchar();
while (!isdigit(ch))
{
if (ch == '-')sign = -1;
ch = getchar();
}
while (isdigit(ch))
{
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
x *= sign;
}
template <typename T, typename... U>
void read(T& x, U&... y)
{
read(x);
read(y...);
}
template <typename T>
void write(T x)
{
if (typeid(x) == typeid(char))return;
if (x < 0)x = -x, putchar('-');
if (x > 9)write(x / 10);
putchar(x % 10 ^ 48);
}
template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
write(x), putchar(c);
write(c, y...);
}
template <typename T11, typename T22, typename T33>
struct T3
{
T11 one;
T22 tow;
T33 three;
bool operator<(const T3 other) const
{
if (one == other.one)
{
if (tow == other.tow)return three < other.three;
return tow < other.tow;
}
return one < other.one;
}
T3() { one = tow = three = 0; }
T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
{
}
};
template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
if (x < y)x = y;
}
template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
if (x > y)x = y;
}
constexpr int N = 2e5 + 10;
vector<pii> segLtoR[N], segRtoL[N];
vector<int> update1[N];
vector<pii> update2L[N], update2R[N];
ll p1, p2;
int n, m;
int L[N], R[N];
struct
{
int bit[N];
void Add(int x)
{
while (x <= n)bit[x]++, x += lowBit(x);
}
int Query(int x) const
{
int ans = 0;
while (x)ans += bit[x], x -= lowBit(x);
return ans;
}
} Bit;
struct
{
struct Node
{
int cnt, add;
} node[N << 2];
#define cnt(x) node[x].cnt
#define add(x) node[x].add
void pushUp(const int curr)
{
cnt(curr) = cnt(ls(curr)) + cnt(rs(curr));
}
void Add(const int curr, const int val, const int l, const int r)
{
cnt(curr) += (r - l + 1) * val;
add(curr) += val;
}
void pushDown(const int curr, const int l, const int r)
{
if (add(curr))
{
const int mid = l + r >> 1;
Add(ls(curr),add(curr), l, mid);
Add(rs(curr),add(curr), mid + 1, r);
add(curr) = 0;
}
}
void update(const int curr, const int l, const int r, const int s = 1, const int e = n)
{
if (l <= s and e <= r)
{
Add(curr, 1, s, e);
return;
}
const int mid = s + e >> 1;
pushDown(curr, s, e);
if (l <= mid)update(ls(curr), l, r, s, mid);
if (r > mid)update(rs(curr), l, r, mid + 1, e);
pushUp(curr);
}
int query(const int curr, const int l, const int r, const int s = 1, const int e = n)
{
if (l <= s and e <= r)return cnt(curr);
const int mid = s + e >> 1;
pushDown(curr, s, e);
int ans = 0;
if (l <= mid)ans += query(ls(curr), l, r, s, mid);
if (r > mid)ans += query(rs(curr), l, r, mid + 1, e);
return ans;
}
} SegL, SegR;
int k[N];
ll ans[N];
inline void solve()
{
cin >> n >> m >> p1 >> p2;
forn(i, 1, n)cin >> k[i];
k[n + 1] = n + 1;
deque<int> mx;
forn(i, 1, n+1)
{
while (!mx.empty() and k[mx.back()] < k[i])
{
R[mx.back()] = i;
mx.pop_back();
}
if (!mx.empty())L[i] = mx.back();
mx.push_back(i);
}
forn(i, 1, n)
{
if (L[i])update1[R[i]].push_back(L[i]);
if (i + 1 <= R[i] - 1)update2L[L[i]].emplace_back(i + 1, R[i] - 1);
if (L[i] + 1 <= i - 1)update2R[R[i]].emplace_back(L[i] + 1, i - 1);
}
forn(i, 1, m)
{
int l, r;
cin >> l >> r;
segLtoR[r].emplace_back(l, i);
segRtoL[l].emplace_back(r, i);
ans[i] += (r - l) * p1;
}
forn(r, 1, n)
{
for (const auto l : update1[r])Bit.Add(l);
for (const auto [tL,tR] : update2R[r])SegR.update(1, tL, tR);
for (const auto [l,id] : segLtoR[r])
{
ans[id] += (Bit.Query(r) - Bit.Query(l - 1)) * p1;
ans[id] += SegR.query(1, l, n) * p2;
}
}
forv(l, n, 1)
{
for (const auto [tL,tR] : update2L[l])SegL.update(1, tL, tR);
for (const auto [r,id] : segRtoL[l])ans[id] += SegL.query(1, 1, r) * p2;
}
forn(i, 1, m)cout << ans[i] << endl;
}
signed int main()
{
// MyFile
Spider
//------------------------------------------------------
// clock_t start = clock();
int test = 1;
// read(test);
// cin >> test;
forn(i, 1, test)solve();
// while (cin >> n, n)solve();
// while (cin >> test)solve();
// clock_t end = clock();
// cerr << "time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
}
常见的二维数点实用方法总结：
常见的模型：
求 \(x \le idx,l\le y \le r\) 的点的数量，其他模型都能通过可差性问题差分转变为这个模型。可差性问题：
\(ans(限制条件,l\le x \le r)=ans(限制条件,x \le r)-ans(限制条件,x\le l-1)\)
二维数点不带修，询问离线，将 \(x\) 序列扫描线转化 \(+\) 权值树状数组统计 \(y\) 贡献。
二维数点不带修，询问在线，主席树维护 \([0,x]\) 上关于 \(y\) 权值树。
二维数点带修，询问离线，将 \(time\) 作为第一序，\(x\) 作为第二序，cdq 分治算 \(y\) 的贡献。
二维数点带修，询问在线，树套树，对 \(x\) 为第一维，\(y\) 为第二维。
如果要带根号：
二维数点不带修，询问离线，序列扫描线转化 \(+\) 值域分块计数。
其他情况，序列分块套值域分块。当然也有 \(KD-Tree\)、多叉树、\(bitset\)、归并树等等的一些其他解法。
