cf#305-D. Mike and Feet- 单调栈/ (线段树上二分)

http://codeforces.com/contest/548/problem/D

题意：

给一个n长度的数组

strength 的定义为 当前数组里面 的最小元素 即为 当前数组的strength 

求出给出数组的 长度为 i  的子数组(连续) 的最大的strength值  --   i 是【1，n】；

思路：

一开始想先对元素的值和位置排序，

如果当前元素为i

二分找到当前第i元素右边第一个小于他的元素的下标j，那么len1=j-i；  

同理二分 找到当前第i元素左边第一个小于他的元素的下标j，那么len2=i-j； 

len=len1+len2-1；
  表示 长度为1到len之间的strength可以更新为a[i] (如果a[i]比原值大)

可惜这个 排序有遇到了点问题，暂时没想到什么方法区分开 在i前面和在i后面的元素。

后来是用单调栈解决的：

个人对单调栈的理解是： 通过不断利用之前计算得到的结果，来计算当前位置的最优结果

从而达到线性的复杂度解决这个问题。 代码见下文。

本题和 之前这题单调栈的 基本是一样的 ： http://blog.csdn.net/viphong/article/details/47985285

（Updata）

之前一直以为线段树+二分是nlogn*logn.....现在才知道直接在线段树里二分就OK了。。。复杂度nlogn

建好树以后，对于a[i]，每次在【i+1,n】区间内二分找到最近的比a[i]小的答案，二分时优先进入左子树   ，代码见最后。。

单调栈做法：（一次）

 

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <iostream>
using namespace std;
 
const double pi=acos(-1.0);
double eps=0.000001; 

struct node
{
	int l,r,val;
	node(){}
	node(int a,int b,int c){l=a,r=b,val=c;}
};
node stk[2*100005];
int top=0;
int tm[2*100005];
int max(int a,int b)
{return a>b?a:b;}
int ans[2*100005];
void insert(int l,int r,int v)
{ 
	while(top&&stk[top].val>=v)
	{
		int	num=stk[top].r-stk[top].l+1; 
		ans[num]=max(ans[num],stk[top].val);
		stk[top-1].r=stk[top].r;
		l=stk[top].l;
		  num=r-l+1;
		ans[num]=max(ans[num],v);
		top--; 
	}
	stk[++top]=node(l,r,v);

}
int main()
{
 
	int n,i;
	cin>>n;
	for (i=1;i<=n;i++ ) scanf("%d",&tm[i]);

	for (i=1;i<=n;i++) 
		insert(i,i,tm[i]);  

	while(top)
	{
		node tt=stk[top];
		int num=stk[top].r-stk[top].l+1;
		ans[num]=max(ans[num],stk[top].val);
		stk[top-1].r=stk[top].r;
		top--;
	}
	for (i=n;i>=1;i--) ans[i-1]=max(ans[i],ans[i-1]);
	for (i=1;i<=n;i++)
	{
		if (i!=1) printf(" ");
		printf("%d",ans[i]);
	}
	printf("\n");
	
	
	
	
	
	
	
	return 0;
 
}

另一种单调栈写法： （两次）

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <set>
#include <vector>
using namespace std;

__int64 tm[200005];
__int64 tm2[200005]; 

__int64 l_ans[200005];
__int64 r_ans[200005];
__int64 tmp[200005]; 
struct node
{
    __int64 x;
    __int64 num;
    node(){}
    node(__int64 a,__int64 b)
    {
        x=a;num=b;
    }
};
node ans[200005];
__int64 res[200005];
stack <node> sb;
stack <node> sb2;
__int64 max(__int64 a,__int64 b)
{return a<b?b:a;}
__int64 cmp(node a,node b)
{
    if (a.x!=b.x)
        return a.x>b.x;
    else
        return a.num>b.num;
}
int main()
{
    __int64 t,n,k;
    
    scanf("%I64d",&n);
    while(!sb.empty())
        sb.pop();
    while(!sb2.empty())
        sb2.pop();
    __int64 i;
    //  scanf("%I64d",&n);
    for (i=1;i<=n;i++)
    {
        scanf("%I64d",&tm[i]);
        tm2[n-i+1]=tm[i];
    }
    //****************************************  计算每个数到左边第一个比之小的数的距离 
    l_ans[1]=0;
    sb.push(node(tm[1],1));
    for (i=2;i<=n;i++)
    {
        if (tm[i]>sb.top().x)
            l_ans[i]=i-sb.top().num-1;
        else
        {
            while(!sb.empty()&&tm[i]<=sb.top().x)
                sb.pop();
            if (sb.empty())
                l_ans[i]=i-1;
            else
                l_ans[i]=i-sb.top().num-1;
        }
        sb.push(node(tm[i],i));
    } 
    //****************************************  计算每个数到右边第一个比之小的数的距离     
    r_ans[1]=0;
    sb2.push(node(tm2[1],1));
    for (i=2;i<=n;i++)
    {
        if (tm2[i]>sb2.top().x)
            r_ans[i]=i-sb2.top().num-1;
        else
        {
            while(!sb2.empty()&&tm2[i]<=sb2.top().x)
                sb2.pop();
            if (sb2.empty())
                r_ans[i]=i-1;
            else
                r_ans[i]=i-sb2.top().num-1;
        }
        sb2.push(node(tm2[i],i));
    } 
    
    ///**********翻转r_ans
    for (i=1;i<=n;i++)
    {
        tmp[n-i+1]=r_ans[i];
    }
    
    for (i=1;i<=n;i++)
    {
        r_ans[i]=tmp[i];
    }
    //*************
    /*  for (i=1;i<=n;i++)
    {
    pr__int64f("%d ",l_ans[i]);
    }
    pr__int64f("\n");
    for (i=1;i<=n;i++)
    {
    pr__int64f("%d ",r_ans[i]);
    }
    pr__int64f("\n");*/ 
    for (i=1;i<=n;i++)
    {
        ans[i].x=l_ans[i]+r_ans[i]+1;
        ans[i].num=tm[i];
    }
    
    
    for (i=1;i<=n;i++)
    {
        int len=ans[i].x;
        res[len]=max(res[len],ans[i].num);
    }
    
    int  maxx=0;
    for (i=n;i>=1;i--)
    {
        if (res[i]>maxx)
            maxx=res[i];
        else
            res[i]=maxx;
    }
    for (i=1;i<=n;i++)
    {
        if(i!=1) printf(" ");
        printf("%d",res[i]);
    }
    
    printf("\n");
    
    
    
    return 0;
    
}

线段树上二分的做法code:

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define  inf 0x7fffffff
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
const int maxn = 200005;
int n,m;
int min(int a,int b)
{return a<b?a:b;}

class tree
{
public: 
	void init()
	{
		ok=0;
	} 
	int  ok;
	int st_min[maxn<<2];
	int aa[maxn];
	inline int minn(int a,int b) { return a>b?b:a; } 
	void PushUP(int rt)
	{
		st_min[rt] = minn(st_min[rt<<1],st_min[rt<<1|1]); 
	}
	void build(int l,int r,int rt) {
		if (l == r)
		{
			st_min[rt]=aa[++ok]; 
			return ;
		}
		int m = (l + r) >> 1;
		build(lson);
		build(rson);
		PushUP(rt);
	}

	int query_min(int qL,int qR,int l,int r,int rt,int x) //rt是节点编号
	{
		
		 if (qL>r||qR<l||st_min[rt]>=x)		//st_min[rt]>=x，此情况直接剪掉，否则递归下去会超时(访问节点数会超过2*logn)。。。
		 {
			return inf;
		 }
		 if (l==r)<span style="white-space:pre">			</span>//直到锁定到只有一个的区间
		 {
			 if (st_min[rt]<x)
				 return r;
			 else
				 return inf;
		 }
	    int m=(l+r)/2;
		int ret  ;
	 
		 ret=query_min(qL , qR , lson,x);<span style="white-space:pre">			</span>//如果左子树找到答案直接return,找不到才进入右子树找
		 if (ret==inf)
			ret= query_min(qL , qR , rson,x) ;
		 return ret;
	 
	}
};
int lans[maxn]; 
int rans[maxn];
int len[maxn];
int res[maxn];
tree tp1,tp2;
int max(int a,int b)
{
	return a<b?b:a;
}
int main()
{
    int i,a,b;
	int t;
	
	scanf("%d",&n );
	tp1.init();
	tp2.init();
	for (i=1;i<=n;i++) 
		scanf("%d",&tp1.aa[i]); 
	tp1.build(1 , n , 1);
	
	for(i=1;i<=n;i++) 
	{
		lans[i]= tp1.query_min(i+1,n,1,n,1,tp1.aa[i]); 
		if (lans[i]==inf)
		lans[i]=n-i;
		else
			lans[i]-=i+1; 
	}
	for (i=1;i<=n;i++) 
		tp2.aa[i]=tp1.aa[n-i+1]; 
	tp2.build(1 , n , 1);
	
	for(i=1;i<=n;i++) 
	{
		rans[i]= tp2.query_min(i+1,n,1,n,1,tp2.aa[i]); 	
			if (rans[i]==inf)
		rans[i]=n-i;
		else
			rans[i]-=i+1;
	}


	for (i=1;i<=n;i++) 
		len[i]=rans[n-i+1]+lans[i]+1;  //rans是逆序的
					//len[i]是第i个数构造出满足条件的子数组的max长度	
	
	for (i=1;i<=n;i++)
	{ 
		int ll=len[i];
		int vv=tp1.aa[i];
		res[ll]=max(res[ll],vv);
	}
	int maxx=0;
	
	for (i=n;i>=1;i--)
	{
		if (maxx<res[i])
			maxx=res[i];
		res[i]=maxx;
		
	}
	for (i=1;i<=n;i++)
	{			
		if (i!=1) printf(" ");
		printf("%d",res[i]);
	}		
	printf("\n");
	
    return 0;
}