728x90
반응형

문제:

n명의 권투선수가 권투 대회에 참여했고 각각 1번부터 n번까지 번호를 받았습니다. 권투 경기는 1대1 방식으로 진행이 되고, 만약 A 선수가 B선수보다 실력이 좋다면 A 선수는 B 선수를 항상 이깁니다. 심판은 주어진 경기 결과를 가지고 선수들의 순위를 매기려 합니다. 하지만 몇몇 경기 결과를 분실하여 정화하게 순위를 매길 수 없습니다.

선수의 수 n, 경기 결과를 담은 2차원 배열 results가 매개변수로 주어질 때 정확하게 순위를 매길 수 있는 선수의 수를 return 하도록 solution 함수를 작성해주세요.

풀이 방법:

 각 선수가 이긴 선수와 진 선수의 정보를 hash방식으로 정리하고 한 선수의 win정보의 길이와 lose정보 길이를 합쳤을 때 n-1과 같아지면 그 선수의 순위를 알 수 있게 된다. 또한 실력의 차이가 극명해서 실력이 낮은 사람이 높은 사람을 이길 수 없다고 한다. 따라서 정보를 가지고 있지 않지만 이 조건을 통해서 정보를 다시 얻을 수 있게 된다.

 입출력 예시를 통해서 살펴 보면 2번선수의 경우에는 모든 경기기록이 있어서 순위를 알 수 있지만 5번 선수는 2번 선수와의 기록이 있지만 순위를 유추할 수 있다. 왜냐하면 2번이 1,3,4번 선수한테 졌는데 5번이 2번한테 졌으므로 5번은 당연히 1,3,4번 선수한테 진다는 것을 알 수 있다.(1,3,4 > 2 > 5) 또한 2번이 5번을 이겼기 때문에 5번이 이긴 사람도 당연히 이길 수 있다. (이 문제에서는 이러한 케이스가 없긴 하다.)

 처음에는 리스트로 했더니 시간초과가 발생해서 이를 set으로 바꿔서 했더니 시간초과가 발생하지 않았다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def solution(n, results):
    answer=0
    win={}
    lose={}
    for i in range(1,n+1):
        win[i]=set()
        lose[i]=set()
    results.sort()
    for i in range(1,n+1):
        for re in results:
            if re[0]==i:
                win[i].add(re[1])
            if re[1]==i:
                lose[i].add(re[0])
        for j in win[i]:
            lose[j].update(lose[i])
        for j in lose[i]:
            win[j].update(win[i])
    for i in range(1,n+1):
        if len(win[i])+len(lose[i])==n-1:
            answer+=1
    return answer
cs

문제 링크:



728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]1009. 분산처리  (0) 2019.08.01
[Programmers]Lv 3.배달  (3) 2019.07.31
[Programmers]Lv3. 가장 먼 노드  (0) 2019.07.29
[Programmers]Lv 4. 3xn 타일링  (2) 2019.07.28
[BOJ]2805. 나무 자르기  (0) 2019.07.27
728x90
반응형

문제:

 n개의 노드가 있는 그래프가 있습니다. 각 노드는 1부터 n까지 번호가 적혀있습니다. 1번 노드에서 가장 멀리 떨어진 노드의 갯수를 구하려고 합니다. 가장 멀리 떨어진 노드란 최단경로로 이동했을 때 간선의 개수가 가장 많은 노드들을 의미합니다. 

 노드의 개수 n, 간선의 대한 정보가 담신 2차우너 배열 vertex가 매개변수로 주어질 때, 1번 노드로부터 가장 멀리 떨어진 노드가 몇 개인지를 return 하도록 solution 함수를 작성해주세요.

풀이 방법:

 노드들의 최소경로 값을 나타내는 answer를 만든 뒤에 BFS 방식으로 노드들을 검사한다. 노드를 방문할 때마다 해당 node의 answer 값이 0이면 count로 초기화 해주고, count는 한 층을 더 들어갈 때 마다 1씩 증가하도록 했다. 이렇게 모든 answer가 0이 아닌 값으로 변하면(all) answer의 max값을 찾아서 max로 count를 해 답을 얻을 수 있다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def solution(n, edge):
    answer = [0]*(n+1)
    newedge=[[] for i in range(len(edge)+1)]
    for i in range(len(edge)):
        if not edge[i][1in newedge[edge[i][0]]:
            newedge[edge[i][0]].append(edge[i][1])
            newedge[edge[i][0]].sort()
        if not edge[i][0in newedge[edge[i][1]]:
            newedge[edge[i][1]].append(edge[i][0])
            newedge[edge[i][1]].sort()
    answer[0],answer[1]= -1,-1
    queue=[1]
    count=1
    while not all(answer):
        temp=[]
        for start in queue:
            for i in newedge[start]:
                if answer[i] ==0:
                    answer[i]+=count
                    temp.append(i)
        queue=temp
        count+=1
    ans=answer.count(max(answer))
    return ans
cs

문제 링크:


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[Programmers]Lv 3.배달  (3) 2019.07.31
[Programmers]Lv 3. 순위  (0) 2019.07.30
[Programmers]Lv 4. 3xn 타일링  (2) 2019.07.28
[BOJ]2805. 나무 자르기  (0) 2019.07.27
[BOJ]1654.랜선 자르기  (0) 2019.07.26
728x90
반응형

문제:

N개의 아파트가 일렬로 쭉 늘어서 있습니다. 이 중에서 일부 아파트 옥상에는 4g 기지국이 설치되어 있습니다. 기술이 발전해 5g 수요가 높아져 4g 기지국을 5g 기지국으로 바꾸려 합니다. 그런데 5g 기지국은 4g 기지국보다 전달 범위가 좁아, 4g 기지국을 5g 기지국으로 바꾸면 어떤 아파트에는 전파가 도달하지 않습니다.

예를 들어 11개의 아파트가 쭉 늘어서 있고, [4, 11]번째 아파트 옥상에는 4g 기지국이 설치되어 있습니다. 만약 이 4g 기지국이 전파 도달 거리가 1인 5g 기지국으로 바뀔 경우 모든 아파트에 전파를 전달할 수 없습니다 .(전파의 도달 거리가 W일 땐, 기지국이 설치된 아파트를 기준으로 전파를 양쪽으로  W만큼 전달할 수 있습니다.)

* 초기에 1,2,6,7,8,9번째 아파트에는 전파가 전달되지 않습니다.

* 1,7,9번째 아파트 옥상에 기지국을 설치할 경우, 모든 아파트에 전파를 전달할 수 있습니다.

* 3개의 아파트보다 더 많은 아파트 옥상에 기지국을 설피할 경우에도 모든 아파트에 전파를 전달할 수 있습니다.

이때, 우리는 기지국을 최소로 설치하면서 모든 아파트에 전파를 전달하려고 합니다. 위의 예시에선 최소 3개의 아파트 옥상에 기지국을 설치해야 모든 아파트에 전파를 전달할 수 있습니다.
아파트의 개수 N, 현재 기지국이 설치된 아파트의 번호가 담긴 1차원 배열 stations, 전파의 도달 거리 W가 매개변수로 주어질 때, 모든 아파트에 전파를 전달하기 위해 증설해야 할 기지국 개수의 최솟값을 return하는 solution 함수를 완성해주세요.

문제 풀이:

 처음에는 stations에 주어진 기지국으로 인해서 range(N+1) 의 배열이 나누어진다고 생각을 하였고, 그 나눠진 배열들의 길이와 W에 따라 설치해야할 기지국의 수를 알 수 있다고 생각하였다. (어디에 설치하는지는 관심이 없고, 몇 개를 설치하는지가 중요하다.)

 일정한 규칙을 따라 하나씩 설치해 나가는 방법도 있긴 이렇게 수학적으로 계산하는 것이 더 편하다고 생각했다. stations의 각 값을 i라고 했을 때 설치해야 하는 기지국의 수는 ((i-w)-(이전의 i+w, 초기값은 1)) / (2*W+1)을 올림한 값이다. 그리고 station의 반복문이 끝나고 아직 남은 아파트가 있을 수 있기 때문에 반복문이 끝난 뒤에도 한번 조건을 탐색해 더 하도록 한다.


1
2
3
4
5
6
7
8
9
10
11
12
import math
 
def solution(n, stations, w):
    answer=0
    start=0
    for i in stations:
        if i-w>start+1:
            answer+=math.ceil((i-w-start-1)/(2*w+1))
        start=i+w
    if start < n:
        answer+=math.ceil((n-start)/(2*w+1))
    return answer
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]3053. 택시 기하학  (1) 2019.07.11
[BOJ]1904. 01타일  (0) 2019.07.10
[Programmers]Lv 3. 섬 연결하기  (0) 2019.07.08
[Programmers]Lv 3. 단속카메라  (2) 2019.07.07
[BOJ]2869. 달팽이는 올라가고 싶다.  (0) 2019.07.06
728x90
반응형

문제:

n개의 섬 사이에 다리를 건설하는 비용(costs)이 주어질 때, 최소의 비용으로 모든 섬이 서로 통행 가능하도록 만들 때 필요한 최소 비용을 return 하도록 solution을 완성하세요.

다리를 여러 번 건너더라도, 도달할 수만 있으면 통행가능하다고 봅니다. 예를 들어 A 섬과 B 섬 사이에 다리가 있고, B 섬과 C 섬 사이에 다리가 있으면 A 섬과 C 섬은 서로 통행 가능합니다.


문제 풀이:

전형적인 Kruskal 알고리즘을 사용해서 푸는 문제이다. Kruskal 알고리즘이란, 탐욕적인 방법을 이용하여 그래프의 모든 정점을 최소 비용으로 연결하는 방법이다. Kruskal 알고리즘을 사용하는 방법은 간단하다. 처음 시작하는 노드로 부터 하나의 간선을 선택해가면 된다. 

이 문제의 예시로 설명을 들면 처음에 0에서 시작을 한다고 가정을 하자. 

1. 0에 연결되어 있는 간선은 0-1(1), 0-2(2) 두 가지 간선이 있다. 최소 비용으로 연결하는 것이 목적이므로 0-1 간선을 선택하고 1의 노드를 연결된 노드 집합에 넣도록 한다. 

2. 0과 1의 노드에 연결되어 있는 간선을 찾도록 하자. 그러면 0-2 (2), 1-2(5), 1-3(1) 세 가지 간선이 존재하게 되고, 역시 최소를 선택하므로 1-3을 선택하게 된다.

3. 위와 같은 방법으로 진행을 하면 0-2 간선을 선택하게 되어 모든 노드들이 연결되게 된다.

이제 이 방법들을 코드로 옮기면 다음과 같다. connect라는 연결된 노드 집합을 만들고 이 값이 n과 같게 되면 while이 끝나도록 한다. costs를 반복하여 connect에 있는 노드들의 간선을 찾도록 한다. (단 시점과 종점이 모두 connect에 있으면 안된다.) 이 간선들의 최소값을 찾아 answer에 더하고 connect 집합에 노드를 추가시키고 costs에서는 간선을 빼도록 한다. 이 작업을 모든 노드가 connect에 들어갈 때까지 반복한 answer를 반환하면 된다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def solution(n, costs):
    costs.sort()
    connect=[costs[0][0]]
    answer = 0
    while len(connect)!=n:
        temp=1000000000000000
        idx=0
        for i in range(len(costs)):
            if costs[i][0in connect or costs[i][1in connect:
                if costs[i][0in connect and costs[i][1in connect:
                    continue
                if temp > costs[i][2]:
                    temp=costs[i][2]
                    idx=i
        answer+=temp
        connect.append(costs[idx][0])
        connect.append(costs[idx][1])
        connect=list(set(connect))
        costs.pop(idx)
    return answer
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]1904. 01타일  (0) 2019.07.10
[Programmers]Lv 3. 기지국 설치  (0) 2019.07.09
[Programmers]Lv 3. 단속카메라  (2) 2019.07.07
[BOJ]2869. 달팽이는 올라가고 싶다.  (0) 2019.07.06
[BOJ]1011. Fly me to the Alpha Centauri  (0) 2019.07.05
728x90
반응형

문제:

고속도로를 이동하는 모든 차량이 고속도로를 이동하면서 단속용 카메라를 한 번은 만나도록 카메라를 설치하려고 합니다.

고속도로를 이동하는 차량의 경로 routes가 매개변수로 주어질 때, 모든 차량이 한 번은 단속용 카메라를 만나도록 하려면 최소 몇 대의 카메라를 설치해야 하는지를 return 하도록 solution 함수를 완성하세요.

문제 풀이:

프로그래머스에서 이 문제의 태그를 탐욕법으로 걸어 놓았으니 탐욕적으로 풀려고 한다. 탐욕적인 방법은 말 그래도 욕심을 부려서 최고의 결과를 얻고자 하는 방법이다.( 물론 항상 얻는다는 보장은 없다.!) 따라서 이 문제에서 적게 쓰고 최고의 결과를 얻기 위해서는 차량의 진출입로에 단속카메라를 설치하는 것이 가장 최상의 방법일 것이다. 

따라서 각 차량이 단속카메라에 만났는지 확인하는 check 배열을 만들었고, 임의로 설치한 단속카메라를 만났다면 1로 바뀌도록 하였다. routes를 정렬을 하고 뒤에서부터 진입로에 카메라를 설치해 나가도록 하였다. 
처음에는 -5에 설치를 하고 이 카메라가 확인할 수 있는 다른 차량을 확인해보았을 때. [-14,-5]와 [-20, 15]가 이 카메라로 확인을 할 수 있으니 이 차량들의 check도 1로 바꾼다. 그 다음에는 -18에 설치를 해서 [-18, 13]의 check도 1로 바꾸도록 한다. 따라서 2 개의 단속 카메라가 필요하게 된다.

ps) 뒤에서부터가 아닌 앞에서부터 하려고 했으나 통과를 하지 못해서 하지 못하였습니다.

1
2
3
4
5
6
7
8
9
10
11
12
def solution(routes):
    routes.sort()
    answer = 0
    check =[0]*len(routes)
    for i in range(len(routes)-1,-1,-1):
        if check[i]==0:
            camera = routes[i][0]
            answer+=1
        for j in range(i,-1,-1):
            if check[j]==0 and routes[j][1>= camera >=routes[j][0]:
                check[j]=1
    return answer
cs


728x90
반응형
728x90
반응형

문제 설명:

주어진 항공권을 모두 이용하여 여행경로를 짜려고 합니다. 항상 "ICN" 공항에서 출발합니다.

항공권 정보가 담긴 2차원 배열 tickets가 매개변수로 주어질 때, 방문하는 공항 경로를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

문제 풀이:

이 문제도 역시 경로를 탐색을 하는 문제이므로 깊이/너비 우선 탐색을 하는 문제이다. 또한 제한 사항 중에 주어진 항공권은 모두 사용해야 하고, 모든 도시를 방문을 할 수 없는 경우는 주어지지 않습니다. 라고 하였으니 항상 답이 있다고 가정을 하고 풀면 된다.

먼저 표의 현황을 깔끔하게 정리를 하기 위해서 tickets을 반복문으로 돌아가면서 이를 딕셔너리 타입(해시) 방식으로 정렬을 하였다. 매번 추가하면서 정렬을 한 이유는 만약 가능한 경로가 여러개라면 알파벳 순서가 앞서는 경로를 우선으로 해야하기 때문이다.


티켓을 정리한 뒤에 재귀적으로 탐색을 하는 함수인 travel에 ticket의 정보를 담고 있는 answer_set, 실제 경로인 answer, 출발하는 공항의 이름인 start, 그리고 모든 항공권을 사용했는지 탐색해야하므로 티켓의 갯수인 K 와 몇 개를 사용했는지 알려주는 count를 사용하였다.


처음에는 무조건 ICN에서 시작을 한다는 조건이 있었으므로 초기값은 ICN으로 시작한다. travel 함수에는 세 가지 조건이 존재한다. 


1. count == K 일 때

종료 조건으로 모든 티켓을 다 사용한 경우에 해당한다. 따라서 True를 반환한다.

2. 잘못 경로를 탐색해서 들어갔을 경우

해시 구조를 통해서 티켓을 정리했다보니 B 공항으로 도착을 하긴 했지만 B 공항에서 출발을 하는 티켓이 없을 수도 있다. 따라서 이 경우에 이 값을 찾으려 하면 error가 발생하기 때문에 예외처리구문을 사용해서 이 case를 탐지했다. 이 경우가 발생한거면 잘못된 경로를 온 것이기 때문에 answer의 마지막 값을 빼주고 잘못된 경로이므로 False를 반환한다.

3. 위 두 경우가 아닐 때

해시로 정리한 티켓을 기준으로 하나씩 경로를 늘려가면서 탐색해본다. 


위 과정을 거치다보면 answer를 구할 수 있게 된다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import copy
def travel(answer_set,answer,start,K,count):
    answer.append(start)
    if count==K:
        return True
    try:
        answer_set[start]
    except:
        answer.pop()
        return False
    for i in range(len(answer_set[start])):
        end=answer_set[start][i]
        count+=1
        temp_set=copy.deepcopy(answer_set)
        temp_set[start]=temp_set[start][:i]+temp_set[start][i+1:]
        boolean=travel(temp_set,answer,end,K,count)
        if boolean:
            return True
        else:
            count-=1
    answer.pop()
    return False
def solution(tickets):
    answer_set={}
    for ticket in tickets:
        if ticket[0in answer_set:
            answer_set[ticket[0]].append(ticket[1])
            answer_set[ticket[0]].sort()
        else:
            answer_set[ticket[0]]=[ticket[1]]
    answer=[]
    count=0
    start="ICN"
    travel(answer_set,answer,start,len(tickets),count)
    return answer
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2869. 달팽이는 올라가고 싶다.  (0) 2019.07.06
[BOJ]1011. Fly me to the Alpha Centauri  (0) 2019.07.05
[Programmers]Lv 3. 네트워크  (2) 2019.07.03
[BOJ]11057. 오르막 수  (0) 2019.07.01
[BOJ]1436. 영화감독 숌  (0) 2019.06.29
728x90
반응형

문제 설명:

네트워크란 컴퓨터 상호 간에 정보를 교환할 수 있도록 연결된 형태를 의미합니다. 예를 들어, 컴퓨터 A와 컴퓨터 B가 직접적으로 연결되어있고, 컴퓨터 B와 컴퓨터 C가 직접적으로 연결되어 있을 때 컴퓨터 A와 컴퓨터 C도 간접적으로 연결되어 정보를 교환할 수 있습니다. 따라서 컴퓨터 A, B, C는 모두 같은 네트워크 상에 있다고 할 수 있습니다.

컴퓨터의 개수 n, 연결에 대한 정보가 담긴 2차원 배열 computers가 매개변수로 주어질 때, 네트워크의 개수를 return 하도록 solution 함수를 작성하시오.

문제 풀이:

위와 같이 경로를 탐색해야 하는 경우 깊이/너비 우선 탐색으로 풀어야 하는 경우가 많고, 이 문제 역시 깊이 우선 탐색(DFS)로 풀어야 하는 문제였다. 깊이 우선 탐색은 stack을 이용하고, 너비 우선 탐색은 queue를 사용하는데, python의 list는 stack가 비슷하게 작동을 하기 때문에 stack이라는 리스트를 만들었고, 이미 지나왔던 경로임을 표시하기 위해서 visited라는 bool list를 만들었다.
A 컴퓨터에서 시작해서 지나가는 컴퓨터들을 전부 True로 바꾸면서 이동을 하였고, 더 이상 움직일 수 없을 때까지 반복을 하도록 하였다. 그리고 또한 이 과정을 하나의 count로 취급해 하나의 network가 생겼다고 생각을 하였다. 따라서 모든 컴퓨터가 True가 될 때까지 이 count를 반복해서 하면 network의 수를 구할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def Network(computers,visited,SNode):
    stack=[SNode]
    while stack:
        path = stack.pop()
        if not visited[path]:
            visited[path]=True
        for i in range(len(computers)):
            if computers[path][i]==1 and not visited[i]:
                stack.append(i)
def solution(n,computers):
    answer=0
    visited=[False for i in range(n)]
    idx=0
    while not all(visited):
        if not visited[idx]:
            Network(computers,visited,idx)
            answer+=1
        idx+=1
    return answer
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]1011. Fly me to the Alpha Centauri  (0) 2019.07.05
[Programmers]Lv 3. 여행경로  (0) 2019.07.04
[BOJ]11057. 오르막 수  (0) 2019.07.01
[BOJ]1436. 영화감독 숌  (0) 2019.06.29
[BOJ]1018. 체스판 다시 칠하기  (0) 2019.06.28
728x90
반응형

문제:

하드디스크는 한 번에 하나의 작업만 수행할 수 있습니다. 디스크 컨트롤러를 구현하는 방법은 여러 가지가 있습니다. 가장 일반적인 방법은 요청이 들어온 순서대로 처리하는 것입니다.

예를 들어,
0ms 시점에 3ms가 소요되는 A작업 요청
1ms 시점에 9ms가 소요되는 B작업 요청
2ms 시점에 6ms가 소요되는 C작업 요청

과 같이 요청이 들어왔습니다. 한 번에 하나의 요청만을 수행할 수 있기 때문에 각각의 작업을 요청받은 순서대로 처리하면 다음과 같이 처리 됩니다.

A: 3ms 시점에 작업 완료 (요청에서 종료까지 : 3ms)
B: 1ms부터 대기하다가, 3ms 시점에 작업을 시작해서 12ms  시점에 작업 완료(요청에서 종료까지 : 11ms)
C: 2ms부터 대기하다가, 12ms 시점에 작업을 시작해서 18ms 시점에 작업 완료(요청에서 종료까지 : 16ms)

이 때 각 작업의 요청부터 종료까지 걸린 시간의 평균은 10ms(=(3+11+16)/3)가 됩니다.

하지만 A->C->B 순서대로 처리하면

A: 3ms 시점에 작업 완료 (요청에서 종료까지 : 3ms)
C: 2ms부터 대기하다가, 3ms 시점에 작업을 시작해서 9ms  시점에 작업 완료(요청에서 종료까지 : 7ms)
B: 2ms부터 대기하다가, 9ms 시점에 작업을 시작해서 18ms 시점에 작업 완료(요청에서 종료까지 : 17ms)

이렇게 A->C->B의 순서로 처리하면 각 작업의 요청부터 종료까지 걸린 시간의 평균은 9ms(=(3+7+17)/3)가 됩니다.


각 작업에 대해 [작업이 요청되는 시점, 작업의 소요시간]을 담은 2차원 배열 jobs가 매개변수로 주어질 때, 작업의 요청부터 종료까지 걸린 시간의 평균을 가장 줄이는 방법으로 처리하면 평균이 얼마나 되는지 return 하도록 solution 함수를 작성해주세요. (단, 소주점 이하의 수는 버립니다)


풀이 방법:

 위에서 처음 소개한 방법은 FCFS 방법으로 먼저 들어오는 작업을 먼저 수행하는 것으로 긴 작업이 먼저 들어올 경우 뒤에 들어온 작업들이 수행하기까지 많은 시간을 대기하기 때문에 평균시간이 길어지게 된다. 따라서 이를 해결하기 위해서 후자의 방법인 SJF를 사용하는 것이다. 즉 짧은 요청을 먼저 수행하는 것이다. 별도의 정렬이 없어도 작은 값을 반환해줄 수 있는 힙 구조를 사용해서 이 문제를 풀어야 한다.

 last와 now라는 두 변수를 사용해서 하나의 작업이 들어간 시점과 나오는 시점을 구분해준다. 또한 이 두 변수를 이용해 구간을 구성하고 이 구간 사이에 있는 jobs들을 heap에 담도록 한다. heap에 담기전에 now에서 그 작업이 들어온 시점부터까지의 시간을 계산해서 더해준다.
 
 'C와 B의 작업은 A가 수행되고 있는 도중에 들어오게 되었으며, A가 끝나는 시점인 3ms 까지 각각 1ms, 2ms를 대기한다.'

또한 len(wait)와 wait[0]을 곱한 값을 더하기도 한다. 이 말은 다음과 같다.

 'C가 수행되는 동안에 B가 이미 들어와 있어서 같이 대기를 해야 한다. 즉 C의 수행시간인 6ms 만큼 B가 대기하고 있다. 총 12ms 만큼 시간이 더해져야 한다.'

와 같은 말이다. 

count 변수를 만들어서 이 변수가 jobs의 길이와 같이 지는 순간까지 반복하면 각 작업들이 총 수행되는 시간을 알 수 있고 이를 jobs의 길이로 나누어 준 몫을 구하면 평균을 구할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import heapq
def solution(jobs):
    last=-1
    now=0
    answer=0
    wait=[]
    n=len(jobs)
    count=0
    while(count<n):
        for job in jobs:
            if last <job[0]<=now:
                answer+=(now-job[0])
                heapq.heappush(wait,job[1])
        if len(wait)>0:
            answer+=len(wait)*wait[0]
            last=now
            now+=heapq.heappop(wait)
            count+=1
        else:
            now+=1
    return answer//n
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]11050. 이항 계수 1  (0) 2019.05.08
[BOJ]11866. 조세퍼스 문제0  (0) 2019.05.07
[BOJ]8979. 올림픽  (0) 2019.05.05
[BOJ]1076. 저항  (0) 2019.05.04
[BOJ]1977. 완전제곱수  (0) 2019.05.03
728x90
반응형

문제:

라면 공장에서는 하루에 밀가루를 1톤씩 사용합니다. 원래 밀가루를 공급받던 공장의 고장으로 앞으로 k일 이후에야 밀가루를 공급받을 수 있기 때문에 해외 공장에서 밀가루를 수입해야 합니다.

해외 공장에서는 향후 밀가루를 공급할 수 있는 날짜와 수량을 알려주었고, 라면 공장에서는 운송비를 줄이기 위해 최소한의 횟수로 밀가루를 공급받고 싶습니다.

현재 공장에 남아있는 밀가루 수량 stock, 밀가루 공급 일정(dates)과 해당 시점에 공급 가능한 밀가루 수량(supplies), 원래 공장으로부터 공급받을 수 있는 시점 k가 주어질 때, 밀가루가 떨어지지 않고 공장을 운영하기 위해서 최소한 몇 번 해외공장으로부터 밀가루를 공급받아야 하는지를 return 하도록 solution 함수를 완성하세요.

dates[i]에는 i번째 공급 가능일이 들어있으며, supplies[i]에는 dates[i] 날짜에 공급 가능한 밀가루 수량이 들어 있습니다.

풀이 방법:

stock의 합이 k를 넘어가면 더이상 공급을 받지 않아도 된다. 그러므로 while의 조건을 stock<k 으로 잡았다. 기본적으론 남아있는 stock에 따라서 공급을 받을 수 있는 양이 다르게 된다. 예시에서와 같이 초기 stock이 4이므로 dates의 4일째인 20을 받을 수밖에 없다. 만약 기간 내에 여러 개의 날에서 공급을 받을 수 있다면 가장 많은 양을 받아오는 것이 적게 공급을 받도록 할 수 있다. 따라서 이 과정에서 우선순위 큐, 즉 힙을 사용하게 된다. stock에 따라서 받을 수 있는 공급들을 리스트에 담고 인덱스를 저장한다. 그리고 이 리스트 중에서 가장 많은 공급의 양을 빼서 stock에 더한다.
python에서 heapq라는 모듈을 제공해서 힙구조를 만들 수 있도록 한다. 하지만 이 힙은 최소힙을 제공하므로 힙구조에서 pop을 했을 때 최솟값이 나오게 된다. 하지만 이 문제에서는 최댓값을 빼야 하므로 최대 힙을 만들도록 한다. 따라서 힙에 넣을 당시에 heapq.heappush(h,(-supplies[i],supplies[i])) 와 같이 넣어서 최대힙을 구성하도록 하고 stock+=heapq.heappop(h)[1] 로 값을 빼도록 한다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import heapq
def solution(stock, dates, supplies, k):
    answer = 0
    idx=0
    h=[]
    while(stock<k):
        for i in range(idx,len(dates)):
            if dates[i]<=stock:
                heapq.heappush(h,(-supplies[i],supplies[i]))
                idx=i+1
            else:
                break
        stock+=heapq.heappop(h)[1]
        answer+=1
    return answer
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2839.설탕 배달  (1) 2019.03.31
[BOJ]11718.그대로 출력하기  (0) 2019.03.30
[Programmers]Lv 2. 영어 끝말잇기  (0) 2019.03.28
[Programmers]Lv 2. 점프와 순간이동  (0) 2019.03.27
[Programmers]Lv 2.소수 만들기  (0) 2019.03.26
728x90
반응형

문제:

1부터 n까지 번호가 붙어있는 n명의 사람이 영어 끝말잇기를 하고 있습니다. 영어 끝말잇기는 다음과 같은 규칙으로 진행됩니다.

1. 1번부터 번호 순서대로 한 사람씩 차례대로 단어를 말합니다..
2. 마지막 사람이 단어를 말한 다음에는 다시 1번부터 시작합니다.
3. 앞사람이 말한 단어의 마지막 문자로 시작하는 단어를 말해야 합니다.
4. 이전에 등장했던 단어는 사용할 수 없습니다.
5. 한 글자인 단어는 인정되지 않습니다.

다음은 3명이 끝말잇기를 하는 상황을 나타냅니다.

tank ->kick ->know->wheel ->land->dream->mother->robot->tank

위 끝말잇기는 다음과 같이 진행됩니다.

* 1번 사람이 자신의 첫 번째 차례에 tank를 말합니다.
* 2번 사람이 자신의 첫 번째 차례에 kick을 말합니다.
* 3번 사람이 자신의 첫 번째 차례에 know을 말합니다.
* 1번 사람이 자신의 두 번째 차례에 wheel을 말합니다.
* (계속 진행)

끝말잇기를 계속 진행해 나가다 보면, 3번 사람이 자신의 세 번째 차례에 말한 tank라는 단어는 이전에 등장했던 단어이므로 탈락하게 됩니다.

사람의 수 n과 사람들이 순서대로 말한 단어 words가 매개변수로 주어질 때, 가장 먼저 탈락하는 사람의 번호와 그 사람이 자신의 몇 번째 차례에 탈락하는지를 구해서 return 하도록 solution 함수를 완성해주세요.

풀이 방법:

끝말잇기에서 탈락하는 조건은 이전에 말했던 단어를 말하는 것과 잘못된 단어를 말하는 것이다. 이전에 말했던 단어임을 체크하기 위해서 past라는 배열을 만들어서 말한 단어들을 담았다. 다음 사람이 말한 단어가 past에 있으면 problem을 True로 바꿔주고 반복문을 종료하고 없다면 past에 넣고 마지막 두개의 값을 비교해 옳게 이어서 말했는지 확인한다. 이후 몇번째에 틀린것인지 확인하기 위해 divmod로 확인한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def solution(n, words):
    answer = [0,0]
    past=[]
    past.append(words[0])
    words.remove(words[0])
    count=0
    problem=False
    for word in words:
        count+=1
        if word in past:
            problem=True
            break
        else:
            past.append(word)
            if past[-2][-1]==past[-1][0]:
                pass
            else:
                problem=True
                break
 
    if not problem:
        return answer
    else:
        answer[1],answer[0]=divmod(count,n)
        answer[0]+=1
        answer[1]+=1
        return answer
cs


728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]11718.그대로 출력하기  (0) 2019.03.30
[Programmers]Lv 2. 라면공장  (0) 2019.03.29
[Programmers]Lv 2. 점프와 순간이동  (0) 2019.03.27
[Programmers]Lv 2.소수 만들기  (0) 2019.03.26
[Programmers]Lv 3.단어 변환  (0) 2019.03.25

+ Recent posts