dukongmon

LG전자 AX SCHOOL 1기 지원 후기

duiiminish — Mon, 22 Jun 2026 14:37:41 +0900

SSAFY, SKALA 전형이 모두 끝난 후 최종결과를 기다리면서 LG전자 AX School을 알게되었다.

이번이 1기이긴 하지만 LG전자 주관이라는 점과 교육장소가 집에서 10분거리라는 엄청난 장점에 바로 자세히 알아봤다.

지원 동기

LG전자의 AX와 관련된 3가지 직무중 1가지를 선택할 수 있었고 이중 나는 'AI 엔지니어' 과정을 선택했다.

AI 엔지니어 과정 커리큘럼을 봤을 때 고객 데이터를 분석하고, 최종적으로 LLM·Agent·Docker 등을 활용해서 AI Agent 서비스를 구현하는 과정인 것 같았다.

나의 경우 대기업 부트캠프에 관심을 갖게 된 가장 큰 이유는 현업 데이터와 실제 비즈니스 문제를 기반으로 서비스 개발 프로젝트 경험을 쌓기 위함이었는데,

LG전자 AX School에서 진행하는 3가지 프로젝트가 이를 충족시킬 수 있을 것 같았다.

교육과정 외에 장점이라고 생각되었던 부분은 팀단위 일일미팅을 통해 교육과정이 느슨해지지 않게 유지해주는 점과 LG전자 HS본부 채용 가산점이었다!

전형과정

전형 과정은 서류전형, 인적성검사, 온라인면접으로 총 세 단계였다.

깨알이지만 LG전자 AX School 장점중 하나는 지원 후 전형 상세 일정을 바로 알려주셨다...

일반 채용도 그렇고 다른 교육과정도 상세 일정은 잘 안알려주기 때문에 항상 언제나오나 하고 기다렸는데

전형 일정과 각 전형별 결과 발표일도 함께 알려주는게 별거 아니지만 너무 좋았다!!! ㅎㅅㅎ

서류 전형

지원서 양식은 다른 교육과정에 비해 상대적으로 간단했다.

기본 인적사항과 함께 지원동기, 데이터분석/프로그래밍 역량, 디지털 역량 관련 자격증을 모두 100자 내외로 작성하면 됐었다.

채용 지원서 작성할 때마다 700자 1000자 작성하던 것과 비교하면 너무 분량이 작아서 마음이 한결 편했다.

디지털 역량과 자격증은 있는대로 작성했고, 지원동기는 LG전자 AX School을 통해 얻어가고 싶은 점 위주로 작성했다.

지원서를 접수하고, 생각해보니 이 교육과정은 LG careers로 지원한 것도 아니고 제출 확인 메일도 안와서 전형 진행 안내가 어떻게 되나 했는데 전형 결과 및 공지사항은 모두 문자로 왔다!

처음에 공지해준 날짜에 전형 결과와 함께 다음 전형 안내가 함께 온다.

인적성 검사

인적성 검사가 좀 걱정됐었다.

SKALA의 경우 홈페이지에 SKCT 전과정이 아니라 심층 검사만 진행한다고 공지되어있는데, LG전자 AX School은 별다른 공지가 없었다.

그러다 누군가 문의를 한건지 최소한의 요건만 평가하기 때문에 부담없이 응시해도 된다는 안내 문자가 왔다!

인적성 검사를 실제로 응시해보니 LG Way Fit은 아니었다.

프로그램을 따로 다운받지도 않았고, 그냥 메일로 온 검사 사이트에서 응시했다.

소요시간은 90분 정도 걸렸고, 시험은 일반 대기업 인적성검사 문제들과 인성검사 2종류로 총 세 종류로 구성되었었다.

문제 난이도는 왜 부담없이 응시해도 된다고 했는지 알 수 있었던 정도였다. (인적성 검사 준비해본 경험이 없어도 그냥 풀 수 있는 정도?)

근데 제한시간이 좀 당황스러웠다.

보통 인적성 검사는 큰 카테고리와 제한시간을 주는데 (ex. 언어 N문제 15분, 수리 N문제 15분)

이 검사는 카테고리도 여러가지고 제한시간도 상대적으로 짧아서 처음엔 연습문제인가? 하고 천천히 구경하다가 첫 카테고리 그냥 날렸다 ㅎ하핳ㅎ하

아무튼 대기업 인적성검사 공부를 시작한지 얼마 안됐기에... LG Way Fit 그대로였다면 꽤 힘들었을 것 같다...힛

온라인 면접

인적성 검사 전형까지 합격하고 마지막으로 온라인 면접을 안내받았다.

LG전자 AX School 전형 중에 SKALA 합격 결과를 받아서 온라인 면접은 응시하지 않기로 했다.

응시하지는 않았지만, 안내 문자를 보니 면접은 30분 정도 소요되고 다대다 면접인 것 같았다.

SKALA 4기 합격 수기

duiiminish — Fri, 19 Jun 2026 18:46:26 +0900

SKALA 야호 마떼루용

2026 상반기 AI 엔지니어 직무로 첫 취준을 해보며 느낀 점

2026년 상반기가 끝나고 그동안 지원한 AI 엔지니어 직무 채용 공고를 분석하며 기업들이 요구하는 역량에 대해 다시 생각해보게 되었다.

삼성리서치, CJ제일제당 BIO AI, 롯데이노베이트 등 여러 기업의 JD를 살펴보며 느낀 점은, 기업들은 AI 이론과 모델 구현 능력은 기본 역량으로 보고, '데이터 처리, 소프트웨어 개발, Cloud·MLOps, LLM·Agent 서비스 개발 역량, 비즈니스 문제 정의 및 해결 능력'을 중요하게 보는 것 같았다.

기본 서비스 개발 능력 + 인공지능 인재를 원하는 느낌...!

나의 경우 AI 석사 과정을 거치며 연구 및 모델 개발 경험은 있었지만, 실제 서비스 환경에서 요구되는 Cloud·MLOps·Backend·서비스 개발 경험과 산업 문제를 정의하여 서비스로 연결하는 경험은 상대적으로 부족하다고 판단했다.

또 그동안 진행했던 의료 AI 도메인 프로젝트들은 연구적으로는 의미가 있었지만, 채용 과정에서 직관적으로 실력을 보여줄 수 있는 서비스형 프로젝트나 산업 문제 해결 사례는 부족하다고 느껴졌다.

이러한 고민 끝에 나는 부족한 부분을 보완하기 위한 선택지로 SKALA를 선택하게 되었다.

SKALA를 선택한 이유

솔직히 SSAFY랑 SKALA를 둘다 지원했고, 어떤 과정을 선택할지 고민했다.

SSFAY 역시 AI 이론, 코딩 공부, 데이터 처리, 프로젝트 등 탄탄한 교육과정이고

반년동안 공부하고 반년동안 프로젝트를 한다는 점에서 충분한 학습과 프로젝트 경험을 모두 가져갈 수 있다는 점은 큰 장점이었다.

다만 내가 이번에 부트캠프를 하는 가장 큰 이유는 '현업 문제를 다루는 프로젝트 경험'을 쌓는 것이기 때문에 이를 위해 반년을 기다려야 한다는 점이 아쉬웠다.

이러한 점에서 SKALA는 내가 부족하다고 느낀 부분들을 집중적으로 보완할 수 있는 과정이었다.

특히 백엔드, 데이터분석, AIOps, Cloud(쿠버네티스, DevOps), SK 현업 문제를 다루는 AI 프로젝트를 배우고 경험할 수 있다는 점이 매우 매력적이었다.

또 프로젝트 전 과정에서는 현직자 멘토링이 함께하기 때문에 실무적으로 배울 점이 많을 것 같았다.

또 하나 크게 고려했던 부분은 '채용 연계'였다.

SKALA는 교육 과정 우수 수료자들에게 SK그룹 채용 연계 기회를 제공해주는데, 요즘 같이 어려운 채용 시장에서는 이런 채용 연계 기회가 중요하다는걸 지난 상반기에 정말 많이 느꼈다...

심지어 수료생 전원에게 SK AX 채용 연계 기회를 제공하고, 26년부터는 아예 SKALA 수료생을 대상으로만 채용을 진행한다니... 대박사건..bb

전형과정

전형 과정은 서류 접수, SKCT + AI 역량면접으로 크게 두 단계였다.

지원서 접수

이번 4기에서는 캠퍼스가 3개로 늘어난만큼 입과 희망 캠퍼스 1,2,3지망을 작성할 수 있었다.

하지만 나는 연고가 없는 광주, 울산에 5개월간 내려갈 자신이 없어서 1지망만 작성했었다...ㅎㅎ

지원서에서 특이했던 점은 경험 기술서 부분이 구체적이었다.

개발 언어, 개발 환경, 데이터베이스, AI/Data에 대한 활용 수준을 각각 최대 5개까지 기재해야했는데,

나는 인공지능 직무와 밀접하다고 생각되는 순으로 가능한 꽉꽉 채워넣었다.

자소서는 지원동기(800자 이내)와 기술 경험(1000자 이내) 총 두 문항으로 구성되어있었다.

지원동기는 SKALA가 교육과정이라는 점에서 SKALA를 통해 얻어가고 싶은 점과 내 목표 위주로 작성했고,

기술 경험은 AI 경험 관련 어려움 극복 경험 문항이라서 SK 인재상을 참고하며 상황설명, 구체적인 나의 역할, 느낀점 위주로 작성했다.

외에 github, 블로그, 노션, 드라이브 공유 링크 등 추가 자료를 제출할 수 있는 란이 있었는데 따로 제출하지 않았다.

(근데 오픈카톡에서 다른 사람들이 이 부분 화려하게 제출한걸 알고 좀 쫄렸음,,ㅎ)

SKCT + AI 역량면접

SKALA SKCT는 SK그룹 채용과 달리 온라인으로 심층 검사만 진행해서 그냥 마음 편히 봤다.

파워 I인 INTJ이지만 살짝 활발한 척만 조금 했달까 하핳ㅎㅎ

AI 역량면접이 좀 충격적이었다.

JOBDA 외에 AI 면접을 SKALA에서 처음 봤는데 그냥 사람이랑 면접보는 느낌이라 기술의 발전에 놀랐달까..

지원서 기반으로 질문이 나오지 않을까 해서 클로드랑 예상 질문 열심히 뽑아봤는데 별로 의미 없었던 것 같다.

오히려 JOBDA AI 면접 문항 기준으로 예전부터 면접스터디 해왔던게 도움이 되었다!

SKALA랑 별개로 예전부터 면접스터디를 했었는데 여러 경험기반 질문에 대해 고민하고 내 경험을 계속 정리해왔던게 많은 도움이 되었다.

누군가 이 글을 본다면.. 자소서랑 본인 프로젝트 및 경험 정리를 하시는걸 추천드립니당 b

결과

전형을 다 끝내고, 어디서 솟아나는지 모를 근자감이 들었다. ㅋㅎㅋㅎㅎ

문제는 지난 상반기 채용 때도 항상 근자감'만'은 있었는데 다 떨어져서 너무 슬펐지만 SKALA는 다행히 붙어서 간만에 기분이 좋았다 히히

5개월간 매일 왕복 3시간 통학하며 저 커리큘럼을 내 것으로 만들려면 부단히 노력해야겠지만,,,

이번에 정리했던 부족한 역량들을 보완하고 채용 연계까지 잡을 수 있도록 최선을 다해볼 생각이다. 아쟈쟈

[그래프] 깊이/너비 우선 탐색(DFS/BFS)문제 6

duiiminish — Fri, 12 Jun 2026 21:28:29 +0900

문제 설명
n개의 섬 사이에 다리를 건설하는 비용(costs)이 주어질 때, 최소의 비용으로 모든 섬이 서로 통행 가능하도록 만들 때 필요한 최소 비용을 return 하도록 solution을 완성하세요.
다리를 여러 번 건너더라도, 도달할 수만 있으면 통행 가능하다고 봅니다. 예를 들어 A 섬과 B 섬 사이에 다리가 있고, B 섬과 C 섬 사이에 다리가 있으면 A 섬과 C 섬은 서로 통행 가능합니다.

제한사항

섬의 개수 n은 1 이상 100 이하입니다.
costs의 길이는 ((n-1) * n) / 2이하입니다.
임의의 i에 대해, costs[i][0] 와 costs[i] [1]에는 다리가 연결되는 두 섬의 번호가 들어있고,
costs[i] [2]에는 이 두 섬을 연결하는 다리를 건설할 때 드는 비용입니다.
같은 연결은 두 번 주어지지 않습니다. 또한 순서가 바뀌더라도 같은 연결로 봅니다.
즉 0과 1 사이를 연결하는 비용이 주어졌을 때, 1과 0의 비용이 주어지지 않습니다.
모든 섬 사이의 다리 건설 비용이 주어지지 않습니다. 이 경우, 두 섬 사이의 건설이 불가능한 것으로 봅니다.
연결할 수 없는 섬은 주어지지 않습니다.

입출력 예

n	costs	return
4	[[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]]	4

오답노트

[처음에 접근한 방식과 코드]

처음에는 모든 섬이 연결만되면 된다는거니까 각 노드에 연결된 edge중 가중치가 가장 작은걸 선택하면 되는거 아닌가?라고 생각함
테스트 케이스는 통과됐지만, 채점에서 막힘

def solution(n, costs):
    answer = 0

    #각 노드에서 연결된 edge 중 가장 가중치가 적은거 고르면 되는거 아닌가?
    cost_graph = {}
    graph =[[] for _ in range(n)]
    low_cost = [0 for _ in range(n)]

    for x,y,z in costs :
        cost_graph[(min(x,y),max(x,y))] = z
        graph[x].append(y)
        graph[y].append(x)

    for i in range(n) :
        min_c = float('inf')
        for j in graph[i] :
            cost = cost_graph[(min(i,j),max(i,j))]
            if min_c > cost :
                print("cost : ", cost)
                min_c = cost
                low_cost[i] = (min(i,j),max(i,j))

    low_cost=set(low_cost)
    for i in low_cost :
        answer += cost_graph[i]

    return answer


n = 4
costs = [[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]]
print(solution(n,costs))

이전 코드의 문제점 → 전체 최소 연결이 보장되지 않음

예를 들어 이런 모양의 그래프가 있다고 할 때, 각 노드에서 가중치가 가장 작은 edge를 고르면 0,1,2 노드끼리 사이클이 생김
하지만 0-2 노드 사이에 간선이 없어도 전체 그래프 연결이 되기 때문에 이는 최소 연결이 아님
이런 모든 노드가 연결되고 사이클이 없는 그래프를 신장 트리(Spanning Tree)라고 하고
가중치가 있다고 했을 때, 모든 노드를 연결하며 사이클이 없는데 총 비용이 최소인 그래프를 최소 신장 트리(Minimum Spanning Tree) 라고 함
MST 특징은 edge가 반드시 N-1개여야 하고
MST를 만들기 위해 크루스칼 알고리즘과 Union-Find를 많이 씀

def solution(n, costs):
    answer = 0

    # 처음에는 모든 섬이 자기 자신 그룹
    parent = [i for i in range(n)]

    # x섬이 현재 어느 그룹에 속해있나? 확인
    def find(x):
        if parent[x] != x:
            parent[x] = find(parent[x])
        return parent[x]

    # 두 그룹을 합치는 함수
    # a와 b를 연결해도 괜찮은가? 검사
    def union(a, b):
        root_a = find(a)
        root_b = find(b)

        if root_a == root_b:
            return False  # 이미 같은 그룹 → 사이클 발생

        parent[root_b] = root_a
        return True

    # 비용 기준으로 정렬해서 가장 비용이 싼 다리부터 보겠다
    # 근데 sort 함수는 기본적으로 각 리스트의 앞에서부터 비교하며 정렬함
    # key=lambda x: x[2] x는 costs 리스트의 각 원소를 의미 ex.costs[0]
    # 근데 우리는 비용 기준이니까 costs[i][2]를 봐야하니까 x[2]
    costs.sort(key=lambda x: x[2]) # 즉, costs 리스트의 2번 원소 기준으로 정렬해
    print(costs)

    edge_count = 0

    for a, b, cost in costs:
        if union(a, b):
            answer += cost
            print(parent)
            print(answer)
            edge_count += 1

            if edge_count == n - 1:
                break

    return answer


n = 4
costs = [[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]]
print(solution(n,costs))

시행착오 및 배운점

#1 MST(Minimum Spanning Tree) : 최소 신장 트리

MST : 가중치가 있다고 했을 때, 모든 노드를 연결하며 사이클이 없는데 총 비용이 최소인 그래프

[용어]

노드(Node) = 정점(섬) : 그래프에서 동그라미에 해당되는 부분
간선(Edge) = 거리(비용) : 그래프에서 선에 해당되는 부분
오른쪽 예시에서는 4개의 노드와 5개의 엣지로 구성됨

MST 특징

MST를 만들기 위해 '크루스칼 알고리즘'과 'Union-Find'를 많이 씀
사용되는 Edge의 개수는 반드시 " Node 개수 - 1 "
사이클이 생기면 절대 X

1) Union-Find 알고리즘 (합집합 찾기)

대표적인 그래프 알고리즘
'합집합 찾기' 또는 '서로소 집합(Disjoint-Set) 알고리즘'이라고 불림
여러개의 노드가 존재할 때, 2개의 노드를 선택해서 이 두 노드가 현재 서로 같은 그래프에 속하는지 판별하는 알고리즘

2) 크루스칼 알고리즘(Kruskal Algorithm)

가장 적은 비용으로 모든 노드를 연결하기 위해 사용하는 알고리즘
그래프를 입력받아서 MST(트리)를 만드는 알고리즘
모든 노드를 최대한 적은 비용으로 연결시키면 되기 때문에 아래 순서로 알고리즘 작동
- 모든 Edge 정보(비용)를 기준으로 오름차순으로 정렬
- 이후 비용이 적은 Edge부터 차근차근 그래프에 포함시키기
- 단, 사이클이 발생되지 않아야 함 (사이클 발생 = 트리 X)
- 따라서 사이클이 형성되는 경우 해당 Edge는 그래프에 포함시키지 않음

MST와 Union-Find, Kruskal 알고리즘

[그래프 용어]노드(Node) = 정점 : 그래프에서 동그라미에 해당되는 부분간선(Edge) = 거리(가중치) : 그래프에서 선에 해당되는 부분오른쪽 예시에서는 4개의 노드와 5개의 엣지로 구성됨 1) Union-Find

kongs-code.tistory.com

#2 lambda 함수

익명 함수라고도 불리며, 간단한 한줄짜리 함수를 정의할 때 사용됨
복잡한 로직이나 여러줄의 코드 처리에는 적합하지 않음
함수이지만 def 키워드를 사용하지 않고 lambda 키워드로 함수 정의
주로 filter(), map(), sorted() 등의 함수와 함께 사용되며 함수 인자로 전달되는 경우가 많음

lambda arguments : expression

lambda : 람다 함수 정의 키워드
arguments : 람다 함수에 전달되는 인자들. 쉼표로 구분해서 여러 인자 전달 가능
expression : 표현식. 이 표현식의 결과가 람다 함수의 return 값이 됨

예를 들어 더하기 함수를 람다 함수로 구현하면 아래와 같음

add = lambda a, b: a + b
print(add(10,20))

MST와 Union-Find, Kruskal 알고리즘

duiiminish — Fri, 12 Jun 2026 21:09:38 +0900

[그래프 용어]

노드(Node) = 정점 : 그래프에서 동그라미에 해당되는 부분
간선(Edge) = 거리(가중치) : 그래프에서 선에 해당되는 부분
오른쪽 예시에서는 4개의 노드와 5개의 엣지로 구성됨

1) Union-Find 알고리즘 (합집합 찾기)

대표적인 그래프 알고리즘
'합집합 찾기' 또는 '서로소 집합(Disjoint-Set) 알고리즘'이라고 불림
여러개의 노드가 존재할 때, 2개의 노드를 선택해서 이 두 노드가 현재 서로 같은 그래프에 속하는지 판별하는 알고리즘

위와 같이 아직 연결되지 않은 8개의 노드가 있다고 하자
현재는 각 노드가 자기 자신만을 원소로 갖기 때문에 8개의 집합이 생김
이를 테이블로 만들면 아래와 같이 만들 수 있음 (= 모든 값이 자기 자신을 가리키도록 테이블 생성)

테이블 첫 행은 각 노드의 번호
두번째 행은 부모 노드(집합) 번호

# 부모 테이블 초기화
parent = [i for i in range(n)]

이때 노드 0과 노드 1이 연결되었다고 하자
이러한 연결성에 대해 프로그래밍 언어로 어떻게 표현할 수 있나?

⇒ 확인하는 2개의 노드 중 더 작은 번호 노드를 부모 노드로 설정하자(=합집합을 만들자)

따라서 parent_table[1] = 0이 됨
이렇게 부모 노드(집합)를 합칠 때는 일반적으로 더 작은 값 기준으로 합치며, 이를 Union(합침)이라고 함

동일한 방식으로 노드 0과 노드 2가 연결되면

parent_table은 parent_table[2] = 0 으로 바뀜

동일한 방식으로 노드 2와 노드 4가 연결되면

parent_table은 parent_table[4] = 2 로 바뀜
그럼 이때 노드 0,1,2는 부모 노드가 0을 동일하게 가리키고 있는데,
노드 4는 그래프가 연결되었는지 또는 동일한 집합인지 어떻게 알 수 있나?

⇒ Find() 라는 재귀 함수를 활용해서 최종 부모 노드를 찾아가게 하자!

노드 4는 노드 2를 가리키고 있고, 노드 2는 노드 0을 가리키고 있다.
즉, 노드 4도 노드 0을 가리키도록 함수가 find 함수

코드 상에서 union(2,4)는 위와 같이 바로 Parent[4]=0이 된다

parent_table[4] → parent_table[2] → parent_table[0] = 0
다시말해, Find 알고리즘은 확인하려는 노드의 최종 부모 노드를 찾는 것

이와 같이 연결되는 노드들을 Find 알고리즘을 통해 부모 노드로 Union 시키는게 "Union-Find 알고리즘"

node = 8
edge = [(0, 1), (0, 2), (2, 4)]

# 부모 테이블 초기화
parent = [i for i in range(node)]
print("default table :",parent)

# 루트(부모) 노드 찾기 재귀함수
def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])
    return parent[x]

# 두 집합 합치기
def union(a, b):
    root_a = find(a)
    root_b = find(b)

    # 작은 루트 번호 기준으로 부모 union
    if root_a < root_b:
        parent[root_b] = root_a
    else:
        parent[root_a] = root_b

# edge 기준 노드 union
for a,b in edge :
    union(a, b)
    print(f"Union node{a}, node{b} :",parent)

default table : [0, 1, 2, 3, 4, 5, 6, 7]
Union node0, node1 : [0, 0, 2, 3, 4, 5, 6, 7]
Union node0, node2 : [0, 0, 0, 3, 4, 5, 6, 7]
Union node2, node4 : [0, 0, 0, 3, 0, 5, 6, 7]

+) 어떤 연결된 edge들이 있는 그래프를 기준으로, Union이 진행된 Parent table이 있다고 할 때,
어떤 두 노드가 같은 그래프에 속했는지 확인하려면 find 함수로 간단히 찾으면 된다

if find(a) == find(b):

2) 크루스칼 알고리즘(Kruskal Algorithm)

가장 적은 비용으로 모든 노드를 연결하기 위해 사용하는 알고리즘
MST를 구하는 대표 알고리즘
모든 노드를 최대한 적은 비용으로 '연결만' 시키면 되기 때문에 알고리즘은 아래와 같음
- 모든 Edge 정보(비용)를 기준으로 오름차순으로 정렬
- 이후 비용이 적은 Edge부터 차근차근 그래프에 포함시키기
- 단, 사이클이 발생되지 않아야 함 (사이클 발생 = 트리 X)
  따라서 사이클이 형성되지 않는 경우에만 해당 Edge를 그래프에 포함시킴
- Edge 개수는 항상 Node 개수 - 1

크루스칼 알고리즘의 핵심 : Edge를 비용이 작은 순서대로 그래프에 포함시키자

예시 1)

1. 값이 10인 Edge가 가장 비용 작음 → Node 0과 Node 1 연결

2. 값이 20인 Edge가 가장 비용 작음 → Node 1과 Node 2 연결

3. 값이 30인 Edge가 가장 비용 작음 → Node 0과 Node 2 연결 → 사이클 발생 → 연결 X

4. 값이 50인 Edge가 가장 비용 작음 → Node 2과 Node 3 연결

5. 모든 Node 연결 완료. 연결된 Edge 개수는 3개

예시 2)

위와 같은 그래프가 있다고 할 때 크루스칼 알고리즘 구현

사이클 테이블(= 자기 자신을 가리키는 parent table) 생성
사이클이 발생하는지 여부는 이 테이블에 대해 'Union-Find 알고리즘' 적용
연결된 node들과 edge 값으로 구성된 2차원 배열 생성 (= edges)

n = 8 # 노드 개수
parent = [i for i in range(n)] # 사이클 테이블

# [노드,노드,비용]
edges = [[0, 1, 10],[0, 2, 110],[0, 3, 100],[0, 6, 20],[1, 6, 30],[2, 6, 40],
    [2, 4, 60],[3, 5, 90],[3, 4, 70],[4, 7, 50],[5, 6, 120],[5, 7, 80]]

모든 Edge value(비용)를 기준으로 오름차순 정렬
즉, Edge 값이 작은 것부터 순서대로 2차원 배열 정렬

edges.sort(key=lambda x: x[2]) # 즉, edges 리스트의 2번 원소 기준으로 정렬

이후 "Edge 개수 = Node 개수 -1"이 될 때 까지 비용이 적은 Edge부터 차근차근 그래프에 포함시키기
단, 사이클이 발생되지 않아야 함 (사이클 발생 = 트리 X)

def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])
    return parent[x]

# 사이클 검사 후 두 그룹을 합치는 함수
def union(a, b):
    root_a = find(a)
    root_b = find(b)

    if root_a == root_b:
        return False  # 이미 같은 그룹 → 사이클 발생

    # 작은 루트 번호 기준으로 부모 union
    if root_a < root_b:
        parent[root_b] = root_a
    else:
        parent[root_a] = root_b

    return True

# Edge 개수 = Node 개수 -1이 되면 알고리즘 종료
edge_count = 0
for a, b, cost in edges:
    if union(a, b):
        # print(parent) # parent table 변화
        edge_count += 1
        graph.append((a,b))

        if edge_count == n - 1:
            break

위 find(), union(), for문으로 edge 개수가 node 개수 -1이 될 때까지 크루스칼 알고리즘 수행

Edge 개수 = 1

Edge 개수 = 2

사이클 발생
find(1)=0, find(6)=0 → 이미 같은 집합
그래프 추가 X

Edge 개수 = 3

Edge 개수 = 4

Edge 개수 = 5

Edge 개수 = 6

Edge 개수 = 7 = Node 개수 -1
그래프 edge 추가 종료
나머지 edge는 무시

최종 그래프와 parent table
최소 비용 신장 트리 완성

이와 같이 최소 비용으로 모든 노드를 연결하는게 "크루스칼 알고리즘"

n = 8 # 노드 개수
parent = [i for i in range(n)] # 사이클 테이블
edges = [[0, 1, 10], [0, 2, 110], [0, 3, 100], [0, 6, 20], [1, 6, 30], [2, 6, 40],
         [2, 4, 60], [3, 5, 90], [3, 4, 70], [4, 7, 50], [5, 6, 120], [5, 7, 80]]
graph=[] # 크루스칼 알고리즘으로 만든 최종 그래프

# x 루트(부모) 노드 찾기 재귀함수
def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])
    return parent[x]

# 사이클 검사 후 두 그룹을 합치는 함수
def union(a, b):
    root_a = find(a)
    root_b = find(b)

    if root_a == root_b:
        return False  # 이미 같은 그룹 → 사이클 발생

    # 작은 루트 번호 기준으로 부모 union
    if root_a < root_b:
        parent[root_b] = root_a
    else:
        parent[root_a] = root_b

    return True

# 비용 기준으로 정렬해서 가장 비용이 싼 것 부터 보겠다
edges.sort(key=lambda x: x[2]) # 즉, edges 리스트의 2번 원소 기준으로 정렬

# Edge 개수 = Node 개수 -1이 되면 알고리즘 종료
edge_count = 0
for a, b, cost in edges:
    if union(a, b):
        # print(parent) # parent table 변화
        edge_count += 1
        graph.append((a,b))

        if edge_count == n - 1:
            break

print("최종 그래프 :",graph)

3) MST(Minimum Spanning Tree) : 최소 신장 트리

MST : 가중치가 있는 그래프가 있을 때 모든 노드를 연결하며 사이클이 없고 총 비용이 최소인 트리를 찾는 문제

MST를 구하기 위해 '크루스칼 알고리즘'과 'Union-Find'를 많이 씀
- 외에도 프림(Prim) 알고리즘 등이 있음
사용되는 Edge의 개수는 반드시 " Node 개수 - 1 "
Edge들의 가중치 합은 최소여야 한다.
사이클이 포함되면 안됨 (사이클이 있으면 그래프는 가능하나 트리는 안됨)
대표 문제 : 여러 개의 도시가 있을 때, 각 도시를 도로를 이용해 연결하고자 함. 이때 비용을 최소로 해서 모든 도시를 연결해라

[그래프] 깊이/너비 우선 탐색(DFS/BFS)문제 5

duiiminish — Tue, 9 Jun 2026 02:17:57 +0900

문제 설명
n명의 권투선수가 권투 대회에 참여했고 각각 1번부터 n번까지 번호를 받았습니다.
권투 경기는 1대1 방식으로 진행이 되고, 만약 A 선수가 B 선수보다 실력이 좋다면 A 선수는 B 선수를 항상 이깁니다.
심판은 주어진 경기 결과를 가지고 선수들의 순위를 매기려 합니다. 하지만 몇몇 경기 결과를 분실하여 정확하게 순위를 매길 수 없습니다.
선수의 수 n, 경기 결과를 담은 2차원 배열 results가 매개변수로 주어질 때 정확하게 순위를 매길 수 있는 선수의 수를 return 하도록 solution 함수를 작성해주세요.

제한사항

선수의 수는 1명 이상 100명 이하입니다.
경기 결과는 1개 이상 4,500개 이하입니다.
results 배열 각 행 [A, B]는 A 선수가 B 선수를 이겼다는 의미입니다.
모든 경기 결과에는 모순이 없습니다.

입출력 예

n	results	return
5	[[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]]	2

오답노트

[처음에 접근한 방식과 코드]

처음에는 각 선수보다 못하는 선수가 몇명인지 리스트업하고, 못하는 선수 명수가 중복되기 전까지를 세는 문제라고 인식
DFS로 어떤 선수가 이길 수 있는 사람 수 기준으로만 코드 작성
아래 코드로 실행하니 테스트 케이스만 통과하고, 채점에서는 통과 못함

def solution(n, results):
    answer = 0

    graph = [[] for i in range(n+1)]
    for w,l in results :
        graph[w].append(l)
    print(graph)

    def dfs(v) :
        print(v,end='')
        visited[v] = True
        count = 1
        for i in graph[v] :
            if not visited[i] :
                count += dfs(i)
        return count

    stronger = [0 for i in range(n + 1)]
    stronger[0] = -1
    for i in range(n) :
        # print(i,end='')
        visited = [False] * (n + 1)
        stronger[i+1] = dfs(i+1) - 1
        print("stronger",(i+1),stronger[i+1])

    # 가장 숫자가 작은 사람이 꼴찌 순위.
    # 숫자가 중복되지 않을 때까지
    stronger.sort()
    if len(stronger) == len(set(stronger)):
        answer = n
    for i in range(n-1) :
        if stronger[i]==stronger[i+1] :
            answer = stronger[i]
            break

    return answer

n = 5 # 권투선수 인원
results = [[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]]
print(solution(n,results))

이전 코드의 문제점 → 정확한 순위를 잘못 정의함
정확한 순위란 어떤 선수 i가 있을 때, " i 보다 강한 사람 수 + i 보다 약한 사람 수 = n - 1 "이 성립되는 것

[고친 코드]

def solution(n, results):
    answer = 0

    # 정확한 순위 = i보다 강한 사람 수 + i보다 약한 사람 수 = n - 1
    win_graph = [[] for i in range(n+1)] # 어떤 선수가 이길 수 있는 사람 명단
    lose_graph = [[] for i in range(n + 1)]  # 어떤 선수가 항상 지는 사람 명단

    for w,l in results :
        win_graph[w].append(l)
        lose_graph[l].append(w)

    def dfs(v,graph) :
        # print(v,end='')
        visited[v] = True
        count = 1
        for i in graph[v] :
            if not visited[i] :
                count += dfs(i,graph)
        return count

    for i in range(n) :
        # print(i,end='')
        # 정확한 순위 = i보다 강한 사람 수 + i보다 약한 사람 수 = n - 1
        visited = [False] * (n + 1)
        win = dfs(i+1,win_graph) -1
        
        visited = [False] * (n + 1)
        lose = dfs(i+1,lose_graph) -1
        
        if (win + lose) == n - 1 :
            answer += 1

    return answer

n = 5 # 권투선수 인원
results = [[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]]
print(solution(n,results))

GPT 추천 답안

def solution(n, results):
    answer = 0

    win_graph = [[] for _ in range(n + 1)]
    lose_graph = [[] for _ in range(n + 1)]

    for winner, loser in results:
        win_graph[winner].append(loser)
        lose_graph[loser].append(winner)

    def dfs(graph, start):
        visited = [False] * (n + 1)
        stack = [start]
        count = 0

        while stack:
            now = stack.pop()

            for next_player in graph[now]:
                if not visited[next_player]:
                    visited[next_player] = True
                    count += 1
                    stack.append(next_player)

        return count

    for player in range(1, n + 1):
        win_count = dfs(win_graph, player)    # 내가 이길 수 있는 사람 수
        lose_count = dfs(lose_graph, player)  # 나를 이길 수 있는 사람 수

        if win_count + lose_count == n - 1:
            answer += 1

    return answer

나는 재귀 DFS로 구현했는데 GPT는 stack을 쓴 반복 DFS로 구현
GPT가 모범 답안으로 반복 DFS로 쓴 이유는 보통 코테에서 더 안전하기 때문
재귀 DFS는 코드는 직관적이지만 재귀 깊이 제한에 걸릴 수 있음.
파이썬은 재귀가 깊어지면 RecursionError가 날 수 있어서, 노드 수가 큰 문제에서는 반복 DFS가 더 안정적.
- 노드 수 작고 구조 이해가 중요함 → 재귀 DFS 추천
- 노드 수 크거나 실전 안정성 중요함 → 반복 DFS 추천

시행착오 및 배운점

#1 DFS에서 방문한 노드 개수를 셀 때

일반적으로 아래와 같은 구조를 많이 사용

def dfs(v):
    visited[v] = True
    count = 1

    for i in graph[v]:
        if not visited[i]:
            count += dfs(i)

    return count
    

visited 리스트 정의
graph 정의
result = dfs(1)

#2 리스트 정렬

처음에 접근한 방식에서는 리스트 내 원소 정렬이 필요했었음

1. 오름차순 정렬

sample = [3, 1, 4, 2, 5]
 
sample.sort() # 리스트를 오름차순으로 정렬
print(sample) # [1, 2, 3, 4, 5]

2. 내림차순 정렬

sample = [3, 1, 4, 2, 5]
 
sample.sort(reverse=True) # 리스트를 내림차순으로 정렬
print(sample) # [5, 4, 3, 2, 1]

#3 코테 문제에 있는 변수 범위는 어떻게 활용하는걸까?

코테 문제에는 항상 제한사항을 줌
이번 문제로 생각해보면, n과 results의 범위 같은 것들
근데 실제로 구현한 코드를 보면 이 범위를 직접적으로 명시하진 않음. 괜찮은걸까?

→ 제한사항은 대체로 시간복잡도 판단용 (문제를 보고 어떻게 생각할지는 구체적인건 다음에 더 알아보는걸류..)

오늘 푼 문제 기준으로 시간복잡도 구해보면

1. DFS가 한 번에 얼마나 보나? 생각하기

[ 조건 : 선수 수 n ≤ 100, 경기 결과 ≤ 4500 ]

DFS 최악의 경우 = 모든 선수 방문 + 모든 경기 결과 확인
= 100명 + 4500 경기

DFS 1번 ≈ 4600번

2. DFS를 몇번 돌리나?

    for i in range(n) :
        # print(i,end='')
        # 정확한 순위 = i보다 강한 사람 수 + i보다 약한 사람 수 = n - 1
        visited = [False] * (n + 1)
        win = dfs(i+1,win_graph) -1

        visited = [False] * (n + 1)
        lose = dfs(i+1,lose_graph) -1

        if (win + lose) == n - 1 :
            answer += 1

for i in range(n): 로 DFS를 돌리고 있으니까 100번 반복.
그리고 win, lose로 한 사람당 2번씩 DFS를 돌림.

3. 앞에 구한걸 다 곱하면

100명 x DFS 2번씩 x 4600 = 920,000

약 92만

4. 괜찮은건가?

코테에서는 보통 1초 ≈ 1억 번 연산 정도로 대략 계산.

100만 → 매우 여유
1000만 → 보통 가능
1억 → 경계
10억 → 위험

따라서 92만이면 여유여유

정리하면

DFS 1번
→ O(V+E)

100명마다 DFS 2번
→ O(2N(V+E))

상수 제거
→ O(N(V+E))

(V = Vertex = 정점(노드) 개수, E = Edge = 간선 개수)

Queue & BFS

duiiminish — Mon, 8 Jun 2026 05:35:48 +0900

그래프 탐색 대표 알고리즘 DFS / BFS

탐색(Search)란 많은 양의 데이터 중에서 원하는 데이터를 찾는 과정
코테에서 매우 자주 등장하는 유형

Queue

입구와 출구가 모두 뚫려있는 터널과 같은 형태
FIFO(First In First Out) 구조 : 먼저 들어온 데이터가 먼저 나가는 선입선출 형식의 자료구조

컨베이어 벨트처럼 들어온대로 나가는 구조!

EX ) 삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제()

⇒ 5 2 3 7 1 4

List 자료형을 이용해 기능적으로는 큐를 구현할 수 있음
But, List는 시간 복잡도가 더 높아서 비효율적으로 동작할 수 있음
- 만약 pop()으로 원소를 꺼내면 그 후에 나머지 원소들의 위치를 조정해줘야 하기 때문에 O(k)만큼의 시간복잡도가 요구됨
deque는 스택과 큐 라이브러리의 장점을 합쳐놓은 자료구조

from collections import deque
# collections 모듈에서 deque 함수만 쓰겠다.

# queue 구현을 위해 deque 라이브러리 활용
queue = deque()

# 삽입(5)-삽입(2)-삽입(3)-삽입(7)-삭제()-삽입(1)-삽입(4)-삭제()
queue.append(5)
queue.append(2)
queue.append(3)
queue.append(7)
queue.popleft()
queue.append(1)
queue.append(4)
queue.popleft()

# 넣은 순서대로 queue list 출력 = 출구에 가까운 순
print(queue)
# 데크 없이 리스트 형태만 출력하고 싶다면
print(list(queue))

# 나중에 들어온 원소부터 출력
queue.reverse()
print(queue)

deque([3, 7, 1, 4])
[3, 7, 1, 4]
deque([4, 1, 7, 3])

큐의 append()와 popleft()의 시간복잡도는 O(1). 상수시간

BFS(Breadth-First Search) : 깊이우선탐색

BFS : 너비 우선 탐색이라고도 부르며, 그래프에서 가까운 노드부터 우선적으로 탐색하는 알고리즘

BFS 특징

큐 자료구조를 이용함
루트 노드나 시작 정점에서 출발해 가장 가까운 인접 노드를 먼저 모두 방문한 뒤, 넓게 퍼져나가며 탐색하는 그래프/트리 탐색 알고리즘
DFS와의 가장 큰 차이로, 여러 갈래 중 무한한 길이를 가지는 경로가 존재하고 탐색 목표가 다른 경로에 존재하는 경우 BFS는 모든 경로를 동시에 진행하기 때문에 탐색이 가능하다는 특징이 있음
한 갈림길에서 연결되는 모든 길을 한번씩 탐색하기 때문에 가중치가 없는 그래프에서는 시작점에서 끝점까지의 최단경로를 알아낼 수 있음

from collections import deque

def bfs(graph, start, visited) :
    queue = deque([start])
    visited[start] = True
    while queue :
        v = queue.popleft()
        print(v, end=' ')
        for i in graph[v] :
            if not visited[i] :
                # print(f"\n방문하지 않은 {i} 추가")
                queue.append(i)
                visited[i] = True

graph=[
    [],
    [2,3,8],
    [1,7],
    [1,4,5],
    [3,5],
    [3,4],
    [7],
    [2,6,8],
    [1,7]
]

visited = [False]*9
# print(visited)

bfs(graph,1,visited)

1 2 3 8 7 4 5 6

재귀 함수(Recursive Function)

자기 자신을 다시 호출하는 함수를 의미DFS, BFS에서 많이 사용함무한히 재귀 함수를 반복하면 어느정도 출력하다 최대 재귀 깊이 초과 메시지 출력됨RecursionError: maximum recursion depth exceeded while call

kongs-code.tistory.com

참고 : 동빈나 DFS & BFS

Stack & DFS

duiiminish — Mon, 8 Jun 2026 05:17:13 +0900

그래프 탐색 대표 알고리즘 DFS / BFS

탐색(Search)란 많은 양의 데이터 중에서 원하는 데이터를 찾는 과정
코테에서 매우 자주 등장하는 유형

Stack

리스트의 한쪽 끝에서 수행되는 선형 리스트의 한가지 형태
입구와 출구가 동일한 형태
LIFO(Last In First Out) 구조 : 선입후출 형태로 스택에 마지막으로 입력된 자료가 제일 먼저 삭제되는 구조

깊은 상자라고 생각했을 때 차곡차곡 넣는데, 마지막에 넣은걸 먼저 꺼낼 수 있는 구조!

EX ) 삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제()

⇒ 5 2 3 7 1 4

stack = []

# 삽입(5)-삽입(2)-삽입(3)-삽입(7)-삭제()-삽입(1)-삽입(4)-삭제()
stack.append(5)
stack.append(2)
stack.append(3)
stack.append(7)
stack.pop()
stack.append(1)
stack.append(4)
stack.pop()

# 넣은 순서대로 stack list 출력
print(stack)
# 출구에 가까운 순으로 stack list 출력
print(stack[::-1])

[5, 2, 3, 1]
[1, 3, 2, 5]

스택의 append()와 pop()의 시간복잡도는 O(1). 상수시간

DFS(Depth-First Search) : 깊이우선탐색

그래프 탐색 : 하나의 정점에서 시작해서 차례대로 모든 정점들을 한번씩 방문하는 것.

DFS : 루트 노드 또는 다른 임의의 노드에서 시작해서 다음 분기(branch)로 넘어가기 전에 해당 분기를 모두 탐색하는 방법.
즉, 넓게(wide) 탐색하기 전에 깊게(deep) 탐색하는 것.

모든 노드를 방문하고자 하는 경우 이 알고리즘을 선택하며, BFS(너비우선탐색)보다 좀 더 간단하지만 검색 속도는 더 느리다.

DFS 특징

자기 자신을 호출하는 순환 알고리즘의 형태를 가지고 있음
전위 순회(Pre-Order Traversals)를 포함한 다른 형태의 트리 순회는 모두 DFS의 한 종류.
중요한 특징은 그래프 탐색의 경우 무한 루프에 빠질 수 있기 때문에 어떤 노드를 방문했었는지 여부를 반드시 검사해야 함.
또 데이터를 찾을 때는 항상 앞으로 방문할 노드와 이미 방문한 노드를 기준으로 데이터를 탐색해야함.
DFS는 스택/큐를 활용할 수도 있고, 재귀함수를 통해 구현할 수도 있음

def dfs(graph, v, visited) :
    visited[v] = True
    print(v, end=' ')
    for i in graph[v] :
        if not visited[i] :
            dfs(graph, i, visited)

# 스택 호출 인덱스를 고려해서 0번째는 빈 리스트로 두기
# 호출 인덱스 번호와 연결된 노드들로 구성된 리스트 만들기
graph=[
    [],
    [2,3,8],
    [1,7],
    [1,4,5],
    [3,5],
    [3,4],
    [7],
    [2,6,8],
    [1,7]
]

visited = [False]*9
# print(visited)

dfs(graph,1,visited)

1 2 7 6 8 3 4 5

재귀 함수(Recursive Function)

kongs-code.tistory.com

참고 : 동빈나 DFS & BFS

재귀 함수(Recursive Function)

duiiminish — Mon, 8 Jun 2026 05:14:28 +0900

자기 자신을 다시 호출하는 함수를 의미
DFS, BFS에서 많이 사용함
무한히 재귀 함수를 반복하면 어느정도 출력하다 최대 재귀 깊이 초과 메시지 출력됨
- RecursionError: maximum recursion depth exceeded while calling a Python object
- 더보기
  추가 설명
  실제로 컴퓨터 시스템 상에서 함수가 재귀적으로 호출되면 컴퓨터 시스템의 스택 프레임에 함수가 반복적으로 쌓여서
  가장 마지막에 호출된 함수가 처리가 된 이후에 그 함수를 불렀던 함수까지 처리되는 방식임
  실제로는 스택과 같은 형태로 동작한다고 이해할 수 있음
  즉, 일종의 스택 자료 구조 안에 함수에 대한 정보가 차례대로 담겨서 컴퓨터 메모리에 올라가게 된다고 이해할 수 있음
  당연히 컴퓨터의 메모리는 한정된 크기만큼의 자원을 가지고 있기 때문에 그냥 무작정 함수가 종료되지 않고 계속해서 쌓아 올려서 재귀적으로 호출만 하게 되면 빠르게 메모리가 가득 차서 문제가 발생할 수 있어 이와 같은 재귀 깊이 제한을 걸어 둘 수가 있는 것
- 만약 제한 없이 재귀 함수를 호출하고자 한다면 재귀 제한을 느슨하게 하거나 스택 객체를 따로 만들어서 이용하기도 함.
의도적으로 무한루프를 이용하는게 아니라면 재귀 함수 문제풀이에서는 반드시 종료 조건을 명시해야함

def wait_100(i) :
    if i == 100 :
        return
    print(f"{i}번째 재귀 함수에서 {i+1}번째 재귀 함수를 호출합니다.")
    wait_100(i+1)
    
    # i가 100이 되면 함수들이 차례대로 return되어 나옴 like 스택
    print(f"{i}번째 재귀 함수 종료")

wait_100(1)

재귀 함수 사용시 유의사항
- 재귀 함수를 잘 활용하면 수학적 점화식이나 복잡한 알고리즘을 간단하게 작성할 수 있음
- 근데 다른 사람에게 오히려 어려워 보일 수 있음
- 모든 재귀 함수는 반복문으로 동일하게 구현 가능하고, 그 반대도 성립함
- 근데 재귀 함수가 반복문 보다 유리한 경우도 있고 불리한 경우도 있으니 주의
- 재귀 함수 연속 호출 시 컴퓨터 메모리 내부 스택 프레임에 쌓임.
  그래서 스택을 사용해야 할 때 구현상 스택 라이브러리 대신 재귀 함수를 이용하는 경우가 많음

[팩토리얼 구현 예제]

$n! = 1 \times 2 \times 3 \times ... \times (n-1) \times n$

# 반복문으로 구현한 팩토리얼
def factorial_iterative(n) :
    result = 1
    for i in range(n) :
        result *= (i+1)
    return result

# 재귀함수로 구현한 팩토리얼
def factorial_recursive(n) :
    if n <= 1 :
        return 1
    # n! = n * (n-1)!를 구현
    return n * factorial_recursive(n-1)

print(factorial_iterative(5))
print(factorial_recursive(5))

120

120

재귀 함수를 이용한 계산

5 x func(4)

= 4 x func(3)

= 3 x func(2)

= 2 x func(1)

[유클리드 호제법]

재귀 함수를 효과적으로 사용할 수 있는 또 다른 예시
최대 공약수를 구하고자 할 때 사용할 수 있는 방법
- 최대 공약수(Greatest Common Divisor) = 두 자연수가 있을 때 공통된 약수 중 가장 큰 것

유클리드 호제법
- 두 자연수 A, B에 대하여 (A > B) A를 B로 나눈 나머지를 R이라고 합시다.
- 이때 A와 B의 최대공약수는 B와 R의 최대공약수와 같다.

Ex) GCD(192, 162)

단계	A	B
1	192	162
2	162	30
3	30	12
4	12	6

def GCD (a, b) :
    if (a % b) == 0 :
        print(f"최대공약수는 {b}!")
        return b
    return GCD(b,a%b)

x, y = map(int,input("두 수를 입력하시오 : ").split(' '))

if x > y :
    print(f"A는 {x} B는 {y}")
    GCD(x, y)
else :
    print(f"A는 {y} B는 {x}")
    GCD(y, x)

두 수를 입력하시오 : 162 192
A는 192 B는 162
최대공약수는 6!

[그래프] 깊이/너비 우선 탐색(DFS/BFS)문제 4

duiiminish — Mon, 8 Jun 2026 00:33:48 +0900

문제 설명

ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다.

따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.
지금부터 당신은 한 팀의 팀원이 되어 게임을 진행하려고 합니다.

다음은 5 x 5 크기의 맵에, 당신의 캐릭터가 (행: 1, 열: 1) 위치에 있고, 상대 팀 진영은 (행: 5, 열: 5) 위치에 있는 경우의 예시입니다.

위 그림에서 검은색 부분은 벽으로 막혀있어 갈 수 없는 길이며, 흰색 부분은 갈 수 있는 길입니다.

캐릭터가 움직일 때는 동, 서, 남, 북 방향으로 한 칸씩 이동하며, 게임 맵을 벗어난 길은 갈 수 없습니다.
아래 예시는 캐릭터가 상대 팀 진영으로 가는 두 가지 방법을 나타내고 있습니다.

첫 번째 방법은 11개의 칸을 지나서 상대 팀 진영에 도착했습니다.

두 번째 방법은 15개의 칸을 지나서 상대팀 진영에 도착했습니다.

위 예시에서는 첫 번째 방법보다 더 빠르게 상대팀 진영에 도착하는 방법은 없으므로, 이 방법이 상대 팀 진영으로 가는 가장 빠른 방법입니다.

만약, 상대 팀이 자신의 팀 진영 주위에 벽을 세워두었다면 상대 팀 진영에 도착하지 못할 수도 있습니다. 예를 들어, 다음과 같은 경우에 당신의 캐릭터는 상대 팀 진영에 도착할 수 없습니다.

게임 맵의 상태 maps가 매개변수로 주어질 때, 캐릭터가 상대 팀 진영에 도착하기 위해서 지나가야 하는 칸의 개수의 최솟값을 return 하도록 solution 함수를 완성해주세요.

단, 상대 팀 진영에 도착할 수 없을 때는 -1을 return 해주세요.

제한사항

maps는 n x m 크기의 게임 맵의 상태가 들어있는 2차원 배열로, n과 m은 각각 1 이상 100 이하의 자연수입니다.
n과 m은 서로 같을 수도, 다를 수도 있지만, n과 m이 모두 1인 경우는 입력으로 주어지지 않습니다.
maps는 0과 1로만 이루어져 있으며, 0은 벽이 있는 자리, 1은 벽이 없는 자리를 나타냅니다.
처음에 캐릭터는 게임 맵의 좌측 상단인 (1, 1) 위치에 있으며, 상대방 진영은 게임 맵의 우측 하단인 (n, m) 위치에 있습니다.

입출력 예

maps	answer
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,1],[0,0,0,0,1]]	11
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,0],[0,0,0,0,1]]	-1

입출력 예 설명
#1

캐릭터가 적 팀의 진영까지 이동하는 가장 빠른 길은 다음 그림과 같습니다.

오답노트

from collections import deque

def solution(maps):
    answer = 0
    # n by m 일 때를 고려
    n = len(maps) - 1
    m = len(maps[0]) - 1

    def bfs(x,y) :
        # map 밖으로 벗어나거나 벽이면 return
        if x < 0 or y < 0 or x > 4 or y > 4 or maps[x][y] == 0:
            print("범위 밖")
            return

        queue = deque([(x, y)])
        # print("큐 생성")
        while queue :
            a,b = queue.popleft()
            print(a,b)

            # n by m 일 때를 고려
            if a == n and b == m :
                print("목적지 도착")
                break
            else :
                if (a+1) <= n and maps[a+1][b] == 1 :
                    maps[a+1][b] = maps[a][b] + 1
                    queue.append((a + 1,b))
                if (a-1) >= 0 and maps[a-1][b] == 1 :
                    maps[a - 1][b] = maps[a][b] + 1
                    queue.append((a - 1, b))
                if (b+1) <= m and maps[a][b+1] == 1 :
                    maps[a][b + 1] = maps[a][b] + 1
                    queue.append((a, b+1))
                if (b-1) >= 0 and maps[a][b-1] == 1 :
                    maps[a][b - 1] = maps[a][b] + 1
                    queue.append((a, b-1))
        if maps[len(maps)-1][len(maps[0])-1] == 1 :
            return -1
        else :
            return maps[len(maps)-1][len(maps[0])-1]

    answer = bfs(0,0)
    print("bfs 후 :",maps)

    return answer

maps = [[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,1],[0,0,0,0,1]]
# maps = [[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,0],[0,0,0,0,1]]
print("정답 : ",solution(maps))

가중치 없는 최단거리 -> BFS 접근
맵 바깥 좌표로 나가면 X, 다음 스텝 좌표가 벽이면 X
초반에 문제에서 (1,1) 출발이라고 했는데 실제 코드에서는 (0,0)이라 약간 헤맴
answer 개수 = 큐 Pop한 개수 처리해버리면서 BFS 쓰겠다 해놓고 다 둘러봄 ㅠ -> 방문 노드 값 +1로 수정
결론 : 풀긴 풀었는데 코드가 지저분함

GPT 추천 답안

from collections import deque

def solution(maps):
    answer = 0
    n = len(maps) # 행
    m = len(maps[0]) # 열

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

    queue = deque([(0, 0)])

    while queue:
        x, y = queue.popleft()

        if x == n - 1 and y == m - 1:
            return maps[x][y]

        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            if 0 <= nx < n and 0 <= ny < m and maps[nx][ny] == 1:
                maps[nx][ny] = maps[x][y] + 1
                queue.append((nx, ny))

    return -1

maps = [[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,1],[0,0,0,0,1]]
# maps = [[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,0],[0,0,0,0,1]]
print("정답 : ",solution(maps))

시행착오 및 배운점

# 1 동서남북 1칸씩 이동할 때 쓰면 좋을 루틴코드

    dx = [1,-1,0,0]
    dy = [0,0,1,-1]
    
    for i in range (4) :
    nx = x + dx[i]
    ny = y + dy[i]

[그래프] 깊이/너비 우선 탐색(DFS/BFS)문제 3

duiiminish — Sun, 7 Jun 2026 04:46:13 +0900

문제 설명
n개의 노드가 있는 그래프가 있습니다. 각 노드는 1부터 n까지 번호가 적혀있습니다. 1번 노드에서 가장 멀리 떨어진 노드의 갯수를 구하려고 합니다. 가장 멀리 떨어진 노드란 최단경로로 이동했을 때 간선의 개수가 가장 많은 노드들을 의미합니다.
노드의 개수 n, 간선에 대한 정보가 담긴 2차원 배열 vertex가 매개변수로 주어질 때, 1번 노드로부터 가장 멀리 떨어진 노드가 몇 개인지를 return 하도록 solution 함수를 작성해주세요.

제한사항

노드의 개수 n은 2 이상 20,000 이하입니다.
간선은 양방향이며 총 1개 이상 50,000개 이하의 간선이 있습니다.
vertex 배열 각 행 [a, b]는 a번 노드와 b번 노드 사이에 간선이 있다는 의미입니다.

가중치 없는 edge의 최단거리 -> BFS 접근
vertex 배열로 그래프 먼저 만들자
그 거리값을 가진 노드 개수 세기???
- <GPT hint>
- 거리 배열을 하나 만들어봐. -> distance = [-1] * (n + 1)
- 시작 노드는 distance[1] = 0
- BFS를 실행하며 아직 방문하지 않은 노드라면 -> distance[next] = distance[current] + 1

from collections import deque

def solution(n, edge):
    answer = 0
    far_edge = 0
    def bfs(start) :
        queue = deque([start])
        distance[start] = 0

        while queue :
            v = queue.popleft()
            for i in graph[v] :
                if distance[i] == -1 :
                    distance[i] = distance[v] + 1
                    queue.append(i)

    # graph = [[]]*(n+1) # 이렇게 하면 모든 칸이 같은 리스트 공유
    graph = [[] for _ in range(n + 1)]
    for a, b in edge:
        graph[a].append(b)
        graph[b].append(a)

    distance = [-1]*(n+1)
    bfs(1)
    # print(graph)
    # print(distance)
    # print(max(distance))
    for i in distance :
        if i == max(distance) :
            answer += 1
    # print(answer)

    return answer

# n = 6
# vertex = [[3, 6], [4, 3], [3, 2], [1, 3], [1, 2], [2, 4], [5, 2]]
# solution(n,vertex)

시행착오

#1 2차원 배열 빈 리스트 만들기

graph = [[]]*(n+1) # 이렇게 하면 모든 칸이 같은 리스트 공유

처음에 빈 리스트 배열 이렇게 만들었더니 append 하면 모든 리스트에 동일한 값이 할당됨
위와 같이 빈 리스트를 만들면 print 했을 때는 문제 없어 보이지만, 메모리 상에서는 동일한 1개의 빈 리스트 객체를 가리키는 꼴이 되어버림
따라서 서로 다른 객체의 빈 리스트 원소를 여러개 생성할 때는 아래와 같이 for문을 활용

graph = [[] for _ in range(n + 1)]

#2 distance 리스트를 왜 bfs의 매개변수로 넣어주지 않아도 bfs 함수 내에서 에러가 안생기는지?

Python의 클로저(Closure) 와 LEGB 규칙 때문.

Python은 변수를 찾을 때 아래 순서로 탐색함.

현재 함수(Local) → 바깥 함수(Enclosing) → 전역(Global) → 내장(Built-in)

따라서 bfs() 내부에 distance가 없더라도, 바깥 함수인 solution()의 distance를 찾아 사용할 수 있음.

또한 BFS 내부에서 수행하는

distance[i] = distance[v] + 1

은 distance 변수를 새로 만드는 것이 아니라 리스트 객체 내부의 값만 수정하는 것.

그래서 nonlocal 선언도 필요하지 않음.

반면,

distance = [0, -1, -1]

이와 같이 distance 자체를 새로 할당/정의하면 Python은 이를 bfs()의 지역 변수로 판단함.

이 경우 바깥 함수의 distance와는 다른 변수가 되며, 상황에 따라 UnboundLocalError가 발생할 수 있음.