작심삼일

LeetCode : 177. Nth Highest Salary

profailure — Fri, 22 Oct 2021 14:53:20 +0900

https://leetcode.com/problems/nth-highest-salary/

Nth Highest Salary - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

CASE WHEN

CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT
BEGIN
  RETURN (
      # Write your MySQL query statement below.
      SELECT CASE WHEN COUNT(*) < N THEN NULL
                  ELSE MIN(SUB.SALARY) END
      FROM (SELECT SALARY
            FROM EMPLOYEE
            ORDER BY SALARY DESC
            LIMIT N) SUB
  );
END

LIMIT

CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT
BEGIN
  SET N = N - 1;
  RETURN (
      SELECT DISTINCT SALARY
      FROM EMPLOYEE
      ORDER BY SALARY DESC
      LIMIT N, 1
  );
END

LeetCode : 185. Department Top Three Salaries

profailure — Fri, 22 Oct 2021 13:39:53 +0900

https://leetcode.com/problems/department-top-three-salaries/

Department Top Three Salaries - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

Window Func

SELECT EMP_INFO.DEPT_NAME AS Department,
       EMP_INFO.EMP_NAME AS Employee, 
       SALARY AS Salary
FROM (SELECT E.NAME AS EMP_NAME, D.NAME AS DEPT_NAME, E.SALARY, 
      DENSE_RANK() OVER(PARTITION BY E.DEPARTMENTID ORDER BY SALARY DESC) AS SAL_RANK
      FROM EMPLOYEE E
      JOIN DEPARTMENT D ON E.DEPARTMENTID = D.ID) EMP_INFO
WHERE EMP_INFO.SAL_RANK <= 3
ORDER BY SALARY

Leetcode : 180. Consecutive Numbers

profailure — Fri, 22 Oct 2021 10:59:36 +0900

https://leetcode.com/problems/consecutive-numbers/

Consecutive Numbers - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

Multiple Self JOIN

SELECT L.NUM AS ConsecutiveNums
FROM LOGS L
JOIN LOGS L2 ON L.ID + 1 = L2.ID
JOIN LOGS L3 ON L.ID + 2 = L3.ID
WHERE L.NUM = L2.NUM = L3.NUM

Using Window Function

SELECT DISTINCT N1 AS ConsecutiveNums
FROM (
SELECT NUM AS N1, LEAD(1, NUM) OVER(ORDER BY ID) AS N2, LEAD(2, NUM) OVER(ORDER BY ID) AS N3
FROM LOGS)
WHERE N1 = N2= N3

HackerRank : The Report

profailure — Fri, 22 Oct 2021 10:50:30 +0900

https://www.hackerrank.com/challenges/the-report/problem?h_r=internal-search&isFullScreen=true

The Report | HackerRank

Write a query to generate a report containing three columns: Name, Grade and Mark.

www.hackerrank.com

JOIN ON BETWEEN

join 절에 다음과 같이 between을 사용 할 수 있다.

SELECT IF(G.GRADE >= 8, S.NAME, NULL), G.GRADE, S.MARKS
FROM STUDENTS S
JOIN GRADES G ON S.MARKS BETWEEN G.MIN_MARK AND G.MAX_MARK
ORDER BY G.GRADE DESC, S.NAME

HackerRank : Challenges

profailure — Fri, 22 Oct 2021 10:21:34 +0900

https://www.hackerrank.com/challenges/challenges/problem?h_r=internal-search&isFullScreen=true

Challenges | HackerRank

Print the total number of challenges created by hackers.

www.hackerrank.com

Sub Query

SELECT H.HACKER_ID, MAX(H.NAME), COUNT(C.CHALLENGE_ID) AS NUM_OF_CHALLENGES
FROM HACKERS H
JOIN CHALLENGES C ON H.HACKER_ID = C.HACKER_ID
GROUP BY H.HACKER_ID
HAVING NUM_OF_CHALLENGES = (SELECT MAX(SUB.NUM_OF_CHALLENGES)
                            FROM (SELECT COUNT(CHALLENGE_ID) AS NUM_OF_CHALLENGES  
                                  FROM CHALLENGES
                                  GROUP BY HACKER_ID) SUB)
OR NUM_OF_CHALLENGES IN (SELECT SUB.NUM_OF_CHALLENGES
                         FROM (SELECT HACKER_ID, COUNT(*) AS NUM_OF_CHALLENGES
                               FROM CHALLENGES
                               GROUP BY HACKER_ID) SUB
                         GROUP BY SUB.NUM_OF_CHALLENGES
                         HAVING COUNT(*) = 1)
ORDER BY NUM_OF_CHALLENGES DESC, H.HACKER_ID

여러번 쓰이는 SUB QUERY는 WITH 문으로 미리 테이블을 정의하여 재사용하면

코드를 간략화 할 수 있다.

WITH CHALLENGES_COUNT AS(
SELECT COUNT(CHALLENGE_ID) AS NUM_OF_CHALLENGES  
FROM CHALLENGES
GROUP BY HACKER_ID)

SELECT H.HACKER_ID, MAX(H.NAME), COUNT(C.CHALLENGE_ID) AS NUM_OF_CHALLENGES
FROM HACKERS H
JOIN CHALLENGES C ON H.HACKER_ID = C.HACKER_ID
GROUP BY H.HACKER_ID
HAVING NUM_OF_CHALLENGES = (SELECT MAX(SUB.NUM_OF_CHALLENGES)
                            FROM CHALLENGES_COUNT SUB)
OR NUM_OF_CHALLENGES IN (SELECT SUB.NUM_OF_CHALLENGES
                         FROM CHALLENGES_COUNT SUB
                         GROUP BY SUB.NUM_OF_CHALLENGES
                         HAVING COUNT(*) = 1)
ORDER BY NUM_OF_CHALLENGES DESC, H.HACKER_ID

LeetCode : 184. Department Highest Salary

profailure — Thu, 21 Oct 2021 17:47:29 +0900

https://leetcode.com/problems/department-highest-salary/

Department Highest Salary - LeetCode

Level up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.

leetcode.com

FROM절 서브쿼리, JOIN

SELECT D.NAME AS DEPARTMENT,
        E.NAME AS EMPLOYEE,
        E.SALARY AS SALARY
FROM EMPLOYEE E
JOIN (SELECT DEPARTMENTID, MAX(SALARY) AS MX_SAL
FROM EMPLOYEE
GROUP BY DEPARTMENTID) SUB ON E.SALARY = SUB.MX_SAL 
                            AND E.DEPARTMENTID = SUB.DEPARTMENTID
JOIN DEPARTMENT D ON E.DEPARTMENTID = D.ID

Window Func

SELECT EMP_INFO.DEPT_NAME AS Department,
       EMP_INFO.EMP_NAME AS Employee,
       EMP_INFO.SALARY AS Salary
FROM (
    SELECT E.NAME AS EMP_NAME, 
           D.NAME AS DEPT_NAME, 
           E.SALARY,
           MAX(SALARY) OVER(PARTITION BY DEPARTMENTID) AS MAX_SAL
    FROM EMPLOYEE E
    JOIN DEPARTMENT D ON E.DEPARTMENTID = D.ID) EMP_INFO
WHERE EMP_INFO.SALARY = EMP_INFO.MAX_SAL

백준 1311 : 할 일 정하기1

profailure — Wed, 22 Sep 2021 22:38:07 +0900

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

1311번: 할 일 정하기 1

N명의 사람과 N개의 일이 있다. 각 사람은 일을 하나 담당해야 하고, 각 일을 담당하는 사람은 한 명 이어야 한다. 또한, 모든 사람은 모든 일을 할 능력이 있다. 사람은 1번부터 N번까지 번호가 매

www.acmicpc.net

해결 방법 : BitMask DP

N이 최대 20이므로, 완탐시 20!의 탐색 필요.
최소 비용을 찾기 위해서는 어찌됐든 모든 경우의수를 고려해야한다. 따라서 메모제이션 기법을 사용하여 탐색 횟수를 줄인다.
- 기본적인 DFS탐색과 같이 진행되며, 이전에 이미 계산한 state를 확인하기 위해 비트마스킹 기법을 사용한다.
이해하기 힘들 수 있으니 간단한 예시를 남김

cost_table을 완전탐색하면 처음 탐색은 다음과 같이 진행된다. (bold 표시된 부분이 탐색한 부분)

<cost_table>

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

이후 4번의 조합이 더 생기고 첫번째 사람이 첫번째 일을 점유하는 탐색이 끝났다고 생각하자.

그럼 다음 탐색 순서는 첫번째 사람이 두번째 일을 점유하는 상황이고, 다음과 같이 진행될 것이다.

<cost_table>

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

이때, 다음의 빨간색 state는 이전과 완전히 동일하다.

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

FEE FEE FEE FEE FEE FEE FEE FEE

그러므로 이전 탐색(첫번째 사람이 첫번째 일을 점유하는)시 해당 부분의 최소 비용을

dp[2][1100]에 저장하도록 구현하는 것이다.(1100 means, 현재 첫번째, 두번째 일은 점유되어 있는 상태)

만약,

FEE FEE

FEE FEE 가 최소 비용이었다면, 해당 비용이 dp[2][1100]에 저장되어 있을 것이고,

이후의 탐색은 진행하지 않고 최소 비용을 참조 할 수 있다.

import sys
input = sys.stdin.readline

def solution(N, costs):
    dp = [[float('inf')] * (1 << N) for _ in range(N)] # [person][bitmask]

    def dfs(c, state): # 전체 탐색
        if dp[c][state] < float('inf'): # 이미 계산된 state이면, dp table 참조
            return dp[c][state]

        for idx in range(N): # idx : 다음 person
            if state & (1 << idx) == 0: # idx가 현재 state에 포함 X 이면,
                if c + 1 == N: # c가 마지막 person이면 최솟값은 costs[c][idx]
                    dp[c][state] = costs[c][idx]
                else: # dp 최솟값 갱신
                    dp[c][state] = min(dp[c][state], dfs(c+1, state | (1<<idx)) + costs[c][idx])

        return dp[c][state]

    return dfs(0, 0)

if __name__ == '__main__':
    N = int(input())
    costs = [list(map(int, input().split())) for _ in range(N)]
    result = solution(N, costs)
    print(result)

백준 1799 : 비숍

profailure — Thu, 16 Sep 2021 20:54:35 +0900

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

1799번: 비숍

첫째 줄에 체스판의 크기가 주어진다. 체스판의 크기는 10이하의 자연수이다. 둘째 줄부터 아래의 예와 같이 체스판의 각 칸에 비숍을 놓을 수 있는지 없는지에 대한 정보가 체스판 한 줄 단위로

www.acmicpc.net

해결 방법 : DFS

비숍이 위치 할 수 있는 경우를 '선택적으로' 탐색한다.
- 사실 로직상 백트레킹 기법을 사용한 것으로 봐도 무방함
우선, 체스판의 최대 크기는 10*10이고, 만약 board가 모두 1(활성 상태)라면, 탐색해야 하는 비숍 배치의 경우의 수는 2^100이다. 물론 추가적으로 비숍이 서로 생존할 수 있는지를 탐색해야 하지만, 일단 생각하지말자. 아무튼, 탐색 횟수를 줄이는 '조건'을 추가하는 것이 문제의 key point임을 알 수 있다.
- 비숍이 무한정 움직일 수 있다고 해도 서로 잡을 수 없는 경우가 있다. 좌우-앞뒤로 붙어 있는 비숍쌍을 생각하면 쉽다. 특정 비숍의 위치가 (r, c)라면, r + c 가 짝수인 경우끼리만 서로 만날 수 있음을 떠올리자. (반대로 r + c가 홀수라면 홀수인 비숍끼리만 만날 수 있을 것이다.)
- 이를 even_bishops, odd_bishops라고 정의하고, even_bishops끼리의 비숍 위치 탐색 + odd_bishops끼리의 비숍위치 탐색으로 진행한다면 최악의 경우 2^51의 조합이 생긴다. 하지만 board 위에는 비숍이 위치 할 수 없는 공간도 주어지기 때문에 이보다는 낮을 것으로 기대한다.
만약 비숍을 하나씩 추가하면 탐색하다가 불가능한 조합임을 확인하면 해당 조합을 포함하는 모든 조합은 탐색하지 않도록 가지치기한다.
- 만약 비숍 두쌍이 (r1, c1), (r2, c2)에 위치했을 때, if abs(r1-r2) = abs(c1-c2) then, 불가능임을 생각하자.
- 이와 같이 백트레킹 로직이 추가되면 탐색해야 하는 조합은 기하급수적으로 줄어들 것이다.

import sys
input = sys.stdin.readline

def solution(N, board):
    answer = [0, 0] # [even_bishop 최대 개수, odd_bishop 최대 개수]
    even_bishops, odd_bishops = [], []

    for r in range(N): # even_bishop, odd_bishop 각각 비숍이 위치 가능한 좌표쌍 추가
        for c in range(N):
            if board[r][c] == 1:
                if (r + c) % 2 == 0: # even
                    even_bishops.append((r, c))
                else: # odd
                    odd_bishops.append((r, c))


    def dfs(index, entries, bishops, case): # (현재 고려할 비숍 index, 현재 존재하는 비숍들, ..., even or odd)
        for i in range(index, len(bishops)): 
            flag = True # bishops[i]가 board에 세워질 수 있는지
            for e in entries: # 현재 존재하는 비숍과 공격 가능한지 탐색
                if abs(bishops[i][0] - bishops[e][0]) == abs(bishops[i][1] - bishops[e][1]):
                    flag = False
                    break
            if flag == True: # board에 등록 가능
                entries.append(i)
                dfs(i + 1, entries, bishops, case)
                entries.remove(i)

        answer[case] = max(answer[case], len(entries)) # 마지막 비숍까지 탐색한 경우들은 entries의 개수 비교


    dfs(0, [], even_bishops, 0)
    dfs(0, [], odd_bishops, 1)

    return sum(answer)


if __name__ == '__main__':
    N = int(input())
    board = [list(map(int, input().split())) for _ in range(N)]
    result = solution(N, board)
    print(result)

백준 3190 : 뱀

profailure — Sun, 12 Sep 2021 16:54:19 +0900

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

3190번: 뱀

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

해결 방법 : Linked List

board가 (2 <= N <= 100)이고 최대 second가 10,000밖에 되지 않기 때문에 최대 10,100초 안에 답이 나온다. 따라서 1초 마다 뱀이 움직이는 것을 그대로 구현하였다.
뱀은 연결 리스트로 표현된다. 현재 sec에 이동한 칸은 리스트의 head에, 꼬리의 끝은 리스트의 tail이 될 것이다.
사과를 먹으면 해당 sec에는 tail을 감소시키지 않는다.
방향 전환은 시간은 순서대로 있으므로 방향 전환 정보를 담은 배열의 0번째만 참조한다.
board 범위를 벗어나거나, 뱀을 표현한 연결 리스트안에 있는 좌표쌍에 들어가게 되면 종료.

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

def solution(N, apples, rotates):
    D = {(0,1) : ((1,0),(-1,0)), (1,0) : ((0,-1),(0,1)),
         (0,-1) : ((-1,0),(1,0)), (-1,0) : ((0,1),(0,-1))} # 방향 전환 
    Q = deque([(0,0)]) # linked list로 사용
    sec, d = 0, (0,1) # 처음 시작, 처음 방향(Right)
    while True:
        sec += 1
        r, c = Q[-1][0] + d[0], Q[-1][1] + d[1] # 이동한 좌표 row, col
        
        if not (0 <= r < N and 0 <= c < N) or (r, c) in Q: # board 이탈 or 몸통박치기
            return sec
        
        Q.append((r, c)) # 머리 추가

        if (r+1, c+1) not in apples: # 꼬리 제거
            Q.popleft()
        else:
            apples.remove((r+1, c+1)) # 먹은 사과 제거
        
        if rotates: # 방향 전환
            if rotates[0][0] == str(sec):
                d = D[d][0] if rotates.pop(0)[1] == 'D' else D[d][1]


if __name__ == '__main__':
    N = int(input())
    K = int(input())
    apples = [tuple(map(int, input().split())) for _ in range(K)]
    L = int(input())
    rotates = [tuple(input().split()) for _ in range(L)]
    result = solution(N, apples, rotates)
    print(result)

백준 13460 : 구슬 탈출 2

profailure — Sun, 5 Sep 2021 17:37:10 +0900

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

13460번: 구슬 탈출 2

첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B'

www.acmicpc.net

해결 방법 : BFS

10번까지 판을 기울이는 모든 경우를 탐색한다.
- 중복 탐색을 허용한다면 최악의 경우 $4^10$ 만큼을 탐색하게 되므로, visited 해쉬테이블을 만들어 구슬의 위치가 이전의 어떤 시점과 동일하다면 더 이상 탐색하지 못하도록 한다.
한 번의 탐색 마다 빨간 구슬과 파란 구슬을 상하좌우로 벽에 부딪힐 때까지 움직이며, 움직이는 과정에 빨간 구슬만 구멍에 들어갔다면 현재 count 를 반환한다.
빨간 구슬과 파란 구슬이 겹쳐지는 경우를 방지하기 위한 방법으로 조건문을 두었다.

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

def solution(N, M, board):
    D = [(0,1), (1,0), (0,-1), (-1,0)] # 상하좌우 이동 가중치
    for r in range(N): # 최초 빨간 구슬, 파란 구슬 위치 찾기
        for c in range(M):
            if board[r][c] == 'R':
                redRow, redCol = r, c
            if board[r][c] == 'B':
                blueRow, blueCol = r, c
        
    Q = deque([(redRow, redCol, blueRow, blueCol, 0)])
    visited = dict() # 중복 탐색 방지
    visited[(redRow, redCol, blueRow, blueCol)] = True
    while Q:
        RR, RC, BR, BC, count = Q.popleft()
        if count == 10: return -1 # 종료 조건

        for d in D: # 상하좌우 기울이기
            redGoal = blueGoal = False # 각 구슬이 구멍에 들어갔는지를 나타내는 변수
            nRR, nRC, nBR, nBC = RR, RC, BR, BC
            while board[nRR + d[0]][nRC + d[1]] != '#': # 벽에 부딪힐 때까지 
                nRR += d[0]
                nRC += d[1]
                if board[nRR][nRC] == 'O': # 구멍에 들어감
                    redGoal = True
            while board[nBR + d[0]][nBC + d[1]] != '#':
                nBR += d[0]
                nBC += d[1]
                if board[nBR][nBC] == 'O':
                    blueGoal = True

            if redGoal and not blueGoal: # 빨간 구슬만 구멍에 들어간 경우
                return count + 1
            if blueGoal: # 파란 구슬이 구멍에 들어간 경우 현재 탐색은 무효
                continue

            if nRR == nBR and nRC == nBC: # 빨간 구슬과 파란 구슬이 겹쳐진 경우, 
                if RR == BR and RC < BC:
                    if d[1] == 1: nRC -= 1
                    else: nBC += 1
                elif RR == BR and RC > BC:
                    if d[1] == 1: nBC -= 1
                    else: nRC += 1
                elif RC == BC and RR < BR:
                    if d[0] == 1: nRR -= 1
                    else: nBR += 1
                else:
                    if d[0] == 1: nBR -= 1
                    else: nRR += 1
            
            if visited.get((nRR, nRC, nBR, nBC)) is None: # 탐색하지 않은 구슬 위치일 경우,
                visited[(nRR, nRC, nBR, nBC)] = True
                Q.append((nRR, nRC, nBR, nBC, count + 1)) # 탐색 Q에 push
                
    return -1


if __name__ == '__main__':
    N, M = map(int, input().split())
    board = [input() for _ in range(N)]
    result = solution(N, M, board)
    print(result)