์ง์ง ๋ชจ๋ฅด๊ฒ ๋ค. ๋๋ฌด ์ด๋ ต๋ค.
์ด๋ป๊ฒ๋ ํ์ด ๋ณด๊ฒ ๋ค๊ณ ์๊ฐํ์ ์ด ํ์ .
-
๋ง์๋จน์ ๋ด ์ฝ๋
package ์ฌ์ฑํ.์๊ณ ๋ฆฌ์ฆ_2์ฃผ์ฐจ; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.List; public class ์คํ์์ด_1874 { static public BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); static public int[] input(int n) throws NumberFormatException, IOException { int[] input = new int[n]; for (int i = 0; i < n; i++) { input[i] = Integer.parseInt(br.readLine()); } return input; } static public void stack(int[] input) { int subPlus = 0; List<Integer> list = new ArrayList<Integer>(); for (int i = 1; i <= input.length; i++) { if (list.isEmpty() || !list.get(list.size() - 1).equals(input[subPlus])) { list.add(i); System.out.println("+"); } else { list.remove(list.size() - 1); subPlus++; System.out.println("-"); } for (int k = 0; k < list.size(); k++) { System.out.print(list.get(k) + " "); } System.out.println(" / list.size() = " + list.size()); } } public static void main(String[] args) throws NumberFormatException, IOException { int[] input = input(Integer.parseInt(br.readLine())); stack(input); } }
๋ ๋ค์ ๋ค๋ฅธ ์ฌ๋ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ๋ค. ๋ฏธ์ณค๋ค๊ณ ์๊ฐํ๋ค. ์ ๋ง๋ก.
์ฒ์์๋ stack์ ๋ํด์ ์ดํด๋ ํ์ง๋ง ๋ฌธ์ ์์ฒด๋ฅผ ์ด๋ป๊ฒ ํ์ด์ผํ ์ง ๋ชฐ๋ผ์ ์์ด ์บ์บํ๋ค. ๊ทธ๋๋ ๋ฌธ์ ๊ฐ ์๊ตฌํ๋ ๊ฒ ๊ทธ๋๋ก ๊ทธ๋ ธ๋๋ ์ด๋์ ๋ ๊ฐ์ ์กํ๋ค. ํ์ง๋ง ์ฌ๊ธฐ์ ํฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค. ๋๋ ์ด ๋ฌธ์ ๋ฅผ ArrayList ํด๋์ค๋ฅผ ์ด์ฉํด์ ์ด๋ป๊ฒ๋ ํ์ด๋ด๋ ค๊ณ ํ์ง๋ง ๋ ํ ์ ์์๋ค.(๐)
- Stack ํด๋์ค์ ์กด์ฌ๋ฅผ ๋ชฐ๋๋ ์ .
- ๋ค์ค for๋ฌธ์ ์ฌ์ฉํ๊ณ ์ถ์ง ์์ ์ด์ํ ๊ณ ์ง.
- ๋ฑ๋ฑ...
์ ๋ง 1, 2๋ฒ์ ๋น์ค์ด ๋๋ฅผ ํ๋๊ฒ ํ๋ ํฐ ์์ธ์ด๋ผ๊ณ ์๊ฐํ๋ค.
- ์ด๋ป๊ฒ๋ ํ์ด๋ณด๋ ค๊ณ ๋ ธ๋ ฅํ ๋์ ํ์ ๋ค..
์ฝ๋์ ํ๊ธฐ๋ฅผ ๋ณด๋ฉด ๋์ถฉ ๋๋์ด ์ค๊ฒ ์ง๋ง,
Stack ํด๋์ค ์กด์ฌ ์ ๋ฌด๋ ๋ชฐ๋๋ ๋ฐ๋ณด ์ฌ์ฑํ์ push, pop
์ ArrayList.remove()์ for๋ฌธ
์ ํตํด์ ํด๊ฒฐํ๋ ค๊ณ ํ๋ค.(๐คฎ)
Stack ํด๋์ค
๋ฌธ์ ๋ฅผ ํ ์ ์๋ค๋ ์ด๋ฑ๊ฐ์ ์ง๊ณ ๋ง์๋ค. ๊ทธ๋์ ๊ตฌ๊ธ์ ๊ฒ์ํ๋ค.
์ด ๋ Stack ํด๋์ค๋ฅผ ์๊ฒ ๋์๊ณ , ํด๋น ํด๋์ค์๋ push(), pop(). peek()
๋ฉ์๋๊ฐ ์กด์ฌํ๊ณ ๋ง์ ์ฌ๋๋ค์ด ์์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
- Stack.push(n) → Stack์ n์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์
- Stack.pop() → Stack์ ๋ง์ง๋ง ๋ฐ์ดํฐ๋ฅผ ์ญ์
- Stack.peek() → Stack์ ๋ง์ง๋ง ๋ฐ์ดํฐ ์กฐํ
๋ค๋ฅธ ์ฌ๋๋ค์ ์ฝ๋๋ฅผ ์กฐ๊ธ ์ฐธ๊ณ ํ์ง๋ง, ์ด์จ๋ ๋ด ์์ผ๋ก ํ์๋ค๊ณ ์๊ฐํ๊ณ ์ถ๋ค.(์ฐฉ๊ฐ์ ๋ช)
-
Stack ํด๋์ค๋ฅผ ์ด์ฉํ ์ฝ๋
package ์ฌ์ฑํ.์๊ณ ๋ฆฌ์ฆ_2์ฃผ์ฐจ; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Stack; public class ์คํ์์ด_1874 { public static void main(String[] args) throws NumberFormatException, IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringBuffer sb = new StringBuffer(); Stack<Integer> stack = new Stack<Integer>(); int n = Integer.parseInt(br.readLine()); int[] arr = new int[n]; int m = 0; for (int i = 0; i < n; i++) { arr[i] = Integer.parseInt(br.readLine()); stack.push(i + 1); sb.append("+ \n"); while (!stack.isEmpty() && stack.peek() == arr[m]) { stack.pop(); sb.append("- \n"); m++; } } if (!stack.isEmpty()) { System.out.println("NO"); } else { System.out.println(sb.toString()); } } }
์์ ๋์ ๊ฑฐ๋ฆฐ ํ๊ธฐ์ ๋์ ๊ณ ์ง์ ์ด๊ฒจ๋ด๋ ค๋ ๋ง์์ผ๋ก ์ฝ๋๋ฅผ ์งฐ๋ค.
๋จผ์ ๋ฐ์ดํฐ ์
๋ ฅ์ BufferReader ํด๋์ค๋ฅผ ์ฌ์ฉํ๊ณ , + / - ๋ฅผ ์ถ๋ ฅํ๊ธฐ ์ํ ๋ฌธ์์ด ํด๋์ค๋ StringBuffer ํด๋์ค๋ฅผ ์ฌ์ฉํ๋๋ฐ StringBuilder ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ์ฌ๋๋ ๋ง์๋ค.
๋น๋ก ๋ค์ค ๋ฐ๋ณต๋ฌธ์ ํตํด ํด๊ฒฐํ์ง๋ง, ๋ค์ค ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ์ง ์์ผ๋ฉด ํด๊ฒฐํ ์ ์๋ ๋ฌธ์ ๋ผ๊ณ ์๊ฐํ๋ค. ์ฒ์์๋ 1 ~ n๊น์ง ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ ๋ฐ๋ ๊ฒ๋ ๋ ๋ค๋ฅธ for๋ฌธ์ ์ ์ธํด์ ์ ๋ ฅํ๋ค. ํ์ง๋ง BufferReader ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด์ ์ค๋ณต๋๋ ๋ฐ๋ณต๋ฌธ์ ์ค์ผ ์ ์์๋ค.
for๋ฌธ์ ์์ํ๋ฉด์ ์์ด๋ก ๋ฑ๋กํ ๋ณ์์ ๋ฐ์ดํฐ๋ฅผ ์
๋ ฅํ๊ณ , stack์ i + 1
๋ฅผ ์ฝ์
ํ๋ค. ๊ทธ๋ ๊ฒ ๋๋ฉด i
๊ฐ ์ปค์ง๋ฉด์ stack์ ์์ด๊ฒ ๋ ๊ฒ์ด๋ค.
i = 0 / stack.get(0) = i + 1 = 1
i = 1 / stack.get(1) = i + 1 = 2
i = 2 / stack.get(2) = i + 1 = 3
์ฌ๊ธฐ์ ์ค์ํ ์ ์ ์์ด์ ์ ๋ ฅํ ๋ฐ์ดํฐ์ stack์ ๋ง์ง๋ง ๋ฐ์ดํฐ๊ฐ ๊ฐ์ผ๋ฉด stack์ ๋ง์ง๋ง ๋ฐ์ดํฐ๋ pop์ด ๋์ด์ผ ํ๋ค. ๊ทผ๋ฐ ์ด๋ฌํ ๊ฒฝ์ฐ๊ฐ ํ ๋ฒ๋ง ๋ฐ์ํ๋ ๊ฒ์ด ์๋๋ผ ์ฐ์์ผ๋ก ๋ฐ์ํ ์ ์๋ค๋ ๊ฒฝ์ฐ๋ ์๊ฐํด์ผ ํ๋ค!
์์ ๊ฐ์ด ์ฐ์์ผ๋ก pop()์ ์คํํด์ผ ํ๋ ๊ฒฝ์ฐ๋ ๊ณ ๋ คํด์ผ ํ๊ธฐ ๋๋ฌธ์, ๋ ผ๋ฆฌ ์ฐ์ฐ์ ํตํ ๋ฐ๋ณต์ ์ํํ๋ while๋ฌธ์ ์ฌ์ฉํด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๊ณ ํ๋ค.
pop()๋ฅผ ์คํํ๊ธฐ ์ํ ์กฐ๊ฑด
1.ํ์ฌ(i) ์ ๋ ฅํ ์์ด์ ๊ฐ๊ณผ stack.peek()์ ๊ฐ์ด ๊ฐ๋ค๋ฉด!
2.stack์ด ๋น์ด ์์ง ์๋ค๋ฉด!
์ฒ์์๋ stack์ด ๋น์ด ์๋ ๊ฒฝ์ฐ๋ฅผ while๋ฌธ์ ์กฐ๊ฑด์ผ๋ก ๋ฃ์ง ์์๋๋ฐ, ๊ทธ๋ ๊ฒ๋๋ฉด stack.peek()๊ณผ ์์ด์ ๊ฐ์ ๋น๊ตํ ์ ์์ด์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
(stack์ด ๋น์ด ์๊ธฐ ๋๋ฌธ์ peek()์ ์คํํ ์ ์๋ค.)
๋ ํ ๊ฐ์ง ๋ ์ค์ํ ๊ฒ์ ์์ด์ ์ธ๋ฑ์ค ๋ฒํธ๊ฐ i
๊ฐ ๋๋ฉด ์๋๋ค. ์์ด์ ๊ฒฝ์ฐ๋ pop()์ด ์คํ๋๋ ๊ฒฝ์ฐ(์ฆ, while๋ฌธ์ด ์คํ ๋๋ฉด์ ์กฐ๊ฑด์ด true
์ธ ๊ฒฝ์ฐ)์๋ง ์ธ๋ฑ์ค ๋ฒํธ๊ฐ 1์ฉ ์ฆ๊ฐํด์ผ ํ๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๋๋ ์์ด์ ์ํ ์ธ๋ฑ์ค ๋ฒํธ๋ฅผ ๋ณ๋๋ก ์ ์ธํ๋ค.
(int m = 0;
)
์ด๋ ๊ฒ ํ๋ฉด ๋ฌธ์ ์กฐ๊ฑด์ ๋ง๊ฒ ์ ์์ ์ผ๋ก ํด๊ฒฐ์ด ๋๋ค.
์ด์ ๋ง์ง๋ง์ผ๋ก stack์ด ๋น์ด ์์ง ์์ ๊ฒฝ์ฐ์ "NO"๋ผ๋ ๋ฌธ์์ด์ ์ถ๋ ฅํด์ผ ํ๋๋ฐ, ์ฌ๊ธฐ์ ํด๋น ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ ์กฐ๊ฑด์ด stack์ด ๋น์ด ์์ง ์์ ๊ฒฝ์ฐ๋ pop()์ ์ํํ๊ธฐ ์ํ ์กฐ๊ฑด์ ์ฐ์ฐํ ๋ ์์ด์ ์
๋ ฅ๋ ๊ฐ์ด -1 ์ฉ ๊ฐ์ํ์ง ์์ ๋๋ฅผ ์๋ฏธํ๋ค.
for๋ฌธ์ i
๋ 1์ฉ ์ฆ๊ฐํ๋ฉฐ, stack์์๋ 1์ฉ ์ฆ๊ฐํ i
๋ฅผ pushํ๋ค. ๊ทธ๋ฐ๋ฐ ์ ์ ์ํ๋ ๋ฐ๋ณต๋ฌธ์์ pop๋ ๋ฐ์ดํฐ๋ณด๋ค ํฐ ๋ฐ์ดํฐ๋ฅผ ๋ค์ pop ์กฐ๊ฑด์์ ๊ฒ์ฌํ ์ ์๋ค.(๋ง๊ฒ ๋ง์ ํ๋์ง ๋ชจ๋ฅด๊ฒ ๋ค.)
์๋ํ๋ฉด ์์ ๊ฒฝ์ฐ์ ๊ฒ์ฌํ์ง ๋ชปํ ๋ฐ์ดํฐ๊ฐ stack์ ๋จ์ ์๊ธฐ ๋๋ฌธ์ ์
๋ ฅํ ์์ด ๋ฐ์ดํฐ๋งํผ ์ํํ์ง ๋ชปํ๋ค๋ ์๋ฏธ๊ฐ ๋๊ธฐ ๋๋ฌธ์ด๋ค.
์ด ๋ถ๋ถ์ ์กฐ๊ฑด๋ฌธ์ผ๋ก ํด๊ฒฐํ๋ฉด ํด๋น ๋ฌธ์ ๋ ๋ง์์ต๋๋ค! ๋ฅผ ๋ณผ ์ ์์ ๊ฒ์ด๋ค.
์๊ฐ์ด ๋๋ฌด ๋ฆ์๋ค. ์ด์ ์๊ฑฐ๋ค. ์๋ !
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฑ์ค 5585 | ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ, ๊ฑฐ์ค๋ฆ ๋ (0) | 2020.10.18 |
---|---|
๋ฐฑ์ค 7568 | ๋ธ๋ฃจํธ ํฌ์ค ์๊ณ ๋ฆฌ์ฆ, ๋ฉ์น (0) | 2020.10.18 |
๋ฐฑ์ค 10818 | ์ต์, ์ต๋๊ฐ ๊ตฌํ๊ธฐ (0) | 2020.10.16 |
๋ณ ์ฐ๊ธฐ (0) | 2020.09.29 |
Prime / Composite | ์์์ ํฉ์ฑ์ (0) | 2020.08.02 |