๋จ์ด ๋ณํ (with.Java)
๋จ์ด ๋ณํ (with.Java) ์ ๋ํ์ฌ ์์๋ณธ ๊ธ์ ๋๋ค.
์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ฅผ ํ๋ฉฐ, ํ์๋ ๋ฌธ์ ์ ๋ํ ํ๊ณ ์ ๋ค๋ฅธ ํ์ด ๋ฐฉ๋ฒ์ ์์๋ณด๋ฉฐ, ์์๊ฐ๊ณ ์ ํฉ๋๋ค.
๋ฌธ์ ์ ๋ํด ๋จผ์ ์์๋ณด๊ฒ ์ต๋๋ค.
๋ฌธ์
๋ ๊ฐ์ ๋จ์ด begin, target๊ณผ ๋จ์ด์ ์งํฉ words๊ฐ ์์ต๋๋ค.
์๋์ ๊ฐ์ ๊ท์น์ ์ด์ฉํ์ฌ begin์์ target์ผ๋ก ๋ณํํ๋ ๊ฐ์ฅ ์งง์ ๋ณํ ๊ณผ์ ์ ์ฐพ์ผ๋ ค๊ณ ํฉ๋๋ค.
- ํ ๋ฒ์ ํ ๊ฐ์ ์ํ๋ฒณ๋ง ๋ฐ๊ฟ ์ ์์ต๋๋ค.
- words์ ์๋ ๋จ์ด๋ก๋ง ๋ณํํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด begin์ด โhitโ, target๊ฐ โcogโ, words๊ฐ [โhotโ,โdotโ,โdogโ,โlotโ,โlogโ,โcogโ]๋ผ๋ฉด โhitโ -> โhotโ -> โdotโ -> โdogโ -> โcogโ์ ๊ฐ์ด 4๋จ๊ณ๋ฅผ ๊ฑฐ์ณ ๋ณํํ ์ ์์ต๋๋ค.
๋ ๊ฐ์ ๋จ์ด begin, target๊ณผ ๋จ์ด์ ์งํฉ words๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต์ ๋ช ๋จ๊ณ์ ๊ณผ์ ์ ๊ฑฐ์ณ begin์ target์ผ๋ก ๋ณํํ ์ ์๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ๊ฐ ๋จ์ด๋ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ๊ฐ ๋จ์ด์ ๊ธธ์ด๋ 3 ์ด์ 10 ์ดํ์ด๋ฉฐ ๋ชจ๋ ๋จ์ด์ ๊ธธ์ด๋ ๊ฐ์ต๋๋ค.
- words์๋ 3๊ฐ ์ด์ 50๊ฐ ์ดํ์ ๋จ์ด๊ฐ ์์ผ๋ฉฐ ์ค๋ณต๋๋ ๋จ์ด๋ ์์ต๋๋ค.
- begin๊ณผ target์ ๊ฐ์ง ์์ต๋๋ค.
- ๋ณํํ ์ ์๋ ๊ฒฝ์ฐ์๋ 0๋ฅผ return ํฉ๋๋ค.
์ ์ถ๋ ฅ ์
begin | target | words | return |
---|---|---|---|
โhitโ | โcogโ | [โhotโ, โdotโ, โdogโ, โlotโ, โlogโ, โcogโ] | 4 |
โhitโ | โcogโ | [โhotโ, โdotโ, โdogโ, โlotโ, โlogโ] | 0 |
๋ฌธ์ ํ์ด
import java.util.Queue;
import java.util.LinkedList;
import java.util.ArrayList;
class Solution {
public int solution(String begin, String target, String[] words) {
int answer = 0;
Queue<String> que = new LinkedList<>();
ArrayList<String> list = new ArrayList<>();
int check = 0;
for(String str : words){
list.add(str);
}
if(!list.contains(target)){
return 0;
}
que.offer(begin);
list.remove(begin);
while(!que.isEmpty()){
for(int i = 0; i < que.size(); i++){
String temp = "";
String current_str = que.poll();
if(current_str.equals(target)){
return answer;
}
for(String str : list){
if(convert(current_str, str)){
que.offer(str);
temp = str;
}
}
list.remove(temp);
}
answer++;
}
return 0;
}
public boolean convert(String word_1, String word_2){
int count = 0;
for(int i = 0; i < word_1.length(); i++){
if(word_1.charAt(i) != word_2.charAt(i)){
count++;
}
}
return count == 1;
}
}
ํ์ด ์ค๋ช
์ฃผ์ด์ง ๋ฌธ์ ๋ ์์ ๋ฌธ์์ด begin์์ ๋ชฉํ ๋ฌธ์์ด target์ผ๋ก ๋ณํํ๊ธฐ ์ํด ์ต์ํ์ ๋ณํ ํ์๋ฅผ ๊ตฌํ๋ ๊ฒ์ ๋๋ค.
๋จ, ๋ณํ ๊ณผ์ ์์ ๊ฐ ๋จ์ด๋ ๋ฏธ๋ฆฌ ์ฃผ์ด์ง ๋จ์ด ๋ชฉ๋ก(words)์ ์กด์ฌํด์ผ ํ๋ฉฐ, ๊ฐ ๋จ์ด๋ ํ ๋ฒ์ ํ๋์ ๋ฌธ์๋ง ๋ฐ๋ ์ ์์ต๋๋ค.
๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด Queue์ ArrayList๋ฅผ ์ฌ์ฉํ BFS๋ฅผ ๊ตฌํํฉ๋๋ค.
BFS๋ฅผ ์ฌ์ฉํ์ฌ begin ๋ฌธ์์ด์์ target ๋ฌธ์์ด๋ก์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ์ต๋๋ค.
๊ฐ ๋ณํ ๋จ๊ณ์์ ํ์ฌ ๋จ์ด์ ๋ค์ ๋จ์ด๊ฐ ํ ๊ธ์๋ง ๋ค๋ฅธ์ง ๊ฒ์ฌํฉ๋๋ค.
๋ณํ ๊ณผ์ ์์ ๋ชฉํ ๋จ์ด target์ ๋๋ฌํ๋์ง ํ์ธํฉ๋๋ค.
์ด๊ธฐํ ๋จ๊ณ์์ Queue
answer ๋ณ์๋ ๋ณํ ํ์๋ฅผ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. words ๋ฐฐ์ด์ list๋ก ๋ณํํ๊ณ target ๋จ์ด๊ฐ ๋ชฉ๋ก์ ์๋์ง ํ์ธํฉ๋๋ค.
๋ง์ฝ target์ด ๋ชฉ๋ก์ ์์ผ๋ฉด ๋ณํํ ์ ์์ผ๋ฏ๋ก 0์ ๋ฐํํฉ๋๋ค.
BFS ํ์ ๊ณผ์ ์์๋ ์์ ๋จ์ด begin์ ํ์ ์ถ๊ฐํ๊ณ ๋ฆฌ์คํธ์์ ์ ๊ฑฐํฉ๋๋ค.
ํ๊ฐ ๋น ๋๊น์ง ๋ฐ๋ณตํ์ฌ ๊ฐ ๋ ๋ฒจ์ ๋ชจ๋ ๋จ์ด๋ฅผ ํ์ํฉ๋๋ค.
ํ์ฌ ๋จ์ด์ ๋ณํ ๊ฐ๋ฅํ ๋จ์ด๋ฅผ ์ฐพ์ ํ์ ์ถ๊ฐํฉ๋๋ค. ๋ณํ๋ ๋จ์ด๋ ๋ฆฌ์คํธ์์ ์ ๊ฑฐํ์ฌ ์ค๋ณต ํ์์ ๋ฐฉ์งํฉ๋๋ค.
๋ชฉํ ๋จ์ด์ ๋๋ฌํ๋ฉด ๋ณํ ํ์๋ฅผ ๋ฐํํฉ๋๋ค.
convert ๋ฉ์๋๋ ๋ ๋จ์ด๊ฐ ํ ๊ธ์๋ง ๋ค๋ฅธ์ง ๊ฒ์ฌํฉ๋๋ค.
๋ ๋จ์ด์ ๊ฐ ๋ฌธ์๋ฅผ ๋น๊ตํ์ฌ ์ฐจ์ด๊ฐ 1์ธ ๊ฒฝ์ฐ ๋ณํ์ด ๊ฐ๋ฅํ๋ฏ๋ก true๋ฅผ ๋ฐํํฉ๋๋ค.
๊ฒฐ๋ก
์ฃผ์ด์ง ์ ์ฝ ์กฐ๊ฑด ๋ด์์ ์์ ๋ฌธ์์ด์์ ๋ชฉํ ๋ฌธ์์ด๋ก์ ์ต์ ๋ณํ ํ์๋ฅผ BFS๋ฅผ ํตํด ํจ๊ณผ์ ์ผ๋ก ์ฐพ์ ์ ์์ต๋๋ค.
์ด ๊ณผ์ ์์ ๋ณํ ๊ฐ๋ฅ์ฑ์ ๊ฒ์ฌํ๊ณ , ๋ณํ๋ ๋จ์ด๋ฅผ ๊ด๋ฆฌํ์ฌ ์ต์ ์ ๊ฒฝ๋ก๋ฅผ ํ์ํฉ๋๋ค.