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;
}