1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ๋ฐฉ์
1) ์คํ์ ์ฌ์ฉํ์ง ์๊ณ ํ๊ธฐ
๋ฌธ์์ด์ ์ํํ๋ฉฐ ๋ซํ ๊ดํธ์ ์ด๋ฆฐ ๊ดํธ์ ๊ฐฏ์๋ฅผ ๋ณ์์ ์ ์ฅํ๊ณ ๊ฐ์๊ฐ ๊ฐ์ผ๋ฉด true, ํ๋ฆฌ๋ฉด false ๋ฅผ ๋ฐํํ๋ ๋ฐฉ๋ฒ
2) ์คํ์ ์ฌ์ฉํ์ฌ ๊ดํธ์ ์ง์ ๋ง์ถ๋ ๋ฐฉ๋ฒ
๋จ์ํ ์๊ฐํด์ ๊ดํธ๊ฐ ์ด๋ฆฐ ๊ฒฝ์ฐ ์คํ์ ๋ฃ๊ณ , ๋ซํ ๊ดํธ๊ฐ ๋์ค๋ฉด ์คํ์์ ๊บผ๋ด๋ ๋ฐฉ์
3. ๋ฌธ์ ํ์ด
3-1. ์คํ ์ฌ์ฉํ์ง ์๊ณ ํ๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค์์๋ ํ/์คํ ์นดํ
๊ณ ๋ฆฌ์ ์๋ ๋ฌธ์ ์ด์ง๋ง ๊ตณ์ด ์คํ์ ์ฌ์ฉํ์ง ์์๋ ๊น๋ํ๊ฒ ํ ์ ์๋ ๋ฌธ์ ์ด๋ค.
์ฒ์์๋ ์ด๋ฆฐ ๊ดํธ๋ฅผ openCnt, ๋ซํ ๊ดํธ๋ฅผ closeCnt ์ ์ ์ฅํด์ ๊ทธ ๊ฐฏ์๊ฐ ์ผ์นํ๋ฉด true๋ฅผ ๋ฐํํ๋ ๋ฐฉ์์ผ๋ก ์ฝ๋๋ฅผ ์งฐ๋ค.
class Solution {
boolean solution(String s) {
int openCnt = 0;
int closeCnt = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i)=='(') {
openCnt++;
} else if(s.charAt(i)==')') {
closeCnt++;
}
}
if(openCnt==closeCnt) {
return true;
}
return false;
}
}
ํ์ง๋ง ๋ด๊ฐ ์ง ์ฝ๋์ ํ ๊ฐ์ง ๋ฌธ์ ๊ฐ ์์๋ค. ํ
์คํธ ์ผ์ด์ค์์ ๊ดํธ๊ฐ ")()("์ธ ๊ฒฝ์ฐ ์ด๋ฆฐ๊ดํธ ๊ฐฏ์ = ๋ซํ ๊ดํธ ๊ฐฏ์๊ฐ ์ผ์นํด์ true ๊ฐ์ด ๋ฐํ๋์๋ค. ํ์ง๋ง ์ด ๊ฒฝ์ฐ ๋ซํ ๊ดํธ๊ฐ ๋จผ์ ์์๋์๊ธฐ ๋๋ฌธ์ false๋ฅผ ๋ฐํํด์ฃผ์ด์ผ ํ๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ฝ๋๋ฅผ ์๋ด์ฃผ์๋ค. for๋ฌธ ์์์ openCnt๊ฐ closeCnt๋ณด๋ค ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ค๋ ์กฐ๊ฑด์ ํ๋ ๋ ์ถ๊ฐํด ์ฃผ๋ฉด ๊ฐ๋จํ ํด๊ฒฐ๋์๋ค.
class Solution {
boolean solution(String s) {
int openCnt = 0;
int closeCnt = 0;
for (int i = 0; i < s.length(); i++) {
// ์ด๋ฆฐ ๊ดํธ๊ฐ ๋์ค๋ฉด openCnt ์ฆ๊ฐ
if (s.charAt(i) == '(') {
openCnt++;
}
// ๋ซํ ๊ดํธ๊ฐ ๋์ค๋ฉด closeCnt ์ฆ๊ฐ
else if (s.charAt(i) == ')') {
closeCnt++;
}
// ๋ซํ ๊ดํธ๊ฐ ์ด๋ฆฐ ๊ดํธ๋ณด๋ค ๋จผ์ ๋์ค๋ฉด ์๋ชป๋ ๋ฌธ์์ด
if (openCnt < closeCnt) {
return false;
}
}
// ๋ฐ๋ณต๋ฌธ์ด ๋๋ ํ ์ด๋ฆฐ ๊ดํธ์ ๋ซํ ๊ดํธ ๊ฐ์๊ฐ ๊ฐ์์ผ ์ ํจํ ๋ฌธ์์ด
return openCnt == closeCnt;
}
}
์๊ฐ ํด ๋ณด๋ ์์ ์ฝ๋๋ฅผ ๋ ๊ฐ๋จํ๊ฒ ์์ ํ ์ ์๋๋ฐ openCnt๋ closeCnt๋ฅผ ๋๋ ํ์ ์์ด, ๊ทธ๋ฅ ํ๋์ ๋ณ์ cnt์ ์ด๋ฆฐ ๊ดํธ๊ฐ ๋์ค๋ฉด 1 ์ฆ๊ฐํ๊ณ , ๋ซํ ๊ดํธ๊ฐ ๋์ค๋ฉด 1 ๊ฐ์๋ฅผ ํด ์ฃผ์ด๋ ๋๋ค.
class Solution {
boolean solution(String s) {
int cnt = 0;
for (int i = 0; i < s.length(); i++) {
// ์ด๋ฆฐ ๊ดํธ๊ฐ ๋์ค๋ฉด cnt ์ฆ๊ฐ
if (s.charAt(i) == '(') {
cnt++;
}
// ๋ซํ ๊ดํธ๊ฐ ๋์ค๋ฉด cnt ๊ฐ์
else if (s.charAt(i) == ')') {
cnt--;
}
// ๋ซํ ๊ดํธ๊ฐ ์ด๋ฆฐ ๊ดํธ๋ณด๋ค ๋จผ์ ๋์ค๋ฉด ์๋ชป๋ ๋ฌธ์์ด
if (cnt < 0) {
return false;
}
}
// ๋ชจ๋ ๊ดํธ๊ฐ ์ง์ด ๋ง์ผ๋ฉด cnt๊ฐ 0์ด์ด์ผ ํ๋ค.
return cnt == 0;
}
}
3-2. ์คํ ์ฌ์ฉํ ์ฝ๋
๊ดํธ๊ฐ ์ด๋ฆฐ ๊ฒฝ์ฐ ์คํ์ ๋ฃ๊ณ , ๋ซํ ๊ดํธ๊ฐ ๋์ค๋ฉด ์คํ์์ ๊บผ๋ด๋ ๋ฐฉ์์ผ๋ก ์ฝ๋ ์์ฑ
import java.util.Stack;
class Solution {
boolean solution(String s) {
Stack<Character> cnt = new Stack<>();
for (int i = 0; i < s.length(); i++) {
// ์ด๋ฆฐ ๊ดํธ๊ฐ ๋์ค๋ฉด ์คํ์ ์ถ๊ฐ
if (s.charAt(i) == '(') {
cnt.push('(');
}
// ๋ซํ ๊ดํธ๊ฐ ๋์ค๋ฉด ์คํ์์ ๊บผ๋ธ๋ค
else if (s.charAt(i) == ')') {
// ์คํ์ด ๋น์ด ์์ผ๋ฉด ์๋ชป๋ ๊ดํธ ํ์
if (cnt.isEmpty()) {
return false;
}
// ์คํ์์ ํ๋ ๊บผ๋ด๊ธฐ
cnt.pop();
}
}
// ์คํ์ด ๋น์ด ์์ผ๋ฉด ๋ชจ๋ ๊ดํธ๊ฐ ์ง์ ์ด๋ฃจ์๋ค๋ ์๋ฏธ
return cnt.isEmpty();
}
}
cnt.isEmpty(); ๊ฐ true๋ฅผ ๋ฐํํ๋ค๋ ๊ฒ์ stack์ ์๋ฌด๊ฒ๋ ๋จ์ง ์์๋ค๋ ๊ฒ์ด๊ณ , ๊ดํธ ์ง์ด ๋ง๋๋ค๋ ๋ป์ด๋ค. ๋ฐ๋ฉด, false๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ stack์ ์ด๋ฆฐ ๊ดํธ๊ฐ ์์ง ๋จ์ ์๋ค๋ ๋ป์ด๋ค.
๋ง์ฝ ๋ซํ ๊ดํธ ์ด๋ฆฐ ๊ดํธ๋ณด๋ค ๋ ๋ง์ ๊ฒฝ์ฐ์๋ loop์์ if(cnt.isEmpty()) { return false; } ๊ตฌ๋ฌธ์ ์ํด false๋ฅผ ๋ฆฌํดํ๋ค.
4. ๋์ผ ์ ํ ๋ฌธ์ (์คํ/ํ)
'Algorithm > Programmers_Best' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ํธ๋ญ (์คํ/ํ) (8) | 2024.11.11 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ํ๋ก์ธ์ค ๋ฌธ์ ํ์ด (์คํ/ํ) (4) | 2024.11.09 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๊ธฐ๋ฅ๊ฐ๋ฐ (์คํ/ํ) (10) | 2024.11.07 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๊ฐ์ ์ซ์๋ ์ซ์ด ๋ฌธ์ ํ์ด (์คํ/ํ) (9) | 2024.11.06 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) H-INDEX (์ ๋ ฌ) (6) | 2024.11.02 |