ํฐ์คํ ๋ฆฌ ๋ทฐ
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ๋ฉ๋ด ๋ฆฌ๋ด์ผ
๊ฐ๋ฐ๊ฐ๊ตด๐ธ 2022. 5. 29. 19:30https://programmers.co.kr/learn/courses/30/lessons/72411
์ฝ๋ฉํ ์คํธ ์ฐ์ต - ๋ฉ๋ด ๋ฆฌ๋ด์ผ
๋ ์คํ ๋์ ์ด์ํ๋ ์ค์นดํผ๋ ์ฝ๋ก๋19๋ก ์ธํ ๋ถ๊ฒฝ๊ธฐ๋ฅผ ๊ทน๋ณตํ๊ณ ์ ๋ฉ๋ด๋ฅผ ์๋ก ๊ตฌ์ฑํ๋ ค๊ณ ๊ณ ๋ฏผํ๊ณ ์์ต๋๋ค. ๊ธฐ์กด์๋ ๋จํ์ผ๋ก๋ง ์ ๊ณตํ๋ ๋ฉ๋ด๋ฅผ ์กฐํฉํด์ ์ฝ์ค์๋ฆฌ ํํ๋ก ์ฌ๊ตฌ์ฑํด์
programmers.co.kr
๋ฌธ์ ์ค๋ช
๋ ์คํ ๋์ ์ด์ํ๋ ์ค์นดํผ๋ ์ฝ๋ก๋19๋ก ์ธํ ๋ถ๊ฒฝ๊ธฐ๋ฅผ ๊ทน๋ณตํ๊ณ ์ ๋ฉ๋ด๋ฅผ ์๋ก ๊ตฌ์ฑํ๋ ค๊ณ ๊ณ ๋ฏผํ๊ณ ์์ต๋๋ค.
๊ธฐ์กด์๋ ๋จํ์ผ๋ก๋ง ์ ๊ณตํ๋ ๋ฉ๋ด๋ฅผ ์กฐํฉํด์ ์ฝ์ค์๋ฆฌ ํํ๋ก ์ฌ๊ตฌ์ฑํด์ ์๋ก์ด ๋ฉ๋ด๋ฅผ ์ ๊ณตํ๊ธฐ๋ก ๊ฒฐ์ ํ์ต๋๋ค. ์ด๋ค ๋จํ๋ฉ๋ด๋ค์ ์กฐํฉํด์ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด๋ก ๊ตฌ์ฑํ๋ฉด ์ข์ ์ง ๊ณ ๋ฏผํ๋ "์ค์นดํผ"๋ ์ด์ ์ ๊ฐ ์๋๋ค์ด ์ฃผ๋ฌธํ ๋ ๊ฐ์ฅ ๋ง์ด ํจ๊ป ์ฃผ๋ฌธํ ๋จํ๋ฉ๋ด๋ค์ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด๋ก ๊ตฌ์ฑํ๊ธฐ๋ก ํ์ต๋๋ค.
๋จ, ์ฝ์ค์๋ฆฌ ๋ฉ๋ด๋ ์ต์ 2๊ฐ์ง ์ด์์ ๋จํ๋ฉ๋ด๋ก ๊ตฌ์ฑํ๋ ค๊ณ ํฉ๋๋ค. ๋ํ, ์ต์ 2๋ช
์ด์์ ์๋์ผ๋ก๋ถํฐ ์ฃผ๋ฌธ๋ ๋จํ๋ฉ๋ด ์กฐํฉ์ ๋ํด์๋ง ์ฝ์ค์๋ฆฌ ๋ฉ๋ด ํ๋ณด์ ํฌํจํ๊ธฐ๋ก ํ์ต๋๋ค.
์๋ฅผ ๋ค์ด, ์๋ 6๋ช
์ด ์ฃผ๋ฌธํ ๋จํ๋ฉ๋ด๋ค์ ์กฐํฉ์ด ๋ค์๊ณผ ๊ฐ๋ค๋ฉด,
(๊ฐ ์๋์ ๋จํ๋ฉ๋ด๋ฅผ 2๊ฐ ์ด์ ์ฃผ๋ฌธํด์ผ ํ๋ฉฐ, ๊ฐ ๋จํ๋ฉ๋ด๋ A ~ Z์ ์ํ๋ฒณ ๋๋ฌธ์๋ก ํ๊ธฐํฉ๋๋ค.)
์๋ ๋ฒํธ / ์ฃผ๋ฌธํ ๋จํ๋ฉ๋ด ์กฐํฉ
1๋ฒ ์๋ | A, B, C, F, G |
2๋ฒ ์๋ | A, C |
3๋ฒ ์๋ | C, D, E |
4๋ฒ ์๋ | A, C, D, E |
5๋ฒ ์๋ | B, C, F, G |
6๋ฒ ์๋ | A, C, D, E, H |
๊ฐ์ฅ ๋ง์ด ํจ๊ป ์ฃผ๋ฌธ๋ ๋จํ๋ฉ๋ด ์กฐํฉ์ ๋ฐ๋ผ "์ค์นดํผ"๊ฐ ๋ง๋ค๊ฒ ๋ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด ๊ตฌ์ฑ ํ๋ณด๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ฝ์ค ์ข ๋ฅ / ๋ฉ๋ด / ๊ตฌ์ฑ์ค๋ช์๋ฆฌ 2๊ฐ ์ฝ์ค | A, C | 1๋ฒ, 2๋ฒ, 4๋ฒ, 6๋ฒ ์๋์ผ๋ก๋ถํฐ ์ด 4๋ฒ ์ฃผ๋ฌธ๋์ต๋๋ค. |
์๋ฆฌ 3๊ฐ ์ฝ์ค | C, D, E | 3๋ฒ, 4๋ฒ, 6๋ฒ ์๋์ผ๋ก๋ถํฐ ์ด 3๋ฒ ์ฃผ๋ฌธ๋์ต๋๋ค. |
์๋ฆฌ 4๊ฐ ์ฝ์ค | B, C, F, G | 1๋ฒ, 5๋ฒ ์๋์ผ๋ก๋ถํฐ ์ด 2๋ฒ ์ฃผ๋ฌธ๋์ต๋๋ค. |
์๋ฆฌ 4๊ฐ ์ฝ์ค | A, C, D, E | 4๋ฒ, 6๋ฒ ์๋์ผ๋ก๋ถํฐ ์ด 2๋ฒ ์ฃผ๋ฌธ๋์ต๋๋ค. |
[๋ฌธ์ ]
๊ฐ ์๋๋ค์ด ์ฃผ๋ฌธํ ๋จํ๋ฉ๋ด๋ค์ด ๋ฌธ์์ด ํ์์ผ๋ก ๋ด๊ธด ๋ฐฐ์ด orders, "์ค์นดํผ"๊ฐ ์ถ๊ฐํ๊ณ ์ถ์ดํ๋ ์ฝ์ค์๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ ๋จํ๋ฉ๋ด๋ค์ ๊ฐฏ์๊ฐ ๋ด๊ธด ๋ฐฐ์ด course๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, "์ค์นดํผ"๊ฐ ์๋ก ์ถ๊ฐํ๊ฒ ๋ ์ฝ์ค์๋ฆฌ์ ๋ฉ๋ด ๊ตฌ์ฑ์ ๋ฌธ์์ด ํํ๋ก ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
[์ ํ์ฌํญ]
- orders ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 2 ์ด์ 20 ์ดํ์ ๋๋ค.
- orders ๋ฐฐ์ด์ ๊ฐ ์์๋ ํฌ๊ธฐ๊ฐ 2 ์ด์ 10 ์ดํ์ธ ๋ฌธ์์ด์
๋๋ค.
- ๊ฐ ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ๊ฐ ๋ฌธ์์ด์๋ ๊ฐ์ ์ํ๋ฒณ์ด ์ค๋ณตํด์ ๋ค์ด์์ง ์์ต๋๋ค.
- course ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 1 ์ด์ 10 ์ดํ์
๋๋ค.
- course ๋ฐฐ์ด์ ๊ฐ ์์๋ 2 ์ด์ 10 ์ดํ์ธ ์์ฐ์๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ต๋๋ค.
- course ๋ฐฐ์ด์๋ ๊ฐ์ ๊ฐ์ด ์ค๋ณตํด์ ๋ค์ด์์ง ์์ต๋๋ค.
- ์ ๋ต์ ๊ฐ ์ฝ์ค์๋ฆฌ ๋ฉ๋ด์ ๊ตฌ์ฑ์ ๋ฌธ์์ด ํ์์ผ๋ก ๋ฐฐ์ด์ ๋ด์ ์ฌ์ ์์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ return ํด์ฃผ์ธ์.
- ๋ฐฐ์ด์ ๊ฐ ์์์ ์ ์ฅ๋ ๋ฌธ์์ด ๋ํ ์ํ๋ฒณ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด์ผ ํฉ๋๋ค.
- ๋ง์ฝ ๊ฐ์ฅ ๋ง์ด ํจ๊ป ์ฃผ๋ฌธ๋ ๋ฉ๋ด ๊ตฌ์ฑ์ด ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด, ๋ชจ๋ ๋ฐฐ์ด์ ๋ด์ return ํ๋ฉด ๋ฉ๋๋ค.
- orders์ course ๋งค๊ฐ๋ณ์๋ return ํ๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 1 ์ด์์ด ๋๋๋ก ์ฃผ์ด์ง๋๋ค.
[์ ์ถ๋ ฅ ์]orders / course / result
["ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"] | [2,3,4] | ["AC", "ACDE", "BCFG", "CDE"] |
["ABCDE", "AB", "CD", "ADE", "XYZ", "XYZ", "ACD"] | [2,3,5] | ["ACD", "AD", "ADE", "CD", "XYZ"] |
["XYZ", "XWY", "WXA"] | [2,3,4] | ["WX", "XY"] |
----------------------------------------------------------------------------------------------------------------------
[๋ฌธ์ ํ์ด]
- getCource()
์ฃผ๋ฌธ๋ค๋ง๋ค ์ฃผ๋ฌธ ๋ฉ๋ด์ ์ด๊ฐ์ >= ์กฐํฉ์ ์งํํ ๊ฐ์ ์ผ๋๋ง, getMenu()๋ฅผ ํตํด ๋ฉ๋ด๋ฅผ ์กฐํฉํฉ๋๋ค.
- getMenu()
i๋ฒ์งธ ์๋์ ๋จํ ๋ฉ๋ด๋ค๋ก, cnt ํฌ๊ธฐ์ ์กฐํฉ์ ๋ฝ์๋ด์ด map์ ์ ์ฅํฉ๋๋ค.
์ด๋ map์ ํด๋น ์กฐํฉ์ด ์ด๋ฏธ ๋ค์ด์๋ค๋ฉด, ํด๋น ์กฐํฉ์ ๊ฐ์๋ฅผ +1ํ์ฌ ๊ฐฑ์ ํฉ๋๋ค.
๋ํ, ๊ฐฑ์ ๋ ์ด ๊ฐ์์ ์ต๋๊ฐ์ max์ ๊ณ์ ๊ฐฑ์ ํฉ๋๋ค.
-findMax()
๋ชจ๋ ์กฐํฉ์ด ์ ์ฅ ์๋ฃ๋ map์์ ์ต๋๊ฐ max๋งํผ ๊ฐ์ง๊ณ ์๋ ๋ฉ๋ด๋ฅผ ์ฐ์ ์์ํ pq์ ์ ์ฅํฉ๋๋ค.
์ด๋ฌํ ์์ ์ด ์๋ฃ๋ ํ, pq์์ ๊ฐ์ ํ๋์ฉ ๊บผ๋์ answer๋ฐฐ์ด์ ์ ์ฅํฉ๋๋ค.
[์ ๋ต ์ฝ๋]
import java.util.*;
class Solution {
public static HashMap<String, Integer> map = new HashMap<String, Integer>();
public static int max = 0;
public static PriorityQueue<String> pq = new PriorityQueue<>();
public String[] solution(String[] orders, int[] course) {
String[] answer = {};
for(int i=0;i<course.length;i++) {
getCourse(course[i], orders);
}
answer = new String[pq.size()];
int index = 0;
while(!pq.isEmpty()) {
answer[index] = pq.poll();
index++;
}
return answer;
}
public static void getCourse(int count, String[] orders) {
//์ฃผ๋ฌธ๋ค ๋ง๋ค ์ฃผ๋ฌธ๊ฐ์ >= ์กฐํฉํ ๊ฐ์ ์ด๋ฉด, getMenu()๋ฅผ ์คํ
for(int i=0;i<orders.length;i++) {
int len = orders[i].length();
if(len >= count) {
String[] menu = orders[i].split("");
// XWA -> AWX
Arrays.sort(menu);
boolean[] visit = new boolean[len];
getMenu(menu, count, "", visit, 0);
}
}
//๊ฐ๋ฅํ ๋ชจ๋ ๋ฉ๋ด๊ฐ map์ ์ถ๊ฐ๋จ
//map์ menu์ค ์ต๋๊ฐ์ max์ ์ ์ฅ๋จ
// ์ต์ 2๋ช
์ด์์ ์๋์๊ฒ์ ์ฃผ๋ฌธ๋ ๊ตฌ์ฑ๋ง ์ฝ์ค ๊ฐ๋ฅ
if(max > 1) {
findMax();
}
max = 0;
map.clear();
}
// ๋ฉ๋ด cnt๊ฐ ์กฐํฉ ๊ฐ๋ฅํ๊ฒ๋ค ์ฐพ์์ map์ (menu, ๊ฐ์)๋ก ์ถ๊ฐํจ
public static void getMenu(String[] menu, int cnt, String set, boolean[] visit, int index) {
if(set.length() == cnt) {
if(map.get(set) != null) {
int newCount = map.get(set) + 1;
map.put(set, newCount);
if(max < newCount) {
max = newCount;
}
} else {
map.put(set, 1);
}
return;
}
for(int i=index;i<menu.length;i++) {
if(!visit[i]) {
visit[i] = true;
getMenu(menu, cnt, set + menu[i], visit, i);
visit[i] = false;
}
}
}
public static void findMax() {
for(String key:map.keySet()) {
if(max == map.get(key)) {
pq.offer(key);
}
}
}
}
'Algorithm > Programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ์๋ฌผ์ ์ ์ด์ (0) | 2022.06.13 |
---|---|
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ๋ก๋์ ์ต๊ณ ์์์ ์ต์ ์์ (0) | 2022.06.05 |
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ์ซ์ ๋ฌธ์์ด๊ณผ ์๋จ์ด (0) | 2022.06.05 |
[Java] ํ๋ก๊ทธ๋๋จธ์ค - ์ ํ๋ฒ์ค (0) | 2022.06.05 |
[Java] ํ๋ก๊ทธ๋๋จธ์ค - k์ง์์์ ์์ ๊ฐ์ ๊ตฌํ๊ธฐ (0) | 2022.06.05 |
- Total
- Today
- Yesterday
- git
- ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
- ํ๋กํ ์ฝ
- 2019 ์นด์นด์ค ๊ฐ๋ฐ์ ๊ฒจ์ธ ์ธํด
- ๋คํธ์ํฌ
- ๋์์ธ ํจํด
- ์๊ณ ๋ฆฌ์ฆ
- ์ด๋ถํ์
- ํ๋ก๊ทธ๋๋จธ์ค
- JavaScript
- TDD
- ๋ชจ๋ ์๋ฐ์คํฌ๋ฆฝํธ deep dive
- fp
- ์ด์์ฒด์
- ์ฝ๋ฉํ ์คํธ
- ์๋ฐ์คํฌ๋ฆฝํธ
- Baekjoon
- ํ๋กํผํฐ
- ์นด์นด์ค ์ธํด
- ๋ ์์ปฌ ํ๊ฒฝ
- ๋ฐฑ์ค
- ์ ์ญ ๋ณ์
- ํฌํฌ์ธํฐ
- ๋ฐฑ์ค javascript
- ํจ์ํ ํ๋ก๊ทธ๋๋ฐ
- ์๋ฐ
- ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
- ๋ฐฑ์ค node.js
- http
- map
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | ||
6 | 7 | 8 | 9 | 10 | 11 | 12 |
13 | 14 | 15 | 16 | 17 | 18 | 19 |
20 | 21 | 22 | 23 | 24 | 25 | 26 |
27 | 28 | 29 | 30 |