6-H0ngJu

[H0ngJu]

🔗 문제 링크

오큰수

✔️ 소요된 시간

2시간

✨ 수도 코드

일단, 처음에는 문제에서 요구하는 바를 따라가면서 코드를 작성하였다.

1. arr을 입력받고, arr이 빌 때까지 아래를 반복
2. arr에서 popleft한 원소와 남은 arr 원소를 비교하며 왼쪽에 있으면서 arr.popleft()보다 큰 수를 찾는다
   1. 조건을 만족하는 경우가 있으면 check을 1로 설정
3. 조건을 충족하는 경우가 없으면 check = 0이므로 -1를 반환

import sys
from collections import *

def input(): return sys.stdin.readline().strip()
N = int(input())
arr = deque(map(int, input().split()))

while arr:
    num = arr.popleft()
    answer = 0
    check = 0
    cnt = 1000001
    tmp_cnt = 0

    for _ in range(len(arr)):
        tmp = arr.popleft()
        tmp_cnt += 1
        if tmp > num and tmp_cnt < cnt:
            answer = tmp
            cnt = tmp_cnt
            check = 1
        arr.append(tmp)
    
    if not check: answer = -1

    print(answer, end=" ")

이 코드의 문제점은 N이 1000000이고, 시간 복잡도가 O(N^2)이므로 시간 초과 발생한다는 것이다.

제한 시간 내에 통과하기 위해서는 O(N logN)이나 O(log N)이여야 가능한데,

시간 복잡도를 줄이기위해서는 while 안의 for문 로직을 다른 방식으로 구현해야 한다고 생각했다.

그런데 .. 아무리 생각해봐도 왼쪽에 있는 원소들을 하나씩 비교하는 순간 O(N^2)이 되어버리고,

그렇다고 binary search를 하자니, '오름차순 정렬이 아닌 점', '오름차순 정렬한 배열을 추가 생성한다고 하더라도 같은 값 다른 원소에 대해서 비교가 불가능하다는 점'을 해결할 수 없어서 이분탐색도 아니라고 생각했다.

결국 시간 초과를 해결할 방법을 생각하지 못해서 다른 풀이를 참고했다.

이 문제에서 사용하는 자료구조는 '스택'이다.

핵심 아이디어는 다음과 같다.

1. 입력받은 수열 arr, 빈 stack을 생성
2. 처음에는 arr.pop()을 stack에 넣어준다.
3. arr이 빌 때까지 다음을 시행한다.
   1. arr의 top이 stack의 top 보다 크면, arr을 answer[ ]에 넣는다. (stack top < arr top 이거나 stack이 빌 때까지 반복)
   2. arr에서 pop하여 stack에 넣는다.

---

제가 참고한 블로그를 첨부합니다

📚 새롭게 알게된 내용

• 골드 4는 ,, 어렵다 ,, (이 정도일줄은 몰랐음)

지금 다시 생각해봐도 어디서 스택을 떠올려야 하는지 의문 ....... (의문을 해결하면 알게된 내용에 추가 예정)

[pknujsp]

arr을 뒤집거나 pop()해서 지우는 식으로 arr을 크게 건드리지 않아도 돼요

stack에서 원소를 꺼내서 answer에 오큰수를 넣어주는 상황에서는,
스택에 있던 원소의 인덱스가 현재 순회중인 arr의 원소 인덱스보다 항상 앞에 있어요

그래서 arr을 건드리지 않고, 순서대로 순회하면서 인덱스만 스택에 넣어주면서 진행하면 돼요

1. arr을 순서대로 순회합니다
2. 현재 원소가 스택에 있는 원소보다 크면, 그 원소의 오큰수로 설정해줍니다
3. 스택이 비거나 현재 원소보다 큰 원소를 만날 때까지 이걸 계속합니다
4. 현재 원소의 인덱스를 스택에 넣습니다

이렇게 하면, arr을 따로 건드리지 않고, 한 번만 봐도 모든 오큰수를 찾을 수 있어요
메모리도 따로 튜플을 생성하면서 진행하지 않으니 많이 줄어들어요

N = int(input())
A = list(map(int, input().split()))

stack = deque()
result = [-1] * N

for i in range(N):
    while stack and A[stack[-1]] < A[i]:
        result[stack.pop()] = A[i]
        
    stack.append(i)

print(*result)

[tgyuuAn]

사실 내부 구현만 다를 뿐,

큰 구조는 같을 거라고 생각이 됩니다.

total_numbers_count = int(input())
numbers = list(map(int,input().split()))

answer = [-1 for _ in range(total_numbers_count)]
temp = []

for idx, i in enumerate(range(len(numbers))):
    now = numbers[i]

    while temp:
        if temp[-1][1] < now:
            temp2 = temp.pop()
            answer[temp2[0]] = now
        else:
            break

    temp.append([idx,now])
        
print(*answer)

이 문제 정말 자료구조에 대해 잘 알고 있느냐를 물어보는 문제인 것 같아요.

이 문제 기억해두셨다가, 나중에 자료구조 익숙해지시면 다시 풀어보는 것을 추천드립니다!!!

[Munbin-Lee]

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;

    vector<int> A(N), answer(N, -1);

    for (int &num: A) {
        cin >> num;
    }

    stack<int> st;

    for (int i = N - 1; i >= 0; i--) {
        while (!st.empty() && st.top() <= A[i]) {
            st.pop();
        }

        if (!st.empty()) {
            answer[i] = st.top();
        }

        st.emplace(A[i]);
    }

    for (int num: answer) {
        cout << num << ' ';
    }

    return 0;
}

고생하셨습니다.

제가 거친 사고방식은

앞에서부터 처리하면 대소가 가치에 영향을 미치지 않는다

-> 뒤에서부터 처리하면 이른 숫자가 더 클 경우 더 가치가 높다

-> 스택을 사용하여 시간복잡도 줄이기

이렇게 풀었어요.