题目链接
AcWing 3547. 特殊数字
AcWing 3548. 双端队列
AcWing 3549. 最长非递减子序列
题目描述
3547.特殊数字
我们规定，对于一个整数 a，如果其各位数字相加之和能够被 4 整除，则称它是一个特殊数字。
现在，给定一个整数 n，请你计算并输出不小于 n 的最小特殊数字。
输入格式
一个整数 n。
输出格式
一个整数，表示不小于 n 的最小特殊数字。
数据范围
对于 30% 的数据，
1
≤
n
≤
100
1≤n≤100
1≤n≤100。
对于 100% 的数据，
1
≤
n
≤
1000
1≤n≤1000
1≤n≤1000。
输入样例：
42
输出样例：
44
- 时间复杂度： O ( n ) O(n) O(n)
代码：
#include<iostream>
using namespace std;
//计算 x 的每一位数的和
int fun(int x){
string s = to_string(x);
int ans = 0;
for(auto &c:s) ans += (c-'0');
return ans;
}
int main(){
//根据题意直接模拟即可
int n;
cin>>n;
while(true){
if(fun(n) % 4 == 0) break;
n++;
}
cout<<n<<endl;
return 0;
}
3548.双端队列
给定一个双端队列，初始时队列为空。
你要对其进行 q 次操作，每次操作可能是以下三种之一：
L x，从队列的左端插入整数 x。
R x，从队列的右端插入整数 x。
? x，请你计算为了使已经处于队列中的整数 x 位于队列的最左端或最右端，至少需要从最左端或最右端弹出多少个数字。
保证操作 3 一定合法（ ? x 中的 x 一定已经处于队列之中）。
每个数字最多被插入到队列中 1 次（队列中一定不会存在重复数字）。
注意，操作 3 只是询问最少需要弹出多少数字，不是真的要弹出它们，队列中的数字始终不会减少。
输入格式
第一行包含整数 q。
接下来 q 行，每行包含一个操作信息，格式如题所述。
输出格式
对于每个操作 3，输出一行，一个整数表示结果。
数据范围
对于 30% 的数据，
1
≤
q
≤
30
,
1
≤
x
≤
30
1≤q≤30,1≤x≤30
1≤q≤30,1≤x≤30。
对于 100% 的数据，
1
≤
q
≤
2
×
1
0
5
,
1
≤
x
≤
2
×
1
0
5
1≤q≤2×10^5,1≤x≤2×10^5
1≤q≤2×105,1≤x≤2×105。
保证至少包含一个操作 3，
保证操作 1 和 2 不会重复插入数字。
保证操作 3 不会询问队列中不存在的数字。
输入样例1：
8
L 1
R 2
R 3
? 2
L 4
? 1
L 5
? 1
输出样例1：
1
1
2
输入样例2：
10
L 100
R 100000
R 123
L 101
? 123
L 10
R 115
? 100
R 110
? 115
输出样例2：
0
2
1
分析：
根据题意，我们只需要构建一个双向链表，可以在前面插入元素，也可以在后面插入元素。只需要遍历一遍链表找到对应的x的位置，要弹出左边元素的个数 与 要弹出右边元素的个数 取个min即可。
但实际上我们并不需要真正的模拟这个过程。我们只需要对相应的下标做操作即可。
- 时间复杂度： O ( n ) O(n) O(n)
代码：
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 2e5+10;
int idx[N];
int main(){
int q;
cin>>q;
int l = 0,r = -1;
while(q--){
char op[2];
int x;
scanf("%s%d",op,&x);
if(*op == 'L'){
idx[x] = --l;
}
else if(*op == 'R'){
idx[x] = ++r;
}
else{
cout<<min(idx[x] - l,r - idx[x])<<endl;
}
}
return 0;
}
3549. 最长非递减子序列
给定一个长度为 n 的数字序列 a 1 , a 2 , … , a n a_1,a_2,…,a_n a1,a2,…,an，序列中只包含数字 1 和 2。
现在，你要选取一个区间 [ l , r ] ( 1 ≤ l ≤ r ≤ n ) [l,r](1≤l≤r≤n) [l,r](1≤l≤r≤n)，将 a l , a l + 1 , … , a r a_l,a_{l+1},…,a_r al,al+1,…,ar进行翻转，并且使得到的新数字序列 a 的最长非递减子序列的长度尽可能长。
请问，这个最大可能长度是多少？
一个非递减子序列是指一个索引为 p 1 , p 2 , … , p k p_1,p_2,…,p_k p1,p2,…,pk 的序列，满足 p 1 < p 2 < … < p k p_1<p_2<…<p_k p1<p2<…<pk 并且 a p 1 ≤ a p 2 ≤ … ≤ a p k a_{p1}≤a_{p2}≤…≤a_{pk} ap1≤ap2≤…≤apk，其长度为 k。
输入格式
第一行一个整数 n。
第二行 n 个空格隔开的数字 1 或 2，表示 a 1 , … , a n a_1,…,a_n a1,…,an。
输出格式
输出一个整数，表示得到的新数字序列 a 的最长非递减子序列的最大可能长度。
数据范围
对于 30% 的数据，
1
≤
n
≤
100
1≤n≤100
1≤n≤100。
对于 100% 的数据，
1
≤
n
≤
1
0
6
1≤n≤10^6
1≤n≤106。
本题读入数据规模较大，需注意优化读入。
C++ 尽量使用 scanf 读入，Java 尽量使用 BufferedReader 读入。
输入样例1：
4
1 2 1 2
输出样例1：
4
输入样例2：
10
1 1 2 2 2 1 1 2 2 1
输出样例2：
9
分析：
按照题意，我们翻转一个区间 [ l , r ] [ l , r ] [l,r]之后，将会得到最大的非递减上升子序列。那么其翻转之前的形式应该是如下的：
所以可能有四种合法情况：
- 只有第一段存在，111111…，用 s1 记录第一种情况的长度
- 第一段和第二段都存在，111111122222…，用 s2 记录第二种情况的长度
- 前三段都存在，11111222211111，用 s3 记录第三种情况的长度
- 四段全部存在，11111222211112222，用 s4 记录第四种情况的长度
- 最后的答案即为 max{ s1,s2,s3,s4 }
- 时间复杂度: O ( n ) O(n) O(n)
代码：
#include<iostream>
using namespace std;
int main(){
int n ;
cin>>n;
int s1 = 0,s2 = 0,s3 = 0,s4 = 0;
for(int i = 1;i <= n;i++){
int x;
scanf("%d",&x);
//如果x = 1，有可能是加在 s1 后面，也有可能是加在 s3 后面
//s1 111111....
//s3 11111222211111...
if(x == 1){
s1++;
//s3 此时的情况有可能是 1111122222 + 1
//也有可能是 1111122221111... + 1
//所以要取两者的最大值
s3 = max(s3+1,s2+1);
}
//x = 2既有可能是加在 s2 后面，也有可能是加在 s4 后面
//s2 111112222....
//s4 11111222211112222....
else{
s2 = max(s1+1,s2+1);
s4 = max(s3+1,s4+1);
}
}
cout<<max(s3,s4)<<endl;
return 0;
}
![[ADT笔记]图(graph)](https://img-blog.csdnimg.cn/6d6a9250b0e142cf80f2adb585b9f4b2.png#pic_center)
