POj 2823 单调队列 / 优先队列

解法1:  单调队列

所谓单调队列就是一个单调递增或递减的队列，并不是什么神奇的东西。

单调队列（就递增来说）严格来说就是队头的原素是最大的，不断从队尾加原素，如果队尾的原素比要加入来的原素大，就不断退队，就到队尾的原素比要加入来的原素小或等于要加入来的原素。

这题只要分别维护单调递增和单调递减的队列，每读入一个数就加入两个队列，然后从两个队头拿两个队顶原素出来，[L，R](L,R分别Sliding Windows的左边界和右边界)，如果拿出来的原素在左边界的左边就仍掉，取出来的原素在[L,R]内,就为结果。

代码G++超时了，C++ AC看来还要改进下！

#include <iostream>
#include <cstdio>
using namespace std;
#define MAXN 1000000
struct cnode
{
	int val;
	int INDEX;
}maxqu[MAXN  + 10];//递增队列（队尾到队头递增）
cnode minqu[MAXN + 10];//递减队列
int minans;
int maxans[MAXN + 10];
int mintop;
int minrear;
int maxtop;
int maxrear;
inline void  mininsert(int n,int IND)//加入递减队列
{
	while(minqu[minrear].val> n&&minrear>=mintop)//队尾原素比队尾大，退队
	{
		minrear--;
	}
	minqu[++minrear].val = n;//加原素到队尾
	minqu[minrear].INDEX = IND;
	int i;
/*	cout<<"min"<<endl;
	for(i=mintop;i<=minrear;i++)
	{
		cout<<minqu[i].val<<" ";
	}
	cout<<endl;
	cout<<"min"<<endl;*/

}
inline void  maxinsert(int n,int IND)//加入递增队列
{
	while(maxqu[maxrear].val < n&&maxrear>=maxtop)//队尾原素比队尾小，退队
	{
		maxrear--;
	}
	maxqu[++maxrear].val = n;//加原素到队尾
	maxqu[maxrear].INDEX = IND;
/*cout<<"max"<<endl;
	int i;
	for(i=maxtop;i<=maxrear;i++)
	{
		cout<<maxqu[i].val<<" ";
	}
	cout<<endl;
	cout<<"max"<<endl;*/

}
inline int fmintop(int i,int k)//取队头原素
{
	//return minqu[mintop].val;
	while(minqu[mintop].INDEX < i&&mintop<=minrear)//队头原素在[L,R]的左边，仍掉
	{
		mintop++;
	}
	return minqu[mintop].val;
}
inline int fmaxtop(int i,int k)//取队头原素
{
	 //maxqu[maxtop].val;
	while(maxqu[maxtop].INDEX < i&&maxtop<=maxrear)队头原素在[L,R]的左边，仍掉
	{
		maxtop++;
	}
	return maxqu[maxtop].val;

}
int main()
{
	int n,m;
	int i;
	int num;
	while(scanf("%d %d",&n,&m) != EOF)
	{
		 mintop = 0;
		 minrear = -1;
		maxtop = 0;
		 maxrear = -1;
		for(i = 0;i < n;i++)
		{
			scanf("%d",&num);
			mininsert(num,i);
			maxinsert(num,i);
			if(i>=m-1)
			{
				minans=fmintop(i-m+1,i);
				maxans[i-m+1]=fmaxtop(i-m+1,i);
				printf("%d",minans);
					if(i!=n-1)
			{
				printf(" ");
			}
			}


		}
		n = n-m+1;
		printf("\n");
		for(i=0;i<n;i++)
		{
			printf("%d",maxans[i]);
			if(i!=n-1)
			{
				printf(" ");
			}
		}
		printf("\n");
	}
	return 0;
}

解法2： 优先队列

用上面的做法，换一种数据结构-堆,同样可以解决这道题,也是不断放入最小堆，最大堆，不在[L,R]区间的仍掉

代码G++超时了，C++ AC看来还要改进下！

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
#define MAXN 1000000
struct cnode
{
	int val;
	int INDEX;
	/*	bool operator <  (cnode e)//从大到小
	{
	return e.val<val;
}*/
}node;
struct cmp1{
	bool operator()(const cnode e1,const cnode e2)
	{
		return e1.val<e2.val;
	}
};
struct cmp2
{
	bool operator()(const cnode e1,const cnode e2)
	{
		return e1.val<e2.val? false:true;
	}
};
int maxans[MAXN + 10];
int  main()
{
	int n,m;
	int i;
	int num;
	while(scanf("%d %d",&n,&m) != EOF)
	{
		priority_queue<cnode,vector<cnode>,cmp1> maxqu;//最大堆
			priority_queue<cnode,vector<cnode>,cmp2> minqu;//最小堆
		for(i = 0;i < n;i++)
		{
			scanf("%d",&node.val);
			node.INDEX = i;
			minqu.push(node);
			maxqu.push(node);
			if(i>=m-1)
			{
				node = minqu.top();
				while(node.INDEX<i-m+1)//不在[L,R]区间的仍掉
				{
					minqu.pop();
					node = minqu.top();
					

				}
				printf("%d%c",node.val,i==n-1 ? '\n':' ');
				node = maxqu.top();
				while(node.INDEX<i-m+1)//不在[L,R]区间的仍掉
				{
					maxqu.pop();
					node = maxqu.top();
					

				}
				maxans[i-m+1] = node.val;

			}
			
			
		}
		n = n - m + 1;
		for(i = 0;i < n;i++)
		{
					printf("%d%c",maxans[i],i==n-1 ? '\n':' ');
		}
		
		
		
		
	}
	return 0;
}