2023. 10. 31. 11:07ใ์ธํ๋ฐ/์๋ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ ๋ฌธ : ์ฝ๋ฉํ ์คํธ ๋๋น
https://hyejin.tistory.com/1235
-> ์ด์ ๋ฌธ์ ํ์ด
5. ์ ๋ง๋๊ธฐ
์ค๋ช
์ฌ๋ฌ ๊ฐ์ ์ ๋ง๋๊ธฐ๋ฅผ ๋ ์ด์ ๋ก ์ ๋จํ๋ ค๊ณ ํ๋ค. ํจ์จ์ ์ธ ์์ ์ ์ํด์ ์ ๋ง๋๊ธฐ๋ฅผ ์๋์์ ์๋ก ๊ฒน์ณ ๋๊ณ ,
๋ ์ด์ ๋ฅผ ์์์ ์์ง์ผ๋ก ๋ฐ์ฌํ์ฌ ์ ๋ง๋๊ธฐ๋ค์ ์๋ฅธ๋ค. ์ ๋ง๋๊ธฐ์ ๋ ์ด์ ์ ๋ฐฐ์น๋ ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ค.
- ์ ๋ง๋๊ธฐ๋ ์์ ๋ณด๋ค ๊ธด ์ ๋ง๋๊ธฐ ์์๋ง ๋์ผ ์ ์๋ค.
- ์ ๋ง๋๊ธฐ๋ฅผ ๋ค๋ฅธ ์ ๋ง๋๊ธฐ ์์ ๋๋ ๊ฒฝ์ฐ ์์ ํ ํฌํจ๋๋๋ก ๋๋, ๋์ ์ ๊ฒน์น์ง ์๋๋ก ๋๋๋ค.
- ๊ฐ ์ ๋ง๋๊ธฐ๋ฅผ ์๋ฅด๋ ๋ ์ด์ ๋ ์ ์ด๋ ํ๋ ์กด์ฌํ๋ค.
- ๋ ์ด์ ๋ ์ด๋ค ์ ๋ง๋๊ธฐ์ ์ ๋์ ๊ณผ๋ ๊ฒน์น์ง ์๋๋ค.
์๋ ๊ทธ๋ฆผ์ ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์๋ฅผ ๋ณด์ฌ์ค๋ค. ์ํ์ผ๋ก ๊ทธ๋ ค์ง ๊ตต์ ์ค์ ์ ์ ๋ง๋๊ธฐ์ด๊ณ , ์ ์ ๋ ์ด์ ์ ์์น,
์์ง์ผ๋ก ๊ทธ๋ ค์ง ์ ์ ํ์ดํ๋ ๋ ์ด์ ์ ๋ฐ์ฌ ๋ฐฉํฅ์ด๋ค.
์ด๋ฌํ ๋ ์ด์ ์ ์ ๋ง๋๊ธฐ์ ๋ฐฐ์น๋ ๋ค์๊ณผ ๊ฐ์ด ๊ดํธ๋ฅผ ์ด์ฉํ์ฌ ์ผ์ชฝ๋ถํฐ ์์๋๋ก ํํํ ์ ์๋ค.
1. ๋ ์ด์ ๋ ์ฌ๋ ๊ดํธ์ ๋ซ๋ ๊ดํธ์ ์ธ์ ํ ์ ‘( ) ’ ์ผ๋ก ํํ๋๋ค. ๋ํ, ๋ชจ๋ ‘( ) ’๋ ๋ฐ ๋์ ๋ ์ด์ ๋ฅผ ํํํ๋ค.
2. ์ ๋ง๋๊ธฐ์ ์ผ์ชฝ ๋์ ์ฌ๋ ๊ดํธ ‘ ( ’ ๋ก, ์ค๋ฅธ์ชฝ ๋์ ๋ซํ ๊ดํธ ‘) ’ ๋ก ํํ๋๋ค.
์ ์์ ๊ดํธ ํํ์ ๊ทธ๋ฆผ ์์ ์ฃผ์ด์ ธ ์๋ค.
์ ๋ง๋๊ธฐ๋ ๋ ์ด์ ์ ์ํด ๋ช ๊ฐ์ ์กฐ๊ฐ์ผ๋ก ์๋ ค์ง๋๋ฐ, ์ ์์์ ๊ฐ์ฅ ์์ ์๋ ๋ ๊ฐ์ ์ ๋ง๋๊ธฐ๋ ๊ฐ๊ฐ 3๊ฐ์ 2๊ฐ์ ์กฐ๊ฐ์ผ๋ก ์๋ ค์ง๊ณ ,
์ด์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ฃผ์ด์ง ์ ๋ง๋๊ธฐ๋ค์ ์ด 17๊ฐ์ ์กฐ๊ฐ์ผ๋ก ์๋ ค์ง๋ค.
์ ๋ง๋๊ธฐ์ ๋ ์ด์ ์ ๋ฐฐ์น๋ฅผ ๋ํ๋ด๋ ๊ดํธ ํํ์ด ์ฃผ์ด์ก์ ๋,
์๋ ค์ง ์ ๋ง๋๊ธฐ ์กฐ๊ฐ์ ์ด ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
ํ ์ค์ ์ ๋ง๋๊ธฐ์ ๋ ์ด์ ์ ๋ฐฐ์น๋ฅผ ๋ํ๋ด๋ ๊ดํธ ํํ์ด ๊ณต๋ฐฑ์์ด ์ฃผ์ด์ง๋ค. ๊ดํธ ๋ฌธ์์ ๊ฐ์๋ ์ต๋ 100,000์ด๋ค.
์ถ๋ ฅ
์๋ ค์ง ์กฐ๊ฐ์ ์ด ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์๋ฅผ ํ ์ค์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
()(((()())(())()))(())
์์ ์ถ๋ ฅ 1
17
์์ ์ ๋ ฅ 2
(((()(()()))(())()))(()())
์์ ์ถ๋ ฅ 2
24
๋ฌธ์ ํ์ด 1
public int solution(String str)
{
int answer = 0;
Stack<Character> stack = new Stack<>();
char[] chars = str.toCharArray();
stack.push(chars[0]);
for (int i = 1; i < chars.length; i++)
{
if (chars[i] == '(')
{
stack.push(chars[i]);
}
else
{
stack.pop();
if (chars[i - 1] == '(') { // ๋ ์ด์
answer += stack.size();
}else { // ๋ง๋๊ธฐ ๋
answer++;
}
}
}
return answer;
}
๐ฉ๐ป : ์ด ๋ฌธ์ ์ญ์ Stack์ ์ฌ์ฉํ๋ ๋ฌธ์ ์ด๋ค. ๊ทธ๋ฆฌ๊ณ () ์ด๋ฉด ๋ ์ด์ ์ด๊ณ , ) ๋ง ์์ผ๋ฉด ๊ทธ์ ๋ง๋๊ธฐ์ผ ๋ฟ์ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก ( ์ผ๋๋ ์ผ๋จ stack์ push ํ๊ณ , )์ผ๋๋ ์ผ๋จ Stack์์ pop๋ฅผ ํ๊ณ , ๊ทธ ๋ค์ ์ด์ ๋ฌธ์๋ฅผ ๋ณด๊ณ (์ด๋ฉด ๋ ์ด์ ์ด๋ฏ๋ก stack์ ์์ธ ๋ง๋๊ธฐ์ ๊ฐ์๋ฅผ ๊ตฌํ๊ณ , ์ด์ ๋ฌธ์๊ฐ )์ผ ๋๋ ๋ ์ด์ ๊ฐ ์๋๋ผ๋ ๋ง์ด๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฅ ๋ง๋๊ธฐ์ ๊ฐ์๋ง answer์ ๋ํด์ฃผ๋ฉด ๋๋ค.
๋ฌธ์ ํ์ด 2
public int solution2(String str)
{
int answer = 0;
Stack<Character> stack = new Stack<>();
for (int i = 0; i < str.length(); i++)
{
if (str.charAt(i) == '(') {
stack.push('(');
}else {
stack.pop();
if (str.charAt(i - 1) == '(') {
answer += stack.size();
}else
{
answer++;
}
}
}
return answer;
}
๐พ : ๊ฐ์ฌ๋๋ ๋์ผํ๊ฒ ๋ฌธ์ ๋ฅผ ํ์๋๋ฐ, ๋ค๋ฅธ ์ ์ ๊ทธ๋ฅ for๋ฌธ์ i = 0 ๋ถํฐ ์์ํ๋ค๋ ๊ฒ์ด๋ค.
๋๋ ์๋ชป ์๊ฐํด์ )๊ฐ ๋จผ์ ๋ค์ด์ฌ ์๋ ์์ง ์๋? ์ถ์ด์ ๋ฌธ์ ๋ฐฐ์ด์์ ์ธ๋ฑ์ค 0 ์ ๋ฏธ๋ฆฌ stack์ pushํด์ฃผ๊ณ , for๋ฌธ ๋ฐฐ์ด์ i = 1 ๋ถํฐ ์์ํ๋ค. (๊ทผ๋ฐ ')'๋ถํฐ ๋ค์ด์ฌ ์ ์์ผ๋ฏ๋ก ๊ทธ๋ฅ ํด๋ ๋๋ค.. ใ ใ )
๋๋ ๋ฌธ์์ด์ ๋ฌธ์ ๋ฐฐ์ด๋ก ๋ง๋ค์ด์ ์ฌ์ฉํ๋๋ฐ ๊ฐ์ฌ๋์ ๋ฌธ์์ด์ ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด์ charAt์ ํตํด ๋ฌธ์ ๋ฅผ ํ์๋ค.