척척석사의 코딩기록

생각보다는 쉽게 풀었던 문제인데, 

from collections import deque
N = int(input())
gp = [[] for _  in range (0,N+1)]
for _ in range (0,N-1):
    a,b = map(int,input().split())
    gp[a].append(b)
    gp[b].append(a)
depth = [[] for _ in range (0,N+1)]
depth[1] = (1,1)
deq = deque()
check = [False for _ in range (0,N+1)]
new_graph = [[] for _ in range (0,N+1)]
deq.append((1,1))
while deq:
    x = deq.popleft()
    x,y = x[0], x[1]
    check[x] = True
    for z in gp[x]:
        if check[z] == False:
            deq.append((z,y + 1))
            new_graph[x].append((z,y+1))
            
ans = [0 for _ in range (0,N+1)]

for i in range (0,N+1):
    if new_graph[i] != []:
        for x in new_graph[i]:
            ans[x[0]] = i

for i in range (2,N+1):
    print(ans[i])

말이 어렵게 쓰여있지만, 결국 해답은 뭐냐면 

다각형의 세 점을 이어서 만들 수 있는 삼각형 중 가장 넓이가 큰 것을 찾으시오 라는 문제가 되겠습니다.

여기서, 아이디어로서 사용되는 것은 신발끈 정리입니다.

https://ko.wikipedia.org/wiki/%EC%8B%A0%EB%B0%9C%EB%81%88_%EA%B3%B5%EC%8B%9D

좌표 평면에 점의 좌표가 주어져 있을 때 다각형의 넓이를 구할 수 있게 도와주는 공식이예요.

이를 활용해 아래와 같이 코드를 짤 수 있겠습니다.

def area의 부분이 넓이를 구하는 함수가 되겠습니다.

from itertools import combinations
import math
def area(a,b,c):
    x1,y1 = a[0],a[1]
    x2,y2 = b[0],b[1]
    x3,y3 = c[0],c[1]
    return int(math.fabs(x1*y2 + x2*y3 + x3*y1 - x2*y1 - x3*y2 - x1*y3)) * 1/2
ans = -1
N = int(input())
pts = []
for _ in range (0,N):
    pt = list(map(int,input().split()))
    pts.append(pt)

for t in combinations(pts,3):
    t = list(t)
    a,b,c = t[0],t[1],t[2]
    ans = max(ans, area(a,b,c))
print(ans)

from collections import defaultdict
import sys
input = sys.stdin.readline
N,M = map(int,input().split())
cnt = defaultdict(int)
length = defaultdict(int)
for _ in range (0,N):
    a = input().rstrip()
    if len(a) >= M:
        cnt[a] += 1
        length[a] = len(a)
words = []
dd =  list(cnt.keys())
for word in dd:
    words.append([word, cnt[word], length[word]])

words.sort(key = lambda x:(-x[1],-x[2],x[0]))
for word in words:
    print(word[0])

문자열 정렬을 어떤 우선순위에 따라서 둘 것인지 확인해야할 필요가 있습니다.

key = lambda의 사용법을 익히기에 좋을 것 같습니다.

import sys
sys.setrecursionlimit(10000)

N,M = map(int,input().split())
x,y,di = map(int,input().split())
mapp = []
for _ in range (0,N):
    a = list(map(int,input().split()))
    mapp.append(a)

direction =[[-1,0],[0,1],[1,0],[0,-1]]
check = [[False for _ in range (0,M)] for _ in range (0,N)]
#di는 방향을 나타내고 있는 것
    
def algo(x,y,di):
    cnt = 0
    while True:
        if mapp[x][y] == 0 and check[x][y] == False:
            cnt += 1
            check[x][y] = True
    #첫번째 스텝에서 진행하는 자리가 더러우면 청소하는 경우
    #자신의 4방향 탐지하기
        jud = True
        for i in range (1,5):
        #반시계방향부터 탐색한다는 것에 유의
            t = (di - i) % 4
            xx = x + direction[t][0]
            yy = y + direction[t][1]
            if 0 <= xx < N and 0 <= yy < M:
                if mapp[xx][yy] == 0 and check[xx][yy] == False:
                    jud = False
                    x,y,di = xx,yy,t
                    break
        if jud == True:
            a = x - direction[di][0]
            b = y - direction[di][1]
            if mapp[a][b] == 1 or (0 > a or a == N or 0 > b or M == b):
                print(cnt)
                return
            x,y = a,b        
algo(x,y,di)

시간이 좀 오래 걸렸던 문제 ... 다 짜놓고서 이상한 곳에서 뻘짓을 많이했던 기억이 ....

import copy
N,M = map(int,input().split())
mapp = []
check = [[0 for _ in range (0,M)] for _ in range (0,N)]
camera = []
dx,dy = [1,0,-1,0], [0,1,0,-1]
for i in range (0,N):
    a = list(map(int,input().split()))
    mapp.append(a)
    for j in range (0,M):
        if 1 <= a[j] <= 5:
            camera.append([a[j], i,j])
ans = int(1e9)
pattern = [[],[[0],[1],[2],[3]],[[0,2],[1,3]],[[0,1],[1,2],[2,3],[3,0]],[[0,1,2],[1,2,3],[2,3,0],[3,0,1]],[[0,1,2,3]]]
#pattern은 카메라 종류를 지시함
#카메라의 x,y는 위치
def view(area,mode,x,y):
    for i in mode:
        a,b = x,y
        while True:
            a += dx[i]
            b += dy[i]
            if 0 <= a < N and 0 <= b < M:
                if area[a][b] == 0:
                    area[a][b] = -1
                elif area[a][b] == 6:
                    break
            else:
                break
            
def dfs(depth, area):
    global ans
    if depth == len(camera):
        cnt = 0
        for i in range (0,N):
            cnt += area[i].count(0)
        ans = min(ans,cnt)
        area = copy.deepcopy(mapp)
        return
    
    new_area = copy.deepcopy(area)
    cctv,x,y = camera[depth]
    for i in pattern[cctv]:
        view(new_area,i,x,y)
        dfs(depth + 1, new_area)
        new_area = copy.deepcopy(area)
dfs(0,mapp)
print(ans)

삼성은 이런 카테고리의 문제를 많이 내는구나 싶었다.

백트래킹 / dfs를 잘 익힌 다음에 시험 보러 가는 것이 좋을 것 같다

from itertools import permutations
N = int(input())
num = list(map(int,input().split())) #숫자들
cal = list(map(int,input().split())) #연산자 갯수

sym = []
for i in range (0,4):
    for j in range (0,cal[i]):
        if i == 0:
            sym.append("+")
        elif i == 1:
            sym.append("-")
        elif i == 2:
            sym.append("*")
        elif i == 3:
            sym.append("//")
#A가 결국은 연산자 순서를 나타나게 될 것이다.
number = [i for i in range (0,N-1)]
A = list(permutations(number,N-1))
minimum = 1e10
maximum = -1e10
for a in A:
    t = num[0]
    for i in range (0,N-1):
        if sym[a[i]] == "+":
            t += num[i+1]
        elif sym[a[i]] == "-":
            t -= num[i+1]
        elif sym[a[i]] == "*":
            t *= num[i+1]
        elif sym[a[i]] == "//":
            t = int(t / num[i+1])
    minimum = min(minimum, t)
    maximum = max(maximum, t)
print(maximum, minimum)

이 코드를 짜면서 문제인 부분은, 답이 1e9가 나왔을때 출력이 10000..... 0.000... 으로 실수형으로 나온다는 점에 제대로 착안해야한다는 점이다.

이 부분을 피하기 위해서, 초기 셋팅을 1e10과 -1e10 등으로 변경하는 것이 주효하였다.

삼성 서류에 붙었으니만큼, 코테를 확실히 준비하는 것이 맞지 않나싶어 열심히 풀어보고 있다.

작년 하반기에는 메모리 분석 및 평가 포지션에 넣었는데 광탈했던 슬픈 기억이 새록새록 ㅎㅎ...

from collections import deque
N = int(input())
pool = [] #전체적인 지도
for i in range (0,N):
    a = list(map(int,input().split()))
    for j in range (0,len(a)):
        if a[j] == 9:
            start = [i,j]
    pool.append(a)

ans,exp,lev = 0,0,2 #exp가 lev와 같아지면 lev += 1, exp = 0
dx,dy = [0,0,1,-1], [1,-1,0,0]

def bfs(x,y):
    visited = [[0 for _ in range (0,N)] for _ in range (0,N)]
    deq = deque([[x,y]])
    next = []
    visited[x][y] = 1
    while deq:
        t = deq.popleft()
        a,b = t[0], t[1]
        for i in range (0,4):
            aa,bb = a + dx[i], b + dy[i]
            if 0 <= aa < N and 0 <= bb < N and visited[aa][bb] == 0:
                if pool[x][y] > pool[aa][bb] and pool[aa][bb] != 0:
                    visited[aa][bb] = visited[a][b] + 1
                    next.append([visited[aa][bb]-1, aa,bb])
                elif pool[aa][bb] == pool[x][y]:
                    visited[aa][bb] = visited[a][b] + 1
                    deq.append([aa,bb])
                elif pool[aa][bb] == 0:
                    visited[aa][bb] = visited[a][b] + 1
                    deq.append([aa,bb])
    next.sort(key = lambda x: (x[0], x[1], x[2]))
    pool[x][y] = 0
    if next == []:
        return None
    return next[0]

while True:
    pool[start[0]][start[1]] = lev
    t = bfs(start[0], start[1])
    if t == None:
        break
    else:
        ans += t[0]
        exp += 1
        start = [t[1], t[2]]
        if lev == exp:
            exp = 0
            lev += 1
        pool[start[0]][start[1]] = 0
print(ans)

BFS를 최대한 잘 사용하는 것이 좋을 것 같다.

삼성 코딩 테스트까지 얼마 남지 않았는데, 잘 준비해서 좋은 결과 있었으면 좋겠다.

제발 오전에 봤으면 좋겠다 ... (오후부터 LG전자 코테 예정되어있음)

삼성 출제 문제였다고한다.

아무래도 직접 주사위를 굴렸다면 훨씬 이해가 빨랐을 수도 있을 것 같다 !

N,M,x,y,K = map(int,input().split())
#N,M은 지도의 사이즈, (x,y)는 좌표, K는 명령의 갯수
plane = []
for _ in range (0,N):
    t = list(map(int,input().split()))
    plane.append(t)
#plane을 통해서 각 좌표에 무엇이 쓰여있는지 알 수 있다

cube = [0,0,0,0,0,0,0]
#바닥 - 북 - 동 - 남 - 서 - 천장
coordinate = [x,y]
ans = []
movement = list(map(int,input().split()))
for i in range (0,K):
    n = movement[i]
    if n == 1:
        #동쪽으로 이동
        if 0 <= coordinate[1] + 1 < M:
            coordinate[1] += 1
            cube = [0,cube[3],cube[2],cube[6],cube[1],cube[5],cube[4]]
            if plane[coordinate[0]][coordinate[1]] == 0:
                plane[coordinate[0]][coordinate[1]] = cube[1]
            else:
                cube[1] = plane[coordinate[0]][coordinate[1]]
                plane[coordinate[0]][coordinate[1]] = 0
            ans.append(cube[-1])
        else:
            continue
    elif n == 2:
        #서쪽으로 이동
        if 0 <= coordinate[1] - 1 < M:
            coordinate[1] -= 1
            cube = [0,cube[4],cube[2],cube[1],cube[6],cube[5],cube[3]]
            if plane[coordinate[0]][coordinate[1]] == 0:
                plane[coordinate[0]][coordinate[1]] = cube[1]
            else:
                cube[1] = plane[coordinate[0]][coordinate[1]]
                plane[coordinate[0]][coordinate[1]] = 0
            ans.append(cube[-1])
        else:
            continue
    elif n == 4:
        #남쪽으로 이동
        if 0 <= coordinate[0] + 1 < N:
            coordinate[0] += 1
            cube = [0,cube[5],cube[1],cube[3],cube[4],cube[6],cube[2]]
            if plane[coordinate[0]][coordinate[1]] == 0:
                plane[coordinate[0]][coordinate[1]] = cube[1]
            else:
                cube[1] = plane[coordinate[0]][coordinate[1]]
                plane[coordinate[0]][coordinate[1]] = 0
            ans.append(cube[-1])
        else:
            continue
    elif n == 3:
        #북쪽으로 이동
        if 0 <= coordinate[0] - 1 < N:
            coordinate[0] -= 1
            cube = [0,cube[2],cube[6],cube[3],cube[4],cube[1],cube[5]]
            if plane[coordinate[0]][coordinate[1]] == 0:
                plane[coordinate[0]][coordinate[1]] = cube[1]
            else:
                cube[1] = plane[coordinate[0]][coordinate[1]]
                plane[coordinate[0]][coordinate[1]] = 0
            ans.append(cube[-1])
        else:
            continue
for i in range (0,len(ans)):
    print(ans[i])

하이고 힘들다 ...

문제는 이런 느낌

import math
N = int(input())
jud = False
t = int(math.log2(N+1)) #t개까지 할 수 있을듯?
for k in range (3, t+1): #k는 항의 갯수
    r = 2
    while r ** (k-1) <= N: 
        if N * (r - 1) % (r ** k - 1) == 0:
            a = N * (r - 1) // (r ** k - 1)
            ans = [a * (r**l) for l in range (0,k)]
            jud = True
            break
        else:
            r += 1
if jud == False:
    print(-1)
else:
    print(len(ans))
    print(*ans)

부등식을 통해서 수를 얼마나 잘 컨트롤 할 수 있을지 체크하는 것이 중요하겠다.

처음 공비의 상한을 () ** (1/k) 꼴로 만들어서 했었는데, 이러면 10000이상에서 문제가 해결이 되지 않는 경우가 생겼었다.

이를 해결하게 위해 while을 통해서 그 범위를 컨트롤 하는 것으로 변경하였더니 바로 문제가 풀렸다 :)

졸업식을 마치고 한국으로 들어왔습니다.

졸업식을 위해 약 일주일정도 후쿠오카에 들어가 있었는데, 2일차~3일차에 걸쳐서 몸 컨디션이 굉장히 좋지 않아 하루종일 약을 먹었던 기억이 크네요.

분명 좋아하는 가게에 초밥도 먹으러 가고, 저녁에는 사케바 가서 즐겁게 놀고 오려고 했는데 약때문에 많이 자중하게 된 것 같습니다.

이틀차 점심에 밖에서 1시간 반인가, 그렇게 돈까스집 들어가는걸 기다렸던게 크게 작용했던 것 같습니다. 

목이 아예 나가버려서, 열도 많이 나고 몸살기운도 많이 심했었네요.

이틀날 저녁에 주변에 있던 가게였던

https://tabelog.com/fukuoka/A4001/A400101/40004636/

타로우겐이라는 곳이었는데, 여기서 11,000엔 코스를 먹고왔습니다.

딴것보다 사케 가격이 굉장히 좋았습니다. 아라마사도 있었고, 히로키도 있었습니다.

아라마사는 S타입이 8500엔, R타입이 한 6500엔정도 했었던 것 같습니다. (10퍼 서비스료 포함)

히로키는 한홉에 1430엔이었던 것으로 기억합니다.

진짜 몸 상태만 좋았어도 아라마사 진탕 마시고 죽었을텐데 .... 아쉬움이 많이 남았습니다.

초밥 가게도 그랬고, 점심부터 달릴려고 했었는데 참 아쉬웠던 것이 많이 남았네요.

가족들 가이드 하는것도 굉장히 힘들었습니다 ㅋ.ㅋ

1. 맛이 있어야함

2. 그래도 많이 기다려서는 안됨

3. 한국사람들이 많지는 않은가?

이 순서대로 고려를 했습니다.

아무래도 저 혼자만 먹는게 아니다보니, 여러가지 요소를 생각하게 되더라고요.

첫날 저녁에는 모츠나베

둘쨋날 점심에는 효탄스시 (ㅋㅋ)

저녁에는 굶..지는 않고 주변에 있던 팬케이크 가게 가서 먹었습니다.

세번째날 점심에는 제 졸업식이 있었기에, 이치란 라멘에서 빠르게 먹었고

저녁에는 학교 주변에 있던 야키니쿠집에서 밥을 먹었습니다.

돌아가시는 날 아침에는 나카스카와바타 역 주변에 있던 호텔 조식을 먹었던 것으로 기억하네요.

분명 위 순서에서 한국 사람들이 많지는 않은가? 를 고려했었는데 부모님은 한국사람들이 많은 곳을 선호하시더라고요...

아무래도 일단 한국사람들이 많다 -> 한국 사람들 입맛에는 잘 맞을 확률이 높음 -> 그래도 먹을만 함

이런 느낌이었던 것 아닐까 싶네요.

저는 그렇게 가족들을 보내고, 그 다음날에 돌아오게 되었는데

역시 후쿠오카 하면 라멘 아닐까 싶어 라멘..을 먹으러 갔는데 츠케멘을 먹고 왔네요.

나카스카와바타 상점가 주변에 나카스 기린이라는 곳이 있는데, 가격대는 좀 있는데 맛있는 곳이예요.

저녁은 일본요리점에서 맛있게 잘 먹고 왔습니다. ㅎㅎ.

일본에서는 4월부터 새로운 학기, 삶이 시작되는데

저도 인생에 있어 큰 변화점을 가지게 될 날의 하루전에 이렇게 담담하게 써보네요.

좀만 힘내자 !