https://www.acmicpc.net/problem/2667

 

 

문제 설명에 나와있는 것을 보면....

2차원 행렬을 그래프로 표현해 BFS나 DFS로 순회한다? 설명이 뭔가 난해했다.

2차원 행렬을 그래프로 표현해? 2차원 행렬은 인접 노드들을 표현하기 위한 거였는데...

여기에 낚이지 말자. BFS나 DFS에서 썼던 2차원 행렬은 대각선으로 접었을 때 똑같은 데칼코마니 행렬이고,

여기서 말하는 2차원 행렬은 그냥 집이 있음/없음을 나타내는 불규칙한 행렬이다. 이걸 BFS나 DFS로 순회해보자는 거다.

 

자, 그럼 인접한 노드들은 어떻게 알 수 있을까?

인덱스로 알 수 있다. 어떤 한 집의 주소가 houses[row][col] 이라면, 인접한 집은 위/아래/왼쪽/오른쪽이므로

이웃집들은 [row+1, col], [row-1, col], [row, col-1], [row, col+1] 이다. 인접 노드들은 이것들로 잡으면 된다.

 

하지만 이 이웃집들이 항상 존재하는 것은 아니다.

집이 없을수도 있고 (houses[row][col] == 0),

땅조차 없을 수도 있다. (row나 col이 mapSize를 벗어날 때)

 

이러한 조건들을 맞춰주면서 BFS나 DFS를 짜면 된다.

 

 

 

데이터 입력부

import sys

mapSize = int(sys.stdin.readline())
houses = [sys.stdin.readline()[:-1] for _ in range(mapSize)]  # 입력
visited = [[0 for _ in range(mapSize)] for _ in range(mapSize)]  # 이미 카운트됨 표시
ret = []
for row in range(mapSize):
    for col in range(mapSize):
        if houses[row][col] == '1' and visited[row][col] == 0:
            newTown = BFS(row, col)  # 리스트에 값이 추가될 때마다 새로운 단지 추가
            ret.append(newTown)      # newTown에 저장된 숫자는 각 단지에 포함된 가구 수

mapSize는 한 변의 길이이다. houses는 입력받은 1010111...따위를 저장한 리스트고,

visited는 이미 카운트된 집을 표시하는 리스트이다. DFS나 BFS에서 사용하는 이름을 그냥 따왔다. 어떤 조사원 한 명이 집집마다 방문하면서 단지 수를 센다고 생각하면 이해하기 편하겠다.

7번 줄부터 이중 for문을 돌면서 houses가 1인 곳을 찾는데, mapSize가 최대 25이므로 0부터 제일 끝까지 살펴봤자 25*25=625밖에 안된다. 맘편하게 돌자.

참고로 제출할 때는 4번 줄에 [:-1]을 없애야 한다. 백준 데이터 입력은 스트링 맨 끝에 \n 없이 들어오기 때문이다.

테스트 케이스를 복붙할 때는 \n이 있어서 코딩할 때는 저렇게 해야지 어쩔 수 없다.

 

 

 

DFS (스택)

def DFS(row, col):
    stack = []  # houses가 1인 이웃집들이 추가될 것임
    stack.append([row, col])  
    connected = 0  # 가구 수

    while stack:
        [r, c] = stack.pop()
        if visited[r][c] == 0:
            connected += 1
            visited[r][c] = 1
            for [nR, nC] in [[r+1, c], [r-1, c], [r, c+1], [r, c-1]]:  # 인접
                if 0 <= nR < mapSize and 0 <= nC < mapSize:  # 범위 체크
                    if houses[nR][nC] == '1':
                        stack.append([nR, nC])
    return connected
    

print(len(ret))
ret.sort()
for i in ret:
    print(i)

houses가 1인 이웃집들만 스택에 추가를 해 주면서, 아직 방문하지 않았다면 connected에 하나 추가하는 식으로 가구 수를 세어 나가면 된다.

 

 

 

BFS

import collections

def BFS(row, col):
    queue = collections.deque()  # houses가 1인 이웃집들이 추가될 것임
    queue.append([row, col])
    connected = 0  # 가구 수

    while queue:
        [r, c] = queue.popleft()  # 큐에서 꺼낸 row, col -> r, c
        if visited[r][c] == 0:
            connected += 1
            visited[r][c] = 1
            for [nR, nC] in [[r+1, c], [r-1, c], [r, c+1], [r, c-1]]:  # 인접.이웃.
                if 0 <= nR < mapSize and 0 <= nC < mapSize:  # 범위 체크
                    if houses[nR][nC] == '1':
                        queue.append([nR, nC])
    return connected
    
print(len(ret))
ret.sort()
for i in ret:
    print(i)

BFS도 똑같으니 설명 생략.

 

 

 

'알고리즘 > BFS와 DFS' 카테고리의 다른 글

2206번. 벽 부수고 이동하기  (0) 2019.12.18
7576번. 토마토  (0) 2019.12.17
1012번. 유기농 배추  (0) 2019.12.13
2606번. 바이러스  (0) 2019.12.13
1260번. DFS와 BFS  (0) 2019.12.13

https://www.acmicpc.net/problem/2606

 

 

 

BFS 혹은 DFS로 풀 수 있는 문제인데, 전에 포스팅했던 문제보다는 조건이 덜 까다롭다.

인접 노드들을 일정한 순서대로 방문할 필요가 없으므로 인접 노드들을 저장할 때 set을 사용했다.

 

import sys
import collections


def BFS(start):
    infected = []
    queue = collections.deque()
    queue.append(start)

    while queue:
        node = queue.popleft()
        if node not in infected:
            infected.append(node)
            if node in network:
                queue.extend(network[node])
    return len(infected)-1


nodeCount = int(sys.stdin.readline())
edgeCount = int(sys.stdin.readline())
network = {}

for _ in range(edgeCount):
    start, end = map(int, sys.stdin.readline().split())
    if start not in network:
        network[start] = {end}  # set. 집합
    elif start in network:
        network[start].add(end)
    if end not in network:
        network[end] = {start}
    elif end in network:
        network[end].add(start)

#print(network)

print(BFS(1))

'알고리즘 > BFS와 DFS' 카테고리의 다른 글

2206번. 벽 부수고 이동하기  (0) 2019.12.18
7576번. 토마토  (0) 2019.12.17
1012번. 유기농 배추  (0) 2019.12.13
2667번. 단지번호붙이기  (0) 2019.12.13
1260번. DFS와 BFS  (0) 2019.12.13

https://www.acmicpc.net/problem/1260

 

 

딕셔너리를 이용한 DFS와 BFS 구현하기 문제이다.

인접 행렬(이중 리스트)이 아닌 딕셔너리를 사용한 이유는, 정점은 많은데 간선이 적은 경우 시간 및 메모리 낭비를 피하기 위함이다. 예를 들어 정점은 1000개인데 간선은 1개일 때, 인접 행렬의 0, 1로 이를 표현한다고 생각해보자. 0들로 채워진 수많은 값들은 버려질 것이다. 그리고 탐색할 때도 오래 걸릴 것이다.

따라서 파이썬을 통해 DFS 및 BFS를 구현할 때는 {시작정점:도착정점}으로 이루어진 딕셔너리를 사용하는 것이 좋다고 판단했다.

 

단순한 것 같지만 인터넷에서 BFS, DFS 구현 코드를 배워다 그대로 쓰면 틀리는 문제이다.

문제에 있는 조건 중 신경써야 할 것은 

자식이 여러 개라면 작은 것부터 방문해야 한다는 것이고,

또한 간선이 없는 그래프일 수도 있다 (ex: 입력이 1 0 1 인 경우) 는 것이다.

 

(참고..쓰다보니 단어를 혼합해서 썼는데 정점=노드, 인접=자식 의 의미로 썼다.)

먼저 데이터 삽입부부터 보자.

n, m, v = map(int, sys.stdin.readline().split())  # n=정점 갯수, m=간선 갯수, v=시작점
graph = {}  # 인접 노드들을 표시한 딕셔너리
for _ in range(m):
    start, end = map(int, sys.stdin.readline().split())
    if start in graph:
        if end not in graph[start]:
            graph[start].append(end)
    elif start not in graph:
        graph[start] = [end]
    if end in graph:
        if start not in graph[end]:
            graph[end].append(start)
    elif end not in graph:
        graph[end] = [start]

for vertex in graph.keys():
    graph[vertex].sort()

1) 문제에 있는 알파벳을 그대로 사용했다.

2) graph는 자식 노드(인접 노드)들을 표시한 딕셔너리이다.

3) 간선 갯수만큼 for문을 돌린다. 노드 갯수만큼이 아니다. 입력으로 주어지는 1 3, 2 3 등은 간선을 표시한 거다.

4) start와 end는 시작 정점, 도착 정점을 의미한다. 사실 시작과 도착의 의미는 없지만 1 3에서 앞에 있는 숫자가 시작, 뒤에 있는 숫자가 도착이라고 임의로 정한거다. 

5) 먼저 start라는 정점이 graph에 이미 key로 존재하는지 확인하고, 있다면 거기에 end를 추가한다. 

6) graph[start]에 이미 end라는 정점이 있는지 살피는 이유는 두 정점 사이에 여러 간선이 있을 수 있기 때문이다. 입력이 2 5, 5 2 와 같이 들어왔을 때 굳이 자식들이 중복되서 들어가지 않게 하기 위함이다.

8) 만약 graph에 start라는 key가 없다면, 그 key를 추가하고 end를 리스트화해서 value로 넣는다.

10~14) end라는 정점에 대해서 같은 작업을 반복해준다. 무방향 그래프이므로, 1 3이 주어진다면 1의 자식은 3이며 3의 자식은 1이기 때문이다.

16~17) 입력이 오름차순으로 순차적으로 주어진다는 보장이 없으므로 정렬해준다.

 

설명은 엄청 긴데, 리스트를 사용해서 중복을 제거하며 인접 노드들을 (양방향으로) 추가해줬다고 생각하면 된다.

graph는 {1: [2, 3], 2: [1], 3: [1, 4], 4: [3]} 이런 모양이다.

인접 노드를 추가할 때 중복을 피하는 작업을 하면서까지 굳이 set을 안 쓰고 리스트를 쓴 이유는 

나중에 인접한 노드가 여러 개일 경우 크기가 작은 것부터 방문해야 하는데, set은 순서가 없는 자료형이기 때문이다.

 

아래로는 진짜 구현부다.

 

 

 

재귀를 이용한 DFS

def DFS_recursion(start, visited):
    visited.append(start)
    if start in graph:
        for child in graph[start]:
            if child not in visited:
                DFS_recursion(child, visited)
    return visited
    
ret = []
Print(DFS_recursion(v, ret))

좀더 이해하기 쉬운 재귀를 이용한 방식이다. 먼저 문제에서 정해준 v라는 시작 정점으로 호출한다.

2) 해당 정점을 방문한 리스트에 추가한다.

3) 해당 정점이 인접 노드가 있다면! (무인도처럼 떨어져 있는 정점이 있을 수 있다. 이런 경우에 해당 정점은 graph에 등장하지 않는다. 이 if문이 없다면 런타임 에러가 날 수 있다)

4) 그 인접 노드들을 child로 하나하나 가지고 와서 방문하지 않았을 경우, 그 child로 다시 이 함수를 시작한다.

이 함수는 자식 노드들을 방문하는 함수이므로, 재귀 함수를 호출할 때마다 자식 노드->자식의 자식 노드->자식의 자식의 자식 노드 순으로 방문하게 된다.

하지만 이와 같이 재귀로 DFS를 구현할 경우 이해하기에는 직관적이지만 속도가 느려질 수 있고 최대 재귀 깊이에 따라서 에러가 날 수 있다.

 

 

 

Stack를 이용한 DFS

def DFS_stack(start):
    visited = []
    stack = []
    stack.append(start)

    while stack:
        node = stack.pop()
        if node not in visited:
            visited.append(node)
            if node in graph:
                stack.extend(sorted(graph[node], reverse=True))
    return visited
    
 Print(DFS_stack(v))

 스택을 이용한 방식은 stack이라는 리스트를 따로 만들어줘야 한다. 스택을 이용한 방식에서는 이 함수를 또다시 호출하는 일은 없을 것이므로 visited를 함수 밑에서 생성해도 된다.

4) 먼저 시작 정점을 stack에 추가한다.

6) stack이 비어 있지 않을 때까지 진행한다.

7~8) stack에서 노드를 하나 꺼내서, 아직 방문하지 않았다면 방문한 리스트에 추가하고

9) 그 노드가 인접 딕셔너리에 key로 존재한다면, 즉 인접 노드들을 가지고 있다면! (인접 노드가 0일 수 있음)

10) stack 리스트에 그 인접 노드들을 모두 추가해주되, 역순으로 추가한다. 그 이유는 스택은 마지막에 들어온 것이 먼저 나가는데, 현재 노드가 1이고 앞으로 추가할 노드들이 2, 3, 4라고 한다면 4, 3, 2 순으로 추가해줘야 2부터 방문할 것이기 때문이다.

이게 왜 DFS이냐 하면, 스택에 추가되서 방문되는 순서를 생각해보자. 시작 노드가 1이고 그 자식 노드가 2, 3, 4라고 한다면 스택에 4, 3, 2 순으로 들어올 것이다. 그 다음 반복문에서 2를 pop 하고 방문한 뒤 2의 자식들을 또 stack에 추가하고, 그것들을 방문하고...생각해보면 DFS이다.

 

 

 

리스트를 사용한 BFS

def BFS_list(start):
    visited = []
    queue = []
    queue.append(start)

    while queue:
        node = queue.pop(0)
        if node not in visited:
            visited.append(node)
            if node in graph:
                queue.extend(graph[node])  # node의 자식 노드 추가
    return visited
    
Print(BFS_list(v))

리스트보다는 collections의 deque를 사용하는 것이 빠르지만, 이해를 위해서 일단 리스트를 사용했다.

BFS는 DFS 스택 버전과 거의 비슷하다. 달라지는 것은 7번줄의 pop(0)이다.

앞에서부터 노드를 빼서 방문하겠다는 것이다. 

처음에는 시작 노드의 자식 노드들을 방문했다가, 그 자식들의 자식들을 맨 뒤에 추가하고, 앞에서부터 순차적으로 방문하니 BFS가 되는 것이다.

 

 

 

Collections의 Deque를 사용한 BFS

import collections

def BFS_queue(start):
    visited = []
    queue = collections.deque()
    queue.append(start)

    while queue:
        node = queue.popleft()
        if node not in visited:
            visited.append(node)
            if node in graph:
                queue.extend(graph[node])
    return visited
    
Print(BFS_queue(v))

pop(0) 는 O(N)

deque의 popleft() 는 O(1)이다. 큐를 파이썬에서 사용하려면 이것을 써야한다고 한다.

 

 

 

 

코드 전문

import sys
import collections


def DFS_recursion(start, visited):
    visited.append(start)
    if start in graph:
        for child in graph[start]:
            if child not in visited:
                DFS_recursion(child, visited)
    return visited


def DFS_stack(start):
    visited = []
    stack = []
    stack.append(start)

    while stack:
        node = stack.pop()
        if node not in visited:
            visited.append(node)
            if node in graph:
                stack.extend(sorted(graph[node], reverse=True))
    return visited


def BFS_list(start):
    visited = []
    queue = []
    queue.append(start)

    while queue:
        node = queue.pop(0)
        if node not in visited:
            visited.append(node)
            if node in graph:
                queue.extend(graph[node])  # node의 자식 노드 추가
    return visited


def BFS_queue(start):
    visited = []
    queue = collections.deque()
    queue.append(start)

    while queue:
        node = queue.popleft()
        if node not in visited:
            visited.append(node)
            if node in graph:
                queue.extend(graph[node])
    return visited


def Print(lst):
    for i in lst:
        print(i, end=' ')
    print("")


n, m, v = map(int, sys.stdin.readline().split())  # n=정점 갯수, m=간선 갯수, v=시작점
graph = {}  # 인접 노드들을 표시한 딕셔너리
for i in range(m):
    start, end = map(int, sys.stdin.readline().split())
    if start in graph:
        if end not in graph[start]:
            graph[start].append(end)
    elif start not in graph:
        graph[start] = [end]
    if end in graph:
        if start not in graph[end]:
            graph[end].append(start)
    elif end not in graph:
        graph[end] = [start]

for vertex in graph.keys():
    graph[vertex].sort()

print(graph)
ret = []
#Print(DFS_recursion(v, ret))
Print(DFS_stack(v))
#Print(BFS_list(v))
Print(BFS_queue(v))

'알고리즘 > BFS와 DFS' 카테고리의 다른 글

2206번. 벽 부수고 이동하기  (0) 2019.12.18
7576번. 토마토  (0) 2019.12.17
1012번. 유기농 배추  (0) 2019.12.13
2667번. 단지번호붙이기  (0) 2019.12.13
2606번. 바이러스  (0) 2019.12.13

https://www.acmicpc.net/problem/10816

 

 

참고) 파이썬에서 이 문제를 이분탐색으로 풀면 시간초과가 발생한다.

 

import sys


# 처음으로 key와 같거나 큰 값이 나타나는 위치를 찾는다
def lowerBound(start, end, key):
    while start < end:
        mid = (start + end) // 2
        if nList[mid] <= key:
            end = mid
        elif nList[mid] < key:
            start = mid + 1
    return end


# 처음으로 key보다 큰 값이 나타나는 위치를 찾는다
def upperBound(start, end, key):
    while start < end:
        mid = (start + end) // 2
        if nList[mid] <= key:
            start = mid + 1
        elif key < nList[mid]:
            end = mid
    return end


n = int(sys.stdin.readline())
nList = list(map(int, sys.stdin.readline().split()))  # 상근이 갖고 있는 카드 리스트
m = int(sys.stdin.readline())
mList = list(map(int, sys.stdin.readline().split()))  # 찾아야 할 카드 리스트
nList.sort()

for i in mList:
    ret = upperBound(0, n, i) - lowerBound(0, n, i)
    print(ret, end=' ')

'알고리즘 > 바이너리서치' 카테고리의 다른 글

Upper bound 이진 탐색  (0) 2019.12.12
Lower bound 이진 탐색  (0) 2019.12.11
1920번. 수 찾기  (0) 2019.12.10

앞서 Lower bound 이진 탐색에 대해 알아보았다. 

https://awesomeroo.tistory.com/30

 

 

이번에는 Upper bound 이진 탐색이다. Upper bound 이진 탐색은 처음으로 큰 값이 나타나는 위치를 찾는다.

먼저 일반적인 binary search 코드이다.

Lower bound에서도 그랬지만, Upper bound와의 코드 비교를 위해서 올린다.

def binarySearch(start, end, key):
    while start <= end:
        mid = (start + end) // 2
        if lst[mid] > key:
            end = mid - 1
        elif lst[mid] < key:
            start = mid + 1
        elif lst[mid] == key:
            return 1
    return 0


lst = [0, 1, 2, 3, 3, 5, 6, 7, 8]
print(binarySearch(0, len(lst)-1, 3))

 

 

그리고 Upper bound binary search.

def upperBound(start, end, key):
    while start < end:
        mid = (start + end) // 2
        if lst[mid] == key:
            start = mid + 1
        elif lst[mid] < key:
            start = mid + 1
        elif key < lst[mid]:
            end = mid
    return end
    
lst = [0, 1, 2, 3, 3, 5, 6, 7, 8]
print(upperBound(0, len(lst), 6))

 

이번에도 upper bound에서는 일반 바이너리 서치와 같은 세 가지 if문이 등장한다.

1. lst[mid] == key

2. lst[mid] < key

3. key < lst[mid]

 

먼저 1번을 보자. upper bound는 key보다 큰 값이 나오는 위치를 찾아야 하므로, 

lst[mid]가 key와 같다면 그 값은 포함시킬 필요가 없다. 따라서 start를 mid에서 하나 증가한 값으로 변경한다.

2번. key가 lst[mid]보다 크다면, 마찬가지로 key보다 큰 값을 찾아야 하기 때문에 key보다 작은 lst[mid]는 다음 탐색 범위에 포함시킬 필요가 없다. 그래서 start를 mid에서 하나 증가한 값으로 변경한다.

3번. key가 lst[mid]보다 작을 때를 보자. mid가 너무 큰 것이므로 end를 작게 해줘야 하는데, lst[mid]가 key보다 처음으로 큰 값(원하는 값)일 수도 있으므로 lst[mid]를 포함시키기 위해 end=mid가 된다.

 

return end 하는 이유는, start = end가 되는 순간 start와 end가 정답이 되기 때문이다.

 

또한 함수를 처음 콜하는 부분에서 end가 len(lst)-1이 아니라 len(lst)가 되는 이유는,

리스트를 끝까지 살폈는데 답이 안 나온다면 마지막으로 살폈던 위치를 반환할 것이기 때문이다. 그 때 len(lst)를 반환해서 답이 없음을 알아보기 위함이다. 

'알고리즘 > 바이너리서치' 카테고리의 다른 글

10816번. 숫자카드 2  (0) 2019.12.12
Lower bound 이진 탐색  (0) 2019.12.11
1920번. 수 찾기  (0) 2019.12.10

먼저 이진 탐색 코드.

def binarySearch(start, end, key):
    while start <= end:
        mid = (start + end) // 2
        if lst[mid] > key:
            end = mid - 1
        elif lst[mid] < key:
            start = mid + 1
        elif lst[mid] == key:
            return 1
    return 0
    
lst = [0, 1, 2, 3, 3, 5, 6, 7]
print(binarySearch(0, len(lst)-1, 7))

 

 

Lower bound 이진 탐색이란 

찾고 싶은 key 값과 같은 값이 나타나는 첫 위치를  찾거나,

같은 값이 없으면 큰 값이 나타나는 첫 위치를 찾는 방법이다.

def lowerBound(start, end, key):
    while start < end:
        mid = (start + end) // 2
        if lst[mid] == key:
            end = mid
        elif key < lst[mid]:
            end = mid
        elif lst[mid] < key:
            start = mid + 1
    return end
    
lst = [0, 1, 2, 3, 3, 5, 6, 7]
print(lowerBound(0, len(lst), 7))

범위 설정에 있어서 이진 탐색과 비교했을 때 이해가 안되서 애먹었다.

일부러 이해하기 쉽도록 ==, <, > 세 가지 케이스로 나누었다.

 

먼저 2번째 줄, 보통의 이진 탐색은 조건을 while start <= end 로 잡는다.

하지만 lower bound는 while start < end 로 잡는다.

그 이유는 일반 이진 탐색은 start == end가 되었을 때도 그 값이 찾고자 하는 key였는지 살피고 나서 찾았으면 1을 리턴하고 못 찾았으면 0을 리턴하든지 해야 하는데,

lower bound는 start == end가 되었으면 바로 그 위치를 리턴하면 되기 때문이다. start == end가 되는 순간 그 값이 key와 같은 값이거나 처음으로 큰 것이 나타나는 위치이기 때문이다. 그래서 start == end 는 while이 진행될 조건으로 포함시킬 필요가 없다.

 

다음 if 문을 보자.

일반 이진 탐색에서의 세 가지 if문을 보자.

1. lst[mid] == key

2. key < lst[mid]

3. lst[mid] < key

 

먼저 3번은 일반 이진 탐색과 같다고 보면 된다. 

lower bound는 key와 같거나 더 큰 값을 찾아야 하므로 key가 더 크다면 start를 높여서 최소한 같은 값이라도 찾을 수 있도록 범위를 좁혀주어야 한다.

하지만 1. lst[mid] == key 일 때는?

원하는 key가 나오긴 했지만, 똑같은 값이 더 왼쪽에서 나타날 수도 있다.

따라서 이 위치를 포함해서 더 작은 위치에서 이 값이 등장하지는 않는지 다시 한번 살펴야 하는 것이다.

2. key < lst[mid]도 마찬가지이다. key가 lst[mid]보다 작긴 하지만, 무작정 바이너리 서치처럼 end = mid - 1 할 수 없는 이유는 lst[mid]가 key보다 처음으로 큰 값일 수 있기 때문이다.

 

마지막, lowerBound 함수를 호출하는 부분을 보자.

보통 이진 탐색이라면 함수를 호출할 때 start를 0으로, end를 len(lst)-1로 둘 것이다. 왜냐? 배열은 0부터 시작이니까.

하지만 lower bound 이진 탐색의 경우, end를 len(lst)로 두었다.

그 이유는 리스트 안에 원하는 값이 없었을 경우, 즉 원하는 key보다 작은 값들만 있었을 경우 

마지막 while문을 돌 때 start와 end가 len(lst)가 됨으로써

len(lst)를 반환하게 되고, 리스트에 존재하지 않는 인덱스를 반환했기 때문에 리스트에 key가 없다! 는 것을 알기 위함이다.

(원하는 key보다 큰 값들만 있었을 경우에 리턴값은 0이다. lower bound가 뭔지 생각해보자)

 

'알고리즘 > 바이너리서치' 카테고리의 다른 글

10816번. 숫자카드 2  (0) 2019.12.12
Upper bound 이진 탐색  (0) 2019.12.12
1920번. 수 찾기  (0) 2019.12.10

https://www.acmicpc.net/problem/1920

 

 

import sys


def binarySearch(start, end, num):
    mid = (start + end) // 2
    if nList[mid] == num:
        return 1
    if start > end:
        return 0
    if num > nList[mid]:
        start = mid + 1
    elif num < nList[mid]:
        end = mid - 1
    return binarySearch(start, end, num)


n = int(sys.stdin.readline())
nList = list(map(int, sys.stdin.readline().split()))
m = int(sys.stdin.readline())
mList = list(map(int, sys.stdin.readline().split()))

nList.sort()

for i in mList:
    print(binarySearch(0, n-1, i))

 

'알고리즘 > 바이너리서치' 카테고리의 다른 글

10816번. 숫자카드 2  (0) 2019.12.12
Upper bound 이진 탐색  (0) 2019.12.12
Lower bound 이진 탐색  (0) 2019.12.11

https://www.acmicpc.net/problem/2630

 

 

 

 

처음에는 시작점, 종료점 각각을 매개변수로 넣었다가 더 헷갈려서

시작점의 row, col, 한 변의 길이만을 매개변수로 두었다.

시작하는 row, col 위치만 안다면 각각에 +n만 해서 범위를 잡을 수 있기 때문이다.

어째 분할과 정복보다는 위치 잡는 게 더 헷갈렸던 문제.

import sys


# (시작점 row, 시작점 col, 한 변의 길이)
def devideAndConquer(r, c, n):
    global white, blue
    color = board[r][c]
    for row in range(r, r + n):
        for col in range(c, c + n):
            if board[row][col] != color:
                devideAndConquer(r, c, n//2)  # 0, 0
                devideAndConquer(r, c + n // 2, n//2)  # 0, 1
                devideAndConquer(r + n // 2, c, n//2)  # 1, 0
                devideAndConquer(r + n // 2, c + n // 2, n//2)  # 1, 1
                return
    if color == B:
        blue += 1
    elif color == W:
        white += 1

N = int(sys.stdin.readline())
board = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
W, B = 0, 1
white, blue = 0, 0
devideAndConquer(0, 0, N)

print(white)
print(blue)

+ Recent posts