代码随想录算法训练营第36期DAY10

DAY10

学习了王道-数据结构考研-KMP部分+ACWING算法基础课KMP模板。接下来补DAY9的任务、完成DAY10习题。

（卡码网）替换数字，数组填充问题

新的双指针法：针对数组填充

自己写一遍看能不能过：又学到了：cout<<s<<endl；可以直接打印出string s;

1. #include<iostream>
2. using namespace std;
3. int main()
4. {
5.     string s;
6.     cin>>s;
7.     int lo=s.size(),count=0;
8.     for(int i=0;i<lo;i++)
9.         if(s[i]<='9'&&s[i]>='0') count++;
10.     int ln=lo+count*5;
11.     s.resize(ln);
12.     for(int i=lo-1,j=ln-1;i<j;i--,j--)
13.     {
14.         if(s[i]>'9'||s[i]<'0') s[j]=s[i];
15.         else{
16.             s[j]='r';
17.             s[j-1]='e';
18.             s[j-2]='b';
19.             s[j-3]='m';
20.             s[j-4]='u';
21.             s[j-5]='n';
22.             j-=5;
23.         }
24.     }
25.     cout<<s<<endl;
26.     return 0;
27. }

232用栈实现队列

Stack是栈 stack<int>

Queue是队列 queue<int>

在ACWING语法基础课上学过，回顾一下：

代码随想录的，并没有把in栈固定起来（不复原），动态地，就比较难理解。这里使用acwing的。易懂简单可靠！

1. class MyQueue {
2. public:
3.     stack<int> s1,s2;
4.     MyQueue() {
6.     }
7.     
8.     void push(int x) {
9.         s1.push(x);
10.     }
11.     
12.     int pop() {
13.         while(s1.size()>1) s2.push(s1.top()),s1.pop();
14.         int t=s1.top();
15.         s1.pop();
16.         while(s2.size()>0) s1.push(s2.top()),s2.pop();
17.         return t;
18.     }
19.     
20.     int peek() {
21.         while(s1.size()>1) s2.push(s1.top()),s1.pop();
22.         int t=s1.top();
23.         while(s2.size()>0) s1.push(s2.top()),s2.pop();
24.         return t;
25.     }
26.     
27.     bool empty() {
28.         return s1.empty();
29.     }
30. };
32. /**
33.  * Your MyQueue object will be instantiated and called as such:
34.  * MyQueue* obj = new MyQueue();
35.  * obj->push(x);
36.  * int param_2 = obj->pop();
37.  * int param_3 = obj->peek();
38.  * bool param_4 = obj->empty();
39.  */

225用队列实现栈

队列头部元素是front，队列没有pop

1. class MyStack {
2. public:
3.     queue<int> p1,p2;
4.     MyStack() {
6.     }
7.     
8.     void push(int x) {
9.         p1.push(x);
10.     }
11.     
12.     int pop() {
13.         while(p1.size()>1) p2.push(p1.front()),p1.pop();
14.         int res=p1.front();
15.         p1.pop();
16.         p1=p2;
17.         while(!p2.empty()) p2.pop();
18.         return res;
19.     }
20.     
21.     int top() {
22.        return p1.back();
23.     }
24.     
25.     bool empty() {
26.         return p1.empty();
27.     }
28. };
30. /**
31.  * Your MyStack object will be instantiated and called as such:
32.  * MyStack* obj = new MyStack();
33.  * obj->push(x);
34.  * int param_2 = obj->pop();
35.  * int param_3 = obj->top();
36.  * bool param_4 = obj->empty();
37.  */

总结：

题目中允许使用的：

Stack:竖着放,top(),pop()

Queue:横着放，有back(),front(),pop()

他们都有push(),empty(),size(),

ACWING831KMP字符串

Next数组：最大后缀和前缀相等

1. #include<iostream>
2. using namespace std;
3. const int N=10010,M=100010;
4. int n,m;
5. char p[N],s[M];
6. //不要写next[N]，因为有可能报错，写ne。
7. int ne[N];
8. int main()
9. {
10.     //让下标从1开始
11.     cin>>n>>p+1>>m>>s+1;
12.     
13.     //求next数组：next[1]=0 第一个字母失败了，就只能从0开始。
14.     //从最长匹配前后缀来理解，就好写算法模版了.即：p[1,i]=p[i-1+1,j];
15. 因为next[1]=0,那么i=2开始
16.     for(int i=2,j=0;i<=n;i++)
17.     {
18.         while(j&&p[i]!=p[j+1]) j=ne[j];
19. //这时候是自己和自己做KMP匹配，j+1是因为：分界线之后才开始真正匹配.
20.         if(p[i]==p[j+1]) j++;
21.         ne[i]=j;//求得是next[i]
22.     }
23.     
24.     //KMP匹配过程
25.     //记住：当前与s[i]匹配的应当是p[j+1]。即：j总是往前错一位。
26.     for(int i=0,j=0;i<=m;i++)
27.     {/*j不在0位，且两者匹配不上。持续相同情况用while：
28.     一直退直到退无可退（j==0),也可能是已经匹配上了。那么之后用if来判断是两种情况中的哪一种
29.     */
30.         while(j&&s[i]!=s[j+1]) j=ne[j];
31.         if(s[i]==p[j+1]) j++;
32.         //匹配成功
33.         if(j==n)
34.         {
35.             //返回出现的起始位置记得+1；画个图就好模拟了
36.             printf("%d ",i-n+1);
37.             //匹配好了，继续匹配的话，i不回溯，j=ne[j](不理解);
38. //解释：把前面的匹配成功的信息利用起来的意思
39.             j=ne[j];//
40.         }
41.     }
42.     return 0;
43. }

如果题目的下标（一般来说都是）是从0开始，那么printf(“%d “,i-n+1);改成printf(“%d “,i-n);即可。