나를 잃지 말자

• 위치

 

100m

확대축소초기화

로드뷰길찾기지도 크게 보기

• 별점 : 4.5 / 5
• 주차여부 : 없음
• 메뉴 : 양식(스테이크, 파스타, 랍스타, 샐러드, 와인)
• 가격 : 비싼편
• 룸식 존재 여부 : 없음
• 뷰 : 없음
• 재방문의사 : 있음
• 응대 수준 : 높음

• 후기
  • 연인끼리 오기 좋은 분위기, 분위기 굳
  • 샐러드, 감바스 알 아히요, 스테이크 굳
  • 랍스터구이는 맛이 보기보다는 별로다. 좀 더 좋은 랍스터를 써야하지않나? 같은 생각 들게 함
  • 매니저분께서 와인 추천을 잘해주신다. 와인은 맛과 이름이 기억나지 않지만, 여기 맛은 기억이 난다. 이름은 기억이 안남!

• 위치

 

100m

확대축소초기화

로드뷰길찾기지도 크게 보기

• 별점 : 4 / 5
• 주차여부 : 골목에 찾아서 해야함
• 메뉴 : 사진 참고
• 가격 : 사진 참고
• 룸식 존재 여부 : 없음
• 뷰 : 없음
• 재방문의사 : 있음
• 응대 수준 : 보통

• 후기
  • 기본 차림상에 나오는 밑반찬때문에 가는 곳
  • 잡채가 나오는 게 좋다.
  • 닭도리탕 간은 슴슴한 편
  • 닭도리탕 주문시 공깃밥 따로 주문해야한다는 것이 단점
  • 붐비지 않아서 좋다.

• 위치
  •  
   

  

  

  100m

  

  확대축소초기화

  

  로드뷰길찾기지도 크게 보기
• 별점 : 4.5 / 5
• 주차여부 : 가능
• 메뉴 : 우럭조림, 갈치조림, 추가메뉴, 주류 등
  • 나는 점심에 낙지볶음과 소면을 먹고 왔다
• 가격 :
  • 사진 참조
• 룸식 존재 여부 : 모름
• 뷰 : 오션뷰
• 재방문의사 : 매우 높음
• 응대 수준 : 보통

• 후기
  • 낙지볶음이 보기보다 맵지가 않다. 맛있게 매운맛이다. 맵찔이들도 가능할 것 같다.
  • 든든하게 먹고 어르신과도 오기 좋은 곳
  • 평일 낮에 바다앞에 사람이 매우 적다. 이렇게 사람 적은 곳 찾기 힘든데... 연인과 밥먹고 걷기도 좋은 곳
  • 하지만, 가격이 13,000원이니 맛있어야만 하는 가격

• 위치 :
  •  
   

  

  

  100m

  

  확대축소초기화

  

  로드뷰길찾기지도 크게 보기
• 별점 : 4 / 5
• 주차여부 : 따로 없음, 인근 길에 대는 방식
• 메뉴 : 탕수육, 짬뽕, 짜장면 등
• 가격 : (2022년 11월 기준) 짬뽕 10,000원, 짬뽕 곱빼기 12,000원, 탕수육 23,000원, 숙주탕수육 25,000원
• 룸식 존재 여부 : 존재 안함
• 뷰 : 없음
• 재방문의사 : 높음
• 응대 수준 : 높음

• 후기
  • 해물과 돼지고기 모두가 들어간 짬뽕
  • 너무 자극적이지 않다.
  • 맵게 먹고 싶다고 요청 시, 고추가루를 따로 주신다.
  • 곱빼기가 12,000원이나 한다. 곱빼기 아닌 것도 10,000원인 짬뽕...
  • 그럼에도 맛있어서 또 가고 싶은 곳
  • 분위기나 뷰가 좋은 곳은 아니다. 오로지 식사로 가는 곳이다.
  • 가게 이름이 탕수육인데 탕수육을 안먹었다. 다음엔 탕수육을 먹어보고 와야지.

• 위치 :
  •  
   

  

  

  100m

  

  확대축소초기화

  

  로드뷰길찾기지도 크게 보기
• 별점 : 4 / 5
• 주차여부 : 모름
• 메뉴 : 한식 뷔페
  • 기본적으로 빨간 제육, 콩나물 무침, 스크램블 에그, 미역국, 두부김치국, 된장찌개/카레 격일 등이 나온다.
• 가격 : (2022년 11월 기준) 9,000원
• 룸식 존재 여부 : 존재 안함
• 뷰 : 없음
• 재방문의사 : 높음
• 응대 수준 : 높음

• 후기
  • 매일 제육과 계란이 나와서 남자들이 좋아할 곳
  • 간이 쎄지가 않아서 잘 넘어간다.
  • 밥은 잡곡밥, 보리밥, 흰쌀밥이 제공된다.
  • 프론트에 계신 주인장 분으로 보이시는 분께서 손님이 들어올 때나 나갈 때나 친절하게 맞이해주신다.
  • 글 올리는 지금도 또 가고 싶다!

• 문제
  • 14501번: 퇴사
• 해결

import sys

resignation_day = sys.stdin.readline()

time_and_pay = [list(map(int, x.strip().split())) for x in sys.stdin.readlines()]

time_list = [x[0] for x in time_and_pay]
pay_list = [x[1] for x in time_and_pay]
cand = [0]

def go(time_list, pay_list, cur_ind, cumulative_pay):
    # 불가능
    if cur_ind >= len(time_list):
        return None

    # 정답
    if (cur_ind + time_list[cur_ind]) > len(time_list):
        if cand[0] < cumulative_pay:
            cand[0] = cumulative_pay
    if (cur_ind + time_list[cur_ind]) == len(time_list):
        if cand[0] < (cumulative_pay + pay_list[cur_ind]):
            cand[0] = cumulative_pay + pay_list[cur_ind]

    go(time_list, pay_list, cur_ind + time_list[cur_ind], cumulative_pay + pay_list[cur_ind])
    go(time_list, pay_list, cur_ind + 1, cumulative_pay)

    return cand[0]

print(go(time_list, pay_list, 0, 0))

• 포인트
  • Dynamic programming

• 문제
  • 14500번: 테트로미노
• 해결

import sys

height, width = [int(x) for x in sys.stdin.readline().split()]

mapping = [list(map(int, x.split())) for x in sys.stdin.readlines()]
case_to_sub = {
    0: 2,
    1: 1,
    2: 8,
    3: 4,
    4: 4
}

def case_sub_to_available(case, sub, total_row, total_col):
    if case == 0 and sub == 0:
        return total_row, total_col - 3, 0, 0
    elif case == 0 and sub == 1:
        return total_row - 3, total_col, 0, 0

    elif case == 1 and sub == 0:
        return total_row - 1, total_col - 1, 0, 0

    elif case == 2 and sub == 0:
        return total_row - 2, total_col - 1, 0, 0
    elif case == 2 and sub == 1:
        return total_row - 1, total_col - 2, 0, 0
    elif case == 2 and sub == 2:
        return total_row - 2, total_col - 1, 0, 0
    elif case == 2 and sub == 3:
        return total_row - 1, total_col - 2, 1, 0

    elif case == 2 and sub == 4:
        return total_row - 2, total_col - 1, 2, 0
    elif case == 2 and sub == 5:
        return total_row - 1, total_col - 2, 0, 0
    elif case == 2 and sub == 6:
        return total_row - 2, total_col - 1, 0, 0
    elif case == 2 and sub == 7:
        return total_row - 1, total_col - 2, 0, 0

    elif case == 3 and sub == 0:
        return total_row - 2, total_col - 1, 0, 0
    elif case == 3 and sub == 1:
        return total_row - 1, total_col - 2, 1, 0

    elif case == 3 and sub == 2:
        return total_row - 2, total_col - 1, 1, 0
    elif case == 3 and sub == 3:
        return total_row - 1, total_col - 2, 0, 0

    elif case == 4 and sub == 0:
        return total_row - 1, total_col - 2, 0, 0
    elif case == 4 and sub == 1:
        return total_row - 2, total_col - 1, 1, 0
    elif case == 4 and sub == 2:
        return total_row - 1, total_col - 2, 1, 0
    elif case == 4 and sub == 3:
        return total_row - 2, total_col - 1, 0, 0

def get_val(case, sub, r, c, d):
    if case == 0 and sub == 0:
        return d[r][c] + d[r][c + 1] + d[r][c + 2] + d[r][c + 3]
    elif case == 0 and sub == 1:
        return d[r][c] + d[r + 1][c] + d[r + 2][c] + d[r + 3][c]

    elif case == 1 and sub == 0:
        return d[r][c] + d[r + 1][c] + d[r][c + 1] + d[r + 1][c + 1]

    elif case == 2 and sub == 0:
        return d[r][c] + d[r + 1][c] + d[r + 2][c] + d[r + 2][c + 1]
    elif case == 2 and sub == 1:
        return d[r][c] + d[r][c + 1] + d[r][c + 2] + d[r + 1][c]
    elif case == 2 and sub == 2:
        return d[r][c] + d[r][c + 1] + d[r + 1][c + 1] + d[r + 2][c + 1]
    elif case == 2 and sub == 3:
        return d[r][c] + d[r][c + 1] + d[r][c + 2] + d[r - 1][c + 2]

    elif case == 2 and sub == 4:
        return d[r][c] + d[r][c + 1] + d[r - 1][c + 1] + d[r - 2][c + 1]
    elif case == 2 and sub == 5:
        return d[r][c] + d[r][c + 1] + d[r][c + 2] + d[r + 1][c + 2]
    elif case == 2 and sub == 6:
        return d[r][c] + d[r][c + 1] + d[r + 1][c] + d[r + 2][c]
    elif case == 2 and sub == 7:
        return d[r][c] + d[r + 1][c] + d[r + 1][c + 1] + d[r + 1][c + 2]

    elif case == 3 and sub == 0:
        return d[r][c] + d[r + 1][c] + d[r + 1][c + 1] + d[r + 2][c + 1]
    elif case == 3 and sub == 1:
        return d[r][c] + d[r][c + 1] + d[r - 1][c + 1] + d[r - 1][c + 2]
    elif case == 3 and sub == 2:
        return d[r][c] + d[r][c + 1] + d[r - 1][c + 1] + d[r + 1][c]
    elif case == 3 and sub == 3:
        return d[r][c] + d[r][c + 1] + d[r + 1][c + 1] + d[r + 1][c + 2]

    elif case == 4 and sub == 0:
        return d[r][c] + d[r][c + 1] + d[r][c + 2] + d[r + 1][c + 1]
    elif case == 4 and sub == 1:
        return d[r][c] + d[r][c + 1] + d[r - 1][c + 1] + d[r + 1][c + 1]
    elif case == 4 and sub == 2:
        return d[r][c] + d[r][c + 1] + d[r][c + 2] + d[r - 1][c + 1]
    elif case == 4 and sub == 3:
        return d[r][c] + d[r + 1][c] + d[r + 1][c + 1] + d[r + 2][c]

max_ = 0
for case in case_to_sub.keys():
    for sub in range(case_to_sub[case]):
        row_cnt, col_cnt, start_row, start_col = case_sub_to_available(case, sub, height, width)
        for r in range(start_row, start_row + row_cnt, 1):
            for c in range(start_col, start_col + col_cnt, 1):
                val = get_val(case, sub, r, c, mapping)
                if val > max_:
                    max_ = val
print(max_)

• 포인트
  • Bruteforce
  • 모든 도형마다 가능한 좌우대칭 경우를 생성

• 문제
  • 13023번: ABCDE
• 해결

import sys

person_count, relation_count = [int(x) for x in sys.stdin.readline().strip().split()]

data = [list(map(int, x.strip().split())) for x in sys.stdin.readlines()]

relation = {k: [] for k in range(person_count)}

for x in data:
    relation[x[0]].append(x[1])
    relation[x[1]].append(x[0])

relation = {k: set(v) for k, v in relation.items()}

for k in relation.keys():
    for i in relation[k] - set([k]):
        for j in relation[i] - set([k, i]):
            for u in relation[j] - set([k, i, j]):
                if len(relation[u] - set([k, i, j, u])):
                    print(1)
                    exit()
print(0)

• 포인트
  • 길이가 5인 path의 존재인 문제인데 길이가 5로 고정되어 네번의 for-loop로 해결
  • dfs로 길이가 5되는 것 찾아도 될 듯

• 문제
  • 11724번: 연결 요소의 개수
• 해결

import sys

sys.setrecursionlimit(99999)

vertex_count, edge_count = [int(x) for x in sys.stdin.readline().strip().split()]

edges = [list(map(int, each.strip().split())) for each in sys.stdin.readlines()]

adj_list = [[] for _ in range(vertex_count + 1)]
chk_list = [False] * (vertex_count + 1)
connected_components = []

for each in edges:
    adj_list[each[0]].append(each[1])
    adj_list[each[1]].append(each[0])

for v in range(1, len(adj_list)):
    adj_list[v] = sorted(list(set(adj_list[v])))

def dfs(vertex, connected_component):
    chk_list[vertex] = True
    connected_component.append(vertex)
    for neighbor in adj_list[vertex]:
        if not chk_list[neighbor]:
            dfs(neighbor, connected_component)

for vertex in range(1, len(adj_list)):
    if not chk_list[vertex]:
        connected_component = []
        dfs(vertex, connected_component)
        connected_components.append(connected_component)

print(len(connected_components))

• 포인트
  • dfs

• 문제
  • 10972번: 다음 순열
• 해설

import sys

N = int(sys.stdin.readline())
data = list(map(int, sys.stdin.readline().split()))

def next_permutation(list_):
    get_i = 0
    for i in range(len(list_)-1):
        if list_[i] < list_[i+1]:
            get_i = i

    get_j = 0
    for j in range(get_i+1, len(list_), 1):
        if list_[get_i] < list_[j]:
            get_j = j

    if get_i == 0 and get_j == 0:
        return False
    else:
        list_[get_i], list_[get_j] = list_[get_j], list_[get_i]
        get_j = len(list_)-1
        while (get_i+1 < get_j):
            list_[get_i+1], list_[get_j] = list_[get_j], list_[get_i+1]
            get_i += 1; get_j -= 1
        return True

if next_permutation(data):
    res = [str(x) for x in data]
    res = ' '.join(res)
    print(res)
else:
    print(-1)

• 포인트
  • next permutation은 증가조짐인 가장 오른쪽놈(i)와 (i)의 오른쪽놈들 중 (i)보다 큰놈 중 가장 작은 놈(=큰놈 중 가장 오른쪽 놈)(j)을 교체하는 것