- toc {:toc}
๋ฌธ์
ํ ์ค๋ก ๋ ๊ฐ๋จํ ์๋ํฐ๋ฅผ ๊ตฌํํ๋ ค๊ณ ํ๋ค. ์ด ํธ์ง๊ธฐ๋ ์์ด ์๋ฌธ์๋ง์ ๊ธฐ๋กํ ์ ์๋ ํธ์ง๊ธฐ๋ก, ์ต๋ 600,000 ๊ธ์๊น์ง ์ ๋ ฅํ ์ ์๋ค.
์ด ํธ์ง๊ธฐ์๋ โ ์ปค์ โ ๋ผ๋ ๊ฒ์ด ์๋๋ฐ, ์ปค์๋ ๋ฌธ์ฅ์ ๋งจ ์ (์ฒซ ๋ฒ์งธ ๋ฌธ์์ ์ผ์ชฝ), ๋ฌธ์ฅ์ ๋งจ ๋ค (๋ง์ง๋ง ๋ฌธ์์
์ค๋ฅธ์ชฝ), ๋๋ ๋ฌธ์ฅ ์ค๊ฐ ์์์ ๊ณณ (๋ชจ๋ ์ฐ์๋ ๋ ๋ฌธ์ ์ฌ์ด) ์ ์์นํ ์ ์๋ค. ์ฆ ๊ธธ์ด๊ฐ L ์ธ ๋ฌธ์์ด์ด ํ์ฌ ํธ์ง๊ธฐ์
์ ๋ ฅ๋์ด ์์ผ๋ฉด, ์ปค์๊ฐ ์์นํ ์ ์๋ ๊ณณ์ L+1 ๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์๋ค.
์ด ํธ์ง๊ธฐ๊ฐ ์ง์ํ๋ ๋ช ๋ น์ด๋ ๋ค์๊ณผ ๊ฐ๋ค.
| L | ์ปค์๋ฅผ ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ฎ๊น (์ปค์๊ฐ ๋ฌธ์ฅ์ ๋งจ ์์ด๋ฉด ๋ฌด์๋จ) |
|---|---|
| D | ์ปค์๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์ฎ๊น (์ปค์๊ฐ ๋ฌธ์ฅ์ ๋งจ ๋ค์ด๋ฉด ๋ฌด์๋จ) |
| B | ์ปค์ ์ผ์ชฝ์ ์๋ ๋ฌธ์๋ฅผ ์ญ์ ํจ (์ปค์๊ฐ ๋ฌธ์ฅ์ ๋งจ ์์ด๋ฉด ๋ฌด์๋จ) ์ญ์ ๋ก ์ธํด ์ปค์๋ ํ ์นธ ์ผ์ชฝ์ผ๋ก ์ด๋ํ ๊ฒ์ฒ๋ผ ๋ํ๋์ง๋ง, ์ค์ ๋ก ์ปค์์ ์ค๋ฅธ์ชฝ์ ์๋ ๋ฌธ์๋ ๊ทธ๋๋ก์ |
| P $ | $๋ผ๋ ๋ฌธ์๋ฅผ ์ปค์ ์ผ์ชฝ์ ์ถ๊ฐํจ |
์ด๊ธฐ์ ํธ์ง๊ธฐ์ ์ ๋ ฅ๋์ด ์๋ ๋ฌธ์์ด์ด ์ฃผ์ด์ง๊ณ , ๊ทธ ์ดํ ์ ๋ ฅํ ๋ช ๋ น์ด๊ฐ ์ฐจ๋ก๋ก ์ฃผ์ด์ก์ ๋, ๋ชจ๋ ๋ช ๋ น์ด๋ฅผ ์ํํ๊ณ ๋ ํ
ํธ์ง๊ธฐ์ ์ ๋ ฅ๋์ด ์๋ ๋ฌธ์์ด์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋จ, ๋ช ๋ น์ด๊ฐ ์ํ๋๊ธฐ ์ ์ ์ปค์๋ ๋ฌธ์ฅ์ ๋งจ ๋ค์ ์์นํ๊ณ
์๋ค๊ณ ํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ์ด๊ธฐ์ ํธ์ง๊ธฐ์ ์ ๋ ฅ๋์ด ์๋ ๋ฌธ์์ด์ด ์ฃผ์ด์ง๋ค. ์ด ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ N ์ด๊ณ , ์์ด ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ
์์ผ๋ฉฐ, ๊ธธ์ด๋ 100,000 ์ ๋์ง ์๋๋ค. ๋์งธ ์ค์๋ ์ ๋ ฅํ ๋ช ๋ น์ด์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์ M(1 โค Mย โค
500,000) ์ด ์ฃผ์ด์ง๋ค. ์ ์งธ ์ค๋ถํฐ M ๊ฐ์ ์ค์ ๊ฑธ์ณ ์ ๋ ฅํ ๋ช ๋ น์ด๊ฐ ์์๋๋ก ์ฃผ์ด์ง๋ค. ๋ช ๋ น์ด๋ ์์ ๋ค ๊ฐ์ง ์ค ํ๋์
ํํ๋ก๋ง ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ชจ๋ ๋ช ๋ น์ด๋ฅผ ์ํํ๊ณ ๋ ํ ํธ์ง๊ธฐ์ ์ ๋ ฅ๋์ด ์๋ ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ค.
์ถ์ฒ:https://www.acmicpc.net/problem/1406
ํ์ด
์ฐ๊ฒฐ๋ฆฌ์คํธ ์ผ๋งค ๊ตฌํ๋ฐฉ๋ฒ ํ์คํ๊ฒ ์ตํ๋๊ธฐ โ 3, 4 ๋ฒ ๋ ๊ตฌํํด๋ณด๊ธฐ
์ผ๋งค ํ์ด๋ฒ
// ์ฐ๊ฒฐ๋ฆฌ์คํธ
#include <bits/stdc++.h>
using namespace std;
const int MX = 1000005;
char dat[MX];
int pre[MX], nxt[MX];
int unused = 1;
void insert(int addr, char data){
dat[unused] = data;
pre[unused] = addr;
nxt[unused] = nxt[addr];
if(nxt[addr] != -1) pre[nxt[addr]] = unused;
nxt[addr] = unused;
unused++;
}
void erase(int addr){
nxt[pre[addr]] = nxt[addr];
if(nxt[addr] != -1) pre[nxt[addr]] = pre[addr];
}
void traverse(){
int cur = nxt[0];
while(cur != -1){
cout << dat[cur];
cur = nxt[cur];
}
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
fill(pre, pre+MX, -1);
fill(nxt, nxt+MX, -1);
string str;
int N, M, cursor=0;
char inp;
cin >> str >> M;
N = str.size(); // ๋ฌธ์์ด์ ๊ธธ์ด
for(auto elem : str){ // ๋ฌธ์์ด์ ๋ฌธ์๋ฅผ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ์๋ฃํ
insert(cursor, elem);
cursor++;
}
for (int i = 0; i < M; i++) // ์กฐ์ํค๋ฅผ ๋๋ ์ ๋
{
cin >> inp;
switch (inp){
case 'L':
if(pre[cursor] != -1) cursor = pre[cursor];
break;
case 'D':
if(nxt[cursor] != -1) cursor = nxt[cursor];
break;
case 'B':
if(pre[cursor] != -1){ // ์ปค์์ ์ฐจ์ด dat์ผ ๋ pre์ผ ๋
erase(cursor); // dat์ผ ๋๋ก ํ๋ฉด ์ปค์๊ฐ ํ๋ ๋ ์ด์ ์ผ๋ก ์์นํ๊ฒ ๋จ
cursor = pre[cursor];
}
break;
case 'P':
char c1;
cin >> c1;
insert(cursor, c1);
cursor = nxt[cursor];
break;
}
}
traverse();
return 0;
}STL List ์ฌ์ฉ
ํ์ฌ ๋ฌธ์์ด์ด ABCD ์ผ ๋
(1) A (2) B (3) C (4) D (5)
L.end() โ 5 ๋ฒ
L.begin() โ 1 ๋ฒ
L.erase() ๋ฅผ ์ฌ์ฉํ ๋๋ ์์ชฝ์ ์์นํด์ผ ์ง์ธ ์ ์์.
์๋ฅผ ๋ค์ด 4 ๋ฒ์ ์์ด์ผ D ๋ฅผ ์ง์ธ ์ ์์. ์ดํ ์ค๋ฅธ์ชฝ ๋ฌธ์ ๋ฐํ
3 ๋ฒ ์๋ฆฌ์์ C ๋ฅผ ์ง์ ์ ๊ฒฝ์ฐ 4 ๋ฒ์๋ฆฌ์ ์์นํจ.
L.insert() ๋ ์ฝ์ ํ ๋ฐํ๊ฐ์ด ์๋ ๊ฐ๋ฅดํค๋ ๋ฌธ์๋ฅผ ๊ฐ๋ฅดํด
์๋ฅผ ๋ค์ด K ๋ฅผ 2 ๋ฒ์ ์ฝ์ ํ ๊ฒฝ์ฐ 3 ๋ฒ ์๋ฆฌ์ ์์นํจ.
(1) A (2) K (3) B (4) C (5) D (6)
// ์ฐ๊ฒฐ๋ฆฌ์คํธ stl list ์ฌ์ฉ
#include <bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
list<char> L;
string str;
int M;
cin >> str;
for(auto elem : str) {
L.push_back(elem);
}
auto cursor = L.end();
cin >> M;
char p;
while(M--) {
cin >> p;
switch(p) {
case 'L':
if(cursor != L.begin()) cursor--;
break;
case 'D':
if(cursor != L.end()) cursor++;
break;
case 'B':
if(cursor != L.begin()) {
cursor--;
cursor = L.erase(cursor);
}
break;
case 'P':
char inp;
cin >> inp;
L.insert(cursor, inp);
break;
}
}
for(auto elem : L)
cout << elem;
return 0;
}