๋ฌธ์
ํด๋น ํฌ์คํ ์ ๋ฐฑ์ค์ 9465๋ฒ ์คํฐ์ปค ์ ์ ๊ทผ๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ค๋ช ํ ๊ธ ์ ๋๋ค.
์ ๋ต ์์ค ์ฝ๋๋ฅผ ํ์ธํ์๋ ค๋ฉด solve url ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค.
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํด์ผ ํ๋์ง๋ฅผ ๋จผ์ ์๊ฐํด๋ณด์.
ํด๊ฒฐ๋ฒ
์คํฐ์ปค ๋ฌธ์ ๋ ๋ฐฑ์ค์ ๊ณ๋จ ์ค๋ฅด๊ธฐ ๋ฌธ์ ์ ๋น์ทํ ๋ ผ๋ฆฌ๋ก ํ ์ ์๋ค.
๊ณ๋จ ์ค๋ฅด๊ธฐ๋ 1์ฐจ์ ๋ฐฐ์ด์ด์๊ณ , ์ด๋ฒ ์คํฐ์ปค ๋ฌธ์ ๋ 2์ฐจ์ ๋ฐฐ์ด์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค.
์ ํ์ ์์ฒด๋ฅผ ๋์ถํด๋ด๋ ๋ฐฉ๋ฒ์ ํฌ๊ฒ ์ด๋ ต์ง ์์์ง๋ง 2์ฐจ์ ๋ฐฐ์ด์ ๋ค๋ฃจ๋๋ฐ์ ์กฐ๊ธ ์์ฌ์ด ์ ๋ค์ด ์๋ ๋ฌธ์ ์๋ค.
์์ํด๋ณด์.
์ ๊ทผ๋ฒ
๋์ ํ๋ก๊ทธ๋๋ฐ์์ ํต์ฌ์ ํ์ฌ ๋จ๊ณ(๋ฐฐ์ด์ ์ธ๋ฑ์ค)์ ๊ฐ์ ๊ตฌํ๋ ค๋ฉด ์ด์ ์ ์ด๋ค ๋จ๊ณ(๋ฐฐ์ด์ ์ด์ ์ธ๋ฑ์ค)๋ค์ ๋ํ๋ฉด ๋ ์ง๋ฅผ ์๊ฐํ๋ฉด ์ฝ๊ฒ ํ๋ฆด ์ ์๋ค.
์คํฐ์ปค์ ๊ฐ์ค์น๊ฐ ์ต๋๋ก ๋๋ ค๋ฉด ํฐ ์๋ง ๋ณด๊ณ ๋ฝ์ผ๋ฉด ๋๋ค.
ํ์ง๋ง ์ ์ฝ ์กฐ๊ฑด ํ๋๊ฐ ์ถ๊ฐ๋๋ค.
- ํ ์ฅ์ ๋ผ๋ฉด ํด๋น ์คํฐ์ปค์ ๋ณ์ ๊ณต์ ํ๋ ์คํฐ์ปค๋ ๋ชจ๋ ์ฐข์ด์ ธ ์ฌ์ฉ ๋ถ๊ฐ.
์ด ๋ง์ [n][m]
์นธ์ ์คํฐ์ปค๋ฅผ ๋๋ค๋ฉด [n-1][m]
[n+1][m]
, [n][m+1]
์ ์คํฐ์ปค๋ ์ฌ์ฉํ์ง ๋ชปํ๋ค๋ ๋ป์ด๋ค.
๊ทธ๋ผ [n][m]
๋ฒ ์งธ ์คํฐ์ปค๋ ๋ฌด์กฐ๊ฑด [n-1][m]
์คํฐ์ปค์ ํจ๊ป ์ฐ์ผ ์ ๋ฐ์ ์๋ค.
๊ธฐํธ๋ก ํ๋ ํท๊ฐ๋ฆด ์ ์๋๋ฐ, ์ด ๋ง์ ํ์ฌ ๋ฏ์ผ๋ ค๋ ์คํฐ์ปค์ ๋๊ฐ์ ์คํฐ์ปค๋ง ํจ๊ป ๋ฏ์ ์ ์๋ค๋ ๋ป์ด๋ค.
๋ํ n-2๋ฒ์งธ ์คํฐ์ปค๋ ๋๊ฐ์ ์ด๋ ์๋๋ ๋ ๋ค ์ธ ์ ์์ผ๋ฏ๋ก, n-2 ๋ฒ์งธ ์ด์ ์คํฐ์ปค๋ฅผ ํฌํจํ ํ์ฌ ๊ฐ์ค์น์ n-1๋ฒ์งธ ๋๊ฐ์ ์คํฐ์ปค๋ฅผ ํฌํจํ ํ์ฌ ๊ฐ์ค์น ์ค ๋ ํฐ ์๋ฅผ ๋ฝ์ผ๋ฉด ํด๊ฒฐํ ์ ์๋ ๋ฌธ์ ์ด๋ค.
๊ทธ๋ฆผ์ผ๋ก ๋ณด๋ฉด,
์ด์ ๊ฐ์ ๋ฐฐ์ด์ 100์ด๋ผ๋ ์๊ฐ ์ฐ์ด๊ธฐ ์ํด์๋ ์๋ ํ์ฒ๋ผ ํ๋์์ ์๋ง ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ์ด๋ค์ ์ต๋์์ ํ์ฌ ๋ณด๊ณ ์๋ ์คํฐ์ปค์ ํฉ์ ๋์ ํด์ฃผ๊ณ ๋ฐ๋ณต์ ๋๋ฆฌ๋ฉด ๋๋ค.
์ฃผ์ํ์
์ด ๋ฐฐ์ด์ ๋ฐ๋ณต์ ๋ค๋ฃจ๊ธฐ ์ํด์๋ ์ฐ๋ฆฌ๊ฐ ์ผ๋ฐ์ ์ผ๋ก ์๊ณ ์๋ 2์ค for loop์์ ์กฐ๊ธ ๋ ์๊ฐํด์ผ ํ๋ค.
for (int i = 0; i < arr[0].length; i++) {
for (int j = 0; j < 2; j++) {
System.out.println(arr[j][i]);
}
}
์ ๋ต ์ฝ๋
public class Main {
public static void main (String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int t = Integer.parseInt(br.readLine());
while(t-- > 0) {
int n = Integer.parseInt(br.readLine());
int[][] d = new int[2][100001];
String[] column = br.readLine().split(" ");
d[0] = strArrToIntArr(column, n);
column = br.readLine().split(" ");
d[1] = strArrToIntArr(column, n);
d[0][1] += d[1][0];
d[1][1] += d[0][0];
for(int i = 2; i < n; i++) {
for(int j = 0; j < 2; j++) {
if(j == 0) {
d[j][i] += Math.max(d[1][i-1], Math.max(d[0][i-2], d[1][i-2]));
}else {
d[j][i] += Math.max(d[0][i-1], Math.max(d[0][i-2], d[1][i-2]));
}
}
}
bw.write(findMaxNum(d) + "\n");
}
bw.flush();
bw.close();
}
private static int findMaxNum(int[][] arr) {
int max = 0;
for (int i = 0; i < arr[0].length; i++) {
for (int j = 0; j < 2; j++) {
max = Math.max(arr[j][i], max);
}
}
return max;
}
private static int[] strArrToIntArr(String[] arr, int size) {
int[] ret = new int[arr.length];
for(int i = 0; i < size; i++){
ret[i] = Integer.parseInt(arr[i]);
}
return ret;
}
}
๋ฌธ์ ํ๊ณ
ํ๊ณ
๋๊ธ