๋ด๋ฐฐ์บ ์คํ๋ง ์ ๋ฌธ ๊ฐ์ ๋ฃ๊ธฐ
์ค๋์ ์คํ๋ง ์
๋ฌธ ๊ฐ์๋ฅผ ๋ค์๋ค. ..
์ฌ์ค ๋ค๋ฅธ๊ฑฐ ํ ๊ฒ ์ข ์์ด์ ๋ง์ด ๋ชป๋ค์๋ค.....
์์ง ๋ธ๋ก๊ทธ ์ ๋ฆฌ๋ ๋ ํ๋คใ
ใ
ใ
๊ทธ๋์ ์์์ ์ฅ์ํใ
ใ
ใ
๊ทธ๋๋ ๊ณต๋ถํ๋ฉด์ API์ ๋ํด ์ข ๋ ๋น์ ๋ฅผ ๋ค์ด์ ํ์คํ ๋ฝ! ๊น์ง ์๋์ฌ๋ ์ดํด๋ฅผ ํ๋น\
๋ด์ผ์ ๊ผญ 1์ฃผ์ฐจ ๋ค ์๊ฐํด์ผ์ง!!
ํ๋ก๊ทธ๋๋จธ์ค์์ ์ถ์???ํ ์๊ฒฉ์ฆ ์ ์ฒญ
PCCP ์ํ ์ ์ฒญํ๋ค.!
๊ฝค๋ ๋ง์ ๊ณณ์์ ์ธ์ ํด์ฃผ๊ณ ์์ด์ ๋ฐ๋์ผ๋ฉด ์ข์๊ฑฐ๊ฐ๋น
๋ด ํ ์๊ณ ๋ฆฌ์ฆ ์ค๋ ฅ๋ ์๊ณ ์ถ๊ณ ์ค์ค์ฟใ
๋ชจ์๊ณ ์ฌ๋ ํ์ด๋ดฃ๋ค.
1๋ฒ 2๋ฒ ํ์๋๋ฐ
1๋ฒ. ์ธํจ์ด ๋ฌธ์
๊ฝค๋ ์ด๋ ค์ด๋ฏํ์ง๋ง ๊ฝค๋ ์ฌ์ ๋ค. ์ฌ๋ฌ ๋ฒ ๋์ค๋๋ฐ ๋จ์ด์ ธ์์ผ๋ฉด ์ธํจ์ด ๋ฌธ์์ด๋ค
์ด ์ธํจ์ด ๋ฌธ์๋ค๋ง ์ฐ๊ฒฐํด์ ์ถ๋ ฅ! ์๋ค๋ฉด N ์ถ๋ ฅ
๋๋ MAP์ 2๊ฐ ์ฌ์ฉํด์, ํ๋๋ ๊ฐ์ ์ ์ฅ, ํ๋๋ ์ธ๋ฑ์ค๋ฅผ ๋ชจ๋ ์ ์ฅํ๋ค
๊ทธ ํ ๋ง์ฝ 2๊ฐ์ด์ ๋์๋๋ฐ ๋ชจ๋ ์ธ๋ฑ์ค์ ์ฐจ๊ฐ 1์ด ์๋๋ฉด ์ธํจ์ด ๋ฌธ์๋ก ํ๋จ!!
import java.util.*;
class Solution {
public String solution(String input_string) {
String answer = "";
Map<Character, Integer> countOfAlphabets = new HashMap<>();
Map<Character, List<Integer>> indexOfAlphabets = new HashMap<>();
for(int i = 0; i< input_string.length(); i++){
char a = input_string.charAt(i);
countOfAlphabets.put(a, countOfAlphabets.getOrDefault(a, 0) + 1);
List<Integer> list = new ArrayList<>();
if(indexOfAlphabets.containsKey(a)) list = indexOfAlphabets.get(a);
list.add(i);
indexOfAlphabets.put(a, list);
}
for(char key : countOfAlphabets.keySet()){
if(countOfAlphabets.get(key) > 1){
List<Integer> list = indexOfAlphabets.get(key) ;
for(int i = 0; i < list.size() - 1;i++){
if(list.get(i + 1) - list.get(i) > 1) {
answer += key;
break;
}
}
}
}
if(answer.length() == 0) return "N";
return answer;
}
}
2๋ฒ. ์ฒด์ก๋ํ
์ด๊ฑฐ๋ ์ข ์ด๋ป๊ฒ ์ ๊ทผํด์ผ ํ ์ง ํท๊ฐ๋ ธ๋ค.
๊ทผ๋ฐ ๋ฒ์๊ฐ ํฌ์ง ์์์ ์์ด๋ก ํ์ ์กฐํฉ์ ๋ชจ๋ ๋ฝ์ ์ต๋๊ฐ์ ์ฐพ๋ ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ๋ค
import java.util.*;
class Solution {
int[] index;
int N;
int answer = 0;
public int solution(int[][] ability) {
index = new int[ability[0].length];
N = ability.length;
permutation(ability,0, new boolean[N]);
return answer;
}
public void permutation(int[][] ability, int depth, boolean[] isVisited){
if(depth == ability[0].length){
answer = Math.max(answer, getSumOfScores(ability));
return;
}
for(int i = 0; i < N; i++){
if(isVisited[i]) continue;
isVisited[i] = true;
index[depth] = i;
permutation(ability, depth+1, isVisited);
isVisited[i] = false;
}
}
public int getSumOfScores(int[][] ability){
int sum = 0;
for(int i = 0;i < index.length;i++){
sum += ability[index[i]][i];
}
return sum;
}
}
'TIL๐ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
23.11.06 TIL (2) | 2023.11.06 |
---|---|
23.11.02 TIL (0) | 2023.11.02 |
23.10.31 TIL (0) | 2023.10.31 |
23.10.30 TIL (0) | 2023.10.30 |
23.10.25 TIL (0) | 2023.10.25 |