12018 : Yonsei TOTO

Surdarla

Nov 28 Tue 09:21, 2023

1 min read

• 실버3

시간제한	메모리제한	정답비율
1초	128MB	34.7%

문제

연세대학교 수강신청이 얼마 전부터 바뀌어, 마일리지 제도로 바뀌었다. 이 제도는 각각의 학생들에게 마일리지를 주어 듣고 싶은 과목에 마일리지를 과목당 1~36을 분배한다. 그리고 모두 분배가 끝이 나면 과목에 대해서 마일리지를 많이 투자한 순으로 그 과목의 수강인원만큼 신청되는 방식이다.

성준이는 연세대학교 재학 중인 학생이다. 성준이는 저번 수강신청에서 실패하여 휴학을 했기 때문에 이번 수강신청만은 필사적으로 성공하려고 한다. 그래서 성준이는 학교 홈페이지를 뚫어버렸다.

그 덕분에 다른 사람들이 신청한 마일리지를 볼 수 있게 되었다. 성준이는 주어진 마일리지로 최대한 많은 과목을 신청하고 싶어 한다. (내가 마일리지를 넣고 이후에 과목을 신청하는 사람은 없다) 마일리지는 한 과목에 1에서 36까지 넣을 수 있다.

input

첫째 줄에는 과목 수 n (1 ≤ n ≤ 100)과 주어진 마일리지 m (1 ≤ m ≤ 100)이 주어진다. 각 과목마다 2줄의 입력이 주어지는데 첫째 줄에는 각 과목에 신청한 사람 수 Pi과 과목의 수강인원 Li이 주어지고 그 다음 줄에는 각 사람이 마일리지를 얼마나 넣었는지 주어진다. (1 ≤ Pi ≤100, 1 ≤ Li ≤ 100)

(단 마일리지가 같다면 성준이에게 우선순위가 주어진다고 하자.)

output

주어진 마일리지로 최대로 들을 수 있는 과목 개수를 출력한다.

think

1. list에서 limit만큼만 하되 수강신청인원이 한정인원보다 적으면 최소의 마일리지(1)로 수강신청 가능하다.

2. 만약 수강신청 인원이 꽉찼을 경우에는 한정인원 안에 있는 것 중 최소만큼 넣어주면 된다. 조건때문에 성준이가 동일 마일리지일 경우는 이긴다.

3. 총 마일리지를 까면서 +1씩 해주면 결과가 나올 것이다.

– from su

python

import sys, os

problem_num = "12018"

path = os.getcwd() + f"\\txt\\{problem_num}" + ".txt"
sys.stdin = open(path, "r")
input = sys.stdin.readline

subject_num, mileage = map(int, input().split())
need = []
result = 0

for i in range(subject_num):
    enrolled, limit = map(int, input().split())
    m = sorted(list(map(int, input().split())), reverse=True)[:limit]
if len(m) < limit:
    need.append(1)
else:
    need.append(m[-1])

need.sort()

for i in need:
    if mileage >= i:
        mileage -= i
result += 1

print(result)

1

JavaScript

Listing 6 node.js

const problem_num = "12018";
const path = `${__dirname}\\txt\\${problem_num}.txt`;
// const path = "/dev/stdin"; // for baekjoon

const input = require("fs").readFileSync(path, 'utf8').toString().trim().split('\n');
let currentLine = 0;

//input setting
function readLine() {
    return input[currentLine++].split(' ').map(Number);
}

// mileage는 뒤에서 -= 해줘야하기 때문에 let으로 규정 subject_num은 한 번만 사용
let [subject_num, mileage] = readLine();
let need = [];
let result = 0;

for (let i = 0; i < subject_num; i++) {
    const [enrolled, limit] = readLine();
    const m = readLine().sort((a, b) => b - a).slice(0, limit);
    if (m.length < limit) {
        need.push(1);
    } else {
        need.push(m[m.length - 1])
    }
}

need.sort((a, b) => a - b);
for (let i = 0; i < need.length; i++) {
    if (mileage >= need[i]) {
        mileage -= need[i];
        result++;
    } else {
        break;
    }
}
console.log(result)

readLine을 함수화해서 한 줄씩 읽어가면서 코드가 진행된다. mileage는 변경되어야 하는 변수이기 때문에 let으로 만들어주고, sort((a,b) => b-a)는 역순으로 a-b는 오름차순으로 정렬된다. 코드 자체가 pythonic하긴 하지만 javascript스러움은 나중에 필요에 따라서 채우도록 하자. 지금은 이걸로 만족

JAVA

Listing 7 java code

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int subjectNum = Integer.parseInt(st.nextToken());
        int mileage = Integer.parseInt(st.nextToken());
        ArrayList<Integer> need = new ArrayList<>();

        for (int i = 0; i < subjectNum; i++) {
            st = new StringTokenizer(br.readLine());
            int enrolled = Integer.parseInt(st.nextToken());
            int limit = Integer.parseInt(st.nextToken());

            ArrayList<Integer> m = new ArrayList<>();
            st = new StringTokenizer(br.readLine());
            while (st.hasMoreTokens()) {
                m.add(Integer.parseInt(st.nextToken()));
            }
            Collections.sort(m, Collections.reverseOrder());
            if (m.size() < limit) {
                need.add(1);
            } else {
                need.add(m.get(limit - 1));
            }
        }
        Collections.sort(need);
        int result = 0;
        for (int i : need) {
            if (mileage >= i) {
                mileage -= i;
                result++;
            }
        }

        System.out.println(result);
    }
}

자바는 input을 받는 과정이 엄청 별로다. 길이가 엄청 길어지고 잡설이 엄창나게 많은 것으로 보인다.