대학원생이 쉽게 설명해보기

N, K = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]

weights = [ele[0] for ele in wv]
values = [ele[1] for ele in wv]

dp = [[0 for _ in range(K+1)] for _ in range(N+1)]

for i in range(1, N+1):
    for j in range(1, K+1):
        w = weights[i-1]
        v = values[i-1]
        
        # 먼저, 가질 수 있는 무게보다 물건의 무게가 클 경우는
        # 가져갈 수 없으므로 이전에 구했던 최댓값을 선택한다.
        # 여기서 i-1이 이전에 구했던 것이고, j가 가질 수 있는 무게를 의미한다.
        if(j < w):
            dp[i][j] = dp[i-1][j]
        # 물건의 무게보다 가질 수 있는 무게가 더 작을 경우는
        # 해당 물건을 가져갈 수 있음을 의미한다.
        # 따라서 v + dp[i-1][j-w]
        # --> 현재 물건을 가져감(v)과 동시에
        # 이전에 미리 구해둔 해당 물건의 무게만큼을 제외했을 때의 최댓값과(dp[i-1][j-w])
        # 이전에 구했던 무게를 비교하여 선택한다.(안가져가는게 이득일 수도 있으니까)
        else:
            dp[i][j] = max(v + dp[i-1][j - w], dp[i-1][j])
print(dp[N][K])

from itertools import combinations

N = int(input())
ability_board = []
for _ in range(N):
    ability_board.append(list(map(int, input().split())))

num_list = [i for i in range(N)]
res = float('inf')

def solve():
    global res
    
    # 조합을 이용하여 각 후보자를 생성함
    for cand in combinations(num_list, N // 2):
        # 선택된 후보와 나머지
        start_member = list(cand)
        link_member = list(set(num_list) - set(cand))
        
        # 점수 비교는 2명씩 이루어진다.
        start_comb = list(combinations(start_member, 2))
        link_comb = list(combinations(link_member, 2))
        
        # 점수 구하기
        start_sum = 0
        for x, y in start_comb:
            start_sum += (ability_board[x][y] + ability_board[y][x])
            
        link_sum = 0
        for x, y in link_comb:
            link_sum += (ability_board[x][y] + ability_board[y][x])
        
        # 차이를 구하는 것이므로 abs 사용
        if(res > abs(start_sum - link_sum)):
            res = abs(start_sum - link_sum)
            
solve()
print(res)

1, 2 번째 예제가 맞았는데 3번째 예제가 틀리다면 나눗셈 부분을 잘 처리해주었는지 확인해보세요.

c = int(input())
num_list = list(map(int, input().split()))
calc_list = list(map(int, input().split()))

def make_calc_dict(calc_list):
    calc_dict = dict()
    for i, c in enumerate(calc_list):
        calc_dict[i] = c
        
    return calc_dict

def calc(init_num, num, calc_num):
    if(calc_num == 0):
        return init_num + num
    elif(calc_num == 1):
        return init_num - num
    elif(calc_num == 2):
        return init_num * num
    elif(calc_num == 3):
        if(init_num < 0):
            return -(-init_num // num)
        else:
            return init_num // num
    
calc_dict = make_calc_dict(calc_list)

result_list = []
def solve(num_list, calc_dict):
    print(num_list, calc_dict)
    if(len(num_list) == 1):
        print('end')
        result_list.append(num_list[0])
        return 0
    else:
        # 계산에 사용 될 수
        init_num = num_list.pop(0)
        temp_num = num_list[0]
        
        # 백트래킹
        for key, value in calc_dict.items():
            # 0이면 다음 경우로
            if(value == 0):
                continue
            else:
                # 해당 계산을 수행
                num = calc(init_num, temp_num, key)
                calc_dict[key] = calc_dict[key] - 1
                
                if(len(num_list) == 0):
                    deliver_list = [num]
                else:
                    deliver_list = [num] + num_list[1:]
                solve(deliver_list, calc_dict)
                calc_dict[key] = calc_dict[key] + 1

solve(num_list, calc_dict)
print(max(result_list))
print(min(result_list))

python3 불통과, pypy3 통과

# sdk = [[0, 3, 5, 4, 6, 9, 2, 7, 8],
#             [7, 8, 2, 1, 0, 5, 6, 0, 9],
#             [0, 6, 0, 2, 7, 8, 1, 3, 5],
#             [3, 2, 1, 0, 4, 6, 8, 9, 7],
#             [8, 0, 4, 9, 1, 3, 5, 0, 6],
#             [5, 9, 6, 8, 2, 0, 4, 1, 3],
#             [9, 1, 7, 6, 5, 2, 0, 8, 0],
#             [6, 0, 3, 7, 0, 1, 9, 5, 2],
#             [2, 5, 8, 3, 9, 4, 7, 6, 0]]

import sys

sdk = [list(map(int, input().split())) for _ in range(9)]
zeros = [(i, j) for i in range(9) for j in range(9) if sdk[i][j] == 0]

def sdoku(index):
    
    # 한 바퀴에서 모든 경우를 다 보았으면 출력
    if index == len(zeros):
        for row in sdk:
            print(*row)
        sys.exit(0)
    else:
        x = zeros[index][0]
        y = zeros[index][1]
        dx = (x//3) * 3
        dy = (y//3) * 3

        # 사용할 수 있는 숫자 9개
        num_list = [False] + [True for _ in range(9)]

        for j in range(9):
            # 가로 검사
            # 세로 검사
            if(sdk[x][j]):
                num_list[sdk[x][j]] = False       
            if(sdk[j][y]):
                num_list[sdk[j][y]] = False

        # 3*3 box 검사
        for i in range(dx, dx + 3):
            for j in range(dy, dy + 3):
                check_num = sdk[i][j]
                if(check_num):
                    num_list[check_num] = False

        # 현재 가능한 수만 가져옴
        # 가능한 수를 가져왔으면, 이전에 다뤄왔던 백트래킹을 사용하면 됨
        candidate_list = [i for i, k in enumerate(num_list) if k]
        
        # 경우의 수 고려
        for num in candidate_list:
            sdk[x][y] = num
            sdoku(index + 1)
            sdk[x][y] = 0
sdoku(0)

파이썬을 통한 모든 코드 시간 초과. 해당 코드를 자바로 바꿔서 제출했음. 확실히 타언어에 비해 수십배 느리단걸 다시 한번 느낌.

밑 코드 말고도 다른 유형으로 해보았지만 안됨. 파이썬 코드로 하지말고 애초부터 java나 C로 하는걸 추천. 빨리 풀고 다음 문제로 넘어가세요....

N = int(input())

res = 0
chess = [0] * N

def nqueen(cnt):
    global res
    
    if(cnt == N):
        res += 1
        return 0
    else:
        for i in range(N):
            chess[cnt] = i
            check = True
            for j in range(cnt):
                # 같은 열에 있는가
                if(chess[cnt] == chess[j]):
                    check = False
                # 대각의 관계에 있을 경우, 
                # 행의 거리와 열의 거리가 같다.
                if(abs(chess[cnt] - chess[j]) == cnt - j):
                    check = False
            
            if(check):
                nqueen(cnt + 1)
nqueen(0)
print(res)

단순히 위 코드를 변경한 자바 코드도 첨부합니다.

import java.util.Scanner;
 
public class Main {
    public static int N;
    public static int res;
    public static int[] chess;
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        chess = new int[N];
        
        nqueen(0);
        
        System.out.println(res);
    }
    
    public static void nqueen(int cnt){
        if(cnt == N){
            res++;
        } else{
            for(int i = 0; i < N; i++){
                chess[cnt] = i;
                boolean check = true;
                
                for(int j = 0; j < cnt; j++){
                    if(chess[cnt] == chess[j]){
                        check = false;
                    }
                    if(Math.abs(chess[cnt] - chess[j]) == cnt - j){
                        check = false;
                    }
                }
                if(check){
                nqueen(cnt + 1);
                }
            }
        }
    }
}