[๋ฌธ์ ์ค๋ช ]
๋ค์ ๊ท์น์ ์งํค๋ ๋ฌธ์์ด์ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๊ณ ์ ์ํฉ๋๋ค.
- (), [], {} ๋ ๋ชจ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค.
- ๋ง์ฝ A๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๋ฉด, (A), [A], {A} ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค. ์๋ฅผ ๋ค์ด, [] ๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ฏ๋ก, ([]) ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค.
- ๋ง์ฝ A, B๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๋ฉด, AB ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค. ์๋ฅผ ๋ค์ด, {} ์ ([]) ๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ฏ๋ก, {}([]) ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋๋ค.
๋๊ดํธ, ์ค๊ดํธ, ๊ทธ๋ฆฌ๊ณ ์๊ดํธ๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด s๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ด s๋ฅผ ์ผ์ชฝ์ผ๋ก x (0 ≤ x < (s์ ๊ธธ์ด)) ์นธ๋งํผ ํ์ ์์ผฐ์ ๋ s๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด ๋๊ฒ ํ๋ x์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
[์ ํ์ฌํญ]
s์ ๊ธธ์ด๋ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค.
[์ ์ถ๋ ฅ ์]
s | result |
"[](){}" | 3 |
"}]()[{" | 2 |
"[)(]" | 0 |
"}}}" | 0 |
[์ ์ถ๋ ฅ ์ ์ค๋ช ]
์ ์ถ๋ ฅ ์ #1
๋ค์ ํ๋ "[](){}" ๋ฅผ ํ์ ์ํจ ๋ชจ์ต์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
x | s๋ฅผ ์ผ์ชฝ์ผ๋ก x์นธ๋งํผ ํ์ | ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด? |
0 | "[](){}" | O |
1 | "](){}[" | X |
2 | "(){}[]" | O |
3 | "){}[](" | X |
4 | "{}[]()" | O |
5 | "}[](){" | X |
=> ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด ๋๋ x๊ฐ 3๊ฐ์ด๋ฏ๋ก, 3์ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
๋ค์ ํ๋ "}]()[{" ๋ฅผ ํ์ ์ํจ ๋ชจ์ต์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
x | s๋ฅผ ์ผ์ชฝ์ผ๋ก x์นธ๋งํผ ํ์ | ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด? |
0 | "}]()[{" | X |
1 | "]()[{}" | X |
2 | "()[{}]" | O |
3 | ")[{}](" | X |
4 | "[{}]()" | O |
5 | "{}]()[" | X |
=> ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด ๋๋ x๊ฐ 2๊ฐ์ด๋ฏ๋ก, 2๋ฅผ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
s๋ฅผ ์ด๋ป๊ฒ ํ์ ํ๋๋ผ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋ง๋ค ์ ์์ผ๋ฏ๋ก, 0์ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #4
s๋ฅผ ์ด๋ป๊ฒ ํ์ ํ๋๋ผ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ ๋ง๋ค ์ ์์ผ๋ฏ๋ก, 0์ return ํด์ผ ํฉ๋๋ค.
[๋ฌธ์ ํ์ด]
์ฌ๋ฐ๋ฅธ ๋ฌธ์์ด์ธ์ง ์๋์ง๋ง ํ์ํ๋ฉด ๋๋ฏ๋ก, ์ฌ๋ฐ๋ฅธ ๋ฌธ์์ด์ด ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํํด์ฃผ๋ฉด ๋๋ค.
์ฆ, ๋ค์ 3๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์.
โ (}) ์ด๋ ๊ฒ ๊ดํธ ์ค๊ฐ์ ์๋ชป๋ ๋ซํ ๊ดํธ๊ฐ ๋ค์ด์จ ๊ฒฝ์ฐ
โก ), }, ] ๋ฑ ๋ซํ ๊ดํธ๋ก ์์ํ๋ ๊ฒฝ์ฐ
โข ๊ดํธ๊ฐ ํ์๊ฐ ์ ๋ ฅ๋์ด ๊ดํธ ์์ด ๋ง์ง ์๋ ๊ฒฝ์ฐ
๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์๊ฐํ ๊ฒ๋ค... ์๊ฐ์ ํ๋ฆ ์ฒจ๋ถ
1. ๋ฌธ์์ด s๋ ์ด๋ค ์๋ฃํ์ผ๋ก ๋ฐ์ง? string? char?
ํ๊ธ์์ฉ ์ ์ฅํด์ผํ๋๊น char์ด ๋์ ๊ฑฐ ๊ฐ๋ค.
๊ทผ๋ฐ ํ๋ก๊ทธ๋๋จธ์ค์ ๋์์๋ ๊ธฐ๋ณธํ์ string์ด๋ผ๋ค ํํ
2. ์๊ณ ๋ฆฌ์ฆ์ ๋๋ต์ ์ธ ํ์?
1) ๋ฌธ์๊ธธ์ด๋งํผ ์ผ์ชฝ์ผ๋ก ํ์นธ์ฉ ํ์
2) ์ฌ๋ฐ๋ฅธ ๊ดํธ์ธ์ง ์ฒดํฌ
3) ์ฌ๋ฐ๋ฅธ ๊ดํธ์ด๋ฉด count๊ฐ 1์ฉ ๋๋ ค์ฃผ๊ธฐ
4) ๋ง์ง๋ง์ count๊ฐ ์ถ๋ ฅ
3. ํ์์ ๋น ์ ธ๋์ฌ ์กฐ๊ฑด?
๊ฑฐ์ง์ด ๋ ๊ฒฝ์ฐ์ ์
โ ), }, ]๋ก ์์ํ๋ ๊ฒฝ์ฐ
โก (, {, [๋ก ๋๋๋ ๊ฒฝ์ฐ
โข ์ฃผ์ด์ง ๋ฌธ์์ด์ ๊ธธ์ด(=๊ฐ์)๊ฐ ํ์์ธ ๊ฒฝ์ฐ
4. ์ฌ๋ฐ๋ฅธ ๊ดํธ์ธ์ง๋ ์ด๋ป๊ฒ ์ฒดํฌํ์ง?
๋ฌธ์ ํํธ์์ A๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ฉด (A) or [A] or {A} ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ผ๋ค?
์๋ฅผ ๋ค์ด, []๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด๋ฏ๋ก ([]) ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ธ๊ฑฐ...
๊ทผ๋ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ๋ฅผ ์ด๋ป๊ฒ ์ฐพ๋์ง๋ฅผ ๋ชจ๋ฅด๊ฒ๋ค.
๊ฒ์ํด๋ณด๋ (, {, [ ๋ฅผ ๋ง๋ ๋๋ง๋ค stack์ ๋ฃ์ด์ฃผ๊ณ
), }, ] ๋ฅผ ๋ง๋ ๋ ๋ง๋ค ๊ฐ์ฅ ๋ง์ง๋ง์ ๋ฃ์(์ต์ ) ์ฌ๋ ๊ดํธ๊ฐ ๋ง๋์ง ๋น๊ตํ๋ค.
์๋ํ๋ฉด ์์ ๊ดํธ๊ฐ ์ฌ๋ฐ๋ฅธ ๊ดํธ์ฌ์ผ ๋ฐ๊นฅ ๊ดํธ๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ์ผ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ฆ, ์๋ฅผ๋ค์ด (}) ์ด๋ ๊ฒ ๋๋ฉด ์ ์์ ์ธ ๊ดํธ๊ฐ ์๋๋ค.
๊ทธ๋ผ ํ์ ์ ์ด๋ป๊ฒ ํํํด์ผ ํ ๊น?
๋งจ ์์๊ป ๋นผ์ ๋ค๋ก ๋ฃ๋ ๊ตฌ์กฐ๋๊น queue๋ฅผ ์ด์ฉํด์ผ๊ฒ ๋ค! -> ๋ฌธ์ ์์ string์ ์ฌ์ฉํ์ผ๋ string์ ์ฌ์ฉํด์ ๋ฌธ์๋ฅผ ํ์ ํ๋ ๋ฒ์ ์ฐพ์๋ด์ผ๊ฒ ๋ค.
๊ตฌํ 1์ฐจ ์๋...
๋ซํ ๊ดํธ๋ฅผ ๋ง๋ฌ์ ๋ (), {}, [] ๋ฅผ ์ด๋ป๊ฒ ๊ฐ๋ค๊ณ ํํํ ์ง๊ฐ ๋งํ..
๊ตฌํ 2์ฐจ ์๋
switch ๋ฌธ์ ์ด์ฉํด์ ์ด๋ฆฐ๊ดํธ๋ฅผ ์ ์ฅํ ์คํ์ top๊ณผ ํ์ฌ ํ์ํ๋ ๊ดํธ index๋ฅผ ๋น๊ตํ๋๊น ๊ฐ๋ฅํ๋ค.
#include <iostream>
#include <string>
#include <stack>
using namespace std;
int findCorrectBracket(string); //์ฌ๋ฐ๋ฅธ ๋ฌธ์์ด์ธ์ง ์๋์ง๋ฅผ ์ฒดํฌํ๋ ํจ์
string rotateString(string); //๋ฌธ์์ด ๊ธธ์ด๋งํผ ์ผ์ชฝ์ผ๋ก ํ ์นธ์ฉ ํ์ ํ๋ ํจ์
int main() {
string bracketString;
int correctNum = 0;
cin >> bracketString;
for (int idx = 0; idx < bracketString.length(); idx++) {
correctNum += findCorrectBracket(bracketString);
bracketString = rotateString(bracketString);
}
cout << correctNum;
}
string rotateString(string bracketString) {
string firstString = bracketString.substr(0, 1);
string subString = bracketString.substr(1, bracketString.length() - 1);
return subString + firstString;
}
int findCorrectBracket(string bracketString) {
int correctBracketNum = 0;
stack<char> s_openBracket;
for (int idx = 0; idx < bracketString.length(); idx++) {
char closedBracket;
char currentBracket = bracketString[idx];
//์ฌ๋ฐ๋ฅด์ง ์์ ๊ดํธ์ ๊ฒฝ์ฐ๋ฅผ ์์ธ์ฒ๋ฆฌ๋ฌธ์ผ๋ก ์ ์ด์ฃผ๊ณ
//๊ทธ ์ธ์ ๊ฒฝ์ฐ๋ฅผ ์ฌ๋ฐ๋ฅธ ๊ดํธ๋ผ๊ณ ์ฒ๋ฆฌํด์ฃผ์.
//์ด๋ฆฐ๊ดํธ
if (currentBracket == '(' || currentBracket == '{' || currentBracket == '[') {
s_openBracket.push(currentBracket);
}
//๋ซํ๊ดํธ
else {
if (s_openBracket.empty()) { //๋ฐ๋ก ),},] ๊ฐ์ ๋ซํ๊ดํธ๋ก ์์ํ๋ฉด ๊ทธ๊ฑด ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์์ด์ด ์๋
return 0;
}
switch (currentBracket) { // (,{,[ ์ด๋ฆฐ ๊ดํธ๋ก ์์ํ์ผ๋ฉด ๊ทธ ๋ค์ ์์ธ์ฒ๋ฆฌ๋ฅผ ๋ฐ์ ธ๋ณด์.
case ')':
if (s_openBracket.top() != '(') { //์ง์ ๊ดํธ๊ฐ (์ด๋ฉด ์ด๋ฒ ๊ดํธ๋ )์ฌ์ผ ์ฌ๋ฐ๋ฅธ ๊ดํธ๊ฒ ์ง
return 0;
}
break;
case '}':
if (s_openBracket.top() != '{') { //์ง์ ๊ดํธ๊ฐ {์ด๋ฉด ์ด๋ฒ ๊ดํธ๋ }์ฌ์ผ ์ฌ๋ฐ๋ฅธ ๊ดํธ๊ฒ ์ง
return 0;
}
break;
case ']':
if (s_openBracket.top() != '[') { //์ง์ ๊ดํธ๊ฐ [์ด๋ฉด ์ด๋ฒ ๊ดํธ๋ ]์ฌ์ผ ์ฌ๋ฐ๋ฅธ ๊ดํธ๊ฒ ์ง
return 0;
}
break;
default:
break;
}
s_openBracket.pop(); //์ฌ๋ฐ๋ฅธ ๊ดํธ์ด๋ฉด top() ํฌ์ธํฐ๋ฅผ ํ์นธ ์ฎ๊ฒจ์ ๋ค์๋ ์ฌ๋ฐ๋ฅธ ๊ดํธ์ธ์ง ์ฒดํฌํด๋ณด์.
}
}
if (s_openBracket.empty()) return 1; //๋ง์ง๋ง๊น์ง ๋จ๊น์์ด ์ฌ๋ฐ๋ฅธ ๊ดํธ๋ก ํ๋จ์ด ๋์์ ๋ 1์ return.
else return 0; // โ
๋ง์ง๋ง์ { ํ๋๋ง ๋จ์๋ค๋ฉด ์ฌ๋ฐ๋ฅธ ๊ดํธ๊ฐ ์๋๋๊น ์ด๋ฐ ๊ฒฝ์ฐ๋ ์์ธ์ฒ๋ฆฌ ํด์ฃผ๊ธฐ.
}
๊ฒ์ํด๋ณด๋ ๊ดํธ ๋ฌธ์์ด์ ์ ์ด์ ()๋ 1, {}๋ 2, []๋ 3์ด๋ผ๊ณ ํํํด์ ์ซ์๊ฐ ๊ฐ์์ง๋ฅผ ๋น๊ตํ๊ธฐ๋ ํ๋ค.
์ฝ๋๊ฐ ์ข๋ ๊ฐ๋จํด์ง ๊ฑฐ ๊ฐ๊ธด ํ๋ค~!
์ฐธ๊ณ ๋ก 12๋ฒ Testcase์์ ์คํจ๊ฐ ๋ด์๋๋ฐ, {, (, [ ๊ฐ์ ์ด๋ฆฐ ๊ดํธ๊ฐ ๋ง์ง๋ง์ ์ฌ ๊ฒฝ์ฐ๋ฅผ ๊ณ์ฐํ์ง ์์๊ธฐ ๋๋ฌธ์ด์๋ค.
์๊ฐ๋ณต์ก๋
๊ดํธ ๋ฌธ์์ด์ ๊ธธ์ด ์์์ ์ผ์ชฝ์ผ๋ก ํ์นธ์ฉ ์ด๋ํ๋ ๊ฒฝ์ฐ O(N)
ํ์ฌ ํ์ ๊ฒฐ๊ณผ ์์ ๊ดํธ ๋ฌธ์์ด์ ๊ธธ์ด ๋งํผ ์ฐจ๊ณก์ฐจ๊ณก ์ด๋ฆฐ ๊ดํธ๋ฅผ stack์ ์ ์ฅํ๊ณ ํ์ํ๋ ๊ฒฝ์ฐ O(N) ์ผ๋ก
์ด O(N²)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค.
'๐ Coding Test Study > Algorithm Problem' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++][BAEKJOON][DP] 2156๋ฒ ํฌ๋์ฃผ ์์ (0) | 2021.08.05 |
---|---|
[C++][Baekjoon][Backtracking] 9663๋ฒ N-Queen ํ์ด (0) | 2021.08.05 |
[Baekjoon][C++] 4963๋ฒ ์ฌ์ ๊ฐ์ ๋ฌธ์ ์ค๋ช ๋ฐ ์ฝ๋ (0) | 2021.04.17 |
[Baekjoon][C++] 1759๋ฒ ์ํธ ๋ง๋ค๊ธฐ ๋ฌธ์ ์ค๋ช ๋ฐ ์ฝ๋ (0) | 2021.04.17 |
[Baekjoon][C++] 2667๋ฒ ๋จ์ง๋ฒํธ๋ถ์ด๊ธฐ ๋ฌธ์ ์ค๋ช ๋ฐ ์ฝ๋ (0) | 2021.04.17 |