→

[Baekjoon] 11501번. 주식 - python

thals0 — Tue, 9 Jan 2024 14:20:49 +0900

https://www.acmicpc.net/problem/11501

11501번: 주식

입력의 첫 줄에는 테스트케이스 수를 나타내는 자연수 T가 주어진다. 각 테스트케이스 별로 첫 줄에는 날의 수를 나타내는 자연수 N(2 ≤ N ≤ 1,000,000)이 주어지고, 둘째 줄에는 날 별 주가를 나타

www.acmicpc.net

정답코드부터 공개

정답코드

k = int(input())
for _ in range(k):
    n = int(input())
    nums = list(map(int, input().split()))
    nums.reverse()
    max = nums[0]
    sum = 0

    for i in range(1,n):
        if max < nums[i]:
            max = nums[i]
            continue
        sum += max - nums[i]
    print(sum)

애초에 반복문을 2번이상 돌리면 안되는 문제였다

nums를 뒤에서부터 읽으면서 max보다 큰 값일 경우는 max값으로 바꿔주고

max보다 작을 경우는 max와의 차이를 sum에 더해주면 됨

삽질 기록 ..

메모리 초과 코드

k = int(input())
for _ in range(k):
    n = int(input())
    nums = list(map(int, input().split()))
    tmp = [[] for _ in range(n)]
    answer = 0
    for i in range(n):
        for j in range(i):
            if nums[i] - nums[j] > 0:
                tmp[j].append(nums[i] - nums[j])
    for i in tmp:
        if len(i) != 0:
            answer += max(i)
    print(answer)

수정 후 시간초과 남 (tmp에 append하던 방식 → 그때마다 max값을 구하도록 수정)

k = int(input())
for _ in range(k):
    n = int(input())
    nums = list(map(int, input().split()))
    tmp = [0 for _ in range(n)]
    answer = 0
    for i in range(n):
        for j in range(i):
            if nums[i] - nums[j] > 0:
                tmp[j] = max(tmp[j], nums[i] - nums[j])
    print(sum(tmp))

아예 다른 방법으로 수정

시간초과

k = int(input())
for _ in range(k):
    n = int(input())
    nums = list(map(int, input().split()))
    answer = 0
    while len(nums) > 0:
        m = max(nums)
        idx = nums.index(m)
        tmp = nums[:idx]
        nums = nums[idx+1:]
        for i in range(idx):
            answer += m - tmp[i]
    print(answer)

nums에서 max 값을 찾고, tmp 리스트에 nums의 0부터 max까지 넣어둠

nums는 max 이후의 값들을 넣어두고 반복

예)

nums = [1, 2, 100, 90, 1, 2] 일 때,

[1, 2, 100

/, 90

/, 1, 2]

이렇게 나눈 후 max가 아닌 값들은 max에서 뺀 값을 answer에 더해줌

시간초과

k = int(input())
for _ in range(k):
    n = int(input())
    nums = list(map(int, input().split()))
    answer = 0
    end = 0
    start = -1
    while end != n-1:
        m = max(nums[start+1:])
        end = nums.index(m)
        for i in range(start, end):
            answer += m - nums[i]
        start = end
    print(answer)

위 코드에서 nums list를 계속 만들지 않고, start와 end 만들어서 비교

시간초과

k = int(input())
for _ in range(k):
    n = int(input())
    nums = list(map(int, input().split()))
    answer = 0
    for i in range(n):
        stock = []
        for j in range(i+1,n):
            if nums[i] < nums[j]:
                stock.append(nums[j]-nums[i])
        if len(stock) != 0:
            answer += max(stock)
    print(answer)

[프로그래머스] 이중우선순위큐 - python

thals0 — Thu, 9 Nov 2023 10:47:18 +0900

코드

from heapq import *
def solution(operations):
    q = []
    for i in operations:
        op, n = i.split()
        if op == 'I':
            heappush(q, int(n))
        elif op == 'D' and len(q) != 0:
            if n == "-1":
                heappop(q)
            else:
                q.sort()
                q.pop()
    if q:
        return [max(q), q[0]]
    else:
        return [0,0]

max가 리프 노드에 있다는 것은 보장되지만 가장 끝 노드(인덱스)에 있다는 것은 보장되지 않기 때문에 q.sort() 해줌

최대값 뺄 때 q.sort() 했는데 트리 구조가 안무너지네

왜 다 통과하지

..?

heappop, heappush 할 때 트리구조를 되찾는건지 아니면 테케가 부족해서 운좋게 통과한건지 몰겠슴

의문 해결 과정

https://github.com/lake041/sesac-algorithm/issues/1

[프로그래머스] 이중우선순위큐 질문 · Issue #1 · lake041/sesac-algorithm

문제 링크 : 이중우선순위큐 from heapq import * def solution(operations): q = [] for i in operations: op, n = i.split() if op == 'I': heappush(q, int(n)) elif op == 'D' and len(q) != 0: if n == "-1": heappop(q...

github.com

뭔가 이 문제에서 실질적으로 원한건 max_heap, min_heap 이렇게 heapq를 2개를 만들어서 동기화해가면서 푸는 방법이였을 것 같은데 동기화 방법이 마땅히 떠오르지 않음

문제 자체가 테케가 많이 부족해서 정확하게 맞는지도 모르겠음

일단 통과하긴 하는데 ..

from heapq import heappush, heappop

def solution(operations):
    maxq, minq = [], []
    deleted_index = []

    for i in range(len(operations)):
        op, num = operations[i].split()
        num = int(num)
        if op=="I":
            heappush(maxq, (-num, i))
            heappush(minq, (num, i))
        elif num == 1:
            if maxq:
                _, index = heappop(maxq)
                deleted_index.append(index)
        elif num == -1:
            if minq:
                _, index = heappop(minq)
                deleted_index.append(index)

        while minq and minq[0][1] in deleted_index:
            heappop(minq)
        while maxq and maxq[0][1] in deleted_index:
            heappop(maxq)
                
    return [-heappop(maxq)[0], heappop(minq)[0]] if maxq else [0, 0]

이게 정석 풀이인듯 ?

[프로그래머스] 의상 - python

thals0 — Mon, 30 Oct 2023 15:55:15 +0900

설계

종류를 key, 종류마다 의상의 갯수를 value로 넣음

1개, 2개, 3개 … n개 입을 수 있음

예) 2개 입는 경우 key 중에 2개를 뽑아 내서 value 곱하면 됨

이런식으로 1,2,3 .. n개까지의 경우의 수를 다 더하면 답임

코드

from itertools import combinations

def solution(clothes):
    answer = 1
    dict = {}
    for i in clothes:
        if i[1] not in dict:
            dict[i[1]] = 1
        else:
            dict[i[1]] += 1
    
    for i in range(1,len(dict)+1):
        for j in list(combinations(dict, i)):
            tmp = 1
            for k in j:
                tmp *= dict[k]
            answer += tmp
    return answer-1

1번테케만 틀림

1번이 모든 의상의 종류와 이름이 다른 경우인듯

의상의 수 ≤ 30 이므로, 최대 30이라고 가정했을 때

시간복잡도 계산해보면 30 * 30!/r!(30-r)! * 30 * 30 인데 이게 1억이 넘나 ?

음 그렇구나

조합을 쓰면 무조건 안되겠다 . . .

정답코드

def solution(clothes):
    answer = 1
    dict = {}
    for i in clothes:
        if i[1] not in dict:
            dict[i[1]] = 1
        else:
            dict[i[1]] += 1
    
    for i in dict.values():
        answer *= (i+1)
    return answer-1

의상의 종류가 "1가지"인 경우. ( 의상 A가 a 개 ) a 개의 조합이 가능
의상의 종류가 "2가지"인 경우. ( 의상 A a개, 의상 B, b개 ) 의상 A, B를 한가지 씩 입는 경우 a, b 의상 A B를 섞어 입는 경우 ab a + b + ab 개의 조합이 가능
의상의 종류가 "3가지"인 경우. ( 의상 A a개, 의상 B, b개, 의상 C c개) 의상 A, B, C를 한가지 씩 : a, b, c 의상 A B / A C / B C 2종류씩 : ab, ac, bc 의상 A B C를 섞어 입는 경우 : abc a + b + c + ab + ac + bc + abc개의 조합이 가능

이 것을 공식으로 만들면

: (1번 종류의 수 + 1 )(2번 종류의 수 + 1) ...(n번 종류의 수 + 1) - 1

옷의 종류 1개 : ( a + 1 ) - 1 = a + 1 - 1

옷의 종류 2개 : (a + 1)(b + 1) - 1 = ab + a + b + 1 - 1

옷의 종류 3개 : (a + 1)(b + 1)(c + 1) - 1 = abc + ab + ac + bc + a + b + c + 1 - 1

어려웠던 점

이게 수학문제여 프로그래밍 문제여 ..

[프로그래머스] 전화번호 목록 - python

thals0 — Mon, 30 Oct 2023 15:53:41 +0900

코드

시간 초과 코드

def solution(phone_book):
    phone_book.sort()
    for i in range(len(phone_book)):
        for j in range(i+1, len(phone_book)):
            if phone_book[j].startswith(phone_book[i]):
                return False
    return True

시간복잡도(big-O)에 데이터 크기(n)을 넣어서 나온 값이 100,000,000(1억)이 넘으면 시간 제한 초과할 가능성 있음 !

for문을 2번쓰면 최악의 경우 O(N^2)

1 ≤ phone_book ≤ 1000000 이므로, O(N^2)은 안됨.

https://thals.tistory.com/214

[프로그래머스] 전화번호 목록 - python

문제 정보 https://school.programmers.co.kr/learn/courses/30/lessons/42577 프로그래머스 코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합

thals.tistory.com

놀랍게도 이때와 같은 코드를 작성했다 ㅋ ㅋ

시간복잡도 생각하면서 문제 풀으라고 ! ! ! ! !

정답 코드

def solution(phone_book):
    phone_book.sort()
    for i in range(len(phone_book)-1):
        if phone_book[i] == phone_book[i+1][:len(phone_book[i])]:
            return False
    return True

def solution(phone_book):
    phone_book.sort()
    for i in range(len(phone_book)-1):
        if phone_book[i+1].startswith(phone_book[i]):
            return False
    return True

l = ['10', '1', '5']

print(sorted(l))
# ['1', '10', '5']

string의 sort 방법을 보면 숫자 자릿수

[Baekjoon] 4963. 섬의 개수 - python

thals0 — Fri, 27 Oct 2023 10:36:04 +0900

https://www.acmicpc.net/problem/4963

4963번: 섬의 개수

입력은 여러 개의 테스트 케이스로 이루어져 있다. 각 테스트 케이스의 첫째 줄에는 지도의 너비 w와 높이 h가 주어진다. w와 h는 50보다 작거나 같은 양의 정수이다. 둘째 줄부터 h개 줄에는 지도

www.acmicpc.net

코드

from collections import deque

dx = [1,0,0,-1,1,1,-1,-1]
dy = [0,1,-1,0,1,-1,-1,1]

def bfs(a,b):
    q = deque()
    q.append((a,b))
    graph[a][b] = 0
    while q:
        x,y = q.popleft()
        for i in range(8):
            nx = x + dx[i]
            ny = y + dy[i]
            if nx < 0 or nx >= h or ny < 0 or ny >= w:
                continue
            if graph[nx][ny] == 1:
                graph[nx][ny] = 0
                q.append((nx,ny))
    return 

while True:
    w,h = map(int, input().split())
    if w == 0 and h == 0:
        break

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

    cnt = 0
    for i in range(h):
        for j in range(w):
            if graph[i][j] == 1:
                bfs(i,j)
                cnt += 1
    print(cnt)

처음에 기본 bfs라고 생각하고 풀었는데

문제를 다시 읽어보니 “대각선”도 걸어갈 수 있는 사각형이였음

dx = [1,0,0,-1,1,1,-1,-1] dy = [0,1,-1,0,1,-1,-1,1]

이렇게 바꿔줌으로서 문제 해결 ~>>

[Baekjoon] 1926. 그림 - python

thals0 — Tue, 3 Oct 2023 10:01:12 +0900

https://www.acmicpc.net/problem/1926

1926번: 그림

어떤 큰 도화지에 그림이 그려져 있을 때, 그 그림의 개수와, 그 그림 중 넓이가 가장 넓은 것의 넓이를 출력하여라. 단, 그림이라는 것은 1로 연결된 것을 한 그림이라고 정의하자. 가로나 세로

www.acmicpc.net

문제 정보

문제 유형	난이도	걸린 시간	해결 유무	스스로 구현 성공
BFS	실버1	45m	O	O

설계 방법

BFS

코드

import sys
from collections import deque
input = sys.stdin.readline

n, m = map(int, input().split())
graph = []
for i in range(n):
    graph.append(list(map(int, input().split())))

arr = []
visited = [[0]*m for _ in range(n)]

dx = [1,0,-1,0]
dy = [0,1,0,-1]

def bfs(i,j):
    q = deque()
    q.append((i,j))
    visited[i][j] = 1
    cnt = 0
    while q:
        x, y = q.popleft()
        # q에서 popleft할 때마다 cnt하면, 넓이 구할 수 있음 
        cnt += 1
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if (nx < 0 or nx >= n or ny<0 or ny >= m): continue
            if visited[nx][ny] == 0 and graph[nx][ny] == 1:
                visited[nx][ny] = 1
                q.append((nx, ny))
    return cnt

for i in range(n):
    for j in range(m):
        # graph[i][j] == 1 이면서, 방문하지 않은 칸에서만 bfs 실행
        if graph[i][j] == 1 and visited[i][j] == 0:
            arr.append(bfs(i,j))

print(len(arr))
# len(arr) == 0이면 "ValueError: max() arg is an empty sequence" 발생
if len(arr) == 0:
    print(0)
else:
    print(max(arr))

시간 복잡도

O(N)

어려웠던 점

https://www.acmicpc.net/problem/2178 이 문제와 같이 최단 경로를 구하는 문제에서는 graph[nx][ny] = graph[x][y] + 1해주면 되는데 넓이를 구할 때는 q에서 pop을 한 만큼 더해주어야 함
len(arr) == 0이면 max(arr)시 "ValueError: max() arg is an empty sequence" 발생

[Baekjoon] 7490. 0 만들기 - python

thals0 — Mon, 2 Oct 2023 21:41:17 +0900

https://www.acmicpc.net/problem/7490

7490번: 0 만들기

각 테스트 케이스에 대해 ASCII 순서에 따라 결과가 0이 되는 모든 수식을 출력한다. 각 테스트 케이스의 결과는 한 줄을 띄워 구분한다.

www.acmicpc.net

설계 방법

재귀

sum : 현재까지의 연산값

sign : 다음 연산에 num과 함께 들어갈 연산자(+는 1로, -는 -1로 표현, 빈칸이 들어갈떄는 무의미함)

num : 다음에 연산될 숫자

n : 몇번째 항인지를 나타냄

string : 현재까지의 표현식

코드

def recur(sum, sign, num, n, string):
  if (n == N):
    sum = sum + (sign*num)
    if sum == 0:
      print(string)
  else:
    recur(sum ,sign ,num*10+(n+1), n+1, string+' '+str(n+1))
    recur(sum+sign*num ,1 ,(n+1), n+1, string+'+'+str(n+1))
    recur(sum+sign*num, -1, (n+1), n+1, string+'-'+str(n+1))
      
test_case = int(input())

for _ in range(test_case):
  N = int(input())
  recur(0,1,1,1,"1")
  print()

참고 : https://velog.io/@tks7205/%EB%B0%B1%EC%A4%80-7490-0%EB%A7%8C%EB%93%A4%EA%B8%B0backtracking

[Baekjoon] 14281. 볼록 수열 - python

thals0 — Mon, 2 Oct 2023 21:13:25 +0900

https://www.acmicpc.net/problem/14281

14281번: 볼록 수열

정수 수열 x[0], x[1], ..., x[N-1]이 볼록이 되려면 모든 1 ≤ i ≤ N-2에 대해서, x[i-1]+x[i+1] ≥ 2*x[i]를 만족해야 한다. 또, 길이가 1, 2인 수열은 항상 볼록하다. 예를 들어, 7, 3, 4, 5, 7과 4, 2, 1, 3은 볼록하

www.acmicpc.net

문제 정보

문제 유형 난이도 걸린 시간 해결 유무 스스로 구현 성공

백트래킹

실버2

40m

설계 방법

백트래킹 알고리즘

코드

처음 접근 - 무작정 그리디

import sys
input = sys.stdin.readline

n = int(input())
arr = list(map(int, input().split()))
cnt = 0

for i in range(1, len(arr)-1):
    print(arr)
    if arr[i-1]+arr[i+1] < 2*arr[i]:
        while arr[i-1]+arr[i+1] < 2*arr[i]:
            arr[i] -= 1 
            cnt += 1

print(cnt)

# 이 경우는 뒤의 수가 바뀌었을 때 볼록이 안되게 변할 수 있음

백트래킹으로 접근해야함을 깨달음

import sys
input = sys.stdin.readline

n = int(input())
arr = list(map(int, input().split()))
cnt = 0

def back(n, arr):
    global cnt
    is_convex = True
    for i in range(1, n-1):
        if arr[i-1]+arr[i+1] < 2*arr[i]:
            while arr[i-1]+arr[i+1] < 2*arr[i]:
              arr[i] -= 1 
              cnt += 1
            is_convex = False
    return cnt, is_convex

while True:
    cnt, is_convex = back(n, arr)
    if is_convex: 
        break
  
print(cnt)

바꾸고 끝나는 것이 아니라, arr[i]-=1 했을 때, 앞 쪽 수열이 볼록이 아니게 될 수 있으므로 백트래킹으로 풀어야 했음

근데 시간초과 남

for문안에 while문이 돌면서 시간복잡도가 O(N^2)이 됨

시간초과 해결 코드

import sys
input = sys.stdin.readline

n = int(input())
arr = list(map(int, input().split()))
cnt = 0

def back(n, arr):
    global cnt
    is_convex = True
    for i in range(1, n-1):
        if arr[i-1]+arr[i+1] < 2*arr[i]:
            tmp = arr[i]- (arr[i-1] + arr[i+1])//2
            arr[i] -= tmp
            cnt += tmp
            is_convex = False
    return cnt, is_convex

while True:
    cnt, is_convex = back(n, arr)
    if is_convex: 
        break
  
print(cnt)

while문을 돌지 않고, 1씩 빼야 할 만큼 계산을 해줌

for문안에 있는 while문은 별로 안 돈다고 생각했는데 확실히 연산하는 것 보다는 많이 잡아먹구나

(당연) O(N)이니 ..

참고

https://velog.io/@jieonyoo/백준-14281번-볼록-수열

[Baekjoon] 1469. 숌 사이 수열 - python

thals0 — Fri, 29 Sep 2023 17:17:17 +0900

https://www.acmicpc.net/problem/1469

1469번: 숌 사이 수열

첫째 줄에 X의 크기 N이 주어진다. 둘째 줄에 X에 들어가는 수가 빈칸을 사이에 두고 주어진다. X의 크기는 8보다 작거나 같은 자연수이다. X의 원소는 0보다 크거나 같고 16보다 작거나 같은 정수

www.acmicpc.net

문제 정보

문제 유형	난이도	걸린 시간	해결 유무	스스로 구현 성공
백트래킹	골드 5	1h	o	x

설계 방법

백트래킹 알고리즘

각 단계에서 가능한 모든 숫자를 시도하고, 그 선택이 유효한지 확인함

만약 선택이 유효하지 않으면 다음 숫자로 넘어가고, 유효하면 재귀적으로 다음 단계를 탐색함

back 함수는 현재 위치(pos)와 각 숫자의 이전 위치(prev)를 인자로 받음
pos가 2 * N과 같다면 모든 위치에 대해 값을 할당했다는 뜻이므로 True를 반환
각 단계에서 가능한 모든 숫자 i에 대해 반복문 실행
- used[i] < 2: 해당 숫자 i가 아직 두 번 사용되지 않았는지 확인
- (prev[i] != -1 and pos - prev[i] == X[i]+1) or (prev[i] == -1): 이전에 해당 숫자 i가 사용된 적이 있고, 현재 위치와 이전 위치 사이의 거리가 해당 숫자와 일치하거나, 이전에 해당 숫자 i가 사용된 적이 없는 경우
위의 조건들을 만족하는 경우:
- 수열 S의 현재 위치 pos에 해당하는 값을 i로 설정하고,
- used 배열에서 i번째 값을 증가시키며,
- prev 배열에서 마지막으로 등장한 i의 위치를 현재 pos로 업데이트
그 후 재귀적으로 back 함수를 호출하여 다음 단계를 탐색
만약 back 함수 호출 결과 True라면, 정상적인 수열 생성 완료라는 의미니까 True 반환
그렇지 않다면 백트래킹을 수행:
- 수열 S의 현재 위치 pos값 초기화
- used 배열에서 i번째 값을 감소시키며,
- prev 배열에서 마지막으로 등장한 i의 위치 정보 원상 복구
모든 가능성 탐색 후 문제 해결 실패라면 False 반환

N은 집합 X 안 요소 개수
X: 집합 X 안 요소들 (여기서는 1부터 N까지의 숫자)
S: 생성할 수열, 초기에는 모두 0으로 설정
used: 각 숫자가 몇 번 사용되었는지 저장하는 배열
prev: 각 숫자가 마지막으로 등장한 위치를 저장하는 배열, 초기에는 모두 -1로 설정

만약 수열 생성이 성공적이라면 생성된 수열을 출력하고, 그렇지 않다면 -1을 출력

코드

def back(pos, prev):
    if pos == 2 * N:
        return True

    for i in range(N):
        if used[i] < 2 and ((prev[i] != -1 and pos - prev[i] == X[i]+1) or (prev[i] == -1)):
            S[pos] = X[i]
            used[i] += 1
            prev_tmp = prev[i]
            prev[i] = pos

            if back(pos + 1, prev):
                return True
            
            # Backtrack
            used[i] -= 1
            S[pos] = 0
            prev[i]=prev_tmp
    return False

N = int(input())
X = sorted(list(map(int, input().split()))) # 만약 여러 개일 경우 사전 순으로 가장 빠른 것을 출력
S=[0]*2*N 
used=[0]*N 
prev=[-1]*N 

if back(0,prev): 
    print(' '.join(map(str,S)))
else:
    print(-1)

[Baekjoon] 17392. 우울한 방학 - python

thals0 — Fri, 29 Sep 2023 17:16:00 +0900

https://www.acmicpc.net/problem/17392

17392번: 우울한 방학

1일, 5일, 8일에 약속을 순서대로 배치하면, 4일과 10일에 각각 1만큼의 우울함을 느끼게 되어, 총 2만큼의 우울함을 느끼게 된다. 이보다 덜 우울함을 느끼게 만드는 방법은 존재하지 않는다.

www.acmicpc.net

문제 정보

문제 유형	난이도	걸린 시간	해결 유무
그리디	실버1	1h	o

설계 방법

sum : 0까지는 우울하지 않으니까 arr의 모든 값에 1을 더해줌
left : m - sum # 우울한 날
n+1 : 우울한 날이 들어갈 수 있는 칸
예시(3 10 2 2 1)의 경우에는 들어갈 수 있는 칸이 4개인데 우울한 날이 2이므로 1의 제곱 * 2 이 우울의 총합이 된다
- 만약 들어갈 수 있는 칸이 4개인데 우울한 날이 5이였으면
- -1, -1, -1, -1 먼저 들어가고 나머지 한개 -2의 제곱 더해주는 것

코드

n,m = map(int, input().split())
answer = 0
sum = 0
left = 0

arr = list(map(int, input().split()))
for i in arr:
    sum += i + 1 # 0까지는 우울하지 않으니까 + 1

if sum < m:
    left = m - sum # 나머지 
    div1 = left // (n + 1) # 들어갈 수 있는 칸의 수 
    div2 = left % (n + 1) 
    for i in range(1, div1 + 1):
        answer += i ** 2 * (n + 1)
    answer += (div1 + 1) ** 2 * div2

print(answer)

시간 복잡도

O(n)

어려웠던 점

들어가는 공간에 대해 구현하는 것이 힘들었음