Merge pull request #7 from java-squid/ragdoll

4회차

Author: 102092

06--greedy/ragdoll/baekjoon/11047.py

@@ -0,0 +1,19 @@
+# 문제 조건에 의해 주어지는 동전은 오름차순 정렬
+# => 동전의 최소 개수를 구하는 것이기 때문에 가장 큰 동전부터 탐색 (마지막 인덱스부터)
+
+import sys
+
+input = sys.stdin.readline
+
+coin_count, target = map(int, input().split())
+
+coins = [int(input()) for _ in range(coin_count)]
+
+result = 0
+
+for i in range(coin_count - 1, -1, -1):
+    if coins[i] <= target:
+        result += target // coins[i]
+        target %= coins[i]
+
+print(result)

06--greedy/ragdoll/baekjoon/1541.py

@@ -0,0 +1,15 @@
+numbers = [[int(number) for number in sums.split('+')] for sums in (input().split('-'))]
+
+sums = []
+for number in numbers:
+    sums.append(sum(number))
+
+result = sums[0]
+for i in range(1, len(sums)):
+    result -= sums[i]
+
+print(result)
+
+# 마이너스 기준으로 split
+# 플러스 기준으로 다시 split
+# 마이너스 기준으로 split 된 숫자의 총합을 모두 마이너스 연산

06--greedy/ragdoll/baekjoon/1715.py

@@ -0,0 +1,24 @@
+# (a, b) => (a + b, c) => (a + b + c, d) => ...
+# 이전 수행까지의 합을 최대한 작게 해야 비교 횟수가 작아진다.
+# 데이터의 삽입, 삭제가 발생할 때 정렬을 필요로 하면 다른 컬렉션보다 우선순위 큐 사용을 고려한다.
+
+import sys
+from queue import PriorityQueue
+
+input = sys.stdin.readline
+card_count = int(input())
+cards = PriorityQueue()
+
+result = 0
+
+for _ in range(card_count):
+    cards.put(int(input()))
+
+while cards.qsize() > 1:
+    card1 = cards.get()
+    card2 = cards.get()
+    sum = card1 + card2
+    result += sum
+    cards.put(sum)
+
+print(result)

06--greedy/ragdoll/baekjoon/1744.py

@@ -0,0 +1,62 @@
+# 수열의 크기 : n,  0 < n <= 50
+# 수열의 수 : x,  -1000 <= x <= 1000
+# 1. 정렬 이후 뒷 인덱스부터 곱하기
+# 2. 0은 곱셈 대상에서 제외
+# 3. (-m) * (-n) 가능
+
+number_count = int(input())
+negative_numbers = []
+zero_numbers = []
+positive_numbers = []
+
+for _ in range(number_count):
+    number = int(input())
+    if number > 0:
+        positive_numbers.append(number)
+    if number < 0:
+        negative_numbers.append(number)
+    if number == 0:
+        zero_numbers.append(number)
+
+negative_numbers.sort(reverse=True)
+positive_numbers.sort()
+
+result = 0
+rest_positive_number = 0
+while positive_numbers:
+    temp = []
+    while positive_numbers and len(temp) < 2:
+        temp.append(positive_numbers.pop())
+
+    if len(temp) == 2:
+        number1 = temp.pop()
+        number2 = temp.pop()
+        result += (number1 * number2)
+    elif len(temp) == 1:
+        rest_positive_number = temp.pop()
+        break
+
+rest_negative_number = 0
+while negative_numbers:
+    temp = []
+    while negative_numbers and len(temp) < 2:
+        temp.append(negative_numbers.pop())
+
+    if len(temp) == 2:
+        number1 = temp.pop()
+        number2 = temp.pop()
+        result += (number1 * number2)
+    elif len(temp) == 1:
+        rest_negative_number = temp.pop()
+        break
+
+if not zero_numbers:
+    result += (rest_positive_number + rest_negative_number)
+
+if len(zero_numbers) >= 1:
+    result += rest_positive_number
+    result += (rest_negative_number * 0)
+
+print(result)
+
+# 반례를 못찾음

06--greedy/ragdoll/baekjoon/1744_sol.py

@@ -0,0 +1,42 @@
+from queue import PriorityQueue
+
+number_count = int(input())
+positive_queue = PriorityQueue()
+negative_queue = PriorityQueue()
+
+one = 0
+zero = 0
+
+for i in range(number_count):
+    number = int(input())
+
+    if number > 1:
+        positive_queue.put(number * -1)
+    elif number == 1:
+        one += 1
+    elif number == 0:
+        zero += 1
+    else:
+        negative_queue.put(number)
+
+sum = 0
+
+while positive_queue.qsize() > 1:
+    first = positive_queue.get() * (-1)
+    second = positive_queue.get() * (-1)
+    sum += first * second
+
+if positive_queue.qsize() > 0:
+    sum += positive_queue.get() * (-1)
+
+while negative_queue.qsize() > 1:
+    first = negative_queue.get()
+    second = negative_queue.get()
+    sum += first * second
+
+if negative_queue.qsize() > 0:
+    if zero == 0:
+        sum += negative_queue.get()
+
+sum += one
+print(sum)

06--greedy/ragdoll/baekjoon/1931.py

@@ -0,0 +1,31 @@
+import sys
+from collections import OrderedDict
+
+input = sys.stdin.readline
+
+schedule_count = int(input())
+
+schedules = {}
+for _ in range(schedule_count):
+    start_time, end_time = map(int, input().split())
+
+    if start_time not in schedules:
+        schedules[start_time] = end_time
+        continue
+
+    if schedules.get(start_time) > end_time:
+        schedules[start_time] = end_time
+
+result = 0
+ordered_schedules = OrderedDict(sorted(schedules.items()))
+current_start_time, current_end_time = ordered_schedules.popitem(last=False)
+for start_time, end_time in ordered_schedules.items():
+    if start_time >= current_end_time:
+        result += 1
+
+print(result)
+
+# Fail
+# 시작시간 == 끝 시간이 같을 수 있다는 의미: 이전 회의 종료시간,
+# 1. 다음 회의 시작시간이 겹칠 수 있다는 것 아니라
+# 2. (2, 2)와 같은 케이스가 존재할 수 있다

06--greedy/ragdoll/baekjoon/1931_sol.py

@@ -0,0 +1,18 @@
+schedule_count = int(input())
+schedules = [[0] * 2 for _ in range(schedule_count)]
+
+for i in range(schedule_count):
+    start_time, end_time = map(int, input().split())
+    schedules[i][0] = end_time
+    schedules[i][1] = start_time
+
+schedules.sort()
+count = 0
+end_time = -1
+
+for i in range(schedule_count):
+    if schedules[i][1] >= end_time:
+        end_time = schedules[i][0]
+        count += 1
+
+print(count)

06--greedy/ragdoll/neetcode/contains_duplicate.py

@@ -0,0 +1,14 @@
+from typing import List
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        number_map = {}
+
+        for number in nums:
+            if number in number_map:
+                return True
+            else:
+                number_map[number] = 1
+
+        return False

06--greedy/ragdoll/neetcode/two_sum.py

@@ -0,0 +1,23 @@
+from typing import List
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        numbers = sorted(nums)
+        left = 0
+        right = len(numbers) - 1
+
+        while left < right:
+            sum = numbers[left] + numbers[right]
+            if sum == target:
+                if numbers[left] == numbers[right]:
+                    left_index = nums.index(numbers[left])
+                    right_index = nums.index(numbers[right], left_index + 1)
+                    return [left_index, right_index]
+                else:
+                    return [nums.index(numbers[left]), nums.index(numbers[right])]
+
+            if sum < target:
+                left += 1
+            elif sum > target:
+                right -= 1

06--greedy/ragdoll/neetcode/valid_anagram.py

@@ -0,0 +1,3 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return sorted(s) == sorted(t)

06--greedy/ragdoll/notes.md

@@ -0,0 +1,11 @@
+## Python
+### 2차원 배열의 정렬
+- `sort()` 호출 시 앞 내부 구성요소의 앞 인덱스부터 마지막 인덱스까지 오름차순 순차 정렬
+```python
+# Ex
+arr = [[4, 2], [4, 1], [3, 1], [3, 2]]
+arr.sort()
+
+# after sorted
+# => [[3, 1], [3, 2], [4, 1], [4, 2]]
+```