2476 小b和序列（正解 ：“枚举” + “贪心” / 自己：线段树乱搞）

题目描述：

2476 小b和序列

 

小b有一个长度为n的序列a，她想求，

即选出两个数，使得它们的最小值乘上它们在序列上的距离最大。

你能帮帮她吗?

样例解释：选择a2和a9，答案为min(8,7)×(9−2)=49，不存在其他选法答案更大，

因此最大值就是49。

输入

第一行一个数n，0＜n≤50000；
第二行n个数表示a_i，以空格隔开，0<=a_i<=10000。

输出

输出一个数表示这个最大值

输入样例

9
1 8 6 2 5 4 8 3 7
10
41 8466 6334 6498 9168 5723 1477 9356 6960 4462

输出样例

49
50796

思路描述：

        这题正解“贪心”，枚举所有可能较小数，贪心选择系数每个元素两个权值，

一个下标一个value，按权值升序排列，对于每个元素，找大于等于它的数中

（排序数组中该元素后面位置的元素）下标最大和最小者，代表原序列中value作

为最小值左右能普及到的范围。然后不断选择最大值即可。

         开始没想到排序，想直接在原序列上求元素作为最小值所能普及的左右范围，

思路是1~10000+1（元素权值可能为0）上维护线段树，节点上维护每个元素目前

的最小下标，对于当前元素，只需要在（value+1，10000+1）上查询一个最小下标

即可，并修改该元素对应节点所维护的最小位置。

正解“贪心”代码实现：

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include<set>
#include<algorithm>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int N=4*2e5+100;
const int M=4e5+100;
struct Node
{
	int val,id;
} arr[N];
bool cmp(Node aa,Node bb)
{
	return aa.val<bb.val;
}
int main()
{
	int n,ans;
	int maxs,mini;
	while(cin>>n)
	{
		ans=0;
		for(int i=1; i<=n; i++)
		{
			cin>>arr[i].val;
			arr[i].id=i;
		}
		sort(arr+1,arr+1+n,cmp);
		mini=arr[n].id;
		maxs=arr[n].id;
		for(int i=n-1; i>=1; i--)
		{
			ans=max(ans,arr[i].val*abs(arr[i].id-mini));
			ans=max(ans,arr[i].val*abs(arr[i].id-maxs));
			mini=min(mini,arr[i].id);
			maxs=max(maxs,arr[i].id);
		}
		cout<<ans<<endl;
	}
	return 0;
}

线段树代码实现：

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<cmath>
#include<set>
#include<algorithm>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int N=4*2e5+100;
const int M=4e5+100;
int Left[N],Right[N],dat[N];
void build(int p,int l,int r)
{
	Left[p]=l;
	Right[p]=r;
	if(l==r)
	{
		dat[p]=INF;
		return ;
	}
	int mid=(l+r)/2;
	build(2*p,l,mid);
	build(2*p+1,mid+1,r);
	dat[p]=min(dat[2*p],dat[2*p+1]);
}
void change(int p,int x,int v)
{
	if(Left[p]==Right[p])
	{
		//取当前最小的一个下标 
		dat[p]=min(dat[p],v);
		return ;
	}
	int mid=(Left[p]+Right[p])/2;
	if(x<=mid)change(2*p,x,v);
	else change(2*p+1,x,v);
	dat[p]=min(dat[2*p],dat[2*p+1]);
}
int query(int p,int l,int r)
{
	if(l<=Left[p]&&r>=Right[p])
		return dat[p];
	int mid=(Left[p]+Right[p])/2,val=INF;
	if(l<=mid)val=min(val,query(2*p,l,r));
	if(r>mid)val=min(val,query(2*p+1,l,r));
	return val;
}
struct Node
{
	int val,id;
} arr[N];
int mer[N];
int solve(int n)
{
	int ans=0;
	mer[1]=0;
	change(1,arr[1].val+1,1);
	for(int i=2; i<=n; i++)
	{
		mer[i]=query(1,arr[i].val+1,10000+1);
		if(mer[i]>=INF)mer[i]=i;
		change(1,arr[i].val+1,i);
		ans=max(ans,arr[i].val*(i-mer[i]));
	}
	return ans;
}
int main()
{
	int n,ans;
	while(cin>>n)
	{
		ans=0;
		build(1,1,10000+1);
		for(int i=1; i<=n; i++)
		{
			cin>>arr[i].val;
			arr[i].id=i;
		}
		//正反各求一边，表示左/右普及范围 
		ans=max(ans,solve(n));
		reverse(arr+1,arr+1+n);
		memset(dat,INF,sizeof(dat));
		ans=max(ans,solve(n));
		cout<<ans<<endl;
	}
	return 0;
}

THE END；