ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ๋ฅผ ํ๋ ์ค ๋ต์ ๋ง์ผ๋ ๋ฌธ์ ์ ์ถํ๊ธฐ๋ฅผ ์งํํ์๋ ์ผ์ ๊ตฌ๊ฐ์์ ๊ณ์ ๋ฐํ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
๋๋ ์๋ฌด๋ฆฌ ์๊ฐํด๋ ๋ญ๊ฐ ๋ฌธ์ ์ธ์ง ๋ชจ๋ฅด๊ฒ ์ด์ ๋ด ์ฝ๋์ ์์์ฝ๋๋ฅผ ๋น๊ตํ๋ฉด์ ํ๋์ฉ ์ดํด๋ณด์๋ค.
ํ๋ก๊ทธ๋๋จธ์ค-๋ฌ๋ฆฌ๊ธฐ๊ฒฝ์ฃผ
https://school.programmers.co.kr/learn/courses/30/lessons/178871
์ฐพ์ ์ธ๋ฑ์ค๋ฅผ ๊ธฐ์ค์ผ๋ก ์์ ์ธ๋ฑ์ค๊ฐ๊ณผ ๋ณ๊ฒฝํ๋ฉด ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค.
๊ทธ๋ฆฌ๊ณ ์๋์ ๊ฐ์ด ์ฝ๋ฉ์ ํ๋ค.
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public String[] solution(String[] players, String[] callings) {
ArrayList<String> playerList = new ArrayList<>();
Collections.addAll(playerList, players); // players ๋ฐฐ์ด์ ArrayList๋ก ๋ณต์ฌ
for (String calling : callings) {
int temp = playerList.indexOf(calling);
Collections.swap(playerList, temp - 1, temp);
}
String[] playerArray = playerList.toArray(new String[0]);
return playerArray;
}
}
๊ฒฐ๊ณผ๋~~
๊ทธ๋์ ์์๋ก ๋ฐํ๊ฐ์ ๋ณ๊ฒฝํด๋ดค๋ค.
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public ArrayList<String> solution(String[] players, String[] callings) {
ArrayList<String> playerList = new ArrayList<>();
Collections.addAll(playerList, players); // players ๋ฐฐ์ด์ ArrayList๋ก ๋ณต์ฌ
for (String calling : callings) {
int temp = playerList.indexOf(calling);
Collections.swap(playerList, temp - 1, temp);
}
// String[] playerArray = playerList.toArray(new String[0]);
return playerList;
}
}
๊ฒฐ๊ณผ๋ ๋์ผํ๊ฒ ๋ฐํ์ ์ค๋ฅ!!
์คํ๋ ํญ๋ชฉ๋ ์ด์ ๊ณผ ๋น์ทํ ์ฒ๋ฆฌ์๋๋ฅผ ๋ณด์๋ค.
๊ทธ๋ ๋ค๋๊ฑด ์ด ์ฝ๋ ์์ฒด๊ฐ ๋ฌธ์ ๊ฒ ์ง.....
ํ์ธํด๋ณด๋ ๋ด๊ฐ ํ ์ฝ๋ฉ์ ์๋์ ๊ฐ์ ๋ฌธ์ ๊ฐ ์๋ค.
๋ฐ์ํ ์๊ฐ๋ณต์ก๋๋ฅผ ์ข ๋ ์์ธํ๊ฒ ํ์ธํด๋ณด์๋ค.
Collections.swap(): ์ด ์์ ์ ๋ ๊ฐ์ ์์๋ฅผ ์ค์ํ๋ ๊ฒ์ ๋๋ค. ์ด ์์ ์ O(1)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋๋ค. ํ์ง๋ง ์ฌ๊ธฐ์์ ์ค์์ indexOf()๋ฅผ ํตํด ์ฐพ์ ์ธ๋ฑ์ค์ ๊ทธ ์์ ์ธ๋ฑ์ค๋ฅผ ์ค์ํ๋๋ฐ, indexOf() ์์ฒด๊ฐ O(n)์ด๋ฏ๋ก ์ด ์ฐ์ฐ๋ ๊ฒฐ๊ตญ O(n) ์๊ฐ์ด ๊ฑธ๋ฆฝ๋๋ค.
๋ฐ๋ผ์, callings ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ m์ด๊ณ , playerList์ ๊ธธ์ด๊ฐ n์ผ ๋, callings ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ์ฒ๋ฆฌํ๋ฉด์ indexOf()์ Collections.swap()์ด ์คํ๋๊ธฐ ๋๋ฌธ์ ์ ์ฒด์ ์ธ ์๊ฐ ๋ณต์ก๋๋ O(n * m)์ด ๋ฉ๋๋ค.
import java.util.HashMap;
public class Solution {
public String[] solution(String[] players, String[] callings) {
int n = players.length;
HashMap<String, Integer> indexMap = new HashMap<>();
for (int i = 0; i < n; i++) {
indexMap.put(players[i], i);
}
for (String calling : callings) {
int idx = indexMap.get(calling);
if (idx > 0) {
String temp = players[idx - 1];
players[idx - 1] = players[idx];
players[idx] = temp;
indexMap.put(players[idx - 1], idx - 1);
indexMap.put(players[idx], idx);
}
}
return players;
}
}
์ด ์ฝ๋์์๋ String[] players์ ์์๊ฐ์ key๋ก, ์ธ๋ฑ์ค์ ๋งค์นญ๋๋ i๊ฐ์ value๋ก ์ฌ์ฉํ๋ค.
๊ทธ๋ฆฌ๊ณ temp๋ฅผ ์ด์ฉํ์ฌ ํด๋น๋๋ idx์ idx-1์ ์์น๋ฅผ ๋ฐ๊ฟ ์ ์๋๋ก ์ฝ๋ฉํ๋ค.
= ์ ์ถ ์ฑ๊ณต
Map์ key, value๊ฐ์ ์ด์ฉํ์ฌ ๋น ๋ฅธ ํ์์ ์งํํ๋ค.
temp๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ๊ฟ ์ธ๋ฑ์ค์ ๊ฐ์ ์ค์ ํ๊ณ index.put์ผ๋ก ๋ฐ๋ ์ธ๋ฑ์ค ๋ฒํธ๊น์ง ํจ๊ป ์ฌ์ค์ ํด์คฌ๋ค.
Collections.swap()์ indexOf()๋ ๋ด๊ฐ ์ํ๋๋ฐ๋ก ๋์ํ๋ ๋ฉ์๋๊ฐ ๋ง์ง๋ง, ์ด ๋๊ฐ์ง๊ฐ ํจ๊ป ๋์ํ ๋ ์๊ฐ๋ณต์ก๋๊ฐ n*m์ผ ์ ๋๋ก ๋ง์ด ์์นํ๋ค๋๊ฒ์ ๋ชฐ๋๋ค.
์๊ฐ ๋ณต์ก๋(Time Complexity), ๋น
-์ค ํ๊ธฐ๋ฒ(Big-O Notation)์ ๊ณต๋ถํ์ฌ ๋ด๊ฐ ํ ์ฝ๋ฉ์ ๋ถ์ฌ๋ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ณ ๋ คํด๋ด์ผ ํ ๊ฒ ๊ฐ๋ค.
๋ํ Map์ key๋ฅผ ์ด์ฉํ์ฌ ๋ด๋ถํ์์ ์งํํ๋ ์์
์ด ํ์ํ ๋ ์ ์ฉํ๋ค๋๊ฒ์ ์์ง๋ง์.