[ํ๋ก๊ทธ๋๋จธ์ค] ์คํฌํธ๋ฆฌ
๋ฌธ์ ์ค๋ช
์ ํ ์คํฌ์ด๋ ์ด๋ค ์คํฌ์ ๋ฐฐ์ฐ๊ธฐ ์ ์ ๋จผ์ ๋ฐฐ์์ผ ํ๋ ์คํฌ์ ๋ปํฉ๋๋ค.
์๋ฅผ ๋ค์ด ์ ํ ์คํฌ ์์๊ฐ ์คํํฌ → ๋ผ์ดํธ๋ ๋ณผํธ → ์ฌ๋์ผ๋, ์ฌ๋๋ฅผ ๋ฐฐ์ฐ๋ ค๋ฉด ๋จผ์ ๋ผ์ดํธ๋ ๋ณผํธ๋ฅผ ๋ฐฐ์์ผ ํ๊ณ , ๋ผ์ดํธ๋ ๋ณผํธ๋ฅผ ๋ฐฐ์ฐ๋ ค๋ฉด ๋จผ์ ์คํํฌ๋ฅผ ๋ฐฐ์์ผ ํฉ๋๋ค.
์ ์์์ ์๋ ๋ค๋ฅธ ์คํฌ(ํ๋ง ๋ฑ)์ ์์์ ์๊ด์์ด ๋ฐฐ์ธ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์คํํฌ → ํ๋ง → ๋ผ์ดํธ๋ ๋ณผํธ → ์ฌ๋์ ๊ฐ์ ์คํฌํธ๋ฆฌ๋ ๊ฐ๋ฅํ์ง๋ง, ์ฌ๋ → ์คํํฌ๋ ๋ผ์ดํธ๋ ๋ณผํธ → ์คํํฌ → ํ๋ง → ์ฌ๋์ ๊ฐ์ ์คํฌํธ๋ฆฌ๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
์ ํ ์คํฌ ์์ skill๊ณผ ์ ์ ๋ค์ด ๋ง๋ ์คํฌํธ๋ฆฌ1๋ฅผ ๋ด์ ๋ฐฐ์ด skill_trees๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๊ฐ๋ฅํ ์คํฌํธ๋ฆฌ ๊ฐ์๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- ์คํฌ์ ์ํ๋ฒณ ๋๋ฌธ์๋ก ํ๊ธฐํ๋ฉฐ, ๋ชจ๋ ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ์คํฌ ์์์ ์คํฌํธ๋ฆฌ๋ ๋ฌธ์์ด๋ก ํ๊ธฐํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด, C → B → D ๋ผ๋ฉด CBD๋ก ํ๊ธฐํฉ๋๋ค
- ์ ํ ์คํฌ ์์ skill์ ๊ธธ์ด๋ 1 ์ด์ 26 ์ดํ์ด๋ฉฐ, ์คํฌ์ ์ค๋ณตํด ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- skill_trees๋ ๊ธธ์ด 1 ์ด์ 20 ์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค.
- skill_trees์ ์์๋ ์คํฌ์ ๋ํ๋ด๋ ๋ฌธ์์ด์
๋๋ค.
- skill_trees์ ์์๋ ๊ธธ์ด๊ฐ 2 ์ด์ 26 ์ดํ์ธ ๋ฌธ์์ด์ด๋ฉฐ, ์คํฌ์ด ์ค๋ณตํด ์ฃผ์ด์ง์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
skill skill_trees return
"CBD" | ["BACDE", "CBADF", "AECB", "BDA"] | 2 |
์ ์ถ๋ ฅ ์ ์ค๋ช
- BACDE: B ์คํฌ์ ๋ฐฐ์ฐ๊ธฐ ์ ์ C ์คํฌ์ ๋จผ์ ๋ฐฐ์์ผ ํฉ๋๋ค. ๋ถ๊ฐ๋ฅํ ์คํฌํธ๋ฆฝ๋๋ค.
- CBADF: ๊ฐ๋ฅํ ์คํฌํธ๋ฆฌ์ ๋๋ค.
- AECB: ๊ฐ๋ฅํ ์คํฌํธ๋ฆฌ์ ๋๋ค.
- BDA: B ์คํฌ์ ๋ฐฐ์ฐ๊ธฐ ์ ์ C ์คํฌ์ ๋จผ์ ๋ฐฐ์์ผ ํฉ๋๋ค. ๋ถ๊ฐ๋ฅํ ์คํฌํธ๋ฆฌ์ ๋๋ค.
๋น๊ต๋ฅผ ํด์ผํ๋๊น ์คํ์ ์ฌ์ฉํ๊ณ ์ถ์๋ค.
๋ฌธ์์ด์ด ๊ฐ์ผ๋ฉด ํด๋น๊ฐ์ ๋น์๋ด์ ์คํ์ด ๋น์์ง๋ฉด answer๊ฐ์ ์ฆ๊ฐ์ํค๋ ๋ฐฉ๋ฒ์ ์๊ฐํ๋ค.
import java.util.Stack;
class CodeRunner{
public static int solution(String skill, String[] skill_trees) {
int answer = 0;
Stack stack = new Stack();
for(int i = skill.length() - 1; i >= 0; i--) {
stack.push(skill.charAt(i));
}
for(int j = 0; j < skill_trees.length; j++) {
String st = skill_trees[j];
System.out.println("st๊ฐ : " + st);
System.out.println("ํ์
ํ์ธ : " + stack.peek().getClass().getName());
System.out.println("๋งจ์ ์คํ : " + stack.peek());
System.out.println("st 0๋ฒ์งธ ๊ธ์ : " + st.charAt(0));
int a = 0;
while(stack.isEmpty() == false) {
if(stack.peek()==st.charAt(a)) {
stack.pop();
answer++;
}
}
}
return answer;
}
public static void main(String[] args){
String skill = "CBD";
String[] skill_trees = {"BACDE", "CBADF", "AECB", "BDA"};
int result = solution(skill,skill_trees);
System.out.println(result);
}
}
์คํ์ผ๋ก ํ๋ฉด ์ ์๋๋๊ฑด๊ฐ์
stack.peek()ํ๋ฉด ํ์ ์ด Object๋ผ char์ด๋ ๋น๊ต๊ฐ ์๋๋ค
์ด๋ป๊ฒํ์ง
import java.util.Stack;
class Solution {
public int solution(String skill, String[] skill_trees) {
int answer = 0;
//์คํ ์์ฑ
Stack<Character> stack = new Stack<>();
//์คํ์ skill ๊ฐ ๋ฃ๊ธฐ
for(int i = skill.length() - 1; i >= 0; i--) {
stack.push(skill.charAt(i));
}
//skill_trees
for(int j = 0; j < skill_trees.length; j++) {
//๋น๊ต ๋ฌธ์์ด ๋ด๊ธฐ
String str = skill_trees[j];
int a = 0;
while(stack.isEmpty() == false) {
if(stack.peek()==str.charAt(a)) {
stack.pop();
answer++;
}
}
}
return answer;
}
}
์๋ฌ๋๋ ๊ฒ์ ์์ ํ๋ค. ์คํ์ String์ผ๋ก ๋ง๊ณ charํ์ผ๋ก ๋ง๋ค๋ ค๋ฉด Character๋ฅผ ์จ์ ์ฌ์ฉํด์ค๋ค.
๋๋ฌด ์ค๋๊ฑธ๋ฆฐ๋คใ ใ
๋ค๋ฅธ ์ฌ๋ ํ์ด
import java.util.*;
class Solution {
public int solution(String skill, String[] skill_trees) {
int answer = 0;
ArrayList<String> skillTrees = new ArrayList<String>(Arrays.asList(skill_trees));
//ArrayList<String> skillTrees = new ArrayList<String>();
Iterator<String> it = skillTrees.iterator();
while (it.hasNext()) {
if (skill.indexOf(it.next().replaceAll("[^" + skill + "]", "")) != 0) {
it.remove();
}
}
answer = skillTrees.size();
return answer;
}
}