https://school.programmers.co.kr/learn/courses/30/lessons/42883
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋ฌธ์ ์ค๋ช
์ด๋ค ์ซ์์์ k๊ฐ์ ์๋ฅผ ์ ๊ฑฐํ์ ๋ ์ป์ ์ ์๋ ๊ฐ์ฅ ํฐ ์ซ์๋ฅผ ๊ตฌํ๋ ค ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ์ซ์ 1924์์ ์ ๋ ๊ฐ๋ฅผ ์ ๊ฑฐํ๋ฉด [19, 12, 14, 92, 94, 24] ๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. ์ด ์ค ๊ฐ์ฅ ํฐ ์ซ์๋ 94 ์
๋๋ค.
๋ฌธ์์ด ํ์์ผ๋ก ์ซ์ number์ ์ ๊ฑฐํ ์์ ๊ฐ์ k๊ฐ solution ํจ์์ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. number์์ k ๊ฐ์ ์๋ฅผ ์ ๊ฑฐํ์ ๋ ๋ง๋ค ์ ์๋ ์ ์ค ๊ฐ์ฅ ํฐ ์ซ์๋ฅผ ๋ฌธ์์ด ํํ๋ก return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ ์กฐ๊ฑด
number๋ 2์๋ฆฌ ์ด์, 1,000,000์๋ฆฌ ์ดํ์ธ ์ซ์์
๋๋ค.
k๋ 1 ์ด์ number์ ์๋ฆฟ์ ๋ฏธ๋ง์ธ ์์ฐ์์
๋๋ค.
์ ์ถ๋ ฅ ์
number | k | return |
1924 | 2 | 94 |
1231234 | 3 | 3234 |
4177252841 | 4 | 775841 |
ํ์ด
ํ์๋ฒ์ ํ์ฉํด์ผํ๋ ๋ฌธ์ ์๋ค. ์ฃผ์ด์ง ์ํฉ์์ ์ต์ ์ ์ ํ์ ํด์ผํ๊ณ ์ด ์ ํ์ด ๋ค์ ์ํฉ์ ์ํฅ์ ์ฃผ์ง ์์์ผํ๋ค.
ํฐ ์๋ฅผ ๋ง๋ค๊ธฐ ์ํด์
์ฒซ๋ฒ ์งธ - ์๋ฆฟ์๊ฐ ํฐ ์์ฌ์ผํ๋ค.
๋๋ฒ ์งธ - ์๋ฆฟ ์ ๋ง๋ค ํฐ ์๊ฐ ํ ๋น ๋ผ์ผ ํ๋ค.
๋ฐ๋ผ์ ์ฃผ์ด์ง k๋ฅผ ๋บ digit ํฌ๊ธฐ์ ์๋ฅผ ๊ตฌํด์ผํ๊ณ ๊ทธ ์๋ ์ผ์ชฝ ๊ธฐ์ค ์๋ฆฟ ์๋ถํฐ ํฐ ์๊ฐ ์์ผํ๋ค.
๋ฌธ์ ๊ฐ ์งง๊ณ ๊ฐ๋จํ์ฌ ์ฌ์ด ๋ฌธ์ ์ธ์ค ์์์ง๋ง ์ ๋ต์ ๋ง์ถ๊ธด์ ์ฝ์ง๋ ์์๋ ๊ฒ ๊ฐ๋ค.
n ์ด 1,000,000์๋ฆฌ ์ซ์๊ฐ ์๊ฐ ๋ณต์ก๋์ ๊ฑธ๋ฆด ๊ฒ ๊ฐ๋ค๊ณ ์์ํ์์ง๋ง ์ ์ถํด๋ณด๋ ๊ฑฐ์ ๋ค ํต๊ณผ๋ผ์ ๋ง์ถ ๋ฌธ์ ์ธ์ค ์ฐฉ๊ฐํ์ง๋ง, 10๋ฒ์์ ์๊ฐ์ด๊ณผ๋ก ํ๋ฆฌ๊ฒ ๋์๋ค.
class Solution {
public String solution(String number, int k) {
int digit = number.length() - k;
int startIdx = 0;
StringBuilder sb = new StringBuilder();
for (int i = digit; i > 0; i--) {
int tmp = 0;
for (int j = startIdx; j <= number.length() - i; j++) {
int num = Character.getNumericValue(number.charAt(j));
if (tmp < num) {
tmp = num;
startIdx = j + 1;
}
}
sb.append(tmp);
}
return sb.toString();
}
}
์ค๋ต๋ ธํธ
์ฃผ์ด์ง ๋ฌธ์ ๋ ์ฃผ์ด์ง ์ซ์ ๋ฌธ์์ด์์ k๊ฐ์ ์ซ์๋ฅผ ์ ๊ฑฐํ์ฌ ๋ง๋ค ์ ์๋ ๊ฐ์ฅ ํฐ ์๋ฅผ ๊ตฌํ๋ ๊ฒ์ผ๋ก, ํ์์ (Greedy) ์ ๊ทผ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์๋ค.
์ฃผ์ด์ง ์ฝ๋์์๋ ๋ชจ๋ ๊ฐ๋ฅํ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์ธํ๊ณ ๊ฐ์ฅ ํฐ ์๋ฅผ ์ฐพ๊ธฐ ์ํด ๋ ๋ฒ์ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๊ณ ์๋ค. ํ์ง๋ง ์ด๋ฌํ ๋ฐฉ์์ ์๊ฐ ๋ณต์ก๋๊ฐ O(n^2)์ด๊ธฐ ๋๋ฌธ์ ํฐ ์ ๋ ฅ์ ๋ํด์๋ ๋นํจ์จ์ ์ผ ์ ์๋ค.
๋ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก๋ ์คํ(Stack) ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ์คํ์ ์ฌ์ฉํ์ฌ ์ซ์๋ฅผ ์ฐจ๋ก๋๋ก ์์๊ฐ๋ฉด์ ํ์ฌ ์ซ์๊ฐ ์คํ์ ๋งจ ์ ์ซ์๋ณด๋ค ํฌ๋ฉด ์คํ์์ ๋งจ ์ ์ซ์๋ฅผ ์ ๊ฑฐํ๊ณ ํ์ฌ ์ซ์๋ฅผ ์คํ์ ๋ฃ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์คํ์๋ ํฐ ์ซ์๊ฐ ์์ชฝ์ ์์นํ๊ฒ ๋๋ค.
์ ๋ ฅ ๋ฌธ์์ด์ ํ ๋ฒ๋ง ์ํํ๋ฏ๋ก ์๊ฐ ๋ณต์ก๋๋ O(n)์ด๋ค. ์คํ์ ์ฌ์ฉํ์ฌ ๋ ํจ์จ์ ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
import java.util.Stack;
class Solution {
public String solution(String number, int k) {
Stack<Character> stack = new Stack<>();
int keep = number.length() - k;
for (int i = 0; i < number.length(); i++) {
char digit = number.charAt(i);
while (!stack.isEmpty() && k > 0 && stack.peek() < digit) {
stack.pop();
k--;
}
stack.push(digit);
}
StringBuilder sb = new StringBuilder();
while (!stack.isEmpty()) {
sb.append(stack.pop());
}
return sb.reverse().substring(0, keep);
}
}
๋๊ธ