有n个小组要排成一个队列，每个小组中有若干人。
当一个人来到队列时，如果队列中已经有了自己小组的成员，他就直接插队排在自己小组成员的后面，否则就站在队伍的最后面。
请你编写一个程序，模拟这种小组队列。
输入格式：
输入将包含一个或多个测试用例。
对于每个测试用例，第一行输入小组数量t。
接下来t行，每行输入一个小组描述，第一个数表示这个小组的人数，接下来的数表示这个小组的人的编号。
编号是0到999999范围内的整数。
一个小组最多可包含1000个人。
最后，命令列表如下。 有三种不同的命令：
1、ENQUEUE x - 将编号是x的人插入队列；
2、DEQUEUE - 让整个队列的第一个人出队；
3、STOP - 测试用例结束
每个命令占一行。
当输入用例t=0时，代表停止输入。
需注意：测试用例最多可包含200000（20万）个命令，因此小组队列的实现应该是高效的：
入队和出队都需要使用常数时间。
输出样例
对于每个测试用例，首先输出一行“Scenario #k”，其中k是测试用例的编号。
然后，对于每个DEQUEUE命令，输出出队的人的编号，每个编号占一行。
在每个测试用例（包括最后一个测试用例）输出完成后，输出一个空行。
数据范围
1≤t≤1000
输入样例：
2
3 101 102 103
3 201 202 203
ENQUEUE 101
ENQUEUE 201
ENQUEUE 102
ENQUEUE 202
ENQUEUE 103
ENQUEUE 203
DEQUEUE
DEQUEUE
DEQUEUE
DEQUEUE
DEQUEUE
DEQUEUE
STOP
2
5 259001 259002 259003 259004 259005
6 260001 260002 260003 260004 260005 260006
ENQUEUE 259001
ENQUEUE 260001
ENQUEUE 259002
ENQUEUE 259003
ENQUEUE 259004
ENQUEUE 259005
DEQUEUE
DEQUEUE
ENQUEUE 260002
ENQUEUE 260003
DEQUEUE
DEQUEUE
DEQUEUE
DEQUEUE
STOP
0
输出样例：
Scenario #1
101
102
103
201
202
203
Scenario #2
259001
259002
259003
259004
259005
260001
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1010, M = 1000010;
int teamid[M]; //每个人的队伍id
int main()
{
int n, C = 1;
while(cin >> n, n) //输入一个n，n不为0继续
{
printf("Scenario #%d\n", C ++);
for(int i = 0; i < n; i++)
{
int cnt;
cin >> cnt;
while(cnt --)
{
int x;
cin >> x;
teamid[x] = i;
}
}
queue<int> team; //组间顺序
queue<int> person[N]; //组内顺序
string command;
while(cin >> command, command != "STOP")
{
if(command == "ENQUEUE")
{
int x;
cin >> x;
int tid = teamid[x];
if(person[tid].empty()) team.push(tid);
person[tid].push(x);
}
else
{
int tid = team.front(); //出队最前面的编号
auto &q = person[tid];
cout << q.front() << endl;
q.pop();
if(q.empty()) team.pop(); //q为空 删小组
}
}
cout << endl;
}
return 0;
}蛐蛐国最近蚯蚓成灾了！
隔壁跳蚤国的跳蚤也拿蚯蚓们没办法，蛐蛐国王只好去请神刀手来帮他们消灭蚯蚓。
蛐蛐国里现在共有 n 只蚯蚓，第 i 只蚯蚓的长度为 ai，所有蚯蚓的长度都是非负整数，即可能存在长度为0的蚯蚓。
每一秒，神刀手会在所有的蚯蚓中，准确地找到最长的那一只，将其切成两段。
若有多只最长的，则任选一只。
神刀手切开蚯蚓的位置由有理数 p 决定。
一只长度为 x 的蚯蚓会被切成两只长度分别为 ?px?和 x??px?的蚯蚓。
特殊地，如果这两个数的其中一个等于0，则这个长度为0的蚯蚓也会被保留。
此外，除了刚刚产生的两只新蚯蚓，其余蚯蚓的长度都会增加一个非负整数 q 。
蛐蛐国王知道这样不是长久之计，因为蚯蚓不仅会越来越多，还会越来越长。
蛐蛐国王决定求助于一位有着洪荒之力的神秘人物，但是救兵还需要 m 秒才能到来。
蛐蛐国王希望知道这 m 秒内的战况。
具体来说，他希望知道：
1.m 秒内，每一秒被切断的蚯蚓被切断前的长度，共有 m 个数。
2.m 秒后，所有蚯蚓的长度，共有 n+m 个数。
输入格式
第一行包含六个整数 n,m,q,u,v,t，其中：n,m,q 的意义参考题目描述；u,v,t 均为正整数；你需要自己计算 p=u/v（保证 0<u<v）；t 是输出参数，其含义将会在输出格式中解释。
第二行包含 n 个非负整数，为 a1,a2,…,an，即初始时 n 只蚯蚓的长度。
同一行中相邻的两个数之间，恰好用一个空格隔开。
输出格式
第一行输出 ?m/t? 个整数，按时间顺序，依次输出第 t 秒，第 2t 秒，第 3t 秒，……被切断蚯蚓（在被切断前）的长度。
第二行输出 ?(n+m)/t? 个整数，输出 m 秒后蚯蚓的长度；需要按从大到小的顺序，依次输出排名第 t，第 2t，第 3t，……的长度。
同一行中相邻的两个数之间，恰好用一个空格隔开。
即使某一行没有任何数需要输出，你也应输出一个空行。
请阅读样例来更好地理解这个格式。
数据范围
1≤n≤105,
0≤ai≤108,
0<p<1,
0≤q≤200,
0≤m≤7?106,
0<u<v≤109,
1≤t≤71
输入样例：
3 7 1 1 3 1
3 3 2
输出样例：
3 4 4 4 5 5 6
6 6 6 5 5 4 4 3 2 2
样例解释
样例中，在神刀手到来前：3只蚯蚓的长度为3,3,2。
1秒后：一只长度为3的蚯蚓被切成了两只长度分别为1和2的蚯蚓，其余蚯蚓的长度增加了1。最终4只蚯蚓的长度分别为(1,2),4,3。 括号表示这个位置刚刚有一只蚯蚓被切断。
2秒后：一只长度为4的蚯蚓被切成了1和3。5只蚯蚓的长度分别为：2,3,(1,3),4。
3秒后：一只长度为4的蚯蚓被切断。6只蚯蚓的长度分别为：3,4,2,4,(1,3)。
4秒后：一只长度为4的蚯蚓被切断。7只蚯蚓的长度分别为：4,(1,3),3,5,2,4。
5秒后：一只长度为5的蚯蚓被切断。8只蚯蚓的长度分别为：5,2,4,4,(1,4),3,5。
6秒后：一只长度为5的蚯蚓被切断。9只蚯蚓的长度分别为：(1,4),3,5,5,2,5,4,6。
7秒后：一只长度为6的蚯蚓被切断。10只蚯蚓的长度分别为：2,5,4,6,6,3,6,5,(2,4)。
所以，7秒内被切断的蚯蚓的长度依次为3,4,4,4,5,5,6。
7秒后，所有蚯蚓长度从大到小排序为6,6,6,5,5,4,4,3,2,2。
#include <iostream>
#include <algorithm>
#include <limits.h>
using namespace std;
const int N = 100010, M = 7000010;
int n, m, q, u, v, t;
int q1[N], q2[M], q3[M];
int hh1, hh2, hh3, tt1, tt2 = -1, tt3 = -1;
int delta; //定义整个的偏移量
int get_max() //求最大值，并删掉
{
int x = INT_MIN;
if(hh1 <= tt1) x = max(x, q1[hh1]);
if(hh2 <= tt2) x = max(x, q2[hh2]);
if(hh3 <= tt3) x = max(x, q3[hh3]);
if(hh1 <= tt1 && x == q1[hh1]) hh1++; //在第一个选
else if(hh2 <= tt2 && x == q2[hh2]) hh2++;
else hh3++;
return x;
}
int main()
{
scanf("%d%d%d%d%d%d", &n, &m, &q, &u, &v, &t);
for(int i = 0; i < n; i++) scanf("%d", &q1[i]); //读入原序列每一段的长度
sort(q1, q1 + n); //从小到大排序
reverse(q1, q1 + n);
tt1 = n - 1;
for(int i = 1; i <= m; i++)
{
int x = get_max();
x += delta; //x + delta 等于原来值
int left = x * 1ll * u / v;
int right = x - left;
if(i % t == 0) printf("%d ", x);
delta += q;
q2[++ tt2] = left - delta;
q3[++ tt3] = right - delta;
}
puts("");
for(int i = 1; i <= n + m; i++)
{
int x = get_max();
if(i % t == 0) printf("%d ", x + delta);
}
puts("");
return 0;
}达达现在碰到了一个棘手的问题，有N个整数需要排序。
达达手头能用的工具就是若干个双端队列。
她从1到N需要依次处理这N个数，对于每个数，达达能做以下两件事：
1．新建一个双端队列，并将当前数作为这个队列中的唯一的数；
2．将当前数放入已有的队列的头之前或者尾之后。
对所有的数处理完成之后，达达将这些队列按一定的顺序连接起来后就可以得到一个非降的序列。
请你求出最少需要多少个双端序列。
输入格式
第一行输入整数N，代表整数的个数。
接下来N行，每行包括一个整数Di,代表所需处理的整数。
输出格式
输出一个整数，代表最少需要的双端队列数。
数据范围
1≤N≤200000
输入样例：
6
3
6
0
9
6
3
输出样例：
2
#include <iostream>
#include <algorithm>
#include <limits.h>
using namespace std;
typedef pair<int, int> PII;
const int N = 200010;
int n;
PII a[N];
int main()
{
cin >> n;
for(int i = 0; i < n; i++)
{
cin >> a[i].first; //数值
a[i].second = i; //下标
}
sort(a, a + n); //从小到大排序
int res = 1, last = INT_MAX, dir = -1; //res一共要分多少段, last 上一点， dir -1表示下降
for(int i = 0; i < n; )
{
int j = i; //找出相同的段数
while(j < n && a[j].first == a[i].first) j++;
int minp = a[i].second, maxp = a[j - 1].second;
if(dir == -1) //如果前面趋势是下降的
{
if(last > maxp) last = minp;
else dir = 1,last = maxp;
}
else
{
if(last < minp) last = maxp;
else
{
res ++; //开一个新的坡谷
dir = -1;
last = minp;
}
}
i = j;
}
cout << res << endl;
return 0;
}输入一个长度为n的整数序列，从中找出一段长度不超过m的连续子序列，使得子序列中所有数的和最大。
输入格式
第一行输入两个整数n,m。
第二行输入n个数，代表长度为n的整数序列。
同一行数之间用空格隔开。
输出格式
输出一个整数，代表该序列的最大子序和。
数据范围
1≤n,m≤300000
输入样例：
6 4
1 -3 5 1 -2 3
输出样例：
7
#include <iostream>
#include <limits.h>
using namespace std;
typedef long long LL;
const int N = 300010;
int n, m;
int q[N]; //单调队列
LL s[N]; //前缀和数组
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++)
{
cin >> s[i];
s[i] += s[i - 1]; //计算前缀和序列
}
int hh = 0, tt = 0; //单调队列队头 队尾
LL res = INT_MIN;
for(int i = 1; i <= n; i++)
{
if(i - q[hh] > m) hh++; //把不在范围里的队列弹出去
res = max(res, s[i] - s[q[hh]]);
while(hh <= tt && s[q[tt]] >= s[i]) tt --; //(hh <= tt 表示队列不空 && 队尾元素 >= 当前元素
q[++ tt] = i; //当前数插到队尾里去
}
cout << res <<endl;
return 0;
}原文：https://www.cnblogs.com/wmxnlfd/p/10889018.html