작성 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class leave_15486 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());

        int[] t = new int[n+2];
        int[] p = new int[n+2];
        int[] dp = new int[n+2];

        for (int i = 0; i < n+2; i++){
            t[i] = 0;
            p[i] = 0;
            dp[i] = 0;
        }

        for (int i = 1 ; i < n+1; i++) {
            st = new StringTokenizer(br.readLine());
            t[i] = Integer.parseInt(st.nextToken());
            p[i] = Integer.parseInt(st.nextToken());
        }


        for (int i = 1; i < n+1; i++) {
            if (i + t[i] <= n + 1) {
                dp[i + t[i]] = Math.max(dp[i + t[i]], dp[i] + p[i]);
            }
            dp[i + 1] = Math.max(dp[i], dp[i+1]);
        }

        int max = 0;
        for (int i = 0; i < n+2; i++) {
            if (max < dp[i]){
                max = dp[i];
            }
        }

        System.out.println(max);
    }
}

설명

위의 코드는 주어진 일정 기간 동안 얻을 수 있는 최대 이익을 계산하는 프로그램입니다. 주어진 일정 기간 내에는 여러 작업을 수행할 수 있으며, 각 작업은 소요 시간과 해당 작업을 수행했을 때 얻을 수 있는 이익으로 표현됩니다.

로직은 다음과 같습니다:

1. 입력을 받습니다.
   • BufferedReader를 사용하여 입력을 받습니다.
   • 첫 번째 입력은 일정 기간을 나타내는 정수 n입니다.
   • 다음 n개의 줄에는 각 작업의 소요 시간과 해당 작업을 수행했을 때 얻을 수 있는 이익이 주어집니다.
2. 배열과 변수 초기화:
   • 크기가 n+2인 배열 t, p, dp를 선언합니다. (인덱스 0부터 사용하지 않기 위해 n+2로 설정합니다.)
   • t 배열은 작업의 소요 시간을 저장합니다.
   • p 배열은 작업을 수행했을 때 얻을 수 있는 이익을 저장합니다.
   • dp 배열은 해당 시점까지 얻을 수 있는 최대 이익을 저장합니다.
3. 작업 정보 입력:
   • n번 반복하면서 각 작업의 소요 시간과 이익을 입력받아 t 배열과 p 배열에 저장합니다.
4. 최대 이익 계산:
   • 1부터 n까지 반복하면서 각 작업을 수행하는 경우와 수행하지 않는 경우를 비교합니다.
   • 만약 현재 작업을 수행할 수 있는 시간 범위 내에 있다면, 해당 작업을 수행했을 때의 이익과 현재까지의 최대 이익(dp[i])을 비교하여 더 큰 값을 dp[i + t[i]]에 저장합니다.
   • 현재 작업을 수행하지 않는 경우에는 dp[i]와 dp[i+1]을 비교하여 더 큰 값을 dp[i+1]에 저장합니다.
   • 이렇게 하면 dp 배열에는 각 시점까지의 최대 이익이 저장됩니다.
5. 최대 이익 출력:
   • dp 배열을 순회하면서 최대 이익을 찾고, 이를 max 변수에 저장합니다.
     max 값을 출력합니다.

이러한 로직을 통해 주어진 작업 정보를 기반으로 일정 기간 동안 얻을 수 있는 최대 이익을 계산할 수 있습니다.

자바스크립트

const readline = require('readline');

let n;
let t;
let p;
let dp;
let inputT = [];
let inputP = [];

readline
    .createInterface(process.stdin, process.stdout)
    .on('line', (line) => {
        if (!n) {
            n = parseInt(line);
            t = Array(n + 2).fill(0);
            p = Array(n + 2).fill(0);
            dp = Array(n + 2).fill(0);
        } else {
            const [a, b] = line.split(" ").map(Number);
            inputT.push(a);
            inputP.push(b);
        }
    })
    .on('close', () => {
        inputT.push(0);
        inputP.push(0);

        for (let i = 0; i < n + 2; i++) {
            t[i] = inputT[i];
            p[i] = inputP[i];
        }

        for (let i = 1; i < n + 1; i++) {
            if (i + t[i] <= n + 1) {
                dp[i + t[i]] = Math.max(dp[i + t[i]], dp[i] + p[i]);
            }
            dp[i + 1] = Math.max(dp[i], dp[i + 1]);
        }

        console.log(Math.max(...dp));
        process.exit();
    });

파이썬

import sys
input = sys.stdin.readline

n = int(input())
t, p = [0] * (n+2), [0] * (n+2)
dp = [0] * (n+2)
for i in range(1, n+1):
    t[i], p[i] = map(int, input().split())

for i in range(1, n+1):
    if(i+t[i] <= n+1):
        dp[i+t[i]] = max(dp[i+t[i]], dp[i] + p[i])
    dp[i+1] = max(dp[i+1], dp[i])
    
print(max(dp))