CF855B Marvolo Gaunt‘s Ring题解

传送门

题意

---

给 $n$ 个数，按顺序取三个 $a_i,a_j,a_k$ ，使
$p\times a_i+q\times a_j+r\times a_k$ 最大。

注意 $1\le i\le j\le k\le n$ 。

$O(n^3)$ 暴力解法

---

for循环枚举 $a_i,a_j,a_k$ ，取 $max$ 。

或者是枚举 $a_i,a_j$ ，最后的 $a_k$ 取 $[j,n]$ 的最值，

如果 $r>0$ ， $a_k$ 取最大值；
反之， $a_k$ 取最小值。

这样显然会TLE的。

$O(n\log n)$ 解法

---

在看看上面枚举两个数的算法，再想想可以只枚举一个数吗？

诶，好像可以诶！

我们枚举中间的 $a_j$ ，那么 $a_i$ 就是 $[1,j]$ 的最值， $a_k$ 是 $[j,n]$ 的最值。然后用ST算法或线段树，维护区间最值。（不会？戳这儿->ST算法）

话不多说，上代码！

这里用的是ST算法，可以通过 $O(n\log n)$ 的时间复杂度作预处理后，在 $O(1)$ 的复杂度内查询区间最值。

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
using namespace std;

typedef long long ll;

const int N=100005;
const ll INF=9e18;

int n;
ll p,q,r;
ll a[N];
ll f[N][20][2]; //f[i][j][0]表示在子区间[i,i + 2^j - 1]的区间最大值，f[i][j][1]位最小值
int Log[N];
ll ans=-9e18;

void ST_prework()
{
	for(int i=1;(1<<i)<=n;i++) Log[1<<i]=i; //预处理log2(x)的值，方便查找
	for(int i=1;i<=n;i++) if(!Log[i]) Log[i]=Log[i-1];
	int t=Log[n]+1;
	for(int i=1;i<=n;i++) //初始化
		for(int j=1;j<=t;j++)
		{
			f[i][j][0]=-INF;
			f[i][j][1]=INF;
		}
	for(int i=1;i<=n;i++) f[i][0][0]=f[i][0][1]=a[i]; //赋初值
	for(int j=1;j<t;j++)
		for(int i=1;i<=n-(1<<j)+1;i++)
		{
			f[i][j][0]=max(f[i][j-1][0],f[i+(1<<(j-1))][j-1][0]);
			f[i][j][1]=min(f[i][j-1][1],f[i+(1<<(j-1))][j-1][1]); 
		}
}

long long ST_query(int l,int r,bool flag) //flag用于判断p/q/r大于0还是小于等于0
{
	int k=Log[r-l+1];
	if(flag) return max(f[l][k][0],f[r-(1<<k)+1][k][0]);
	return min(f[l][k][1],f[r-(1<<k)+1][k][1]);
}

int main()
{
	scanf("%d%lld%lld%lld",&n,&p,&q,&r);
	for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
	ST_prework();
	for(int i=1;i<=n;i++)
		ans=max(ans,q*a[i]+p*ST_query(1,i,p>0)+r*ST_query(i,n,r>0)); //取最大值
	printf("%lld\n",ans);
	return 0;
} 

$O(n)$ 算法

---

此时，我们换一种枚举思路，枚举到一个数 $a_x$ ，分别考虑：

当枚举到第 $x$ 个数时，

1. 当 $a_x$ 为 $a_i$ 时， $p\times a_i$ 的最大值
2. 当 $a_x$ 为 $a_j$ 时， $p\times a_i+q\times a_j$ 的最大值
3. 当 $a_x$ 为 $a_k$ 时， $p\times a_i+q\times a_j+r\times a_k$ 的最大值

考虑 $dp$ ，设 $dp[i][0/1/2]$ 表示枚举到第 $i$ 个数时，对应的三种情况的最大值，则发现，求出第一种情况的最大值时，再加上 $q\times a_x$ 可以得到第二种情况的最大值，同理可以推出第三种情况的最大值，即：

$dp[i][0]=max(dp[i-1][0],p\times a_i)$

$dp[i][1]=max(dp[i-1][1],dp[i][0]+q\times a_i)$

$dp[i][2]=max(dp[i-1][2],dp[i][1]+r\times a_i)$

由于$i$是递增的，所以存的最大值中取的 $i,j,k$ 一定满足 $i\le j\le k$ ，

所以最后答案为 $dp[n][2]$ 。

再观察，发现 $dp[i]$ 只与 $dp[i-1]$ 的值有关，所以直接压掉第一维，答案为 $dp[2]$ 。

时间复杂度为 $O(n)$ ，空间复杂度 $O(1)$ 。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

typedef long long ll;

const ll INF=9e18;

int n;
int p,q,r;
ll dp[3];

int main()
{
	scanf("%d%d%d%d",&n,&p,&q,&r);
	dp[0]=dp[1]=dp[2]=-INF;
	for(int i=1;i<=n;i++)
	{
		int x;
		scanf("%d",&x);
		dp[0]=max(dp[0],(ll)x*p); //按顺序依次状态转移
		dp[1]=max(dp[1],dp[0]+(ll)x*q);
		dp[2]=max(dp[2],dp[1]+(ll)x*r);
	}
	printf("%lld\n",dp[2]);
	return 0;
}