[๋ฐฑ์ค/1018/๊ตฌํ/์ฒด์คํ ๋ค์ ์น ํ๊ธฐ]
https://www.acmicpc.net/problem/1018
1018๋ฒ: ์ฒด์คํ ๋ค์ ์น ํ๊ธฐ
์ฒซ์งธ ์ค์ N๊ณผ M์ด ์ฃผ์ด์ง๋ค. N๊ณผ M์ 8๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๋ณด๋์ ๊ฐ ํ์ ์ํ๊ฐ ์ฃผ์ด์ง๋ค. B๋ ๊ฒ์์์ด๋ฉฐ, W๋ ํฐ์์ด๋ค.
www.acmicpc.net
<<ํ์ด>>
ํ ใ ใ ์ผ๋จ ๋ด ๋ ผ๋ฆฌ์ ์ธ ์๊ฐ์ ํ๋ฆฐ ๊ฒ์ด ์์๋ค. ๋ค๋ง ,, ใ ใ ใ ํดใ
๋ฌธ์ ๋ฅผ ์ ๋ชป ์ฝ์๋ค ใ ใ ใ ใ
๋ด๊ฐ ์๊ฐํ ๋ฌธ์ ๋ ์ฃผ์ด์ง ๋ชจ๋ ๊ฐ๋ค์์ ์ถ์ถํด ์ฒด์คํ์ ๋ง๋ค ์ ์๋?? ๋ผ๊ณ ์๊ฐํ์ง๋ง,
๋ค์ ์ฝ์ด ๋ณธ ๊ฒฐ๊ณผ, ์ ๊ธฐ์ 8 x 8 ์๋ผ์ ์์ ์น ํ๋ ์ต์ ํ์๋ฅผ ๊ตฌํ๋ ๊ฒ์ด์๋ค.
์์ ์ ๊ทผ์ด ์๋ชป๋ ๊ฒ์ด๋ค.
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;
class Main {
static int N, M = 0;
private int solution(String[] brr, int n, int m) {
for (int i = 0; i < n; i++) {
String leng = "";
String[] a = brr[i].split("W");;
for(String x : a) leng=leng+x;
N += leng.length();
}
M = n * m - N;
int b = Math.min(N, M);
if (32 > b) return 32 - b;
else return 0;
}
public static void main(String[] args) throws Exception{
Main T = new Main();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] arr = br.readLine().split(" ");
int n = Integer.parseInt(arr[0]);
int m = Integer.parseInt(arr[1]);
String[] brr = new String[n];
for (int i = 0; i < n; i++) {
brr[i] = br.readLine();
}
System.out.println(T.solution(brr, n, m));
}
}
โ
์ ๋ตํ์ด
์์ ๊ทธ๋ฆผ์ ๋ณด๋ฉด ์๊ฒ ์ง๋ง ๊ฒฐ๊ตญ ํฐ์ ํ๋ถํฐ ์์ํ๋๊ฑฐ๋ ๊ฒ์์๋ถํฐ ์์ํ๋ ๊ฒ์ ํฉํ๋ค๋ฉด ํ์ ์นธ ์๊ฐ ์ผ์ ํ๊ฒ ๋์ค๊ฒ ๋๋ค.
ํ์ฌ ์ฐ๋ฆฌ๋ 8x8๋ก ํ๊ธฐ ๋๋ฌธ์ 64๊ฐ์ ํ์ด ๋์ค๊ฒ ๋๋๋ฐ ์ด๋ฅผ ํ์ฉํด์ ํ๋๋ง ๊ธฐ์ค์ผ๋ก ์ก๊ณ ๊ฑฐ๊ธฐ์ 64์์ ๋นผ๊ณ ๋บ ๊ฐ๊ณผ ๊ธฐ์ค์ผ๋ก ์ก์ ๊ฒ ์ค์ ์์ ๊ฒ์ ์ถ์ถํ๋ฉด ๋๋ ๊ฒ์ด๋ค !!
import java.util.Scanner;
class Main {
static int min = Integer.MAX_VALUE;
static String[] brr = {"WBWBWBWB", "BWBWBWBW"};
private int solution(int startRow, int startCol, String[] arr) {
int whiteBlock = 0;
for (int i = 0; i < 8; i++) {
int row = startRow + i;
for (int j = 0; j < 8; j++) {
int col = startCol + j;
if (arr[row].charAt(col) != brr[row % 2].charAt(j)) whiteBlock++;
}
}
return Math.min(64-whiteBlock, whiteBlock);
}
public static void main(String[] args) {
Main T = new Main();
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
in.nextLine();
String[] arr = new String[n];
for (int i = 0; i < n; i++) {
arr[i] = in.nextLine();
}
for (int i = 0; i <= n-8; i++) {
for (int j = 0; j <= m-8; j++) {
int answer = T.solution(i, j, arr);
if (min > answer) min = answer;
}
}
System.out.println(min);
}
}
๊ทธ๋ฆฌ๊ณ ์ฌ๊ธฐ์ ๋ ์ ๊ธฐํ ํํ๊ฐ ์๋ค๋ฉด ๋ฐ๋ก ์ํ์ ์ธ ๊ฐ๋ ์ธ๋ฐ r % 2 ์ ํํ์ด๋ค !!
์ด๋ป๊ฒ ๋ณด๋ฉด ๋น์ฐํ ์๋ฆฌ์ด์ง๋ง ์ด๋ฌํ ๋ํ ์ผ์ ๋ฐ๋ก์ ์ฉํ๋๋๋ ์ ๋ง ๋ง์ ์ฐ์ต์ด ํ์ํ ๊ฒ์ด๋ค.
์ด๋ฅผ ํ์ฉํ ๊ฒฝ์ฐ ๋ฐ๋ณต๋๋ ํํ๋ฅผ ๊ตณ์ด ๋ค ์ธ ํ์์๊ฒ ๋๋ค.
๋๋ฌด ์ ๊ธฐํ๋ค ใ ใ
์ด๋ฌํ ์ผ์ค ๋๋ ๋ฐฐ์ฐ๊ณ ๊ฐ๋ จ๋ค ~~
<<์ถ๊ฐ ๊ณต๋ถ>>
nextInt()
nextLine()
next()
๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ๋ณด๋ฉด ์ํฉ์ ๋ฐ๋ผ ์ ๋ ฅ ์ฝ๋๊ฐ ๋ค๋ฅด๋ค!!
nextInt() -> ์ซ์๋ฅผ ์ ๋ ฅ ๋ฐ๋๋ค.
next() -> ๋จ์ด ํ๊ฐ๋ฅผ ๋ฐ๋๋ค.
nextLine() -> ํ ์ค์ ์ ๋ ฅ ๋ฐ๋๋ค.
<์ค๋ฅ ๋ฐ์>
nextInt()๋ฅผ ์ฐ๊ณ
nextLine() ์ ์ฌ์ฉํ๊ฒ ๋๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์๊ฐ ์๋ค.
๋๋ ์๋ฌด๊ฒ๋ ์ ๋ ฅ ์ ํ๋๋ฐ ์๋์ผ๋ก nextLine()์ ์ ๋ ฅ์ด ๋๋๋ฐ
nextInt()๋ฅผ ์์ฑํ๊ณ ์ํฐ๋ฅผ ์น๋ฉด /n ์ด๋ผ๋ ๊ฐํ๋ฌธ์๊ฐ ๊ทธ ๋ค์ nextLine()์ ์ ์ฉ์ด ๋๋ค !!
์์ ์๋ ์ด๋ฐ ๊ฒฝํ์ด ์์ด์ ๊ณต๋ถํ์ง๋ง ๋ ์ค๋ซ๋์ ์ฌ์ฉ ์ ํ๋ค๋ณด๋ ๊น๋จน์๋ค ใ ใ
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋ nextInt()๋ฅผ ์์ฑํด์ฃผ๊ณ ๊ทธ ๋ค์ ํ ์ค์ nextLine() ํ๋๋ฅผ ์ค์ผ๋ก์จ ๊ฐํ๋ฌธ์๋ฅผ ์์ค ๋ค์
๋ค์ nextLine()์ ํ์ฉํ๋ฉด ๋๋ค.
'์ฝ๋ฉํ ์คํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ธํ๋ฐ/BFS/12.ํ ๋งํ ] (1) | 2024.05.19 |
---|---|
[์ธํ๋ฐ/greedy/๊ฒฐํผ์] (0) | 2024.04.17 |
[์ธํ๋ฐ/BFS/11. ๋ฏธ๋ก์ ์ต๋จ๊ฑฐ๋ฆฌ ํต๋ก] (0) | 2024.04.09 |
[๋ฐฑ์ค/1015/์์ด ์ ๋ ฌ] (1) | 2024.04.06 |
[์ธํ๋ฐ/DFS/10.๋ฏธ๋กํ์] (5) | 2024.04.01 |
๋๊ธ