Tags
- ์ ๋ ฌ
- ๊น์ด ์ฐ์ ํ์
- ๊ต์ฌ
- ๋๋น ์ฐ์ ํ์
- BFS
- BOJ
- queue
- stack
- dfs
- ์๋ฃ๊ตฌ์กฐ
- ๋ฌธ์์ด
- SpringBoot
- ๊ทธ๋ํ ์ด๋ก
- LV2
- DP
- ๊ตฌํ
- Study
- ๊ทธ๋ํ ํ์
- ์ ์๋ก
- ์ํ
- Brute Force Algorithm
- Java
- Dynamic Programming
- Python
- ๋ฐฑํธ๋ํน
- CodingTest
- sort
- ์๋ฎฌ๋ ์ด์
- PGM
- greedy
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_1062 : ๊ฐ๋ฅด์นจ ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- K๊ฐ์ ๋ฌธ์๋ฅผ ๋ฐฐ์ ์ ๋, N๊ฐ์ ๋จ์ด(๋ฌธ์์ด) ์ค ์ต๋ ๋ช ๊ฐ๋ฅผ ์ฝ์ ์ ์๋์ง ์ถ๋ ฅํ๋ค.
- ๋ชจ๋ ๋จ์ด๋ anta๋ก ์์ํด tica๋ก ๋๋๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- ๋จ์ด์ ์์๊ณผ ๋์ด ์ ํด์ ธ ์์ผ๋ฏ๋ก, 'a', 'n', 't', 'i', 'c' ๋ค์ฏ ๊ธ์๋ ๋ฐ๋์ ์ฝ์ ์ค ์์์ผ ํ๋ค.
- K๊ฐ 5 ๋ฏธ๋ง์ธ ๊ฒฝ์ฐ์๋ 0์ ๋ฐํํ๋ค.
- K >= 5 ์ผ ๋, K-5 ๊ฐ์ ๋ฌธ์๋ฅผ ์ถ๊ฐ๋ก ๋ฐฐ์์ ๋ช ๊ฐ์ ๋จ์ด๋ฅผ ์ฝ์ ์ ์๋์ง ํ์ธํด์ผ ํ๋ค.
- ๋นํธ ๋ง์คํน์ผ๋ก ๋ฐฐ์ด ๋ฌธ์๋ฅผ ํ์ํ๋ค.
- ๋ฐฐ์ด ๋ฌธ์๋ก ๋จ์ด๋ฅผ ์ฝ์ ์ ์๋์ง ๋นํธ ๋ง์คํน์ผ๋ก ํ์ธํ๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.*;
import java.util.StringTokenizer;
public class Main {
private static int N, K, MAX;
private static int[] usedChar;
public static void main(String[] args) throws IOException {
// Intput
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
K = Integer.parseInt(st.nextToken());
usedChar = new int[N];
for (int i = 0; i < N; i++) {
char[] chars = br.readLine().toCharArray();
for (char c : chars) {
usedChar[i] |= (1 << c - 'a'); // ์ฌ์ฉ ๋ ๋ฌธ์ ๋นํธ๋ง์คํน : 1
}
}
// a, c, i, n, t ๋ ๋ฐ๋์ ์ฝ์ ์ค ์์์ผ ํจ
if (K < 5) {
bw.write("0");
bw.flush();
return;
}
int mustLearned = (1 << ('a' - 'a')) | (1 << ('c' - 'a')) | (1 << ('i' - 'a')) | (1 << ('n' - 'a')) | (1 << ('t' - 'a'));
// Combination : K๊ฐ์ ๋ฌธ์ ์ ํ ํ ์ฝ์ ์ ์๋ ๋จ์ด ์ ์ฒดํฌ
MAX = 0;
combination(0, mustLearned, 5);
// Output
bw.write(Integer.toString(MAX));
bw.flush();
}
private static void combination(int start, int learned, int cnt) {
if (cnt == K) { // K๊ฐ์ ๋ฌธ์๋ฅผ ๊ณจ๋์ผ๋ฉด ์ฝ์ ์ ์๋ ๋จ์ด ์ ํ์ธ
MAX = Math.max(MAX, read(learned));
return;
}
for (int i = start; i < 26; i++) { // ๋นํธ ๋ง์คํน ํ๋์ฉ 1 ๋ง๋ค์ด๋ณด๊ธฐ
if ((learned & (1 << i)) == 0) { // ์๋ฐฐ์ด ๋ฌธ์ ๋ฐฐ์ฐ๊ธฐ
combination(i + 1, learned | (1 << i), cnt + 1);
}
}
}
private static int read(int learned) { // ์ฝ์ ์ ์๋ ๋จ์ด ์ ์ธ๊ธฐ
int cnt = 0;
for (int i = 0; i < N; i++) {
if ((usedChar[i] & learned) == usedChar[i])
cnt++;
}
return cnt;
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ์ฝ์ ๋จ์ด๋ค์ ์ฌ์ฉ๋ ๋ฌธ์๋ฅผ usedChar ๋ฐฐ์ด์ ๋นํธ ๋ง์คํนํ๋ค.
- K๊ฐ 5 ๋ฏธ๋ง์ด๋ฉด ์ฝ์ ์ ์๋ ๋จ์ด๊ฐ ์์ผ๋ฏ๋ก 0์ ์ถ๋ ฅํ๊ณ ํ๋ก๊ทธ๋จ์ ์ข ๋ฃํ๋ค.
- ๋ฐ๋์ ์ฝ์ ์ค ์์์ผ ํ๋ 5๊ฐ์ ๋จ์ด๋ฅผ mustLearned์ ๋นํธ ๋ง์คํนํ๋ค.
- ์ฌ๊ท ๋ฉ์๋ combination์ผ๋ก ์กฐํฉ ํ์์ ํตํด ์ถ๊ฐ์ ์ผ๋ก ๋ฐฐ์ธ ๋ฌธ์๋ฅผ ํ๋์ฉ ์ ํํด๋ณด๊ณ , ์ฝ์ ์ ์๋ ๋จ์ด์ ์ต๋๊ฐ MAX๋ฅผ ๊ตฌํ๋ค.
- K๊ฐ์ ๋ฌธ์๋ฅผ ๋ชจ๋ ๋ฐฐ์ ์ผ๋ฉด read ๋ฉ์๋์์ ์ฝ์ ์ ์๋ ๋จ์ด์ ์๋ฅผ ๊ตฌํ๋ค.
- ๋ฐฐ์ธ ๋ฌธ์๋ฅผ ์ ํํ ๋ start๋ก ๊ฒฝ์ฐ์ ์๊ฐ ๊ฒน์น์ง ์๋๋ก ํ๊ณ , ๋นํธ๊ฐ 0์ธ์ง ํ์ธํด์ ํ์ฌ ๋ฐฐ์ฐ์ง ์์ ๋ฌธ์๋ฉด ๋ฐฐ์๋ณธ๋ค.
- MAX๋ฅผ ์ถ๋ ฅํ๋ค.
๐ธ end ๐ธ
- ์ฒ์์ ์๊ฐ์ด 1์ด๋ก ์งง๊ธธ๋ Greedy๋ก ํ์ดํด์ผํ๋ ์ค ์๊ณ , ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ ๋ฌธ์ ์์ผ๋ก ๋ฐฐ์ฐ๊ณ ์ ํ๋ค.
- ํ์ง๋ง ๋ฐ๋ก๊ฐ ์์๊ณ , ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ดํด๋ด์ผํ๋ Brute Force ๋ฌธ์ ์ฌ์ ํ๋ ธ๋ค.
- ํ๊ทธ์ ๋นํธ ๋ง์คํน์ด ์์ด์, ์กฐํฉ์ผ๋ก ํ์ดํด๋ณด๊ณ ์ ํ์ง๋ง ์๊ฐ ์ด๊ณผ๊ฐ ๋ฌ๋ค. ์๊ณ ๋ณด๋ ๋ฌธ์ ์ ๋จ์ด ์๋ค ๋ฌธ์๋ ๊ณ ์ ๋์ด ์๋ค๋ ๊ฑธ ๋ชป๋ดค์๋ค...
- ์ค๋๋ง์ ์กฐํฉ์ ์ฌ์ฉํด์ ๋ง์ด ๋ฏธ์ํ ์ ์ด ์์๋ค.
- combination ๋ฉ์๋์ ํํ๋ ์์ฃผ ๊ณ ์ ์ ์ผ๋ก start์ ํ์ฌ๊ฐ, cnt ๊ฐ ๋ค์ด๊ฐ๋๋ฐ ํํ๋ฅผ ๋ ์ฌ๋ฆฌ๋๋ฐ ์ค๋๊ฑธ๋ ธ๋ ๊ฒ ๊ฐ๋ค.
- ๋ ๋นํธ๋ง์คํน์ ๋ง์ด ํ์ฉํด๋ณด์ง ์์์ ํ์ฉ์ฑ์ด ์ข์ง ์์๋ ๊ฒ ๊ฐ๋ค. cnt๋ฅผ ์ธ์๋ก ์๋๊ธฐ๊ณ Integer.bitCount()๋ฉ์๋๋ก learned๋ฅผ ํ์ธํด ๋ณด๋ ๋ฐฉ๋ฒ๋ ๊ด์ฐฎ์ ๊ฒ ๊ฐ๋ค.
- ๋๋์ด solved.ac ํ๋กํ ์ ํ์ดํ 100๋ฌธ์ ๋ชจ๋ ๊ณจ๋4 ์ด์์ผ๋ก ๋ง์ท๋ค.
- ์์ผ๋ก๋ ๊ณจ๋3 ์ด์์ ๋ฌธ์ ๋ฅผ ์คํธ๋ฆญ์ผ๋ก ํ์ด์ผํ๋ค.
- ์์ง ๋ฏธ์ํ ๋ถ๋ถ์ด ๋ง์ง๋ง ์ด์ฌํ ํด๋ณด์!
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_11049 : ํ๋ ฌ ๊ณฑ์ ์์ (0) | 2024.05.23 |
---|---|
BOJ_9466 : ํ ํ๋ก์ ํธ (0) | 2024.05.23 |
[ํ๊ธฐ] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉ์ ๋ฌธ์ญ๋์ธ์ฆ(PCCP) Lv3 ์ทจ๋ (0) | 2024.05.20 |
BOJ_5052 : ์ ํ๋ฒํธ ๋ชฉ๋ก (0) | 2024.05.19 |
BOJ_1915 : ๊ฐ์ฅ ํฐ ์ ์ฌ๊ฐํ (0) | 2024.05.11 |