'원사이트'

프론트엔드 관점으로 알고리즘 이해하기

오랜만에 방법론에 관한 글을 쓰게 되었습니다. 최근 상황은 이렇습니다. SSAFY에서는 하루에 엄청난 양의 알고리즘 문제들을 과제로 수행하게 됩니다. 그 과정에서, '구현력'이 매우 떨어진다는 생각이 들었습니다. 완전히 어려운 문제라면 '아쉬움'이라는 감정조차 느끼지

2026년 2월 7일4min read

1. 나는 왜 알고리즘을 못할까? 🎯

오랜만에 방법론에 관한 글을 쓰게 되었습니다.

최근 상황은 이렇습니다. SSAFY에서는 하루에 엄청난 양의 알고리즘 문제들을 과제로 수행하게 됩니다. 그 과정에서, '구현력'이 매우 떨어진다는 생각이 들었습니다.

완전히 어려운 문제라면 '아쉬움'이라는 감정조차 느끼지 못할 테지만, 될 듯 말 듯 한 상황에서 뚝심을 유지하지 못하고 AI에게 굴복하는 스스로가 너무 창피했습니다. 누가 뭐라 한 건 아니지만... 내 생각과 느낌이 항상 중요하죠.

저는 왜 알고리즘을 못할까요?

며칠간 고민하며 질문을 바꿨습니다. 내가 알고리즘에서 어려워하는 부분이 뭐지? 그리고 오늘은 나름대로 정립하게 된 해답을 소개하고자 합니다.

2. 내가 지금까지 해온 것? 🎯

그래도 나름대로 개발은 해왔으니, 내가 갖고 있는 강점을 알고리즘에 적용해 보면 어떨까 하는 생각이 들었습니다.

프론트엔드 개발을 어떻게 해왔는지 반추했습니다.

보통 이런 식입니다.

Header와 Footer를 고정해놓고, 내부에 들어가는 내용이 달라질 경우, 언제든 해당 구조를 재사용할 수 있도록 PageContainer라는 컴포넌트를 개발하곤 했죠.

알고리즘 문제도 크게 다르지 않다는 생각이 문득 들었습니다.

페이지의 기본 구조가 Header, Contents, Footer라면, 알고리즘의 기본 구조는 Input, Logic, Output이라고 할 수 있습니다. 그렇다면 내부 로직 따지기 전에 그릇부터 잘 만들어야 하지 않을까요?

3. 그래서 어떻게 하라고요? 🎯

뭐 이런 문제가 있다고 치자고요. 단어의 길이가 주어지고, 해당 단어가 정확히 들어갈 수 있는 자리의 수를 출력하는 문제입니다.

앞으로 제시할 목차 자체가 앞서 언급한 그릇입니다.

3-1. 입력 섹션 🟣

T = int(input())

for tc in range(1, T+1):
    # input
    N, K = list(map(int, input().split()))
    matrix = [list(map(int, input().split())) for _ in range(N)]

행렬의 사이즈를 N으로, 단어의 길이를 K로 입력받습니다. 추가적으로, 사용자로부터 입력받은 내용으로 matrix를 생성합니다.

3-2. 출력 섹션 🟣

T = int(input())

for tc in range(1, T+1):
    # input
    N, K = list(map(int, input().split()))
    matrix = [list(map(int, input().split())) for _ in range(N)]
    result = 0
    .
    .
    .
    # output
    print(f'#{tc} {result}')

잘 모르겠지만, 단어가 정확히 들어갈 수 있는 '자리의 수'를 출력해야 합니다. 그 값을 result라고 상정하고, 변수에 초깃값을 할당해 놓습니다.

3-3. 내부 로직 🟣

T = int(input())

for tc in range(1, T+1):
    # input
    N, K = list(map(int, input().split()))
    matrix = [list(map(int, input().split())) for _ in range(N)]
    result = 0

    # logic
    ## 가로 탐색
    for row in range(N):
        for column in range(N):
        	.
        	.
        	.
        
    ## 세로 탐색
    for column in range(N):
        for row in range(N):
        	.
            .
            .
              
    # output
    print(f'#{tc} {result}')

여전히 잘 모르겠지만 단어가 가로의 형태로도, 세로의 형태로도 들어갈 수 있으니 두 가지 상황을 고려해야 할 것 같네요.

T = int(input())

for tc in range(1, T+1):
    # input
    N, K = list(map(int, input().split()))
    matrix = [list(map(int, input().split())) for _ in range(N)]
    result = 0

    # logic
    ## 가로 탐색
    for row in range(N):
        row_search_result = 0

        for column in range(N):
            if matrix[row][column] == 1:
                row_search_result += 1
            else:
                if row_search_result == K:
                    result += 1
                row_search_result = 0

        if row_search_result == K:
            result += 1

    ## 세로 탐색
    for column in range(N):
        for row in range(N):
        	.
            .
            .
            
    # output
    print(f'#{tc} {result}')

진정한 고민은 바로 이 단계에서 진행되어야 합니다. 이전 단계들은 사전 작업이죠. 다만 제가 주장하는 것은, 큰 구조가 논리적인 흐름 속에서 당연하게 정해졌기 때문에 인지 부하가 평소보다 굉장히 적었을 것입니다.

그리고 느끼시겠지만, 실상 내부에서 돌아가는 로직에 뭐 대단히 어려운 건 없습니다. 붙이거나 자르거나, 더하거나 빼거나, 뒤집는 식입니다.

그런데 자신만의 구조가 없으니, 이것저것 생각하느라 쉬운 것도 어렵게 느끼는 것이죠. 가로를 한 사람이 세로를 못 할까요?

T = int(input())

for tc in range(1, T+1):
    # input
    N, K = list(map(int, input().split()))
    matrix = [list(map(int, input().split())) for _ in range(N)]
    result = 0

    # logic
    ## 가로 탐색
    for row in range(N):
        row_search_result = 0

        for column in range(N):
            if matrix[row][column] == 1:
                row_search_result += 1
            else:
                if row_search_result == K:
                    result += 1
                row_search_result = 0

        if row_search_result == K:
            result += 1

    ## 세로 탐색
    for column in range(N):
        column_search_result = 0
        for row in range(N):
            if matrix[row][column] == 1:
                column_search_result += 1
            else:
                if column_search_result == K:
                    result += 1
                column_search_result = 0

        if column_search_result == K:
            result += 1
            
    # output
    print(f'#{tc} {result}')

이렇게 접근하면 답은 나옵니다. 그런데 조금 더 욕심을 갖고 사는 것이 좋겠습니다.

3-4. 더 나아가기 🟣

def count_k_in_line(line, K):
    count = 0
    segments = 0
    for cell in line:
        if cell == 1:
            count += 1
        else:
            if count == K:
                segments += 1
            count = 0
   
    if count == K:
        segments += 1
    return segments


T = int(input())

for tc in range(1, T + 1):
    N, K = map(int, input().split())
    matrix = [list(map(int, input().split())) for _ in range(N)]
    result = 0

    # 가로 탐색 
    for row in range(N):
        result += count_k_in_line(matrix[row], K)

    # 세로 탐색 
    for col in range(N):       
        column_line = [matrix[row][col] for row in range(N)]
        result += count_k_in_line(column_line, K)
            
    print(f'#{tc} {result}')

함수에 전달하는 값만 달리하면, 공통된 로직을 분리할 수 있겠습니다.

4. 마치며 🎯

이 방법이 모든 알고리즘 문제를 한 번에 해결해 주는 만능열쇠는 아닐 겁니다. 애초에 이 세상에 Silver Bullet 따위는 없으니까요. 다만, 적어도 '구현력'의 벽에 부딪혀 고민하던 시간만큼은 확실히 줄여줄 수 있다고 확신합니다.

이제서야 가설 하나 세웠으니, 많은 문제들로 테스트하며 저만의 방법론을 고도화할 생각입니다. 자책하지 마십쇼. 방법은 반드시 있습니다.