๐ ๋ฌธ์ ๋งํฌ
https://www.acmicpc.net/problem/20002
20002๋ฒ: ์ฌ๊ณผ๋๋ฌด
N × N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๋ชจ์ ๊ณผ์์์ด ์๊ณ , N × N ๊ฐ์ ์ฌ๊ณผ๋๋ฌด๊ฐ 1 × 1 ํฌ๊ธฐ์ ๊ฐ๊ฒฉ์ผ๋ก ๋ชจ๋ ์นธ์ ์ฌ์ด์ ธ์๋ค. ๋๋ถ ํ๊ณค์ด๊ฐ ๊ฐ์์ ๋ง์ ์ฌ๊ณผ๋ฅผ ์ํํ๋ ค๋๋ฐ, ๋ ์ฃผ์ธ ์ ์์ด๊ฐ "๋๋ ๊ณผ์์
www.acmicpc.net
โธ ๋ฌธ์
N × N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๋ชจ์ ๊ณผ์์์ด ์๊ณ , N × N ๊ฐ์ ์ฌ๊ณผ๋๋ฌด๊ฐ 1 × 1 ํฌ๊ธฐ์ ๊ฐ๊ฒฉ์ผ๋ก ๋ชจ๋ ์นธ์ ์ฌ์ด์ ธ์๋ค.
๋๋ถ ํ๊ณค์ด๊ฐ ๊ฐ์์ ๋ง์ ์ฌ๊ณผ๋ฅผ ์ํํ๋ ค๋๋ฐ, ๋ ์ฃผ์ธ ์ ์์ด๊ฐ "๋๋ ๊ณผ์์ ๋ด์ ์ฌ๊ณผ๋๋ฌด๋ฅผ K × K ์ ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๋ชจ์์ผ๋ก๋ง ์ํํด ๊ฐ์ ธ๊ฐ ์ ์์ด, ์ด๋ K๋ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ N๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์๋ผ๊ตฌ! ๋๋จธ์ง๋ ๋ด๊ฐ ๋จน์๊ป! ํํ!" ๋ผ๊ณ ํต๋ณดํ๋ค.
ํ๋์ ์ฌ๊ณผ๋๋ฌด๋ฅผ ์ํํ ๋, ์ฌ๊ณผ๋ฅผ ํตํด ์ป์ ์ ์๋ ์ด์ต๊ณผ ๋ ธ๋๋น๋ก ๋น ์ ธ๋๊ฐ๋ ์ํด๊ฐ ๋์์ ์ด๋ฃจ์ด์ง๋ค.
๊ทธ๋์ ํ๊ณค์ด๋ ๋๋ฌด์ ์์น๋ฅผ ์ขํ๋ก ํ์ฌ, ์ฌ๊ณผ๋ฅผ ํตํด ์ป์ ์ด์ต๊ณผ ๋ ธ๋๋น๋ฅผ ๋ํ ์ด์ด์ต์ 2์ฐจ์ ๋ฐฐ์ด์ ํํ๋ก ์ ๋ฆฌํ๋ค.
์ ๋ ํ ๋ ์ฃผ์ธ ์ ์์ด๋ก๋ถํฐ ๊ณ ํต๋ฐ๋ ๊ท์ฌ์ด ํ๊ณค์ด์๊ฒ ์ต๋ ์ด์ด์ต์ ์๊ฒจ์ฃผ๊ณ ์ถ์ ๋น์ , ํ๊ณค์ด๋ฅผ ๋์์ฃผ์!
โธ ์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์๋ ๊ณผ์์์ ํฌ๊ธฐ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 300)
๋ ๋ฒ์งธ ์ค๋ถํฐ N + 1๋ฒ์งธ ์ค๊น์ง, ํด๋น ๋๋ฌด๋ฅผ ์ํํ์ ๋ ์ป์ ์ ์๋ ์ด์ด์ต์ ํ์ํ๋ค.
์ด์ด์ต์ -1,000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 1,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค.
โธ ์ถ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ ๋ฌธ์ ์ ๋ณด
- ๐ฅ ๋ฌธ์ ๋ ๋ฒจ : ๊ณจ๋ 5
- ๐ ๋ฌธ์ ์ ํ : ๋ธ๋ฃจํธํฌ์ค ์๊ณ ๋ฆฌ์ฆ, ๋์ ํฉ
- ๐ฌ ํ์ด ์ธ์ด : JAVA
๐ค ๋ฌธ์ ํ์ด
- ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ํด๋น ๋๋ฌด๋ฅผ ์ํํ์ ๋ ์ป์ ์ ์๋ ์ด์ด์ต์ ๋ํ ๋์ ํฉ์ ์ ์ฅํ ๋ฐฐ์ด์ ์์ฑํ ๋ค, ๋ฐฐ์ด์ ๋์ ํฉ์ ๊ณ์ฐํ์ฌ ์ ์ฅํ๋ค.
- k์ ํฌ๊ธฐ๊ฐ ์ ํด์ ธ ์์ง ์๊ธฐ ๋๋ฌธ์ k๊ฐ 1๋ถํฐ n์ผ ๋๊น์ง ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์ํ๋ฉฐ, ๋ชจ๋ ๊ฒฝ์ฐ์ ์์์ ๋์ฌ ์ ์๋ ์ด์ด์ต์ ์ต๋๊ฐ์ ๊ฐฑ์ ํด ์ฃผ์๋ค.
โ ์ต์ข ์ฝ๋
๋ฉ๋ชจ๋ฆฌ : 21472KB
์๊ฐ : 328ms
import java.io.*;
import java.util.StringTokenizer;
public class Main {
static int n;
static int[][] map;
static int[][] prefix;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
n = Integer.parseInt(br.readLine()); // nxn ๊ณผ์์์ ํฌ๊ธฐ
map = new int[n+1][n+1]; // ์ด์ด์ต์ ์ ์ฅํ ๋ฐฐ์ด
prefix = new int[n+1][n+1]; // ์ด์ด์ต์ ๋์ ํฉ์ ์ ์ฅํ ๋ฐฐ์ด
StringTokenizer st;
for (int i = 1; i <= n; i++) {
st = new StringTokenizer(br.readLine());
for (int j = 1; j <= n; j++) {
map[i][j] = Integer.parseInt(st.nextToken());
// 2์ฐจ์ ๋ฐฐ์ด์ ๋์ ํฉ ๊ตฌํ๊ธฐ (์ด์ด์ต์ ๋์ ํฉ)
prefix[i][j] = map[i][j] + prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1];
}
}
int ans = Integer.MIN_VALUE; // ๋ชจ๋ kxk ํฌ๊ธฐ์์ ๋์ฌ ์ ์๋ ์ด์ด์ต์ ์ต๋๊ฐ
for (int i = 1; i <= n; i++) {
int tmp = check(i); // 1๋ถํฐ n๊น์ง ๊ฐ kxk ํฌ๊ธฐ์ ๋ํ ์ด์ด์ต ๊ตฌํ๊ธฐ
ans = Math.max(ans, tmp); // ์ต๋๊ฐ ๊ฐฑ์
}
bw.append(ans + "\n");
bw.flush();
bw.close();
br.close();
}
private static int check(int k) {
int max = Integer.MIN_VALUE; // kxk ํฌ๊ธฐ์ ์ด์ด์ต์ ์ต๋๊ฐ
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i+k-1 > n || j+k-1 > n) continue; // ๋ฒ์ ๋ฒ์ด๋๋ฉด ๊ฑด๋๋๊ธฐ
// kxk ํฌ๊ธฐ์ ์ด์ด์ต
int tmp = prefix[i+k-1][j+k-1] - prefix[i-1][j+k-1] - prefix[i+k-1][j-1] + prefix[i-1][j-1];
max = Math.max(max, tmp); // ์ต๋๊ฐ ๊ฐฑ์
}
}
return max;
}
}
๐ ํจ๊ป ํ์ด๋ณด๋ฉด ์ข์ ๋ฐฑ์ค ๋ฌธ์
'Algorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Boj_1992] ์ฟผ๋ํธ๋ฆฌ (1) | 2023.11.28 |
---|---|
[Boj_2630] ์์ข ์ด ๋ง๋ค๊ธฐ (0) | 2023.11.24 |
[Boj_1446] ์ง๋ฆ๊ธธ (0) | 2023.11.21 |
[Boj_1504] ํน์ ํ ์ต๋จ ๊ฒฝ๋ก (0) | 2023.11.21 |
[Boj_18352] ํน์ ๊ฑฐ๋ฆฌ์ ๋์ ์ฐพ๊ธฐ (1) | 2023.11.15 |