目录
- @[email protected]
- @[email protected]
- @part - [email protected]
- @part - [email protected]
- @part - [email protected]
- @accepted [email protected]
- @version - [email protected]
- @version - [email protected]
- @[email protected]
@[email protected]
已知一个长度为 n 的序列 a1, a2, ..., an。
对于每个1 <= i <= n，找到最小的非负整数 p 满足对于任意的 j，有：
\[a_j <= a_i + p - \sqrt{|i-j|}\]
input
第一行 n (1 <= n <= 500000)。
下面每行一个整数，其中第 i 行是 ai (0 <= ai <= 10^9)。
output
n行，第i行表示对于i，得到的p
sample input
6
5
3
2
4
2
4
sample output
2
3
5
3
5
4
@[email protected]
@part - [email protected]
我们先把式子变形：
\[a_j + \sqrt{|i-j|} - a_i <= p\]
求最小的 p 使得这个式子对于任何 j 都成立，相当于求 \(a_j + \sqrt{|i-j|}\) 的最大值。
我们可以分类处理 i < j 与 i > j 两种情况来去掉根号内的绝对值。现在仅讨论 i > j 的情况， i < j 的方法可以同理。
@part - [email protected]
那么怎么求这个东西的最大值呢？暴力做是 \(O(n^2)\) 的时间复杂度，好像也不能什么线段树斜率优化等诸如此类的优化来着。
这时候就要引入一个新方法：决策单调性。
决策单调性是这样定义的：对于 j < k，在点 i 处 k 比 j 优，则在 i 之后 k 会始终比 j 优。
或者等价的，令点 i 取到最优解的点（决策点）为 \(p_i\)，则决策单调性为：\(p_i \le p_{i+1}\)。
如果具有决策单调性，可以利用先前我们决策时的信息，排除掉一些不可能是最优解的点，以降低时间复杂度。
那么这道题具有决策单调性吗？观察 \(y=\sqrt x\) 这一个函数，直观上它的增长率越来越小（事实上从它的导数来看的确是这样的），所以越靠前的点对后面的点的贡献会越来越小。所以决策单调性好像是成立的。
证明……恕我太弱证不来 QAQ。
【反正我选择打表，打出来单调就假装它是有决策单调性】
@part - [email protected]
假如我们已知这道题具有决策单调性，那我们怎么才能利用这个性质呢？
我已知的有两种方法：
（1）分治。根据决策单调性 \(p_i \le p_{i+1}\)，我们进行分治处理。
对于原数列上的某一个区间 \([l,r]\)，假设它对应的决策点区间为 \([L, R]\)，我们取 \(l, r\) 的终点 \(mid\)，暴力扫一遍 \([L, R]\) 求出 \(mid\) 对应的决策点 \(Mid\)。
则原问题分成两个规模更小的子问题：原区间 \([l, mid-1]\) 对应决策点区间 \([L, Mid-1]\)，原区间 \([mid+1, r]\) 对应决策点区间 \([Mid+1, R]\)。分治即可。
时间复杂度 \(O(n\log n)\)。
该方法具有一定的局限性：决策点的选取前后不能有依赖性。即我们如果要求 \(mid\) 所对的决策点，不能依赖于求解 \(1\dots mid-1\)的决策点。然而大部分的 dp 是满足不了这个性质的。
（2）单调队列 + 二分。还是根据决策单调性 \(p_i \le p_{i+1}\)，所以我们每次加入新的决策点时，它所能影响的区间肯定是从末尾开始依次往前影响。
于是我们维护一个队列，每一次加入新的决策点时就开始弹出队尾，直到新的决策点影响到的点全部更新。
然而这样有一个问题：假如点 j 影响到的区间为 [l, r]，现在加入 k，它所能影响的区间为 [p, r]。则我们必须更新点 j 影响到的区间 [l, p-1]。
更新还好办，关键是怎么找这个 p。这个时候我们就可以根据决策单调性进行二分。
可以发现每次加入一个决策点，只需要我们二分一次。故时间复杂度 \(O(n\log n)\)。
该方法也具有一定的局限性：我们必须要支持快速求某一个决策点对另外一个点的贡献。否则这个方法的时间复杂度将快速退化。
@accepted [email protected]
@version - [email protected]
这个是单调栈 + 二分过的。
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN = 500000;
int a[MAXN + 5], pnt[MAXN + 5];
//pnt -> point -> 决策点 qwq
void reverse(int A[], int n) {
for(int i=1,j=n;i<j;i++,j--)
swap(A[i], A[j]);
}
struct node{
int le, ri;
int num;
node(int _l=0, int _r=0, int _n=0):le(_l), ri(_r), num(_n){}
}que[MAXN + 5];
int s, t;
bool better(int i, int j, int k) {
return a[j] - a[i] + sqrt(i - j) >= a[k] - a[i] + sqrt(i - k);
}
int b_search(node p, int x) {
int le = p.le, ri = p.ri;
while( le < ri ) {
int mid = (le + ri + 1) >> 1;
if( better(mid, p.num, x) ) le = mid;
else ri = mid - 1;
}
return le;
}
void get_point(int n) {
s = 1, t = 0;
for(int i=1;i<=n;i++) {
while( s <= t && que[s].ri < i )
s++;
if( s <= t && que[s].le < i )
que[s].le = i;
while( s <= t ) {
if( better(que[t].ri, i, que[t].num) ) {
if( better(que[t].le, i, que[t].num) )
t--;
else {
que[t].ri = b_search(que[t], i);
break;
}
}
else break;
}
if( s > t ) que[++t] = node(i, n, i);
else if( que[t].ri != n )
que[t+1] = node(que[t].ri+1, n, i), t++;
if( s <= t ) pnt[i] = que[s].num;
}
}
int ans[MAXN + 5];
int main() {
int n; scanf("%d", &n);
for(int i=1;i<=n;i++)
scanf("%d", &a[i]);
get_point(n);
for(int i=1;i<=n;i++)
ans[i] = max(ans[i], int(ceil(a[pnt[i]] - a[i] + sqrt(i - pnt[i]))));
reverse(a, n); get_point(n); reverse(pnt, n); reverse(a, n);
for(int i=1;i<=n;i++)
ans[i] = max(ans[i], int(ceil(a[n-pnt[i]+1] - a[i] + sqrt(n-pnt[i]+1 - i))));
for(int i=1;i<=n;i++)
printf("%d\n", ans[i]);
}
@version - [email protected]
这个是用分治过的。
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN = 500000;
int a[MAXN + 5], pnt[MAXN + 5];
//pnt -> point -> 决策点 qwq
void reverse(int A[], int n) {
for(int i=1,j=n;i<j;i++,j--)
swap(A[i], A[j]);
}
bool better(int i, int j, int k) {
return a[j] - a[i] + sqrt(i - j) >= a[k] - a[i] + sqrt(i - k);
}
void get_point(int l, int r, int L, int R) {
if( l > r ) return ;
int mid = (l + r) >> 1, nw = L;
for(int i=L;i<=R&&i<=mid;i++)
if( better(mid, i, nw) ) nw = i;
pnt[mid] = nw;
get_point(l, mid-1, L, nw);
get_point(mid+1, r, nw, R);
}
int ans[MAXN + 5];
int main() {
int n; scanf("%d", &n);
for(int i=1;i<=n;i++)
scanf("%d", &a[i]);
get_point(1, n, 1, n);
for(int i=1;i<=n;i++)
ans[i] = max(ans[i], int(ceil(a[pnt[i]] - a[i] + sqrt(i - pnt[i]))));
reverse(a, n); get_point(1, n, 1, n); reverse(pnt, n); reverse(a, n);
for(int i=1;i<=n;i++)
ans[i] = max(ans[i], int(ceil(a[n-pnt[i]+1] - a[i] + sqrt(n-pnt[i]+1 - i))));
for(int i=1;i<=n;i++)
printf("%d\n", ans[i]);
}@[email protected]
平方根不能取整，不然会翻车（决策单调性不能成立）
当初做的时候，硬是要简化程序，把整个数组翻转过来再做。结果好多细节，WA 了几遍才过。
早知道我就直接复制粘贴了 TWT。
原文地址：https://www.cnblogs.com/Tiw-Air-OAO/p/10213838.html