๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์
dfs(๊น์ด ์ฐ์ ํ์)์ผ๋ก A,E,I,O,U๋ก ์กฐํฉํด์ ๋ง๋ค ์ ์๋ ๋ชจ๋ ๋จ์ด๋ฅผ ๋ฆฌ์คํธ์ ๋ฃ์ด ์ค๋ค.
๊ทธ๋ฆฌ๊ณ list์ ์ฌ์ด์ฆ๋งํผ ๋ฐ๋ณต๋ฌธ์ ๋๋ฆฌ๋ฉด์ word๋ ์ผ์นํ๋ ๋จ์ด๊ฐ ๋ค์ด ์๋ ์นธ์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ค.
โญ 3. ์ ๋ต์ฝ๋
import java.util.*;
class Solution {
static List<String> list;
static String [] words = {"A", "E", "I", "O", "U"};
public int solution(String word) {
int answer = 0;
list = new ArrayList<>();
dfs("", 0);
int size = list.size();
for (int i = 0; i < size; i++) {
if(list.get(i).equals(word)) {
answer = i;
break;
}
}
return answer;
}
static void dfs(String str, int len) {
list.add(str);
if (len==5) return;
for (int i = 0; i < 5; i++) {
dfs(str + words[i], len + 1);
}
}
}
์ฒ์์ ์ฝ๋ ์ฐ๋ฉด์ `answer = i + 1` ์ด๋ผ๊ณ ํ๋๋ฐ ํ๋ ธ๋ค๊ณ ์ค๋ต์ฒ๋ฆฌ๊ฐ ๋์๋ค.
์ธ๋ฑ์ค๋ 0๋ถํฐ ์์์ธ๋ฐ ์ฌ๋์ ์ธ์ด๋ก ๋ช ๋ฒ์งธ ๋จ์ด๋๊ณ ํ๋ฉด i+1์ด ์๋๊ฐ ์๊ฐํ๋ค.
๋ก์ง ๋ฐ๋ผ๊ฐ๋ฉด์ ์ ์๊ฐ ํด ๋ณด๋๊น ์ฒ์์๋ ๋น๋ฌธ์์ด๋ก ์์ํ๊ธฐ ๋๋ฌธ์ 0๋ฒ ์ธ๋ฑ์ค๋ ๋น ์คํธ๋ง์ด๋ค
๊ทธ๋ฆฌ๊ณ 1๋ฒ ์ธ๋ฑ์ค๋ถํฐ A๊ฐ ์ถ๊ฐ๊ฐ ๋๋ค.
return๊ณผ break๋ ๋ ๋ค ์คํ ํ๋ฆ์ ์ข ๋ฃํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
for๋ฃจํ๋ฅผ ์ข ๋ฃํ ๋ ์ฐ๋ ํค์๋๊ฐ `break`์ด๋ค.
๋ฐ๋ฉด`return`์ ์ฌ๊ทํธ์ถ์ ์ข ๋ฃํ๋ค.
์ฆ, len์ด 5๊ฐ ๋๋ฉด ์ฌ๊ท ํธ์ถ์ ์ข ๋ฃํ๊ณ ์์ํธ์ถ๋ก ๋์ ๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ ์ฐ๋ ๊ฒ์ด๋ค.
์ฌ๊ทํธ์ถ์ ์์ด๋ ํธ์ถ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ์ดํด๊ฐ ์ฝ๋ค.
dfs("AAAAA", 5)๊ฐ ์ข ๋ฃ๋๋ฉด, ์์ธ ์์์ ๋ฐ๋ก ์๋ ๋จ๊ณ์ธ dfs("AAAA", 4)๋ก ๋์๊ฐ๋ค.
dfs("", 0)์ด ์คํ → dfs("A", 1) ํธ์ถ
dfs("A", 1)์ด ์คํ → dfs("AA", 2) ํธ์ถ
dfs("AA", 2)์ด ์คํ → dfs("AAA", 3) ํธ์ถ.
...
dfs("AAAAA", 5) ์คํ → return → ๋์๊ฐ → dfs("AAAA", 4)๋ก ๋ณต๊ท.
dfs("AAAA", 4)์ for๋ฌธ์ ๋ค์ ๋ฐ๋ณต์ ์งํ → dfs("AAAAE", 5) ํธ์ถ.
AAAAU ์ดํ์๋?
dfs("AAAAU", 5) ์ข
๋ฃ → ๋ณต๊ท → dfs("AAAA", 4)๋ก ๋์๊ฐ.
dfs("AAAA", 4)์ for๋ฌธ์ด ๋ชจ๋ ๋๋๋ฏ๋ก ์ข
๋ฃ → ๋ณต๊ท → dfs("AAA", 3)๋ก ๋์๊ฐ.
dfs("AAA", 3)์ for๋ฌธ์์ ๋ค์ ๋ฐ๋ณต(i = 1) ์คํ → dfs("AAAE", 4) ํธ์ถ.
๐๐ป ์ข์์ ๋ง์ด ๋ฐ์ ์ฝ๋
class Solution {
public int solution(String word) {
int answer = 0, per = 3905;
for(String s : word.split("")) answer += "AEIOU".indexOf(s) * (per /= 5) + 1;
return answer;
}
}
์ํ์ ์์ฃผ ์ ํ๋ ์ฌ๋์ด ์ง ์ฝ๋์ด๋ค.
per = 3905๋ 5^4 + 5^3 + 5^2 + 5^1 + 5^0์ ๊ฒฐ๊ณผ์ด๋ค.
๊ฐ ๋ฌธ์์ด์ด ๊ฐ์ง๋ ๊ธธ์ด๋ 1์์ ์ต๋ 5์ด๋ค. ๋ฐ๋์ 3905๋ "AEIOU"๋ก ๊ตฌ์ฑ๋ ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌธ์์ด์ ์ด ๊ฐ์์ด๋ค.
1์๋ฆฌ ๋ฌธ์์ด: "A", "E", "I", "O", "U"๋ก ์ด ๊ฐ์: 5๊ฐ
2์๋ฆฌ ๋ฌธ์์ด: ์ฒซ ๋ฒ์งธ ์๋ฆฌ๋ 5๊ฐ ๋ฌธ์ ์ค ํ๋, ๋ ๋ฒ์งธ ์๋ฆฌ๋ 5๊ฐ ๋ฌธ์ ์ค ํ๋. ์ฆ, 5 * 5 = 25๊ฐ
3์๋ฆฌ ๋ฌธ์์ด: ์ฒซ ๋ฒ์งธ ์๋ฆฌ๋ 5๊ฐ ๋ฌธ์ ์ค ํ๋, ๋ ๋ฒ์งธ ์๋ฆฌ๋ 5๊ฐ ๋ฌธ์ ์ค ํ๋, ์ธ ๋ฒ์งธ ์๋ฆฌ๋ 5๊ฐ ๋ฌธ์ ์ค ํ๋. ์ฆ, 5 * 5 * 5 = 125๊ฐ
4์๋ฆฌ ๋ฌธ์์ด: 5 * 5 * 5 * 5 = 625๊ฐ.
5์๋ฆฌ ๋ฌธ์์ด: 5 * 5 * 5 * 5 * 5 = 3125๊ฐ
5 + 25 + 25 + 625 + 3125 = 3905
๋ฌธ์์ด์ ๋ฌธ์ ๋ฐฐ์ด๋ก ์ชผ๊ฐ์ ๋ถ๋ฆฌํ๋ค.
์ชผ๊ฐ์ง ๋ฌธ์ ํ๋ ํ๋์ ๋ํด์
`AEIOU".indexOf(s)`๋ฅผ ํ๋๋ฐ ๋ฌธ์ s๊ฐ "AEIOU" ๋ฌธ์์ด์์ ๋ช ๋ฒ์งธ ์์น์ ์๋์ง ์ฐพ๋๊ฒ์ด๋ค.
์๋ฅผ ๋ค๋ฉด A์ ์ธ๋ฑ์ค๋ 0์ด๊ณ U๋ ๋งจ ๋ง์ง๋ง์ด๋๊น ์ธ๋ฑ์ค๊ฐ 4์ผ ๊ฒ์ด๋ค.
๊ทธ๋ฆฌ๊ตฌ `per /= 5` ๋ก ๋งค ๋ฐ๋ณต๋ง๋ค per ๊ฐ์ 5๋ก ๋๋์ด ์ค๋ค.
`3905 / 5` → 781, `781 / 5` → 156, `156 / 5` → 31, `31 / 5` → 6, `6 / 5` → 1 ๋ฑ์ผ๋ก, ๊ฐ๊ฐ์ ๋ฌธ์๊ฐ ์ฌ์ ์์ ์ฐจ์งํ๋ ๋น์จ์ ์ค์ฌ๊ฐ๋ฉฐ ๊ณ์ฐํ๋ค. ์ด๋ ๊ฒ ์ฝ๋ ์ง ์ฌ๋ ์ง์ง ์ฒ์ฌ์ธ๊ฐ....?
๐ฆ ์ข์์ ๋ง์ด ๋ฐ์ ์ฝ๋
class Solution {
int answer, cnt;
public int solution(String word) {
dfs(new StringBuilder(), word);
return answer;
}
boolean dfs(StringBuilder sb, String word) {
if (sb.toString().equals(word)) return true;
if (sb.length() >= 5) return false;
for (char c : "AEIOU".toCharArray()) {
sb.append(c);
cnt++;
if (dfs(sb, word)) {
answer = cnt;
return true;
}
sb.deleteCharAt(sb.length() - 1);
}
return false;
}
}
๐๐ป 4. ๊ฐ์ ์ ํ ๋ฌธ์
'Algorithm > Programmers_Best' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์กฐ์ด์คํฑ (๊ทธ๋ฆฌ๋) (60) | 2024.12.07 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ฒด์ก๋ณต (Greedy) (61) | 2024.12.06 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ ๋ ฅ๋ง์ ๋๋ก ๋๋๊ธฐ (์์ ํ์) (6) | 2024.11.23 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ํผ๋ก๋ (์์ ํ์) (56) | 2024.11.22 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์นดํซ (์์ ํ์) (70) | 2024.11.22 |