작은 시작점

import sys
input = sys.stdin.readline

exp = input().rstrip().split('-') 
arr = []

for i in range(len(exp)):
  temp = 0  
  for t in exp[i].rstrip().split('+'):
    temp += int(t)
  arr.append(temp)

res = arr[0]
for a in arr[1:]:
  res -= a

print(res)

최솟값을 찾는 기준을 잘 모르겠어서 고민하다가 검색해서 알아낸 , , 답 

괄호를 적절히 쳐서 값을 최소로 만드는 방법은, 핵심적으로 '-' 연산자를 기준으로 나누는 것

이렇게 하면 '-' 연산자를 기준으로 나눠진 부분들을 먼저 더한 후, 마지막에 뺄셈을 수행하여 값을 최소화할 수 있음

1. 식을 '-' 연산자를 기준으로 나눈다.
2. 나눠진 부분 더하기 > 각 부분 문자열에 대해 '+' 연산자를 기준으로 더한다.
3. 처음 부분은 더한 값을 초기값으로 두고, 그 다음 나머지 더한 값들을 뺀다.

예를 들어, 입력이 "55-50+40-30+20+10"이라면,

1. "-" 기준으로 나누기 > ["55", "50+40", "30+20+10"]
2. 나눠진 부분 더하기
   
   • "55" → 55
   • "50+40" → 90
   • "30+20+10" → 60
3. 첫 번째 값에서 나머지 값들을 빼줍니다:
   • 55 - 90 - 60 = -95

결과적으로, 최소값은 -95

import sys
input = sys.stdin.readline

N = int(input())
time = [*map(int, input().split())]
time.sort() # 인출하는 시간이 짧은 사람 먼저 줄세우기 
sum = 0
total = 0

for i in range(len(time)):
  sum += time[i] 
  time[i] = sum # 앞 사람 시간 + 내 시간 => i번째 사람이 걸리는 시간
  total += time[i] # N명의 사람이 걸리는 총 시간의 최솟값

print(total)

인출하는데 걸리는 시간이 짧은 사람이 먼저와야 누적 시간이 최소화된다.

입력받은 인출 시간이 짧은 사람부터 정렬을 한 뒤에

i번째 사람의 총 시간을 계산하고 (앞 사람 인출 시간 + 자신의 인출 시간)

N명의 각자 총 인출 시간을 합산한다.

import sys
input = sys.stdin.readline

N, K = map(int, input().split())
coins = []
count = 0

coins = [int(input()) for _ in range(N)]

coins.sort(reverse=True)

for coin in coins:
  count += K // coin
  K = K % coin
  if K == 0: break

print(count)

동전이 오름차순으로 입력되는데 우리는 필요한 동전 개수의 최솟값을 출력해야하기 때문에 내림차순 정렬을 한다.

1. K원을 큰 동전부터 나눈 후 몫을 count 한다.

ex) 4200원이면 4200 // 1000 > 동전 4개 카운트

2. K원을 큰 동전으로 나눈 나머지를 다시 반복해서 나눌 수 있도록 K에 넣는다.

ex) 4200 % 1000 > 200원

남은 200원으로 반복문 수행, 남은 돈이 0이 될 때까지 반복

import sys
input = sys.stdin.readline

N = int(input())
time = []

for i in range(N):
  start, end = map(int,input().split())
  time.append((start, end))

time.sort(key=lambda x : (x[1], x[0]))

cnt = 1
end = time[0][1]

for i in range(1, N):
  if time[i][0] >= end:
    end = time[i][1]
    cnt += 1

print(cnt)

회의가 빨리 끝나게 되면 남은 회의 시간이 많아서 더 많은 회의를 할 수 있다.

그래서 빨리 끝나는 순서대로 회의 시간을 정렬한다.

time.sort(key=lambda x : (x[1], x[0]))

두 번째 값(x[1])을 먼저, 첫 번째 값(x[0])을 그 다음 기준으로 삼아 정렬하는 방식

x[1]이 회의 종료시간이기 때문에 회의가 빨리 끝나는 순서대로 정렬되게 됨

(이 과정에서 요소 자체는 변하지 않고, 정렬 기준만 달라지는 것)

정렬된 회의시간을 반복해서 다음 회의 시작 시간 >= 이전 회의 끝나는 시간 을 만족할 때 해당 회의를 진행하도록 한다.

for i in range(1, N):
  if time[i][0] >= end:
    end = time[i][1]
    cnt += 1

이미 회의가 빨리 끝나는대로 정렬되어 있기 때문에 회의 시간이 겹치지 않도록 조건만 걸어준다.

겹치지 않을 때, 해당 회의 끝나는 시간을 end에 넣어서 다음 조건을 실행할 수 있게하고

회의 횟수 cnt를 더한다