C++ deque::pop_back方法代码示例

void func(deque<char>& stack, int left, int right, vector<string>& result)
{
	if(left == 0 && right == 0)
	{
		result.push_back(string(stack.begin(),stack.end()));
		return;
	}

	if(left > right)
		return;
	
	if(left > 0)
	{
		stack.push_back('(');
		func(stack,left-1,right,result);
		stack.pop_back();
	}

	if(right > 0)
	{
		stack.push_back(')');
		func(stack,left,right-1,result);
		stack.pop_back();
	}
}

int main()
{
    int n,m,k;
    int ans,now;
    while (~scanf("%d%d%d",&n,&m,&k))
    {
        ans=0;
        now=0;
        q1.clear();
        q2.clear();
        REP(i,n)
        {
            scanf("%d",&a[i]);
            while (!q1.empty()&&q1.back().first<=a[i]) q1.pop_back();
            q1.push_back(mp(a[i],i));
            while (!q2.empty()&&q2.back().first>=a[i]) q2.pop_back();
            q2.push_back(mp(a[i],i));
            while (!q1.empty()&&!q2.empty()&&q1.front().first-q2.front().first>k)
            {
                if (q1.front().second<q2.front().second)
                {
                    now=q1.front().second+1;
                    q1.pop_front();
                }
                else
                {
                    now=q2.front().second+1;
                    q2.pop_front();
                }
            }
            if (!q1.empty()&&!q2.empty()&&q1.front().first-q2.front().first>=m)
                ans=max(ans,i-now+1);
        }
        printf("%d\n",ans);
    }

int main(){
	scanf("%d",&N);
	for(int i=0;i<N;i++){
		scanf("%d%d",&X[i],&H[i]);
		D.push_back( i );
	}
	int ans = 0;
	lr = MAXL, ll = -MAXL;
	while(!D.empty()){
		while(!D.empty() && ll < X[D.front()] - H[D.front()]){
			ans++; ll = X[D.front()]; D.pop_front();
		}
		while(!D.empty() && X[D.back()] + H[D.back()] < lr){
			ans++; lr = X[D.back()]; D.pop_back();
		}
		if(!D.empty()) ll = X[D.front()], lr = X[D.back()];
		// two sides CANNOT be cut outside
		if(!D.empty() && X[D.front()] + H[D.front()] < ( D.size() == 1 ? lr : X[D.front()+1] ) ){
			ans++; ll = X[D.front()] + H[D.front()];
		}
		if(!D.empty() && X[D.back()] - H[D.back()] > ( D.size() == 1 ? ll : X[D.back()-1] ) ){
			ans++; lr = X[D.back()] - H[D.back()];
		}
		if(!D.empty()) D.pop_front();
		if(!D.empty()) D.pop_back();
	}
	printf("%d",ans);
	return 0;
}

void dfs(int v) {

    vector<int> l1, l2;
    while (dq.size() and deep[dq.back()] < deep[v]) {
        l1.PB(dq.back());
        dq.pop_back();
    }
    dq.push_back(v);
    ans[v] = dq[0];
    //cout << v << ' ' << dq[0] << endl;
    for (auto x: el[v]) {
        while (dq.size() and deep[dq[0]] < x) {
            l2.PB(dq[0]);
            dq.pop_front();
        }
        dfs(x);
        while (l2.size()) {
            dq.push_front(l2.back());
            l2.pop_back();
        }
    }
    dq.pop_back();
    while (l1.size()) {
        dq.push_back(l1.back());
        l1.pop_back();
    }
}

void init(){
	
	while(!que.empty())que.pop_back();

	LL sum=str0[n-1];
	int now=n-1,tmp;
	que.push_back(n-1);
	
	for(int i=n-2;i>=0;i--){
		
		sum+=str0[i];
		while(sum>m){
			myleft[now]=i;
			sum-=str0[now];now--;
		}
		
		tmp=que.back();
		while(str0[i]>=str0[tmp]){
		//	printf("%d > %d\n",i,tmp);
			next[tmp]=i;que.pop_back();	
			if(!que.empty())tmp=que.back();
			else break;		
		}
		que.push_back(i);
		
	}
	while(now>=0)myleft[now--]=-1;
	while(!que.empty()){
		tmp=que.back();que.pop_back();
		next[tmp]=-1;
	}
	
}

int main()
{
    int N, W; scanf("%d%d", &N, &W);
    for(int i=0; i<N; ++i) {
        scanf("%d", vals + i);
    }

    int ans=0;
    if (W==1) { printf("%d\n", N); return 0; }

    minque.push_back(pii(vals[0], 0));
    maxque.push_back(pii(vals[0], 0));
    for(int i=1; i<N; ++i) {
        if (minque.front().second <= i-W) minque.pop_front();
        if (maxque.front().second <= i-W) maxque.pop_front();
        while(!minque.empty() && vals[i] <= minque.back().first) {
            minque.pop_back();
        }
        minque.push_back(pii(vals[i], i));
        while(!maxque.empty() && vals[i] >= maxque.back().first) {
            maxque.pop_back();
        }
        maxque.push_back(pii(vals[i], i));
        if (i>=W-1) {
            int mm, xx;
            mm = minque.front().first;
            xx = maxque.front().first; //printf("%d %d\n", mm, xx);
            if (xx - mm == W-1) ans++;
        }
    }
    printf("%d\n", ans);
}

bool check(int x)
{
	v.clear();
	for(int i=0;i<n;++i)
		v.push_back(hf(p[i],p[(i+x)%n]));
	//stable_sort(v.begin(),v.end(),cmp);
	static deque<hf> q;
	static deque<point> ans;
	q.clear(), ans.clear();
	q.push_back(v[0]);
	for(int i=1;i<(int)v.size();++i){
		//if(sgn(ang(v[i].B-v[i].A)-ang(v[i-1].B-v[i-1].A))==0)continue;
		while(ans.size()&&!satisfy(ans.back(),v[i]))
			ans.pop_back(),q.pop_back();
		while(ans.size()&&!satisfy(ans.front(),v[i]))
			ans.pop_front(),q.pop_front();
		if(parallel(q.back(),v[i]))return false;
		ans.push_back(intersect(q.back(),v[i]));
		q.push_back(v[i]);
	}
	while(ans.size()&&!satisfy(ans.back(),q.front()))
		ans.pop_back(),q.pop_back();
	if(parallel(q.back(),q.front()))return false;
	ans.push_back(intersect(q.back(),q.front()));
	double ret=cross(ans.back(),ans.front());
	for(int i=0;i<(int)ans.size()-1;++i)
		ret+=cross(ans[i],ans[i+1]);
	return fabs(ret)>=eps;
//	return OK;
}

void solve()
{
    int sol = -1, st;
    int m, l = X, r = Y, g;
    while( l<=r ) {
        m = (l+r)>>1; g = 0;
        q.clear(); q2.clear();
        for(int i=1; i<=N; i++) {
            while( !q.empty() && A[i]<A[q.back()] ) q.pop_back(); //min
            q.push_back(i);
            while( !q2.empty() && A[i]>A[q2.back()] ) q2.pop_back(); //max
            q2.push_back(i);
            if( i<m ) continue;
            if( A[q2.front()]-A[q.front()]<=Z && m>=sol ) {
                sol = m; st = i-m+1;
                g = 1;
            }
            while( i-q.front()+1==m ) q.pop_front();
            while( i-q2.front()+1==m ) q2.pop_front();
        }
        if(g) l = m+1;
        else r = m-1;
    }

    sol == -1 ? printf("-1") : printf("%d %d %d", sol, st, st+sol-1);
}

void calc()
{
    LL x = q1.back(); q1.pop_back();
    LL y = q1.back(); q1.pop_back();
    char op = q2.back(); q2.pop_back();
    if(op == '*') q1.push_back(x * y); else q1.push_back(x + y);
}

int main(){	
	int m=0;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		double x_1,y_1,x_2,y_2;
		scanf("%lf%lf%lf%lf",&x_1,&y_1,&x_2,&y_2);
		l[m++]=line(point(x_1,y_1),point(x_2-x_1,y_2-y_1));l[m-1].get();
	}
	l[m++]=line(point(0,0),point(1,0));l[m-1].get();
	l[m++]=line(point(10000,0),point(0,1));l[m-1].get();
	l[m++]=line(point(10000,10000),point(-1,0));l[m-1].get();
	l[m++]=line(point(0,10000),point(0,-1));l[m-1].get();
	sort(l,l+m);
	dq.push_back(l[0]);dq.push_back(l[1]);
	for(int i=2;i<m;i++){
		while(dq.size()>1&&!Onleft(dq.back()*dq[dq.size()-2],l[i]))
			dq.pop_back();
		while(dq.size()>1&&!Onleft(dq.front()*dq[1],l[i]))
			dq.pop_front();
		dq.push_back(l[i]);
	}while(dq.size()>1&&!Onleft(dq.back()*dq[dq.size()-2],dq.front()))
		dq.pop_back();
	while(dq.size()>1&&!Onleft(dq.front()*dq[1],dq.back()))
		dq.pop_front();
	vector<point>vec;
	for(int i=0;i<dq.size();i++)vec.push_back(dq[i]*dq[(i+1)%dq.size()]);
	double ans=0;
	for(int i=1;i+1<vec.size();i++){
		ans+=(vec[i]-vec[0])*(vec[i+1]-vec[0]);
	}printf("%.1lf\n",fabs(ans/2));
	return 0;
}

void Styler_Syntax::GetSubSymbols(unsigned int offset, const submatch& sm, deque<const wxString*>& scopes, vector<SymbolRef>& symbols) const {
	for (auto_vector<stxmatch>::const_iterator p = sm.matches.begin(); p != sm.matches.end(); ++p) {
		const stxmatch& m = *(*p);

		if (!m.m_name.empty()) {
			// Add new scope
			scopes.push_back( &m.m_name );

			// Check for matching symbol
			const wxString* transform;
			if (m_syntaxHandler->ShowSymbol(scopes, transform)) {
				const SymbolRef sr = {offset+m.start, offset+m.end, transform};
				symbols.push_back(sr);

				scopes.pop_back();
				continue;
			}
		}

		if (m.subMatch.get()) {
			// Go into subscopes
			GetSubSymbols(offset + m.start, *m.subMatch, scopes, symbols);
		}

		if (!m.m_name.empty()) {
			// Remove current scope
			scopes.pop_back();
		}
	}
}

bool dfs(int p)
{
    if(p == len) return true;
    int x;
    x = s[p]- '0';
    if(x <= n && !vis[x])
    {
        f.PB(x);
        vis[x] = true;
        if(dfs(p + 1)) return true;
        f.pop_back();
        vis[x] = false;
    }
    if(p + 1 < len)
    {
        x = (s[p] - '0') * 10 + s[p + 1] - '0';
        if(x <= n && !vis[x])
        {
            f.PB(x);
            vis[x] = true;
            if(dfs(p + 2)) return true;
            f.pop_back();
            vis[x] = false;
        }
    }
    return false;
}

int main(){
    scanf("%d",&n);
    for (int i=1; i<=n; i++) {
        scanf("%d",&a[i]);
        a[i] += a[i-1];
    }
    for (int i=1; i<=n; i++) {
        px[i-1] = f(i - (n-1) / 2,i);
    }
    for (int i=0; i<n+(n-1)/2; i++) {
        if(!num.empty() && num.front() == i - (n+1)/2){
            num.pop_front();
            dq.pop_front();
        }
        while (!dq.empty() && dq.back() > px[i%n]) {
            num.pop_back();
            dq.pop_back();
        }
        dq.push_back(px[i%n]);
        num.push_back(i);
        if(i - (n-1)/2 >= 0){
            qx[i - (n-1)/2] = dq.front();
        }
    }
    printf("%d",*max_element(qx,qx+n));
}

int main(){
    while(T-- && ~(scanf("%d",&N))){
        qmax.clear();
        qmin.clear();
        int ans = 0;
        int l = 1;
        for (int i = 1;i <= N;i++){
            scanf("%d",&tmp.val);
            tmp.num = i;
            while(!qmax.empty() && tmp.val > qmax.back().val) qmax.pop_back();
            qmax.push_back(tmp);
            while(!qmin.empty() && tmp.val < qmin.back().val) qmin.pop_back();
            qmin.push_back(tmp);
            while(qmax.front().val-qmin.front().val > 1){
                if (qmax.front().num > qmin.front().num){
                    l = max(l,qmin.front().num+1);
                    qmin.pop_front();
                }
                else if (qmax.front().num < qmin.front().num){
                    l = max(l,qmax.front().num+1);
                    qmax.pop_front();
                }
                else{
                    l = max(l,qmax.front().num+1);
                    qmin.pop_front(), qmax.pop_front();
                }
            }
            ans = max(ans,i-l+1);
        }
        printf("%d\n",ans);
    }
    return 0;
}

int main(){
	scanf("%d %d",&n,&l);
	for (int i=0; i<n; i++) {
		scanf("%d %d",&a[i].first, &a[i].second);
		a[i].second = abs(a[i].second);
	}
	sort(a, a+n);
	for (int i=0; i<n; ) {
		int e = i;
		while(e < n && a[e].first == a[i].first) e++;
		while (stk.size() >= 2 && cross(stk[stk.size()-2], stk.back()) > cross(stk.back(), a[i])) {
			stk.pop_back();
		}
		stk.push_back(a[i]);
		i = e;
	}
	double ret = 0;
	while(stk.size() >= 2 && cross(stk[0], stk[1]) < 0) stk.pop_front();
	while(stk.size() >= 2 && cross(stk[stk.size()-2], stk.back()) > l) stk.pop_back();
	ret = max(ret, solve(0, cross(stk[0], stk[1]), stk[0]));
	ret = max(ret, solve(cross(stk[stk.size()-2], stk.back()), l, stk.back()));
	for(int i=1; i+1<stk.size(); i++){
		ret = max(ret, solve(cross(stk[i-1], stk[i]), cross(stk[i], stk[i+1]), stk[i]));
	}
	printf("%lf",ret);
}