https://www.acmicpc.net/problem/24460
๋ฌธ์
HCPC 2021์ ์ฐธ์ํ N×N ๋ช ์ ์ฌ๋๋ค์ด ์์๊ฐ ์ ์ฌ๊ฐํ ํํ๋ก ๋ฐฐ์น๋ ๋ํ์ฅ์์ ๋ํ๋ฅผ ํ๋ค. ๋ชจ๋ ์์์๋ ์๋ก ๋ค๋ฅธ ์ถ์ฒจ๋ฒํธ๊ฐ ์ ํ์์ผ๋ฉฐ HCPC 2021์ ๋ง์ง๋ง์๋ ์๋์ ์ค๋ช ๋ ๊ท์น์ ๋ฐ๋ผ ํน๋ณ์์ ๋ฐ์ ์ฌ๋ ํ ๋ช ์ ์ ํ๋ค.
- ํน๋ณ์์ ๋ฐ์ ์ ์๋ ์ฌ๋์ด ํ ๋ช ์ด๋ผ๋ฉด, ๊ทธ ์ฌ๋์ด ๋ฝํ๋ค.
- ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ, ๋ํ์ฅ์ ๊ฐ์ ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๋ค ๊ฐ๋ก ๋๋์ด ๊ฐ ๊ตฌ์ญ์์ ์ด ๊ท์น์ ์ฌ๊ท์ ์ผ๋ก ์ ์ฉํด์ ๊ตฌ์ญ๋ง๋ค ํ ๋ช ์ฉ ์ด ๋ค ๋ช ์ ๋ฝ๋๋ค.
- ๋ฝํ ๋ค ๋ช ์ค ์์์ ์ ํ ์ถ์ฒจ๋ฒํธ๊ฐ ๋ ๋ฒ์งธ๋ก ์์ ์ฌ๋์ด ๋ฝํ๋ค.
HCPC 2021์ ์ฐธ๊ฐํ ์ง์์ด๋ ์์ ์ ์ค๋ ฅ์ด ๋ถ์กฑํด์ ์์๊ถ์ด ์๋๋ผ๊ณ ์๊ฐํ์๊ณ , ์ค๋ ฅ๊ณผ ๋ฌด๊ดํ๊ฒ ๋ฐ์ ์ ์๋ ํน๋ณ์์ ๋ ธ๋ฆฌ๊ณ ์๋ค.
์๋ ์์๋ฅผ ์ฐธ๊ณ ํ์.
์์ ๊ฐ์ ์์ ๋ฐฐ์ด์ด ์๋ค๊ณ ๊ฐ์ ํ์. ์ด๋ฅผ ๋ค ๊ฐ์ ๊ตฌ์ญ์ผ๋ก ๋๋๋ฉด ์๋์ ๊ฐ๋ค.
๋๋์ด์ง ๊ตฌ์ญ์ ์ผ์ชฝ ์ ๊ตฌ์ญ์ ๋ค์ ๋ค ๊ฐ์ ๊ตฌ์ญ์ผ๋ก ๋๋๋ฉด ์๋์ ๊ฐ๋ค.
์ฌ๊ธฐ์์ ์ถ์ฒจ๋ฒํธ๊ฐ ๋ ๋ฒ์งธ๋ก ๋ฎ์ ์ฌ๋์ ๊ณ ๋ฅด๋ฉด ์๋์ ๊ฐ๋ค.
์ด์ ๊ฐ์ ์์ ์ ๋ชจ๋ ์์ญ์ ๋ํด ์คํํ๋ฉด ์๋์ ๊ฐ๋ค.
๋ฐ๋ผ์ ํน๋ณ์์ ๋ฐ๋ ์ถ์ฒจ๋ฒํธ๋ ์๋์ ๊ฐ๋ค.
๋ฐ๋ผ์, ์ถ์ฒจ๋ฒํธ 3 ์ด ์ ํ ์์์ ์์ ์ฐธ๊ฐ์๊ฐ ํน๋ณ์์ ๋ฐ๋๋ค.
์์ ๊ฐ๊ฐ์ ์ ํ ์๋ ์ถ์ฒจ๋ฒํธ๊ฐ ์ฃผ์ด์ง ๋, ์ง์์ด๊ฐ HCPC 2021์์ ๊ฒฝํ์ ๋ฐ์ ์ ์์ผ๋ ค๋ฉด ์ด๋ค ์์์ ์์์ผ ํ๋์ง ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์๋ ์ ์ N ์ด ์ฃผ์ด์ง๋ค. (๋จ, N=2m , 0≤m≤10 , m ์ ์ ์)
๋ ๋ฒ์งธ ์ค๋ถํฐ N ๊ฐ ์ค์ i ๋ฒ์งธ ์ค์๋ i ๋ฒ์งธ ์ค์ ์๋ ์์์ ์ ํ ์ถ์ฒจ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์ค์๋ N ๊ฐ์ ์ถ์ฒจ๋ฒํธ๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค.
์ถ์ฒจ๋ฒํธ๋ 231 ๋ณด๋ค ์์ ์์ด ์๋ ์ ์์ด๊ณ , ๋ชจ๋ ์ถ์ฒจ๋ฒํธ๋ ์๋ก ๋ค๋ฆ์ด ๋ณด์ฅ๋๋ค.
์ถ๋ ฅ
์ง์์ด๊ฐ HCPC 2021์์ ๊ฒฝํ์ ๋ฐ๊ธฐ ์ํด ์์์ผ ํ๋ ์์์ ์ ํ ์ถ์ฒจ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค.
ํ์ด
์ฌ๊ทํจ์๋ฅผ ์ด์ฉํ ๋ถํ ์ ๋ณต ๋ฌธ์
// ํ์ด : https://whkakrkr.tistory.com
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int recur(int a, int b, int c, int d, vector<vector<int>>&v) {
if(a==c & b==d) {
return v[a][b];
}
int x = (c+a)/2;
int y = (d+b)/2;
vector<int>tmp(4);
tmp[0] = recur(a,b,x,y, v);
tmp[1] = recur(a,y+1,x,d, v);
tmp[2] = recur(x+1,b,c,y, v);
tmp[3] = recur(x+1,y+1,c,d, v);
sort(tmp.begin(), tmp.end());
return tmp[1];
}
int main() {
int n;
cin >> n;
vector<vector<int>>v(n, vector<int>(n));
for(int i=0; i<n; i++) {
for(int j=0; j<n; j++) {
cin >> v[i][j];
}
}
cout << recur(0,0,n-1,n-1, v);
return 0;
}
'๐๏ธ ICPC Sinchon > Divide and Conquer' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ][C++] ๋ฐฑ์ค 18222๋ฒ: ํฌ์-๋ชจ์ค ๋ฌธ์์ด (0) | 2024.08.21 |
---|---|
[BOJ S4][C++] ๋ฐฑ์ค 17266๋ฒ: ์ด๋์ด ๊ตด๋ค๋ฆฌ (0) | 2022.10.13 |