1-H0ngJu

[H0ngJu]

🔗 문제 링크

프로세스

✔️ 소요된 시간

1시간 30분

✨ 수도 코드

case 1은 처음에 생각한 풀이이고, case 1에서 해결이 안된 부분을 다른 코드를 찾아보면서 case 2로 해결하였습니다.

• case 1
  중요도가 더 높은 process가 먼저 처리되어야 한다.
  따라서 처음에 제공된 프로세스들을 우선순위에 따라 정렬하는 과정이 필요하다.

정렬은 일단 priorities[0]과 다른 priorities의 원소를 비교를 한다. 만약, list안에 우선순위가 높은 process가 있다면 isQueded를 True로 설정한다.

• isQueded(bool) : 순서를 뒤로 미뤄야 하는 process (pop하고 다시 append)

def solution(priorities, location):
    answer = 0
    process = priorities[location]
    #index = location
    
    i = 0
    k = i + 1
    isQueued = False
    
    for i in range(len(priorities)):
        for k in range(len(priorities)):
            if(priorities[0] < priorities[k]):
                isQueued = True
        if(isQueued):
            tmp = priorities.pop(0)
            priorities.append(tmp)
            #print('index : ', index)
            print(priorities)
        isQueued = False
            
    return priorities

이렇게하면 정렬은 되나, 동일 우선순위를 가진 process에 대해서 구분이 힘듭니다.

1시간 정도 case 1로 풀면서 동일한 우선순위를 가지지만 다른 인덱스(process가 다름)에 대해서 어떻게 처리해야하는지에 대한 적절한 풀이가 생각나지 않아 다른 분의 코드를 참고하였습니다.

• case 2

1. priorities를 오름차순으로 정렬한다.
2. 큐를 돌면서 프로세스 수를 증가시킨다.
   if. 큐의 우선순위와 내림차순의 우선순위가 같으면, 큐에서 pop한다.
   단, location이 일치하면 break
   else. 순서를 뒤로 미룬다.

📚 새롭게 알게된 내용

• tuple

1. 소괄호를 통해서 생성
2. 값이 하나만 있어도 , 필요
3. list와 달리, tuple의 요소는 삭제할 수 없다. -> 단순 값 조회의 경우 tuple이 효율적
4. list보다 메모리가 작다.

• enumerate()
  최근에 c만 하다가 오랜만에 python을 하니 문법이 낯설다.
  c에서는 list의 원소에 접근하기 위해서는 index를 증가시키면서 접근하지만, python에서는 for i in list_name 과 같이 바로 원소에 접근이 가능함을 잊고 있었다.

case 2의 코드를 참고하면서, index 값과 해당 index의 원소에 동시에 접근이 가능한 enumerate()에 대해서 알게되었다.

• sort()
  c에서는 정렬을 하기 위해서따로 함수를 작성하는 과정이 필요했는데, sort()를 통해서 내림차순, 오름차순 정렬이 가능함을 알게 되었다.

• deque
  list로 큐를 구현하는 경우와 달리, deque를 사용하면 시간 복잡도가 줄어든다.
  list로 구현하는 경우(FIFO), n개의 원소를 확인하는 과정이 필요하므로, O(n)이다.
  하지만, deque는 양방향에서 원소 추가 및 삭제가 가능하기 때문에 O(1)이다.

이 문제 전에 풀었던 같은_숫자는_싫어, 기능개발, 올바른_괄호에서는 특정 원소를 pop하는 경우에는 list.pop(index)로 사용하였으나, 다음에 풀게 될 문제에서는 deque로 풀어보겠다!

참고한 코드

[tgyuuAn]

홍주님 웰컴 알고리드미 입니다~~~~~

역시 원래 개발 및 협업을 하시던 분이라 그런지 네이밍도 알아보기 너무 쉽고 코드가 직관적으로 잘 보이네요.

약간 사소하지만 중요한 코멘트들을 남겨봤습니다. 고생하셨어요!!! 😁😁😁😁

[tgyuuAn]

커밋으로 리드미 링크를 풀이란에 넣어주세요!

꿀팁을 드리자면 리드미 파일 작성할 때, 레포지토리 PR 마지막 번호에서 +1한 거를 링크로 달면 되어요.

예를 들어 마지막 PR이 150번이면 https://github.com/AlgoLeadMe/AlgoLeadMe-1/pull/151 같이...?

그러면 PR 올릴 때 #151 이렇게 뙇 나온답니다

[tgyuuAn]

저는 진짜 문제대로 구현해서 풀었었는데,

어차피 우선순위가 높은 애들 부터 먼저 나와야 하니 정렬해서 하나씩 뽑는 것도 아이디어 간단하고 좋네요 👍

[tgyuuAn]

pop(0) 은 시간복잡도가 $O(n)$이니까 어차피 pop(0)을 쓰는 거면 priorites 도 deque로 래핑했으면 더 좋았을 것 같아요.

아니면 굳이 이렇게 하기 싫으면

위에 우선순위를 정렬하는 코드를 아래와 같이 오름차순으로 바꾸고,

priorities.sort() # 오름차순 정렬

 while queue:
        cur = queue.popleft() # 가장 앞의 프로세스 꺼내기 (queue.pop(0)) 
        if cur[0] == priorities[-1]: # 오름차순으로 정렬된 우선순위 마지막 항 == 현재 순위 -> 가장 높음
            answer += 1 # 수 ++
            if cur[1] == location: # 찾고자하는 process인 경우
                break
            priorities.pop()

로 하면 매번 우선순위를 뽑을 때 마다 $O(1)$의 시간복잡도로 뺄 수 있을 것 같아요...!

지금은 priorities의 크기가 100밖에 되지 않아서 유의미한 차이가 없지만,

이 정도 자료 구조적 시간 복잡도 이득은 미리 체화시키는 게 좋을 것 같네요...!

아직 자료 구조별 시간 복잡도가 체화가 안되셨으면 스택, 큐, 힙 문제를 집중적으로 풀어서 체화시켜도 좋을 것 같아요.

[H0ngJu]

이 문제 풀 당시에는 pop과 popleft의 차이를 몰랐는데, 코드 리뷰하고 다시 제 코드를 보니까 pop보다 popleft가 더 좋았겠다는게 눈에 보이네요 ㄷㄷ

스택, 큐, 힙 문제도 집중적으로 풀어보겠슴다 -!

[pknujsp]

수고하셨습니다 따끈따끈한 첫 문제 군요

저는 최대 힙(우선순위 큐)를 사용해서 풀어봤습니다.

지금 다시 생각해보니 제 구현이 다소 부적절할 수도 있어요

• 우선순위를 한번 만 정렬해놓고 priorities 큐를 앞에서 부터 차례대로 pop해가며 우선순위를 비교하면 최대 우선순위인 프로세스를 지울 때 리스트에서 빼기만 하면 되니까 O(1) 으로 한번에 처리가 가능한데
• 밑에 코드처럼 최대 힙을 사용해서 우선순위를 비교해가면 최대 우선순위인 것을 지울 때 마다 트리를 정리해야해서 O(logN) 만큼 불필요한 수행 시간이 더 걸려요

from heapq import *
from collections import *

def solution(priorities, location):
    heap = [-p for p in priorities]
    heapify(heap)
    q = deque(enumerate(priorities))
    
    x = 1
    while q:
        i, p = q.popleft()
        p1 = -heap[0]
        
        if p1 > p:
            q.append((i, p))
            continue
        if p1 == p:
            heappop(heap)
        if i == location:
            break

        x += 1
        
    return x

[9kyo-hwang]

와퐁주의 첫 번째 PR 🤩🤩🤩

제 경우엔 덱을 이용해 구현했습니다.

from collections import deque

def solution(priorities, location):
    q = deque(enumerate(priorities))  # (인덱스, 우선순위) 쌍으로 덱에 삽입
    answer = 1
    
    while True:
        top_loc, top_p = max(q, key=lambda x:x[1])  # 가장 높은 우선순위 프로세스를 찾음
        front_loc, front_p = q.popleft()  # 가장 앞에 있는 프로세서 팝
        
        if top_p > front_p:  # front보다 우선순위가 높은 프로세스가 존재한다면
            q.append((front_loc, front_p))  # 맨 뒤에 삽입
        elif front_loc == location:  # front가 가장 우선순위가 높은데 타겟 location이라면
            break  # break
        else:  # 아니라면 
            answer += 1  # 실행 순서 1 증가
            
    return answer

[Munbin-Lee]

#include <string>
#include <vector>
#include <queue>

using namespace std;

int solution(vector<int> priorities, int location) {
    queue<pair<int, int>> q;
    priority_queue<int> pq;
    
    for (int i = 0; i < priorities.size(); i++) {
        q.emplace(i, priorities[i]);
        pq.emplace(priorities[i]);
    }
    
    int answer = 1;
    
    while (!q.empty()) {
        auto [index, cur] = q.front();
        
        if (cur != pq.top()) {
            q.pop();
            q.emplace(index, cur);
            continue;
        }

        if (index == location) {
            return answer;
        }
        
        q.pop();
        pq.pop();
        answer++;
    }
    
    return answer;
}

고생하셨습니다.

저는 "우선순위"라는 말에 현혹되었는지 아무 생각 없이 최댓값을 우선순위 큐로 구하였는데,

다시 생각해보니 정렬한 후 하나씩 pop 하는 게 더 효율적이겠네요!

하나 배우고 갑니다.