PROJECT REBAS

자료구조 · C++로 구현한 덱

레바스 — Tue, 30 Apr 2019 14:23:27 +0900

덱 (Deque)

덱은 Double-Ended Queue의 약자이며, 양쪽에서 원소의 삽입과 삭제가 가능한 선형 자료구조이다.

큐와 스택을 합친 형태라고 생각하면 된다. 원형 큐(Circular Queue)와 비슷하게 구현하므로, 이전 글을 참조.

한쪽에 push 하고 같은 쪽에서 pop 하면, 스택처럼 사용할 수 있다.
한쪽에 push 하고 반대쪽에서 pop 하면, 큐처럼 사용할 수 있다.

Deque C++ 구현 소스코드

#include <iostream>
using namespace std;

const int MAX = 1e5;

class Deque {
private:
    int data[MAX];
    int index_front;
    int index_back;
public:
    Deque();
    bool empty();
    void push_front(int x);
    void push_back(int x);
    void pop_front();
    void pop_back();
    int front();
    int back();
    int size();
};

Deque::Deque() {
    index_front = 0;
    index_back = 0;
}

bool Deque::empty() {
    return index_front == index_back;
}

void Deque::push_front(int x) {
    data[index_front] = x;
    index_front = (index_front-1+MAX) % MAX;
}

void Deque::push_back(int x) {
    index_back = (index_back+1) % MAX;
    data[index_back] = x;
}

void Deque::pop_front() {
    index_front = (index_front+1) % MAX;
}

void Deque::pop_back() {
    index_back = (index_back-1+MAX) % MAX;
}

int Deque::front() {
    return data[(index_front+1)%MAX];
}

int Deque::back() {
    return data[index_back];
}

int Deque::size() {
    return (index_back-index_front+MAX)%MAX;
}

int main() {
    Deque dq;
    for (int i=1; i<=3; i++) dq.push_front(i);  // Push front 1~3
    dq.pop_front();     // Pop front
    for (int i=4; i<=6; i++) dq.push_back(i);   // Push back 4~6
    dq.pop_back();      // Pop back
    dq.push_front(7);   // Push front 7
    Deque dq2 = dq;     // Copy deque
    cout << "* Pop Back: ";
    while (!dq.empty()) {
        cout << dq.back() << " -> ";
        dq.pop_back();  // Pop back all
    }
    cout << "\n* Pop Front: ";
    while (!dq2.empty()) {
        cout << dq2.front() << " -> ";
        dq2.pop_front();  // Pop front all
    }
    return 0;
}

# main 함수 출력 결과

* Size: 5
* Pop Back: 5 -> 4 -> 1 -> 2 -> 7 ->
* Pop Front: 7 -> 2 -> 1 -> 4 -> 5 ->

✓ 배열로 구현한 덱이다. 예외 처리는 하지 않았다.

Deque 클래스 설명

const int MAX = 1e5;

class Deque {
private:
    int data[MAX];
    int index_front;
    int index_back;
public:
    Deque();
    bool empty();
    void push_front(int x);
    void push_back(int x);
    void pop_front();
    void pop_back();
    int front();
    int back();
    int size();
};

✓ MAX는 덱의 최대 사이즈이다. 값을 바꾸면 최대 사이즈를 조절할 수 있다.

✓ Data는 덱에 넣은 원소를 저장하는 배열이다.

✓ index_front는 앞에 넣은 원소의 위치를 가리키는 변수다.

✓ index_back은 뒤에 넣은 원소의 위치를 가리키는 변수다.

# 생성자와 empty 함수

Deque() {
    index_front = 0;
    index_back = 0;
}

bool empty() {
    return index_front == index_back;
}

✓ 생성자를 이용하여 Front 인덱스, Back 인덱스를 둘 다 0으로 초기화한다.

✓ empty 함수는 덱이 비어있는지 확인하는 함수이다. Front 인덱스와 Back 인덱스가 서로 같다면, 덱이 비어있는 상태이다.

# push_front, push_back 함수

void push_front(int x) {
    // Full check
    data[index_front] = x;
    index_front = (index_front-1+MAX) % MAX;
}

void push_back(int x) {
    // Full check
    index_back = (index_back+1) % MAX;
    data[index_back] = x;
}

✓ 덱에 원소를 집어넣는다. push_front 함수는 덱의 앞에 원소를 넣으며, push_back 함수는 덱의 뒤에 원소를 넣는다.

✓ 원소를 넣기 전에, 덱이 꽉 찬 상태인지 확인하여 예외 처리를 해야 한다.

# pop_front, pop_back 함수

void pop_front() {
    // Empty check
    index_front = (index_front+1) % MAX;
}

void pop_back() {
    // Empty check
    index_back = (index_back-1+MAX) % MAX;
}

✓ 덱에서 원소를 제거한다. pop_front 함수는 덱의 가장 앞에 있는 원소를 빼고, pop_back 함수는 덱의 가장 뒤에 있는 원소를 뺀다.

✓ 원소를 빼기 전에, 덱이 비어있는 상태인지 확인하여 예외 처리를 해야 한다.

# front, back 함수

int front() {
    // Empty check
    return data[(index_front+1)%MAX];
}

int back() {
    // Empty check
    return data[index_back];
}

✓ front 함수는 가장 앞에 넣은 원소가 무엇인지 보는 함수이다.

✓ back 함수는 가장 뒤에 넣은 원소가 무엇인지 보는 함수이다.

✓ 두 함수 모두, 덱이 비어있는 상태인지 확인하여 예외 처리를 해야 한다.

# size 함수

int size() {
    return (index_back-index_front+MAX)%MAX;
}

✓ 덱에 몇 개의 원소가 들어있는지 확인하는 함수이다.

자료구조 · C++로 구현한 스택

레바스 — Tue, 30 Apr 2019 14:23:10 +0900

스택 (Stack)

스택은 후입선출(LIFO; Last in First out) 방식의 선형 자료구조이다.

후입선출이란, 나중에 들어간 것이 먼저 나온다는 뜻이다. 즉, 스택은 나중에 들어간 데이터를 먼저 처리하는 자료구조이다.

Stack C++ 구현 소스코드

#include <iostream>
using namespace std;

const int MAX = 1e5;

class Stack {
private:
    int data[MAX];
    int index;
public:
    Stack();
    bool empty();
    void push(int x);
    void pop();
    int top();
    int size();
};

Stack::Stack() {
    index = -1;
}

bool Stack::empty() {
    return index == -1;
}

void Stack::push(int x) {
    index += 1;
    data[index] = x;
}

void Stack::pop() {
    index -= 1;
}

int Stack::top() {
    return data[index];
}

int Stack::size() {
    return index+1;
}

int main() {
    Stack s;
    for (int i=1; i<=10; i++) s.push(i); // Push 1~10
    for (int i=1; i<=4; i++) s.pop(); // Pop 10~7
    for (int i=1; i<=4; i++) s.push(i); // Push 1~4
    cout << "* Size: " << s.size() << '\n';
    while (!s.empty()) {
        cout << "Pop: " << s.top() << '\n';
        s.pop();    // Pop all
    }
    return 0;
}

# main 함수 출력 결과

* Size: 10
Pop: 4
Pop: 3
Pop: 2
Pop: 1
Pop: 6
Pop: 5
Pop: 4
Pop: 3
Pop: 2
Pop: 1

✓ 배열로 구현한 스택이다. 예외 처리는 하지 않았다.

Stack 클래스 설명

const int MAX = 1e5;

class Stack {
private:
    int data[MAX];
    int index;
public:
    Stack();
    bool empty();
    void push(int x);
    void pop();
    int top();
    int size();
};

✓ MAX는 스택의 최대 사이즈이다. 값을 바꾸면 최대 사이즈를 조절할 수 있다.

✓ Data는 스택에 넣은 원소를 저장하는 배열이다.

✓ index는 가장 마지막에 넣은 원소의 위치를 가리키는 변수다.

# 생성자와 empty 함수

Stack() {
    index = -1;
}

bool empty() {
    return index == -1;
}

✓ 생성자를 이용하여 인덱스를 -1로 초기화한다.

✓ empty 함수는 스택이 비어있는지 확인하는 함수이다. 인덱스가 -1이면, 스택이 비어있는 상태이다.

# push 함수

void push(int x) {
    // Full check, if index == MAX-1
    index += 1;
    data[index] = x;
}

✓ 스택에 원소를 집어넣는다. 인덱스를 1 증가시키고, 그 위치에 원소를 저장한다.

✓ 원소를 넣기 전에, 스택이 꽉 찬 상태인지 확인하여 예외 처리를 해야 한다. index == MAX-1 로 확인하면 된다. 스택 사이즈를 넉넉하게 두는 편이 좋다.

# pop 함수

void pop() {
    // Empty check
    index -= 1;
}

✓ 스택에서 가장 나중에 넣은 원소를 뺀다. 인덱스를 1 감소시키면 된다.

✓ 원소를 빼기 전에, 스택이 비어있는 상태인지 확인하여 예외 처리를 해야 한다. 위에서 구현한 empty() 함수를 이용하면 된다.

# top 함수

int top() {
    // Empty check
    return data[index];
}

✓ top 함수는 가장 나중에 넣은 원소가 무엇인지 보는 함수이다.

✓ 스택이 비어있는 상태인지 확인하여 예외 처리를 해야 한다.

# size 함수

int size() {
    return index+1;
}

✓ 스택에 몇 개의 원소가 들어있는지 확인하는 함수이다.

자료구조 · C++로 구현한 큐

레바스 — Tue, 30 Apr 2019 14:22:43 +0900

큐 (Queue)

큐는 선입선출(FIFO; First in First out) 방식의 선형 자료구조이다.

선입선출이란, 먼저 들어간 것이 먼저 나온다는 뜻이다. 즉, 큐는 먼저 들어간 데이터를 먼저 처리하는 자료구조이다.

Queue C++ 구현 소스코드

#include <iostream>
using namespace std;

const int MAX = 1e5;

class Queue {
private:
    int data[MAX];
    int index_front;
    int index_back;
public:
    Queue();
    bool empty();
    void push(int x);
    void pop();
    int front();
    int back();
    int size();
};

Queue::Queue() {
    index_front = 0;
    index_back = 0;
}

bool Queue::empty() {
    return index_front == index_back;
}

void Queue::push(int x) {
    index_back = (index_back+1) % MAX;
    data[index_back] = x;
}

void Queue::pop() {
    index_front = (index_front+1) % MAX;
}

int Queue::front() {
    return data[(index_front+1)%MAX];
}

int Queue::back() {
    return data[index_back];
}

int Queue::size() {
    return (index_back-index_front+MAX)%MAX;
}

int main() {
    Queue q;
    for (int i=1; i<=10; i++) q.push(i); // Push 1~10
    for (int i=1; i<=4; i++) q.pop(); // Pop 1~4
    for (int i=1; i<=4; i++) q.push(i); // Push 1~4
    cout << "* Size: " << q.size() << '\n';
    while (!q.empty()) {
        cout << "Pop: " << q.front() << '\n';
        q.pop();    // Pop all
    }
    return 0;
}

# main 함수 출력 결과

* Size: 10
Pop: 5
Pop: 6
Pop: 7
Pop: 8
Pop: 9
Pop: 10
Pop: 1
Pop: 2
Pop: 3
Pop: 4

✓ 배열로 구현한 원형 큐(Circular Queue)이다. 선형 큐(Linear Queue)보다 메모리 공간 활용이 더 효율적이다.

✓ 모듈러 연산을 통해 큐 내부를 순환하면 된다.

✓ 예외 처리는 하지 않았다.

Queue 클래스 설명

const int MAX = 1e5;

class Queue {
private:
    int data[MAX];
    int index_front;
    int index_back;
public:
    Queue();
    bool empty();
    void push(int x);
    void pop();
    int front();
    int back();
    int size();
};

✓ MAX는 큐의 최대 사이즈이다. 값을 바꾸면 최대 사이즈를 조절할 수 있다.

✓ Data는 큐에 넣은 원소를 저장하는 배열이다.

✓ index_front는 가장 먼저 넣은 원소의 위치를 가리키는 변수다.

✓ index_back은 가장 나중에 넣은 원소의 위치를 가리키는 변수다.

# 생성자와 empty 함수

Queue() {
    index_front = 0;
    index_back = 0;
}

bool empty() {
    return index_front == index_back;
}

✓ 생성자를 이용하여 Front 인덱스, Back 인덱스를 둘 다 0으로 초기화한다.

✓ empty 함수는 큐가 비어있는지 확인하는 함수이다. Front 인덱스와 Back 인덱스가 서로 같다면, 큐가 비어있는 상태이다.

# push 함수

void push(int x) {
    // Full check, if (index_front == (index_back+1)%MAX)
    index_back = (index_back+1) % MAX;
    data[index_back] = x;
}

✓ 큐에 원소를 집어넣는다. Back 인덱스를 1 증가시키고, 그 위치에 원소를 저장한다.

✓ 원소를 넣기 전에, 큐가 꽉 찬 상태인지 확인하여 예외 처리를 해야 한다. index_front == (index_back+1) % MAX 로 확인하면 된다. 큐 사이즈를 넉넉하게 두는 편이 좋다.

# pop 함수

void pop() {
    // Empty check
    index_front = (index_front+1) % MAX;
}

✓ 큐에서 가장 먼저 넣은 원소를 뺀다. Front 인덱스를 1증가시키면 된다.

✓ 원소를 빼기 전에, 큐가 비어있는 상태인지 확인하여 예외 처리를 해야 한다. 위에서 구현한 empty() 함수를 이용하면 된다.

# front, back 함수

int front() {
    // Empty check
    return data[(index_front+1)%MAX];
}

int back() {
    // Empty check
    return data[index_back];
}

✓ front 함수는 가장 먼저 넣은 원소가 무엇인지 보는 함수이다.

✓ back 함수는 가장 나중에 넣은 원소가 무엇인지 보는 함수이다.

✓ 두 함수 모두, 큐가 비어있는 상태인지 확인하여 예외 처리를 해야 한다.

# size 함수

int size() {
    return (index_back-index_front+MAX)%MAX;
}

✓ 큐에 몇 개의 원소가 들어있는지 확인하는 함수이다.

운영체제 · 교착상태 (데드락)

레바스 — Mon, 29 Apr 2019 18:51:04 +0900

교착상태 (Deadlock)

운영체제(또는 소프트웨어)에서 자원을 사용할 때, 두 개 이상의 작업이 순차적으로 상대방의 작업이 끝나기를 기다리면서, 아무것도 진행되지 않는 상태를 말한다.

[그림 1] 교통을 통해 표현한 교착상태

교착상태 발생 조건

✓ 교착상태는 다음 네 가지 조건이 모두 성립될 때 발생한다.

상호 배제 (Mutual exclusion) : 한 번에 하나의 프로세스만 공유 자원을 사용할 수 있다.
점유 대기 (Hold and wait) : 각 프로세스가 하나의 자원을 점유하고 있으면서, 다른 프로세스가 사용하고 있는 자원을 추가로 점유하기 위해 대기한다.
비선점 (No preemption) : 각 프로세스는 다른 프로세스가 사용하고 있는 자원을 강제로 빼앗을 수 없다.
순환 대기 (Circular wait) : 각 프로세스는 순환적으로(원형 형태) 다음 프로세스가 요구하는 자원을 가지고 있다.

교착상태 해결 방법

✓ 예방 기법 (Deadlock Prevention)

교착상태가 발생되지 않도록 사전에 예방하는 방법이다.
교착상태 발생 조건 네 가지 중 적어도 하나가 성립하지 않게 만드는 방법이다.
순환 대기를 막는 방법이 네 가지 중 가장 효율적이다. 자원에 순서를 부여하고, 각 프로세스가 오름차순으로 자원을 요청하도록 구현한다.
예방 기법은 일반적으로 자원 사용 효율성이 떨어지고 비용이 많이 드는 문제점이 있다.

✓ 회피 기법 (Deadlock Avoidance)

교착상태가 발생하는 조건인지 확인하면서 적절히 회피하는 방법이다.
Circular wait가 발생하지 않도록 자원 할당 상태를 검사하면서, 시스템이 안전 상태(Safe state)인지 확인한다.

자원 할당 그래프 알고리즘 (Resource-Allocation Graph Algorithm) : 자원 할당에 대한 그래프를 구성한 후, 그래프에 사이클이 없을 때에만 자원을 할당한다.
은행원 알고리즘 (Banker's Algorithm) : 자원 할당 그래프 알고리즘은 프로세스가 하나의 자원만 사용하는 시스템에서 사용된다. 이에 반해 은행원 알고리즘은 프로세스가 자원을 여러 개 사용하는 경우에도 사용할 수 있는 알고리즘이다.

✓ 탐지와 회복 기법 (Deadlock Detection & Recovery)

시스템에 교착 상태가 발생했는지 확인하기 위해 시스템의 상태를 검사한다.
탐지 후, 교착 상태를 일으킨 프로세스를 종료하거나, 교착상태의 프로세스에 할당된 자원을 선점하여 교착상태를 제거한다.

✓ 무시 기법 (Deadlock Ignorance)

교착상태 자체를 무시하고, 특별한 조치를 취하지 않는다. 교착상태의 발생 확률이 낮은 상황에서 효율적이다.
만약 교착상태가 발생한다면, 프로세스를 종료하거나 자원을 선점하여 회복한다.
UNIX, Windows 등 대부분의 운영체제가 이 방법을 사용한다.

운영체제 · 스핀락

레바스 — Mon, 29 Apr 2019 18:50:54 +0900

스핀락 (Spinlock)

✓ 정의 : 임계 구역에 진입이 불가능할 때, 진입 가능할 때까지 루프를 돌면서 진입을 재시도하는 방식으로 구현된 락

✓ 임계 구역에 진입하기 위해서는 락(Lock)이 필요하기 때문에, 락을 획득할 때까지 해당 프로세스(스레드)가 돌고 있다(Spin)는 것을 의미한다.

✓ 스핀락은 바쁜 대기(Busy waiting)의 한 종류이다.

✓ 스핀락은 운영체제의 스케줄링을 지원받지 않기 때문에, 해당 프로세스(스레드)에 대한 Context switch가 일어나지 않는다.

✓ 장점 : 임계 구역 진입을 짧은 시간 내에 할 수 있다면, Context switch를 하지 않아도 되므로 효율적이다.

✓ 단점 : 오랜 시간 동안 스핀락을 진행하고 있다면, 스레드의 대기 시간이 길어지므로 비효율적이다.

바쁜 대기 (Busy waiting)

✓ 정의 : 어떤 특정 공유 자원에 대하여 두 개 이상의 프로세스(스레드)가 접근 권한을 얻고자 하는 동기화 상황일 때, 그 권한 획득을 위한 과정에서 일어나는 현상

✓ FCFS 등의 우선순위 스케줄링 기반의 싱글 프로세서 시스템에서는 비효율적이다. 멀티 프로세서 환경에서 사용하는 것이 좋다.

운영체제 · 세마포어, 뮤텍스

레바스 — Mon, 29 Apr 2019 18:50:27 +0900

세마포어와 뮤텍스의 차이점

✓ 세마포어 : Signaling mechanism / 일종의 카운터로서 크리티컬 섹션에 프로세스(스레드)가 동시에 N개 접근할 수 있다. 카운터 값이 0과 1로만 제한되면 Binary semaphore이며, 그 이상의 값을 가지면 Counting semaphore이다.

✓ 뮤텍스 : Locking mechanism / 락(Lock)을 가진 하나의 프로세스(스레드)만 크리티컬 섹션에 접근할 수 있다. Binary semaphore로 구현될 수 있다.

세마포어 (Semaphore)

✓ 각 프로세스에 제어 신호를 전달하여 순서대로 작업을 수행하도록 하는 동기화 기법이다.

✓ 세마포어 S는 P와 V 연산으로만 접근 가능한 카운터 변수이며, 0 이상의 값을 가질 수 있다.

✓ S의 값이 0과 1로만 제한되면 이진 세마포어(Binary semaphore)이며, 그 이상의 값을 가지면 카운팅 세마포어(Counting semaphore)이다.

✓ Binary semaphore를 통해 Mutex를 구현할 수 있지만, Mutex로 Semaphore를 구현할 수는 없다.

✓ P 연산 : Wait 동작 / 자원을 사용하려는 프로세스들의 진입 여부를 자원 카운트(S)를 통해 결정한다. 카운트를 감소시켜서(S--) 자원 점유를 알린다.

✓ V 연산 : Signal 동작 / 대기 중인 프로세스를 깨우는 신호이다. 카운트를 증가시켜서(S++) 자원 반납을 알린다.

// Semaphore structure
typedef struct {
    int value;
    struct process *list;
} Semaphore;
// P
void Wait(Semaphore *S) {
    S->value--;
    if (S->value < 0) {
        /* Push the process into S->list. */
        Block();
    }
}
// V
void Signal(Semaphore *S) {
    S->value++;
    if (S->value <= 0) {
        /* Pop process P from S->list. */
        WakeUp(P);
    }
}

// Semaphore implementation
do {
    Wait(&S);
    /* Critical Section */
    Signal(&S);
    /* Remainder Section */
} while (true);

뮤텍스 (Mutex)

✓ 특정 프로세스(스레드)가 공유 자원을 사용하고 있는 상황이라면, 다른 프로세스가 공유 자원을 사용하지 못하도록 하는 동기화 기법이다.

✓ 공유 자원 점유한 프로세스는 락(Lock)을 지니며, 자원 사용을 마치면 락을 반납한다.

// P and V
wait(S) {
    while (S <= 0);
    S--;
}
signal(S) {
    S++;
}

// Mutex implementation in binary semaphore
do {
    wait(&mutex);
    /* Critical Section */
    signal(&mutex);
    /* Remainder Section */
} while (true);

운영체제 · 프로세스 동기화

레바스 — Mon, 29 Apr 2019 18:50:19 +0900

프로세스 동기화 (Process Synchronization)

✓ 정의 : 협력하는 프로세스 사이에서 실행 순서 규칙을 정하여 공유 자원의 일관성을 보장하는 것

✓ 프로세스가 서로 협력하며 공유 자원을 사용하는 상황에서, 경쟁 조건이 발생하면 공유 자원을 신뢰할 수 없게 만들 수 있다. 이를 방지하기 위해 프로세스들이 공유 자원을 사용할 때 특별한 규칙을 만드는 것이 프로세스 동기화이다.

✓ 경쟁 조건 (Race Condition) : 여러 프로세스(또는 스레드)가 공유 자원에 동시에 접근할 때, 공유 자원에 대한 접근 순서에 따라 실행 결과가 달라질 수 있는 상황

✓ 임계 구역 (Critical Section) : 여러 프로세스(또는 스레드)가 자원을 공유하는 상황에서, 하나의 프로세스(스레드)만 접근할 수 있도록 제한해둔 코드 영역

do {
    // Entry Section
    // Critical Section
    // Exit Section
    // Remainder Section
} while (true);

동기화와 관련한 고전적인 문제

✓ 은행 계좌 문제 (Back Account Problem)

부모는 은행 계좌에 입금을 한다. 자식은 은행 계좌에서 출금한다.
입금과 출금 과정이 별도로 이루어져야 한다.
크리티컬 섹션 : 은행 계좌

✓ 독자 저자 문제 (Readers Writers Problem)

독자는 책(공유 데이터베이스)에 쓰여있는 글을 읽는다. 저자는 책에 글을 써서 추가한다.
독자가 글을 읽고 있다면, 독자는 추가적으로 글을 읽을 수 있지만, 저자는 글을 쓸 수 없다.
저자가 글을 쓰고 있다면, 독자는 글을 읽을 수 없으며, 저자 또한 추가적으로 글을 쓸 수 없다.
크리티컬 섹션 : 책 (공유 데이터베이스)

✓ 생산자 소비자 문제 (Producer Consumer Problem)

한정 버퍼 문제(Bounded Buffer Problem)라고도 한다.
생산자는 물건을 생산하여 창고(버퍼)에 넣는다. 소비자는 창고에서 물건을 꺼내서 소비한다.
창고가 가득 차면 생산자는 물건을 넣을 수 없고, 창고가 비어 있으면 소비자는 물건을 소비할 수 없다.
크리티컬 섹션 : 창고 (버퍼)

✓ 식사하는 철학자 문제 (Dining Philosopher Problem)

원형 테이블에 철학자들이 앉아있고 철학자의 수만큼 젓가락이 철학자 사이에 하나씩 놓여있다.
철학자들이 식사를 하기 위해서는 양쪽에 하나씩 놓여있는 젓가락을 둘 다 들어서 사용해야 한다.
어떤 철학자가 젓가락을 사용 중이라면, 다른 어떤 철학자는 식사를 할 수 없다.
크리티컬 섹션 : 젓가락

임계 구역 문제의 해결 조건

✓ 상호 배제 (Mutual Exclusion) : 어떤 프로세스(또는 스레드)가 임계 구역에서 작업 중일 때, 다른 프로세스는 임계 구역으로 접근할 수 없다.

✓ 진행 (Progress) : 임계 구역에서 작업 중인 프로세스가 없다면, 임계 구역으로 진입하려는 프로세스 중 하나를 적절히 선택하여 임계 구역에 진입할 수 있게 해야 한다.

✓ 유한 대기 (Bounded Waiting) : 다른 프로세스의 기아(Starvation)을 방지하기 위해, 임계 구역에 한 번 접근했던 프로세스는 다시 임계 구역에 들어갈 때 제한을 두어야 한다.

임계 구역 문제의 해결 방안

✓ 소프트웨어 동기화 방법

피터슨의 알고리즘 (Peterson's Algorithm) : 피터슨의 해결안(Peterson's Solution)이라고도 하며, 2개의 프로세스만 있을 때 사용할 수 있다.
데커의 알고리즘 (Dekker's Algorithm) : 피터슨의 알고리즘과 비슷하며, 2개의 프로세스만 있을 때 사용할 수 있다.
램포트의 빵집 알고리즘 (Lamport's bakery algorithm) : 2개 이상의 프로세스에서 사용할 수 있다.

* Peterson Algorithm

// Shared data
int turn;
bool flag[2];

// Process i
do {
    flag[i] = true;
    turn = j;
    while (flag[j] && turn == j);
    /* Critical Section */
    flag[i] = false;
    /* Remainder Section */
} while (true);

// Process j
do {
    flag[j] = true;
    turn = i;
    while (flag[i] && turn == i);
    /* Critical Section */
    flag[j] = false;
    /* Remainder Section */
} while (true);

✓ 하드웨어 동기화 방법

락(lock)을 이용한 해결 방안이다. 프로세스가 락을 획득해야만 임계 구역에 진입할 수 있고, 임계 구역을 벗어나면 락을 반납하여, 임계 구역 문제를 해결한다.
싱글 프로세서 환경에서는 공유 데이터가 변경되는 동안 인터럽트를 막으면 임계 구역 문제를 해결할 수 있다. 비선점형 커널에서도 이 방법을 사용한다.
하지만, 멀티 프로세서 환경에서는 시스템 효율성 때문에 인터럽트를 막을 수 없다. 멀티 프로세서 환경에서는 동기화 하드웨어로 임계 구역 문제를 해결할 수 있다. 주로 TestAndSet()과 Swap() 명령어로 이를 구현한다.

* TestAndSet
bool TestAndSet(bool *target) {
    bool ret = *target;
    *target = true;
    return ret;
}
do {
    while (TestAndSet(lock));
    /* Critical Section */
    lock = false;
    /* Remainder Section */
} while (true);

* Swap
void Swap(bool *a, bool *b) {
    bool temp = *a;
    *a = *b;
    *b = temp;
}
do {
    key = true;
    while (key == true) Swap(&lock, &key);
    /* Critical Section */
    lock = false;
    /* Remainder Section */
} while (true);

운영체제 · CPU 스케줄링

레바스 — Mon, 29 Apr 2019 18:48:47 +0900

CPU 스케줄링 (CPU Scheduling, Processor Scheduling)

✓ 정의 : CPU(프로세서)를 사용하려 하는 프로세스들 사이에서 우선순위를 관리하는 일

✓ 작업 처리율과 CPU 이용률을 향상시키기 위해 필요한 기법이다.

✓ 비선점 스케줄링과 선점 스케줄링으로 나뉜다.

비선점 스케줄링 (Non-preemptive Scheduling)

✓ 정의 : 어떤 프로세스가 사용 중인 CPU를 다른 프로세스가 강제로 빼앗아 사용할 수 없는 스케줄링

✓ 일괄 처리 시스템에 적합하며, 응답 시간 예측이 쉬운 장점이 있다.

✓ 중요한 작업(짧은 작업)이 중요하지 않은 작업(긴 작업)을 기다리는 경우가 발생할 수 있는 단점이 있다.

✓ FCFS 스케줄링 (First-Come First-Served Scheduling)

FIFO 스케줄링이라고도 하며, 준비 큐(Ready Queue)에 먼저 도착한 순서에 따라 CPU를 할당하는 스케줄링이다.
먼저 들어온 프로세스가 먼저 처리되어 공평성은 유지되나, 중요한 작업이 중요하지 않은 작업을 기다릴 가능성이 있다.

✓ SJF 스케줄링 (Shortest Job First Scheduling)

실행 시간이 가장 짧은 프로세스에 먼저 CPU를 할당하는 스케줄링이다.
프로세스들의 평균 대기 시간이 가장 짧다.
기아 상태가 발생할 수 있다. 기아는 에이징으로 해결할 수 있다.

✓ HRRN 스케줄링 (Highest Reponse Ratio Next Scheduling)

HRN 스케줄링이라고도 하며, SJF 스케줄링의 문제점을 보완한 스케줄링이다.
실행 시간과 대기 시간을 둘 다 고려해 우선순위를 정하고, 각 프로세스의 우선순위에 따라 CPU를 할당한다.
우선순위 = (대기 시간 + 실행 시간) / 실행 시간

✓ 우선순위 스케줄링 (Priority Scheduling)

각 프로세스마다 우선순위를 부여하고, 각 프로세스의 우선순위에 따라 CPU를 할당하는 스케줄링이다.
우선순위는 시간제한, 메모리 요구, 열린 파일의 수, 평균 실행 시간, 프로세스의 중요도, 자원 사용량 등을 복합적으로 고려하여 정한다.
SJF 스케줄링과 마찬가지로 기아 상태가 발생할 수 있다.

선점 스케줄링 (Preemptive Scheduling)

✓ 정의 : 어떤 프로세스가 사용 중인 CPU를 다른 프로세스가 강제로 빼앗아 사용할 수 있는 스케줄링

✓ 시분할 시스템에 적합하며, 응답 시간이 빠른 장점이 있다.

✓ CPU를 선점할 프로세스에게 일정한 시간을 배정하기 위해 인터럽트용 타이머가 필요하다.

✓ 비선점 스케줄링에 비해 오버헤드가 큰 단점이 있다.

✓ RR 스케줄링 (Round Robin Scheduling)

라운드 로빈 스케줄링은 시분할 시스템을 위해 설계된 스케줄링이다.
FCFS 스케줄링과 유사하며, 선점이 가능하도록 시간 단위(Time Quantum, Time Slice) 개념이 추가돼있다.
FCFS 처럼 준비 큐에 먼저 들어온 프로세스가 먼저 CPU를 할당받지만, 각 프로세스는 Time Quantum 만큼만 실행된 후 다시 준비 큐로 돌아간다.
Time Quantum이 커지면 FCFS 스케줄링과 같아지고, Time Quantum이 작으면 Context Switch가 자주 발생하여 오버헤드가 커진다.

✓ SRT 스케줄링 (Shortest Remaining Time Scheduling)

SJF 스케줄링을 선점이 가능하도록 변형한 스케줄링이다.
실행 중인 프로세스의 남은 실행 시간과 준비 큐에 도착한 프로세스의 실행 시간을 비교하고, 그중 실행 시간이 짧은 프로세스에게 CPU를 할당하는 스케줄링이다.

✓ MLQ 스케줄링 (Multilevel Queue Scheduling)

멀티레벨 큐 스케줄링(다단계 큐 스케줄링)은 프로세스를 특정 그룹으로 분류하고, 각 그룹에 따라 각기 다른 준비 큐를 이용하는 스케줄링이다.
각 준비 큐는 각기 다른 스케줄링 알고리즘을 가질 수 있으며, 큐와 큐 사이에도 스케줄링 알고리즘이 필요하다.

✓ MLFQ 스케줄링 (Multilevel Feedback Queue Scheduling)

멀티레벨 피드백 큐 스케줄링(다단계 피드백 큐)는 멀티레벨 큐를 변형한 스케줄링이다.
MLQ에서는 프로세스가 큐와 큐 사이를 이동할 수 없으나, MLFQ에서는 프로세스가 큐와 큐 사이를 이동할 수 있다.
예를 들어, 특정 프로세스가 CPU를 너무 많이 사용하면(실행 시간이 길면), 우선순위가 낮은 큐로 이동된다. 또한, 우선순위가 낮은 큐에서 너무 오래 대기하는 프로세스가 있다면, 해당 프로세스는 우선순위가 높은 큐로 이동된다.

스케줄링 이해를 돕기 위한 도표

✓ 주어지는 조건 : 4개의 프로세스와, 각 프로세스의 도착 시간(Arrival Time)과 실행 시간(Burst Time)

✓ 조건을 통해 구할 수 있는 것 : 각 프로세스의 대기 시간(Waiting Time)과 소요 시간(Turnaround Time)

✓ Gantt 차트(막대 모양)를 통해 각 프로세스의 스케줄을 표현했다.

용어 설명

✓ 도착 시간 (Arrival Time) : 프로세스가 준비 큐(Ready Queue)에 도착한 시각.

✓ 완료 시간 (Completion Time) : 프로세스가 작업을 마친 시각.

✓ 스케줄 시간 (Schedule Time) : 프로세스가 CPU에서 실행된 시각.

✓ 응답 시간 (Response Time) : 프로세스가 도착 시간부터 CPU에서 실행되기까지 걸린 시간. [도착 시간 - 스케줄 시간]과 같다.

✓ 실행 시간 (Execution Time) : 프로세스가 CPU에서 실행된 총 시간. 버스트 시간(Burst Time)이라고도 한다.

✓ 대기 시간 (Waiting Time) : 프로세스가 준비 큐에서 기다린 총 시간.

✓ 소요 시간 (Turnaround Time) : 프로세스가 모든 작업을 마치는데 걸린 시간. [완료 시간 - 도착 시간] 또는 [실행 시간 + 대기 시간]과 같다. 반환 시간, 총 처리 시간이라고도 한다.

✓ 기아 (Starvation) : 실행 시간이 긴 프로세스가 자원을 계속 할당받지 못하는 문제이다. 실행 시간이 긴 프로세스가 대기하는 상황에서, 실행 시간이 짧은 프로세스가 준비 큐에 계속 들어오면, 실행 시간이 긴 프로세스는 계속 자원을 할당받지 못하는 문제가 생긴다.

✓ 에이징 (Aging) : 준비 큐에 있는 프로세스에 나이를 부여하는 방법이다. 특정 프로세스가 얼마나 오래 기다렸는지 고려하고, 기다린 시간이 길다면 자원을 할당해 준다.

운영체제 · 프로세스 스케줄링

레바스 — Sun, 28 Apr 2019 21:15:53 +0900

프로세스 스케줄링 (Process Scheduling)

✓ 정의 : 멀티 프로그래밍 환경에서 사용되는 것으로, 프로세스들에게 자원 할당을 적절히 함으로써 시스템의 성능을 개선하는 것

✓ CPU 이용률을 극대화하여 다수의 프로세스를 처리할 수 있다.

스케줄러의 종류

✓ 장기 스케줄러 (Long-term Scheduler)

잡 스케줄러(Job Scheduler)라고도 하며, 디스크에 있는 프로세스들을 메모리로 적재하는 역할을 한다.
즉, 장기 스케줄링은 생성된 프로세스들 중 어떤 프로세스에 메모리를 할당하여 준비 큐(Ready Queue)로 보내는 것이다.
Unix, Microsoft Windows 등의 시분할 시스템에는 장기 스케줄러가 없다.

✓ 단기 스케줄러 (Short-term Scheduler)

CPU 스케줄러(CPU Scheduler)라고도 하며, 준비 상태의 프로세스를 하나 선택하여 CPU에 할당하는 역할을 한다.
즉, 단기 스케줄링은 준비 큐에 있는 프로세스 중 어떤 프로세스를 실행(Running) 시킬지 결정하는 것이다.
장기 스케줄러에 비해 실행 간격이 짧으며, 실행 빈도가 높다.

✓ 중기 스케줄러 (Mid-term Scheduler)

메모리에서 프로세스를 제거하여 멀티 프로그래밍의 정도를 완화시키는 역할을 한다.
스와핑 작업을 통해 프로세스 혼합 상태를 개선하거나, 가용 메모리를 확보한다.
스와핑(Swapping) : 메모리에 적재된 프로세스를 디스크로 옮기고(스왑 아웃; Swap out), 디스크에 있는 프로세스를 메모리로 다시 적재하는(스왑 인; Swap in) 작업이다.

[그림 1] 프로세스 상태에 따른 스케줄러

운영체제 · 프로세스 간 통신

레바스 — Sun, 28 Apr 2019 20:08:28 +0900

프로세스 간 통신 (IPC, Inter Process Communication)

✓ 정의 : 프로세스끼리 자원이나 데이터를 서로 주고받는 행위 또는 그에 대한 방법이나 경로

✓ 프로세스는 본래 독립적이나, 상황에 따라 프로세스끼리 협력해야 하는 경우가 있다. 이 경우, 프로세스 간 자원/데이터 공유가 필요한데, 이때 필요한 것이 IPC이다.

IPC가 필요한 이유

✓ 정보 공유 (Information sharing) : 여러 사용자가 동일한 정보를 필요로 할 수 있다.

✓ 계산 가속화 (Computation speedup) : 특정 작업(task)를 빠르게 실행하기 위해, 해당 작업을 부분 작업(서브 태스크)으로 나눠서 병렬로 실행하게 할 수 있다.

✓ 모듈성 (Modularity) : 특정한 시스템 기능을 별도의 프로세스(스레드)로 구분하여 모듈식 형태로 시스템을 구성할 수 있다.

✓ 편의성 (Convenience) : 여러 사용자들이 동시에 많은 작업을 수행할 수 있다.

IPC의 종류

✓ IPC 기법은 크게 메시지 전달과 공유 메모리로 나뉜다.

✓ 메시지 전달 (Message passing)

특징 : IPC를 위해 커널을 통해 메시지를 전달하는 방식으로 자원이나 데이터를 주고받는다.
장점 : 별도로 다른 것을 구축할 필요 없이 커널을 이용하기 때문에 구현이 비교적 쉽다.
단점 : 커널을 이용하기 때문에, 시스템 콜(System call)이 필요하며 이로 인해 오버헤드가 발생한다.
종류 : 파이프, 시그널, 메시지 큐, 소켓 등

✓ 공유 메모리 (Shared memory)

특징 : IPC를 위해 공유 메모리 영역을 구축하고, 공유 영역을 통해 자원이나 데이터를 주고받는다.
장점 : 커널 의존성이 낮기 때문에 속도가 빠르다. 유저 레벨에서 IPC가 가능하기 때문에, 통신이 자유롭다.
단점 : 자원과 데이터를 공유하기 때문에 동기화 이슈가 발생한다.

[그림 1] 메시지 전달과 공유 메모리

메시지 전달 모델

✓ 파이프 (Pipe)

특징 : 하나의 프로세스가 파이프를 통해 다른 프로세스로 메시지를 직접 전달하는 방식
Half-duplex 방식이기 때문에, 데이터는 한쪽 방향으로만 이동한다. 양방향 통신을 하기 위해서는 두 개의 파이프가 필요하다.
파이프에 용량 제한이 있기 때문에 이용에 제약이 있다.

✓ 시그널 (Signal)

특징 : 프로세스 ID를 통해 특정 프로세스에게 메시지를 전달하는 방식
시그널 ID에 따라 어떤 이벤트인지 알 수 있다.

✓ 메시지 큐 (Message Queue)

특징 : 고정 크기의 메시지를 연결 리스트를 통해 통신하는 방식
메시지 단위의 통신이며, 메시지 큐 ID를 통해 통신을 한다.

✓ 소켓 (Socket)

특징 : 네트워크 상에서 프로세스 간에 통신하는 방식
Local 뿐만 아니라, Remote 통신이 가능하다.

운영체제 · 문맥 교환 (컨텍스트 전환)

레바스 — Sun, 28 Apr 2019 20:08:09 +0900

컨텍스트 전환 (Context Switch)

✓ 정의 : 하나의 프로세스가 CPU를 점유한 상태에서, 다른 프로세스가 CPU를 사용하게 만들기 위해, 현재 프로세스의 정보(Context)를 저장하고, 새로운 프로세스의 정보를 CPU에 적재하는 작업

✓ Context Switch를 직역하면 '문맥 교환'이지만, '컨텍스트 스위치' 또는 '컨텍스트 전환'으로 부르는 편이 명확하다.

✓ 프로세스의 Context는 프로세스 제어 블록(PCB)에 저장되어 있다.

✓ 문제점 : Context Switching 중에는 CPU가 작업을 수행할 수 없기 때문에, 문맥 교환이 잦으면 오버헤드가 커진다.

Context Switch의 시점

✓ 멀티 태스킹

✓ 인터럽트 핸들링

✓ 유저 모드와 커널 모드 간 전환

운영체제 · 인터럽트, 트랩

레바스 — Sun, 28 Apr 2019 20:07:12 +0900

인터럽트와 트랩의 차이점

✓ 인터럽트 : 하드웨어적 흐름의 변화 / 프로그램 외부(I/O 장치, 디스크 등)에서 발생하며, 발생 시점이 일정하지 않기 때문에 비동기적이다.

✓ 트랩 : 소프트웨어적 흐름의 변화 / 소프트웨어 인터럽트라고도 하며, 프로그램 내부에서 일어나는 에러이다. 발생 시점이 프로그램의 일정한 지점이기 때문에 동기적이다. 즉, 고정된 영역에서 일어난다.

인터럽트의 종류

✓ 하드웨어 인터럽트 (Hardware Interrupt)

인터럽트는 외부 인터럽트와 내부 인터럽트로 구분하는데, 외부 인터럽트를 하드웨어 인터럽트라 한다. 그냥 인터럽트라 하면, 일반적으로 하드웨어 인터럽트를 의미한다. 내부 인터럽트는 소프트웨어 인터럽트와 같은 개념이라고 보면 된다.
외부 인터럽트는 프로그램 외부에서 일어나는 인터럽트이다.
기계 검사 인터럽트, 입출력 인터럽트, 전원 이상 인터럽트 등이 있다.

✓ 소프트웨어 인터럽트 (SWI, Software Interrupt)

트랩(Trap)이라고도 하며, 프로그램 내부에서 일어나는 인터럽트이다. 예외와 시스템 콜이 있다.
예외 (Exception) : 메모리 참조 오류, 0으로 나누기, Overflow, Underflow 등의 경우에서 발생하는 인터럽트
시스템 콜 (System Call) : 사용자가 의도적으로 일으킨 인터럽트

운영체제 · 프로세스 상태

레바스 — Sun, 28 Apr 2019 20:05:21 +0900

프로세스 상태 (Process State)

프로세스는 실행의 흐름에 따라 상태(스테이트)가 변한다. 상태를 정의하는 이름은 운영체제에 따라 다르지만, 대부분 서로 비슷한 개념으로 구성되어 있다. 프로세스의 흐름은 일반적으로 5개의 상태로 정의된다.

[그림 1] 프로세스 상태 전이도

프로세스의 5가지 상태

✓ 생성 (New) : 프로세스 생성 상태

✓ 실행 (Running) : 프로세스가 CPU에 할당되어 실행 중인 상태

✓ 준비 (Ready) : 프로세스가 CPU에 할당되기를 기다리는 상태

✓ 대기 (Waiting) : 보류(Block)라고도 하며, 프로세스가 입출력이나 이벤트를 기다리는 상태

✓ 종료 (Terminated) : 프로세스 종료 상태

프로세스의 상태 전이

✓ 승인 (Admitted) : 프로세스 생성이 가능하여 승인됨.

✓ 스케줄러 디스패치 (Scheduler Dispatch) : 준비 상태에 있는 프로세스 중 하나를 선택하여 실행시키는 것.

✓ 인터럽트 (Interrupt) : 예외, 입출력, 이벤트 등이 발생하여 현재 실행 중인 프로세스를 준비 상태로 바꾸고, 해당 작업을 먼저 처리하는 것.

✓ 입출력 또는 이벤트 대기 (I/O or Event wait) : 실행 중인 프로세스가 입출력이나 이벤트를 처리해야 하는 경우, 입출력/이벤트가 모두 끝날 때까지 대기 상태로 만드는 것.

✓ 입출력 또는 이벤트 완료 (I/O or Event Completion) : 입출력/이벤트가 끝난 프로세스를 준비 상태로 전환하여 스케줄러에 의해 선택될 수 있도록 만드는 것.

운영체제 · 프로세스 제어 블록

레바스 — Sun, 28 Apr 2019 20:05:04 +0900

프로세스 제어 블록 (PCB, Process Control Block)

✓ 정의 : 프로세스에 관한 다양한 정보를 가지고 있는 커널의 자료 구조

✓ 작업 제어 블록(Task Control Block)이라고도 하며, 운영체제가 프로세스를 표현한 형태이다.

✓ 프로세스에 관한 중요한 정보를 포함하기 때문에, 사용자가 접근하지 못하도록 보호된 메모리 영역 안에 위치한다. 일부 운영체제에서는 커널 스택의 처음에 위치한다.

✓ Linux 운영체제에서는 <linux/sched.h> 헤더 파일의 struct task_struct로 표현된다.

/* PCB Example (task_struct) */
struct task_struct {
	volatile long	state;
	void		*stack;
	atomic_t		usage;
	int		recent_used_cpu;
	int		wake_cpu;
	int		prio;
	unsigned int	rt_priority;
	pid_t		pid;
	pid_t		tgid;
	struct task_struct __rcu	*parent;
	struct list_head		children;
	struct list_head		sibling;
	u64				utime;
	u64				stime;
};

PCB가 포함하는 정보

프로세스 ID (Process ID) : 프로세스를 식별하기 위한 ID
프로세스 상태 (Process State) : 생성(New), 준비(Ready), 실행(Running), 대기(Waiting), 종료(Terminated)
프로그램 카운터 (Process Counter) : 해당 프로세스가 다음에 실행할 명령어의 주소 가리킴.
메모리 관리 정보 : 페이지 테이블 또는 세그먼트 테이블, 베이스 레지스터 등
프로세스 계정 정보 : CPU가 사용한 양, 사용된 실제 시간, 계정 번호 등
입출력 상태 정보 : 프로세스에 할당된 입출력장치 목록, 열린 파일 목록 등
CPU 스케줄링 정보 : 스케줄링 우선순위, 스케줄 큐 포인터 등
CPU 레지스터 : 누산기, 인덱스, 스택 레지스터 등
기타 프로세스 관련 정보

운영체제 · 멀티 스레드, 멀티 스레딩

레바스 — Sun, 28 Apr 2019 20:03:15 +0900

멀티 프로세스와 멀티 스레드의 차이점

✓ 멀티 프로세스 : 독립적인 다수의 프로세스, 메모리 공간(코드, 데이터, 힙, 스택)을 공유하지 않음.

✓ 멀티 스레드 : 하나의 프로세스 내에 존재하는 다수의 스레드, 메모리 공간(코드, 데이터, 힙)을 공유하지만, 스택 영역은 공유하지 않음.

[그림 1] 싱글 스레드와 멀티 스레드

멀티 스레딩 (Multi-threading)

✓ 정의 : 하나의 프로세스를 다수의 스레드로 구성하여 서로 자원을 공유하고, 이를 통해 자원을 효율적으로 사용하여 작업 처리 속도를 향상시키는 것

✓ 각 스레드는 프로세스 내에 존재하며, 코드/데이터/힙 영역을 공유하면서 데이터를 주고받을 수 있다. 이러한 장점 때문에, 프로세스 간 통신(IPC)에 비해 통신 오버헤드가 적고 속도가 빠르다.

✓ 멀티 스레딩을 통해 시스템의 처리량이 향상되고, 자원 소모가 줄어들어 프로그램의 응답시간이 단축된다.

멀티 스레딩의 문제점

✓ 자원을 공유하기 때문에, 다수의 스레드가 특정 자원을 동시에 사용하는 것을 고려해야 한다. 즉, 동기화 처리가 필요하다.

✓ 동기화를 통해 스레드의 작업 처리 순서와 공유 자원에 대한 접근을 제어해야 한다.

✓ 일반적으로 락(Lock)을 이용하여 동기화 처리를 하는데, 락이 과도하면 병목 현상이 발생하여 성능 저하를 유발할 수 있다.

운영체제 · 멀티 프로세싱, 멀티 프로그래밍, 멀티 태스킹

레바스 — Sun, 28 Apr 2019 20:03:05 +0900

멀티 프로세싱, 멀티 프로그래밍, 멀티 태스킹의 차이점

✓ 멀티 프로세싱 : 다수의 프로세서가 다수의 프로세스를 동시에 처리하는 것

✓ 멀티 프로그래밍 : 다수의 프로세스를 메모리에 적재하여 프로세스를 번갈아가면서 처리하는 것

✓ 멀티 태스킹 : 다수의 작업을 운영체제 스케줄링에 의해 번갈아가면서 처리하는 것

멀티 프로세싱 (Multi-processing)

✓ 정의 : 다수의 프로세서가 다수의 프로세스를 협력적으로 동시에 처리하는 것

✓ 프로세서(Processor)는 CPU라고 생각하면 되며, 프로세스(Process)와 다른 개념이다.

✓ 각 프로세서는 다수의 프로세스를 처리하며, 각 프로세스는 다수의 프로세서에 의해 처리된다.

✓ 각 프로세서가 자원을 공유하면서 프로세스를 처리하기 때문에, 하나의 프로세서가 고장 나더라도 작업은 정지되지 않는다.

멀티 프로그래밍 (Multi-programming)

✓ 정의 : 하나의 프로세서에 대하여 다수의 프로세스를 메모리에 적재해 작업을 처리하는 것

✓ 특정 프로세서가 프로세스 A를 처리할 때, 다른 프로세스 B, C 등을 처리하게 만드는 것을 말한다.

✓ 멀티 프로그래밍을 통해 프로세서를 효율적으로 사용할 수 있다.

멀티 태스킹 (Multi-tasking)

✓ 정의 : 다수의 작업(Task)을 운영체제 스케줄링에 의해 번갈아가면서 처리하는 것

✓ Task란 작업의 단위를 말하며, 프로세스, 스레드가 모두 작업의 단위가 될 수 있다.

✓ 멀티 태스킹은 시분할 시스템에서 사용되며, 사용자에게 다수의 작업이 동시에 처리되는 것처럼 느끼게 할 수 있다.

운영체제 · 프로세스, 스레드

레바스 — Sun, 28 Apr 2019 20:02:47 +0900

프로세스와 스레드의 차이점

✓ 프로세스 : 운영체제로부터 자원을 할당받는 작업의 단위

✓ 스레드 : 프로세스가 할당받은 자원을 이용하는 실행의 단위

프로세스 (Process)

[그림 1] 독립적인 프로세스

✓ 정의 : 실행 중인 프로그램에 대한 인스턴스

✓ 프로세스는 운영체제로부터 각각 독립된 자원(code, data, stack, heap, PC register 등)을 할당받는다.

✓ 각 프로세스는 최소 1개 이상의 쓰레드를 가지고 있다.

✓ 다른 프로세스의 자원에 접근하려면, 프로세스 간 통신(IPC)을 이용해야 한다.

✓ 프로세스와 프로그램의 차이

프로그램 : Passive entity, 명령어 리스트를 지닌 실행 파일 클래스
프로세스 : Active entity, 메모리에 적재되어 프로그램 카운터와 자원을 가진 인스턴스

[그림 2] 메모리 상의 프로세스

스레드 (Thread)

[그림 3] 프로세스 내의 스레드

✓ 정의 : 한 프로세스 내에서 동작되는 여러 실행의 흐름

✓ 프로세스의 특성을 가지고 있기 때문에, 경량 프로세스(LWP, Lightweight Process)라고도 한다.

✓ 프로세스 내의 코드, 데이터, 힙 등의 자원을 공유하면서 병렬성을 높일 수 있다.

✓ 스택과 레지스터는 각 스레드가 별도로 할당받으며, 이는 독립적인 실행 흐름을 가능하게 한다.

✓ 기본적으로 하나의 프로세스가 생성되면 하나의 스레드가 같이 생성되며, 이를 메인 스레드라고 부른다.

✓ 하나의 프로세스는 여러 개의 스레드를 가질 수 있으며, 이를 멀티 스레드라고 부른다.

✓ 스레드의 장단점

장점 : 자원 공유를 통해 시스템 자원 소모를 줄일 수 있음, Context Switch에 대한 오버헤드가 감소.
단점 : 동기화 문제가 발생할 수 있음, 프로그램 디버깅이 어려울 수 있음.

운영체제 · 운영체제 개념

레바스 — Sun, 28 Apr 2019 20:02:22 +0900

운영체제 (OS, Operating System)

✓ 정의 : 컴퓨터 시스템의 자원들을 효율적으로 관리하고, 사용자가 컴퓨터를 편리하게 사용할 수 있도록 환경을 제공하는 것

✓ 종류 : Unix, Linux, MS-DOS, Windows, macOS 등

✓ 운영체제의 역할

하드웨어와 사용자 간의 인터페이스 제공 (CUI, GUI 등)
프로세스 처리 및 스케줄링
CPU, 입출력장치, 파일 등의 자원 관리
하드웨어, 네트워크 제어 등 다양한 역할 수행

운영체제의 목적

✓ 처리 능력(Throughput) 향상 : 처리 능력이란 일정 시간 내에 처리할 수 있는 작업량을 뜻하며, 시스템 전체의 생산성을 측정하는 단위이다.

✓ 응답 시간(Turn Around Time) 단축 : 응답 시간이란 사용자가 처리를 요구한 시점부터 결과를 얻을 때까지 걸리는 시간을 말하며, 값이 낮을수록 좋다.

✓ 사용 가능도(Availability) 향상 : 원하는 시간 내에 시스템을 얼마나 빨리 사용할 수 있는지에 대한 정도를 나타낸다.

✓ 신뢰도(Reliability) 향상 : 시스템이 주어진 문제를 얼마나 정확하게 수행하는지에 대한 정도를 나타낸다.

운영체제 방식

✓ 일괄 처리 시스템 (Batch Processing System)

데이터를 일정한 양이나 일정한 기간만큼 모은 후, 한꺼번에 처리하는 시스템이다.
데이터를 순차적으로 처리하며, 하나의 작업이 끝나기 전까지는 다른 작업을 수행할 수 없다.

✓ 시분할 시스템 (Time Sharing System)

CPU 스케줄링과 멀티 프로그래밍을 통해 컴퓨터 자원을 시간적으로 분할하여, 각 사용자들이 동시에 모두 사용할 수 있게 해주는 시스템이다.
엄밀히 말하자면 시스템의 자원을 정해진 시간(Time slice, Quantum) 만큼 번갈아가면서 사용하는 것이지만, 워낙 짧은 시간 안에 빠르게 작업이 처리되기 때문에, 사용자들은 동시에 사용하는 것처럼 느낄 수 있다.
이 시스템을 통해 모든 작업이 동시에 진행되는 것처럼 대화식 처리가 가능하다.

✓ 실시간 시스템 (Real-time System)

자원이 한정돼있는 상황에서 작업 수행이 요청되었을 때, 정해진 시간 내에 결과를 처리해주는 시스템이다.
시간의 정확성과 예측성을 보장해야 하는 환경에서 사용된다. 예) 공장 제어, 인공위성 제어, 무기 제어 등

✓ 분산 처리 시스템 (Distributed Processing System)

다수의 컴퓨터(프로세서)를 네트워크로 연결하여 작업을 처리하는 시스템이다.
다수의 프로세서를 이용하기 때문에, 무겁고 복잡한 계산 문제를 보다 빠르게 계산할 수 있다.

BOJ 17144 · 미세먼지 안녕!

레바스 — Wed, 17 Apr 2019 18:54:26 +0900

알고리즘 분류 : 시뮬레이션

문제에 주어진 조건을 그대로 구현하는 문제다. 크게 두 단계로 나눠서 설계해야 한다. 첫 번째, 미세먼지가 확산되는 과정, 두 번째 공기청정기의 바람이 순환하는 과정이다.

1. 모든 미세먼지는 5 이상의 양이 남아있으면, 상하좌우로 확산할 수 있다.
확산할 때 상하좌우에 이미 먼지가 있는 경우가 있으므로, 별도의 배열을 만들어서 확산되는 먼지의 양을 저장해야 한다. 값을 바로 업데이트하면 다음 먼지 확산에 영향을 주기 때문에, 이 과정이 필요하다.
현재 먼지의 양을 5로 나눈 후, 그 양을 상하좌우 칸에 더한다. 위에서 만든 별도의 배열 B에 더한다.
모든 과정이 끝나면, 원래 먼지 배열 A에 확산 배열 B 값을 업데이트한다.

2. 미세먼지가 바람 방향에 따라 순환한다.
입력받을 때 공기청정기의 위치를 S1, S2에 저장한다.
위쪽 공기청정기는 S1을 기준으로 반시계 방향으로 회전한다.
아래쪽 공기청정기는 S2를 기준으로 시계 방향으로 회전한다.
역순으로 회전하면서, 현재 값에 다음 값을 저장하면 된다.

C++ 소스코드

#include <cstdio>
#include <cstring>

struct air {
    int x, y;
};

int r, c, t, s1=-1, s2, ans;
int a[50][50];
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};


void diffuse() {
    int b[50][50] = {0};
    memcpy(b, a, sizeof(a));
    for (int i=0; i<r; i++) {
        for (int j=0; j<c; j++) {
            if (a[i][j] >= 5) {
                int d = a[i][j]/5;
                for (int k=0; k<4; k++) {
                    int ni = i+dx[k], nj = j+dy[k];
                    if (0 <= ni && ni < r && 0 <= nj && nj < c && a[ni][nj] != -1) {
                        b[ni][nj] += d;
                        b[i][j] -= d;
                    }
                }
            }
        }
    }
    memcpy(a, b, sizeof(b));
}

void purify() {
    // Top purifier
    for (int i=s1-2; i>=0; i--) a[i+1][0] = a[i][0];  // ↓
    for (int i=0; i<c-1; i++) a[0][i] = a[0][i+1];    // ←
    for (int i=0; i<s1; i++) a[i][c-1] = a[i+1][c-1]; // ↑
    for (int i=c-2; i>=0; i--) a[s1][i+1] = a[s1][i]; // →
    a[s1][1] = 0;
    // Bottom purifier
    for (int i=s2+1; i<r-1; i++) a[i][0] = a[i+1][0];   // ↑
    for (int i=0; i<c-1; i++) a[r-1][i] = a[r-1][i+1];  // ←
    for (int i=r-2; i>=s2; i--) a[i+1][c-1] = a[i][c-1];// ↓
    for (int i=c-2; i>=0; i--) a[s2][i+1] = a[s2][i];   // →
    a[s2][1] = 0;
}

void solve() {
    while (t--) {
        diffuse();
        purify();
    }
    for (int i=0; i<r; i++) {
        for (int j=0; j<c; j++) {
            if (a[i][j] > 0) {
                ans += a[i][j];
            }
        }
    }
    printf("%d\n", ans);
}

int main() {
    scanf("%d %d %d", &r, &c, &t);
    for (int i=0; i<r; i++) {
        for (int j=0; j<c; j++) {
            scanf("%d", &a[i][j]);
            if (a[i][j] == -1) {
                // s1 (top), s2 (bottom)
                if (s1 == -1) s1 = i;
                else s2 = i;
            }
        }
    }
    solve();
    return 0;
}

Python 3 소스코드

r, c, t = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(r)]
s1, s2 = -1, 0

def diffuse():
    global a
    b = [[0]*c for _ in range(r)]
    for i in range(r):
        for j in range(c):
            if a[i][j] >= 5:
                d = a[i][j]//5
                for dx, dy in (-1,0), (1,0), (0,1), (0,-1):
                    ni, nj = i+dx, j+dy
                    if 0 <= ni < r and 0 <= nj < c and a[ni][nj] != -1:
                        b[ni][nj] += d
                        a[i][j] -= d
    for i in range(r):
        for j in range(c):
            a[i][j] += b[i][j]

def purify():
    for i in range(s1-2, -1, -1):
        a[i+1][0] = a[i][0]
    for i in range(c-1):
        a[0][i] = a[0][i+1]
    for i in range(s1):
        a[i][c-1] = a[i+1][c-1]
    for i in range(c-2, -1, -1):
        a[s1][i+1] = a[s1][i]
    a[s1][1] = 0
    for i in range(s2+1, r-1):
        a[i][0] = a[i+1][0]
    for i in range(c-1):
        a[r-1][i] = a[r-1][i+1]
    for i in range(r-2, s2-1, -1):
        a[i+1][c-1] = a[i][c-1]
    for i in range(c-2, -1, -1):
        a[s2][i+1] = a[s2][i]
    a[s2][1] = 0

def solve():
    for _ in range(t):
        diffuse()
        purify()
    print(sum(map(sum, a))+2)

for i in range(r):
    for j in range(c):
        if a[i][j] == -1:
            if s1 == -1:
                s1 = i
            else:
                s2 = i
solve()

참고

백준 온라인 저지 : BOJ 17144

BOJ 17143 · 낚시왕

레바스 — Wed, 17 Apr 2019 15:41:27 +0900

알고리즘 분류 : 시뮬레이션

문제에 주어진 조건을 그대로 구현해야 하는 문제다. 크게 두 단계로 나눠서 설계해야 한다. 첫 번째, 낚시왕이 움직인 후 상어를 낚는 과정, 두 번째, 모든 상어가 제각기 움직이면서 서로를 잡아먹는 과정이다.

1. 낚시왕은 매 턴마다 한 칸 움직인 후, 상어 한 마리를 낚는다.
먼저 낚시왕이 한 칸 앞으로 이동한다. 낚시왕은 최대 R(열의 개수)번 움직일 수 있다.
도착한 열에서 땅에 가장 가까운 상어 한 마리를 낚는다. 땅에 가장 가까운 상어는 0에 가까운 행(C)에 위치한다.

2. 상어가 제각기 주어진 속도와 방향에 따라 움직이고, 자신보다 작은 상어를 잡아먹는다.
상어의 속도는 움직일 수 있는 칸의 개수를 의미한다. 가장자리에 도달하면 방향을 바꿔서 남은 횟수만큼 움직여야 한다.
매번 한 칸씩 움직이는 것은 비효율적이므로, 규칙을 찾는 것이 좋다. X에서 출발했다고 가정하면, 움직이다가 결국은 X로 돌아오게 되어있다. 즉, 같은 움직임을 주기적으로 반복한다.
속도를 S, 맵의 크기를 R * C 라고 하자. 단, 맵의 인덱스 범위는 [0, 0] ~ [R-1, C-1] 이다.
위/아래로 움직일 때는 S % ((R-1)*2) 만큼 반복된다. 왼/오른쪽으로 움직일 때는 S % ((C-1)*2) 만큼 반복된다.
구한 주기만큼 움직이면서, 가장자리에 부딪히면 방향을 바꾼다. 위(0) ↔ 아래(1), 오른쪽(2) ↔ 왼쪽(3)
움직임을 마친 후, 도착한 위치에 자신보다 큰 상어가 있는지 확인한다. 이때, 이미 이동을 마친 상어와 크기를 비교해야 한다. 이를 위해 별도의 맵을 만들어 둘 필요가 있다. A는 원래 상어가 위치한 맵이며, B는 상어의 이동을 저장할 맵이다.
자신보다 큰 상어가 없다면, 이동한 상어의 값을 B에 저장한다. 원래 상어가 위치한 A의 값은 0으로 초기화한다.
모든 상어의 이동을 마친 후, B에 들어있는 모든 값을 A에 복사한다.

C++ 소스코드

#include <cstdio>
#include <cstring>

struct shark {
    int s, d, z;
};

int r, c, m, ans;
shark a[100][100];
const int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, 1, -1};

void solve() {
    for (int t=0; t<c; t++) {
        shark b[100][100] = {0};
        // Fishing a shark
        for (int i=0; i<r; i++) {
            if (a[i][t].z) {
                ans += a[i][t].z;
                a[i][t] = {0, 0, 0};
                break;
            }
        }
        // Sharks move
        for (int i=0; i<r; i++) {
            for (int j=0; j<c; j++) {
                if (a[i][j].z) {
                    if (a[i][j].d < 2) { // Up, Down
                        int s = a[i][j].s % ((r-1)*2);
                        int d = a[i][j].d;
                        int ni = i;
                        while (s--) {
                            if (ni == 0 && d == 0) d = 1;
                            if (ni == r-1 && d == 1) d = 0;
                            ni += dx[d];
                        }
                        if (a[i][j].z > b[ni][j].z) b[ni][j] = {a[i][j].s, d, a[i][j].z};
                    } else { // Right, Left
                        int s = a[i][j].s % ((c-1)*2);
                        int d = a[i][j].d;
                        int nj = j;
                        while (s--) {
                            if (nj == 0 && d == 3) d = 2;
                            if (nj == c-1 && d == 2) d = 3;
                            nj += dy[d];
                        }
                        if (a[i][j].z > b[i][nj].z) b[i][nj] = {a[i][j].s, d, a[i][j].z};
                    }
                    a[i][j] = {0, 0, 0};
                }
            }
        }
        memcpy(a, b, sizeof(b));
    }
}

int main() {
    scanf("%d %d %d", &r, &c, &m);
    for (int i=0; i<m; i++) {
        int x, y, s, d, z;
        scanf("%d %d %d %d %d", &x, &y, &s, &d, &z);
        a[x-1][y-1] = {s, d-1, z};
    }
    solve();
    printf("%d\n", ans);
    return 0;
}

Python 3 소스코드

r, c, m = map(int, input().split())
a = [[[0, 0, 0] for _ in range(c)] for _ in range(r)]
for _ in range(m):
    x, y, s, d, z = map(int, input().split())
    a[x-1][y-1] = [s, d-1, z]
dx, dy, ans = (-1, 1, 0, 0), (0, 0, 1, -1), 0

for t in range(c):
    b = [[[0, 0, 0] for _ in range(c)] for _ in range(r)]
    for i in range(r):
        _, _, z = a[i][t]
        if z:
            ans += z
            a[i][t] = [0, 0, 0]
            break
    for i in range(r):
        for j in range(c):
            s, d, z = a[i][j]
            if z:
                if d < 2:
                    ns, nd, ni = s % ((r-1)*2), d, i
                    for _ in range(ns):
                        if ni == 0 and nd == 0:
                            nd = 1
                        if ni == r-1 and nd == 1:
                            nd = 0
                        ni += dx[nd]
                    _, _, bz = b[ni][j]
                    if z > bz:
                        b[ni][j] = [s, nd, z]
                else:
                    ns, nd, nj = s % ((c-1)*2), d, j
                    for _ in range(ns):
                        if nj == 0 and nd == 3:
                            nd = 2
                        if nj == c-1 and nd == 2:
                            nd = 3
                        nj += dy[nd]
                    _, _, bz = b[i][nj]
                    if z > bz:
                        b[i][nj] = [s, nd, z]
                a[i][j] = [0, 0, 0]
    a = b[:]

print(ans)

참고

백준 온라인 저지 : BOJ 17143

BOJ 17142 · 연구소 3

레바스 — Sun, 14 Apr 2019 23:52:16 +0900

알고리즘 분류 : BFS, 브루트 포스

연구소에 바이러스를 퍼트리는 데 걸리는 최소 시간을 구하는 문제다. 바이러스를 놓을 수 있는 경우를 모두 만든 후, 각 케이스에 대해 BFS로 바이러스를 퍼트려서 최솟값을 구하면 된다. BOJ 17141번 '연구소 2'와 거의 동일한 문제이다. 일부 값만 수정하면 된다.

연구소의 사이즈는 N이며, 바이러스의 개수는 M이다.
바이러스를 놓을 수 있는 칸(2)의 좌표를 별도의 리스트 V에 저장한다.
빈칸(0)의 개수를 모두 세고, 이를 K라 하자. 이 값은 바이러스를 퍼트려야 하는 칸의 총개수가 된다.
조합(combination) 방법을 통해 M개의 바이러스를 바이러스 칸(2)에 둔다. 이때 리스트 V를 활용하여, 바이러스를 놓은 칸의 좌표를 큐에 모두 집어넣는다.
BFS를 통해 바이러스를 감염시킨다. 감염시킬 때마다, 감염시킨 칸의 개수를 세고, 감염 시간을 계속 업데이트한다.
감염시킬 수 있는 곳은 빈칸(0)만 가능하지만, 바이러스를 놓을 수 있는 칸(2)으로도 이동할 수 있다.
BFS가 종료된 후, 감염시킨 칸의 개수와 K가 같은지 비교한다. 만약 비교한 값이 같고, 걸린 시간이 최솟값이라면, 정답으로 업데이트한다.
모든 경우의 수에 대해서 BFS를 수행한다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

struct virus {
    int x, y;
};

int a[50][50], dist[50][50];
int n, m, k, ans=1e9;
bool select[10];
vector<virus> v;
queue<virus> q;
const int dx[] = {-1, 0 , 1, 0}, dy[] = {0, 1, 0, -1};

void bfs() {
    int infect=0, times=0;
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y; q.pop(); 
        for (int i=0; i<4; i++) {
            int nx = x+dx[i], ny = y+dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
            if (a[nx][ny] != 1 && dist[nx][ny] == -1) {
                dist[nx][ny] = dist[x][y]+1;
                if (a[nx][ny] == 0) {
                    infect += 1;
                    times = dist[nx][ny];
                }
                q.push({nx, ny});
            }
        }
    }
    if (infect == k && ans > times) ans = times;
}

void solve(int idx, int cnt, int d) {
    if (cnt == m) {
        memset(dist, -1, sizeof(dist));
        for (int i=0; i<d; i++) {
            if (select[i]) {
                q.push({v[i].x, v[i].y});
                dist[v[i].x][v[i].y] = 0;
            }
        }
        bfs();
        return;
    }
    for (int i=idx; i<d; i++) {
        if (!select[i]) {
            select[i] = true;
            solve(i+1, cnt+1, d);
            select[i] = false;
        }
    }
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            scanf("%d", &a[i][j]);
            if (a[i][j] == 2) v.push_back({i, j});
            if (a[i][j] == 0) k += 1;
        }
    }
    solve(0, 0, v.size());
    printf("%d\n", ans == 1e9 ? -1 : ans);
    return 0;
}

Python 3 소스코드

from collections import deque

n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
select = [False] * 10
q, v, k = deque(), [], 0

def bfs(dist):
    global ans
    infect, times = 0, 0
    while q:
        x, y = q.popleft()
        for dx, dy in (-1,0), (1,0), (0,1), (0,-1):
            nx, ny = x+dx, y+dy
            if nx < 0 or nx >= n or ny < 0 or ny >= n:
                continue
            if a[nx][ny] != 1 and dist[nx][ny] == -1:
                dist[nx][ny] = dist[x][y]+1
                q.append((nx, ny))
                if a[nx][ny] == 0:
                    infect += 1
                    times = dist[nx][ny]
    if infect == k:
        ans = min(ans, times)

def solve(idx, cnt, d):
    if cnt == m:
        dist = [[-1]*n for _ in range(n)]
        for i in range(d):
            if select[i]:
                x, y = v[i]
                q.append((x, y))
                dist[x][y] = 0
        bfs(dist)
        return
    for i in range(idx, d):
        if not select[i]:
            select[i] = True
            solve(i+1, cnt+1, d)
            select[i] = False

for i in range(n):
    for j in range(n):
        if a[i][j] == 2:
            v.append((i, j))
        if a[i][j] == 0:
            k += 1
ans = 10**9
solve(0, 0, len(v))
print(ans if ans != 10**9 else -1)

참고

백준 온라인 저지 : BOJ 17142
연구소 2

BOJ 17141 · 연구소 2

레바스 — Sun, 14 Apr 2019 23:46:15 +0900

알고리즘 분류 : BFS, 브루트 포스

연구소에 바이러스를 퍼트리는 데 걸리는 최소 시간을 구하는 문제다. 바이러스를 놓을 수 있는 경우를 모두 만든 후, 각 케이스에 대해 BFS로 바이러스를 퍼트려서 최솟값을 구하면 된다.

연구소의 사이즈는 N이며, 바이러스의 개수는 M이다.
바이러스를 놓을 수 있는 칸(2)의 좌표를 별도의 리스트 V에 저장한다.
빈칸(0)의 개수를 모두 세고, 여기에 바이러스를 놓을 수 있는 칸(2)의 개수를 더한 후, M을 뺀다. 이 값은 바이러스를 퍼트려야 하는 칸의 총개수가 된다. 이를 K라 하자.
조합(combination) 방법을 통해 M개의 바이러스를 바이러스 칸(2)에 둔다. 이때 리스트 V를 활용하여, 바이러스를 놓은 칸의 좌표를 큐에 모두 집어넣는다.
BFS를 통해 바이러스를 감염시킨다. 감염시킬 때마다, 감염시킨 칸의 개수를 세고, 감염 시간을 계속 업데이트한다.
감염시킬 수 있는 곳은 벽(1)을 제외한 모든 곳이다.
BFS가 종료된 후, 감염시킨 칸의 개수와 K가 같은지 비교한다. 만약 비교한 값이 같고, 걸린 시간이 최솟값이라면, 정답으로 업데이트한다.
모든 경우의 수에 대해서 BFS를 수행한다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

struct virus {
    int x, y;
};

int a[50][50], dist[50][50];
int n, m, k, ans=1e9;
bool select[10];
vector<virus> v;
queue<virus> q;
const int dx[] = {-1, 0 , 1, 0}, dy[] = {0, 1, 0, -1};

void bfs() {
    int infect=0, times=0;
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y; q.pop();
        times = dist[x][y];
        for (int i=0; i<4; i++) {
            int nx = x+dx[i], ny = y+dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
            if (a[nx][ny] != 1 && dist[nx][ny] == -1) {
                dist[nx][ny] = dist[x][y]+1;
                q.push({nx, ny});
                infect += 1;
            }
        }
    }
    if (infect == k && ans > times) ans = times;
}

void solve(int idx, int cnt, int d) {
    if (cnt == m) {
        memset(dist, -1, sizeof(dist));
        for (int i=0; i<d; i++) {
            if (select[i]) {
                q.push({v[i].x, v[i].y});
                dist[v[i].x][v[i].y] = 0;
            }
        }
        bfs();
        return;
    }
    for (int i=idx; i<d; i++) {
        if (!select[i]) {
            select[i] = true;
            solve(i+1, cnt+1, d);
            select[i] = false;
        }
    }
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            scanf("%d", &a[i][j]);
            if (a[i][j] == 2) v.push_back({i, j});
            if (a[i][j] == 0) k += 1;
        }
    }
    k = k+v.size()-m;
    solve(0, 0, v.size());
    printf("%d\n", ans == 1e9 ? -1 : ans);
    return 0;
}

Python 3 소스코드

from collections import deque

n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
select = [False] * 10
q, v, k = deque(), [], 0

def bfs(dist):
    global ans
    infect, times = 0, 0
    while q:
        x, y = q.popleft()
        times = dist[x][y]
        for dx, dy in (-1,0), (1,0), (0,1), (0,-1):
            nx, ny = x+dx, y+dy
            if nx < 0 or nx >= n or ny < 0 or ny >= n:
                continue
            if a[nx][ny] != 1 and dist[nx][ny] == -1:
                dist[nx][ny] = dist[x][y]+1
                q.append((nx, ny))
                infect += 1
    if infect == k:
        ans = min(ans, times)

def solve(idx, cnt, d):
    if cnt == m:
        dist = [[-1]*n for _ in range(n)]
        for i in range(d):
            if select[i]:
                x, y = v[i]
                q.append((x, y))
                dist[x][y] = 0
        bfs(dist)
        return
    for i in range(idx, d):
        if not select[i]:
            select[i] = True
            solve(i+1, cnt+1, d)
            select[i] = False

for i in range(n):
    for j in range(n):
        if a[i][j] == 2:
            v.append((i, j))
        if a[i][j] == 0:
            k += 1
ans = 10**9
k = k+len(v)-m
solve(0, 0, len(v))
print(ans if ans != 10**9 else -1)

참고

백준 온라인 저지 : BOJ 17141
연구소 3

BOJ 17140 · 이차원 배열과 연산

레바스 — Sun, 14 Apr 2019 23:29:07 +0900

알고리즘 분류 : 시뮬레이션

문제에 주어진 조건을 그대로 구현하는 문제다. 여러 개의 변수를 가진 구조체(또는 벡터)를 정렬해야 한다. 연산자 오버로딩을 통해 우선순위를 구현하거나, STL pair를 사용하면 된다. 정렬 대신, 우선순위 큐를 사용할 수 있다.

행의 최대 사이즈를 N, 열의 최대 사이즈를 M이라고 하자.
이 문제는 N >= M일 때 각 행을 정렬하고, N < M일 때 각 열을 정렬한다.
정렬의 우선순위는 1) 수의 등장 횟수, 2) 해당 숫자이며, 오름차순으로 정렬한다.
수의 등장 횟수는 별도의 카운터 배열을 만들어서 해당 숫자가 얼마나 등장하는지 센다.
배열에 값이 들어갈 때는 숫자가 먼저 들어가며, 그다음으로 수의 등장 횟수가 들어간다.
정렬 연산이 수행되면, 행 또는 열이 커질 수 있다. 커질 때마다 N 또는 M 값을 최대치로 업데이트한다.
행 연산과 열 연산은 동작이 거의 비슷하다. 그대로 복사 붙여넣기 한 후, 범위와 인덱스만 적절히 수정하면 된다.
정렬을 수행하다가 A[R][C] == K를 발견하면 현재 시간을 출력하고 종료한다.
수행 시간이 100을 초과하면, -1을 출력하고 종료한다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
using namespace std;

int r, c, k, n=3, m=3;
int cnt[101], a[101][101];

void solve() {
    for (int t=0; t<101; t++) {
        if (a[r][c] == k) {
            printf("%d\n", t);
            return;
        }
        if (n >= m) {
            for (int i=1; i<=n; i++) {
                priority_queue<pair<int, int>> pq;
                memset(cnt, 0, sizeof(cnt));
                for (int j=1; j<=m; j++) {
                    if (a[i][j]) {
                        cnt[a[i][j]] += 1;
                        a[i][j] = 0;
                    }
                }
                for (int j=1; j<=100; j++) {
                    if (cnt[j]) pq.push(make_pair(-cnt[j], -j));
                }
                int len = pq.size()*2;
                m = max(m, len);
                for (int j=1; j<=len; j+=2) {
                    a[i][j] = -pq.top().second;
                    a[i][j+1] = -pq.top().first;
                    pq.pop();
                }
            }
        } else {
            for (int i=1; i<=m; i++) {
                priority_queue<pair<int, int>> pq;
                memset(cnt, 0, sizeof(cnt));
                for (int j=1; j<=n; j++) {
                    if (a[j][i]) {
                        cnt[a[j][i]] += 1;
                        a[j][i] = 0;
                    }
                }
                for (int j=1; j<=100; j++) {
                    if (cnt[j]) pq.push(make_pair(-cnt[j], -j));
                }
                int len = pq.size()*2;
                n = max(n, len);
                for (int j=1; j<=len; j+=2) {
                    a[j][i] = -pq.top().second;
                    a[j+1][i] = -pq.top().first;
                    pq.pop();
                }
            }
        }
        
    }
    printf("-1\n");
}

int main() {
    scanf("%d %d %d", &r, &c, &k);
    for (int i=1; i<=3; i++) {
        for (int j=1; j<=3; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    solve();
    return 0;
}

✓ C++ 코드에서는 우선순위 큐를 사용하여 정렬된 상태를 만들었다.

Python 3 소스코드

r, c, k = map(int, input().split())
a = [[0]*101 for _ in range(101)]
n, m = 3, 3

def solve():
    global n, m
    for t in range(101):
        if a[r][c] == k:
            print(t)
            return
        if n >= m:
            for i in range(1, n+1):
                cnt = [0]*101
                for j in range(1, m+1):
                    if a[i][j]:
                        cnt[a[i][j]] += 1
                        a[i][j] = 0
                b = []
                for j in range(1, 101):
                    if cnt[j]:
                        b.append((cnt[j], j))
                b.sort()
                m = max(m, len(b)*2)
                j = 1
                for x in b:
                    a[i][j+1], a[i][j] = x
                    j += 2
        else:
            for i in range(1, m+1):
                cnt = [0]*101
                for j in range(1, n+1):
                    if a[j][i]:
                        cnt[a[j][i]] += 1
                        a[j][i] = 0
                b = []
                for j in range(1, 101):
                    if cnt[j]:
                        b.append((cnt[j], j))
                b.sort()
                n = max(n, len(b)*2)
                j = 1
                for x in b:
                    a[j+1][i], a[j][i] = x
                    j += 2
    print(-1)

for i in range(1, 4):
    a[i][1], a[i][2], a[i][3] = map(int, input().split())
solve()

✓ Python 코드에서는 일반적인 정렬을 사용하였다.

참고

백준 온라인 저지 : BOJ 17140

BOJ 17069 · 파이프 옮기기 2

레바스 — Wed, 10 Apr 2019 12:52:24 +0900

알고리즘 분류 : 다이나믹 프로그래밍

파이프를 옮겨서 한쪽 끝을 (N, N)으로 이동시키는 방법의 개수를 구해야 한다. BOJ 17070번 '파이프 옮기기 1'이 업그레이드된 문제이다. N의 범위가 최대 32로 증가했다. 하지만 시간제한은 0.5초로 줄어들었으므로, 백트래킹으로 구현할 수 없다. 때문에 이 문제는 DP를 이용하여 구현해야 한다. DP로 구현하면 1번 문제도 해결할 수 있다.

파이프의 상태는 3가지로 나눌 수 있다.
1. 가로로 놓여있는 상태 (0) : 가로(0) → 가로(0) 또는 대각선(2)
2. 세로로 놓여있는 상태 (1) : 세로(1) → 세로(1) 또는 대각선(2)
3. 대각선으로 놓여있는 상태 (2) : 대각선(2) → 가로(0) 또는 세로(1) 또는 대각선(2)

D[M][X][Y] : M번 파이프가 (X, Y)에 도착하는 방법의 수 (M은 파이프의 상태 0~2)
D[0][X][Y] : 가로 파이프가 (X, Y)에 도착하는 방법의 수
D[1][X][Y] : 세로 파이프가 (X, Y)에 도착하는 방법의 수
D[2][X][Y] : 대각선 파이프가 (X, Y)에 도착하는 방법의 수
D[0][1][2] = 1 : 가로 파이프 시작 위치 (1, 2)

C++ 소스코드

#include <cstdio>

int n, p[34][34];
long long d[3][34][34];

void solve() {
    d[0][1][2] = 1;
    for (int i=1; i<=n; i++) {
        for (int j=1; j<=n; j++) {
            if (!p[i][j+1]) d[0][i][j+1] += d[0][i][j] + d[2][i][j];
            if (!p[i+1][j]) d[1][i+1][j] += d[1][i][j] + d[2][i][j];
            if (!p[i+1][j+1] && !p[i+1][j] && !p[i][j+1]) {
                d[2][i+1][j+1] += d[0][i][j] + d[1][i][j] + d[2][i][j];
            }
        }
    }
    printf("%lld\n", d[0][n][n]+d[1][n][n]+d[2][n][n]);
}

int main() {
    scanf("%d", &n);
    for (int i=1; i<=n; i++) {
        for (int j=1; j<=n; j++) {
            scanf("%d", &p[i][j]);
        }
    }
    solve();
    return 0;
}

Python 3 소스코드

n = int(input())
p = [[0]*(n+1)]+[[0]+list(map(int, input().split())) for _ in range(n)]
d = [[[0]*3 for _ in range(n+1)] for _ in range(n+1)]

def solve():
    d[1][2][0] = 1
    for i in range(1, n+1):
        for j in range(1, n+1):
            if j < n and not p[i][j+1]:
                d[i][j+1][0] += d[i][j][0] + d[i][j][2]
            if i < n and not p[i+1][j]:
                d[i+1][j][1] += d[i][j][1] + d[i][j][2]
            if i < n and j < n and not (p[i+1][j] or p[i][j+1] or p[i+1][j+1]):
                d[i+1][j+1][2] += d[i][j][0] + d[i][j][1] + d[i][j][2]

solve()
print(sum(d[n][n]))

✓ 파이썬 소스코드는 D[X][Y][M] 으로 구현했다.

참고

백준 온라인 저지 : BOJ 17069
파이프 옮기기 1

BOJ 16985 · Maaaaaaaaaze

레바스 — Tue, 9 Apr 2019 12:21:38 +0900

알고리즘 분류 : BFS, 브루트 포스

3차원 미로를 탈출하는 것을 구현해야 한다. 단순한 3차원 BFS는, BOJ 7569번 '토마토'처럼 구현하면 된다. 하지만, 이 문제는 각 층의 미로가 회전하고, 각 층마다 섞여서 까다롭다. 미로를 제대로 만드는 것이 중요하다.

미로 맵을 나타낼 3차원 배열의 인덱스는 [층 번호] [X좌표] [Y좌표] 이다.
각 층을 섞는 것을 순열을 통해 만든다. 별도의 인덱스[0~4]를 만들어서 층을 나타내고, 이를 순열로 섞으면 된다.
층을 섞은 후, 각 층을 회전해야 한다. 별도의 회전 함수를 만들고, 5중 for문 또는 재귀를 통해 각 층을 순차적으로 회전시킨다.
첫 층의 출발 칸(0, 0, 0)이 이동할 수 있는 칸[1]인 경우에만 다음 층을 섞는다. 이동할 수 없는 칸[0]이라면 다음 층으로 이동할 수 없기 때문이다.
층을 순서대로 회전시키면서 마지막 층까지 회전시킨 후, 도착 칸(4, 4, 4)이 이동할 수 있는 칸[1]인지 확인한다. 이동할 수 있는 칸이라면, BFS 탐색을 시작한다.
BFS 탐색을 할 때마다, 최단 거리 정보를 업데이트한다.
만약 최단 거리가 12로 나왔다면, 이보다 더 짧을 수 없으므로, exit 함수를 통해 프로그램을 바로 종료한다. 이 부분을 처리하면 수행 시간을 대폭 줄일 수 있다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <algorithm>
using namespace std;

struct maze {
    int x, y, z;
};

int a[5][5][5], b[5][5][5], d[5];
int dist[5][5][5], ans = 1e9;
const int dx[] = {1, -1, 0, 0, 0, 0}, dy[] = {0, 0, 1, -1, 0, 0}, dz[] = {0 ,0, 0, 0, 1, -1};

void bfs() {
    queue<maze> q;
    q.push({0, 0, 0});
    memset(dist, -1, sizeof(dist));
    dist[0][0][0] = 0;
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y, z = q.front().z; q.pop();
        if (x == 4 && y == 4 && z == 4) {
            ans = min(ans, dist[x][y][z]);
            if (ans == 12) {
                printf("12\n");
                exit(0);
            }
            return;
        }
        for (int i=0; i<6; i++) {
            int nx = x+dx[i], ny = y+dy[i], nz = z+dz[i];
            if (nx < 0 || nx >= 5 || ny < 0 || ny >= 5 || nz < 0 || nz >= 5) continue;
            if (b[nx][ny][nz] && dist[nx][ny][nz] == -1) {
                q.push({nx, ny, nz});
                dist[nx][ny][nz] = dist[x][y][z]+1;
            }
        }
    }
}

void rotate(int s) {
    int temp[5][5];
    for (int i=0; i<5; i++) {
        for (int j=0; j<5; j++) {
            temp[j][4-i] = b[s][i][j];
        }
    }
    for (int i=0; i<5; i++) {
        for (int j=0; j<5; j++) {
            b[s][i][j] = temp[i][j];
        }
    }
}

void solve() {
    do {
        for (int i=0; i<5; i++) {
            memcpy(b[d[i]], a[i], sizeof(a[i]));
        }
        for (int i=0; i<4; i++) {
            rotate(0);
            if (!b[0][0][0]) continue;
            for (int j=0; j<4; j++) {
                rotate(1);
                for (int k=0; k<4; k++) {
                    rotate(2);
                    for (int m=0; m<4; m++) {
                        rotate(3);
                        for (int n=0; n<4; n++) {
                            rotate(4);
                            if (b[4][4][4]) bfs();
                        }
                    }
                }
            }
        }
    } while (next_permutation(d, d+5));
}

int main() {
    for (int i=0; i<5; i++) {
        for (int j=0; j<5; j++) {
            for (int k=0; k<5; k++) {
                scanf("%d", &a[i][j][k]);
            }
        }
    }
    for (int i=0; i<5; i++) d[i] = i;
    solve();
    printf("%d\n", ans == 1e9 ? -1 : ans);
    return 0;
}

Python 3 소스코드

from collections import deque
from itertools import permutations

ans = 10**9
dx, dy, dz = (1, -1, 0, 0, 0, 0), (0, 0, 1, -1, 0, 0), (0, 0, 0, 0, 1, -1)
a = [[list(map(int, input().split())) for _ in range(5)] for _ in range(5)]
b = [[[0]*5 for _ in range(5)] for _ in range(5)]

def bfs():
    global ans
    q = deque()
    q.append((0, 0, 0))
    dist = [[[-1]*5 for _ in range(5)] for _ in range(5)]
    dist[0][0][0] = 0
    while q:
        x, y, z = q.popleft()
        if (x, y, z) == (4, 4 ,4):
            ans = min(ans ,dist[x][y][z])
            if ans == 12:
                print(12)
                exit(0)
            return
        for i in range(6):
            nx, ny, nz = x+dx[i], y+dy[i], z+dz[i]
            if nx < 0 or nx >= 5 or ny < 0 or ny >= 5 or nz < 0 or nz >= 5:
                continue
            if b[nx][ny][nz] and dist[nx][ny][nz] == -1:
                q.append((nx, ny, nz))
                dist[nx][ny][nz] = dist[x][y][z]+1

def rotate(k):
    temp = [[0]*5 for _ in range(5)]
    for i in range(5):
        for j in range(5):
            temp[j][4-i] = b[k][i][j]
    b[k] = temp

def maze(cnt):
    if cnt == 5:
        if b[4][4][4]:
            bfs()
        return
    for i in range(4):
        if b[0][0][0]:
            maze(cnt+1)
        rotate(cnt)

def solve():
    for d in permutations([0, 1, 2, 3, 4]):
        for i in range(5):
            b[d[i]] = a[i]
        maze(0)

solve()
print(ans if ans != 10**9 else -1)

참고

백준 온라인 저지 : BOJ 16985

BOJ 1149 · RGB거리

레바스 — Mon, 8 Apr 2019 21:01:39 +0900

알고리즘 분류 : 다이나믹 프로그래밍

RGB 거리의 각 집에 색칠하는 비용을 구해야 한다. DP로 구현하여 색칠할 때 드는 최소 비용을 구하면 된다.

D[N][M] : N번째 집을 M으로 칠할 때 드는 최소 비용 (M은 색깔 0~2)
D[N][0] : N번째 집을 빨간색(0)으로 칠할 때 드는 최소 비용
D[N][1] : N번째 집을 초록색(1)으로 칠할 때 드는 최소 비용
D[N][2] : N번째 집을 파란색(2)으로 칠할 때 드는 최소 비용
D[1][0] = P[1][0], D[1][1] = P[1][1], D[1][2] = P[1][2]

C++ 소스코드

#include <cstdio>
#include <algorithm>
using namespace std;

int n, d[1001][3], p[1001][3];

void solve() {
    for (int i=0; i<3; i++) d[1][i] = p[1][i];
    for (int i=2; i<=n; i++) {
        d[i][0] = min(d[i-1][1], d[i-1][2]) + p[i][0];
        d[i][1] = min(d[i-1][0], d[i-1][2]) + p[i][1];
        d[i][2] = min(d[i-1][0], d[i-1][1]) + p[i][2];
    }
    printf("%d\n", min(min(d[n][0], d[n][1]), d[n][2]));
}

int main() {
    scanf("%d", &n);
    for (int i=1; i<=n; i++) {
        for (int j=0; j<3; j++) {
            scanf("%d", &p[i][j]);
        }
    }
    solve();
    return 0;
}

Python 3 소스코드

def solve():
    for i in range(3):
        d[1][i] = p[1][i]
    for i in range(2, n+1):
        d[i][0] = min(d[i-1][1], d[i-1][2]) + p[i][0]
        d[i][1] = min(d[i-1][0], d[i-1][2]) + p[i][1]
        d[i][2] = min(d[i-1][0], d[i-1][1]) + p[i][2]
    print(min(d[n]))

n = int(input())
d = [[0]*3 for _ in range(n+1)]
p = [[0]*3]+[list(map(int, input().split())) for _ in range(n)]
solve()

참고

백준 온라인 저지 : BOJ 1149

BOJ 1012 · 유기농 배추

레바스 — Mon, 8 Apr 2019 19:36:08 +0900

알고리즘 분류 : DFS

배추 밭에 놓아야 하는 배추흰지렁이의 마릿수를 구해야 한다. 배추흰지렁이는 하나의 배추 그룹에 한 마리만 놓으면, 최소 마릿수가 된다. 즉, 이 문제는 배추 그룹의 수를 세는 플러드 필 문제이다. 배추가 인접한 상하좌우로 연결되면, 이것은 하나의 배추 그룹이 된다.

우선 N*M 사이즈의 배열 A를 만들고 모든 좌표를 0으로 둔다.
입력으로 주어지는 배추의 좌표 (X, Y)를 배열 A에 1로 둔다.
N*M 사이즈의 맵을 DFS를 통해 모든 곳을 방문할 때까지 완전 탐색한다.
DFS로 다음 좌표를 이동할 때, 배추(1)로만 이동한다.
테스트케이스가 여러 개 주어지므로, 초기화가 매번 필요하다.

C++ 소스코드

#include <cstdio>
#include <cstring>

int m, n, k, ans;
int a[51][51];
bool check[51][51];
const int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

void dfs(int x, int y) {
    check[x][y] = true;
    for (int i=0; i<4; i++) {
        int nx = x+dx[i], ny = y+dy[i];
        if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
        if (a[nx][ny] && !check[nx][ny]) {
            dfs(nx, ny);
        }
    }
}

void solve() {
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            if (a[i][j] && !check[i][j]) {
                dfs(i, j);
                ans++;
            }
        }
    }
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        ans = 0;
        memset(check, 0, sizeof(check));
        memset(a, 0, sizeof(a));
        scanf("%d %d %d", &m, &n, &k);
        for (int i=0; i<k; i++) {
            int x, y;
            scanf("%d %d", &x, &y);
            a[y][x] = 1;
        }
        solve();
        printf("%d\n", ans);
    }
    return 0;
}

Python 3 소스코드

import sys
sys.setrecursionlimit(10000)

def dfs(x, y):
    check[x][y] = True
    for dx, dy in (-1,0), (1,0), (0,1), (0,-1):
        nx, ny = x+dx, y+dy
        if nx < 0 or nx >= n or ny < 0 or ny >= m:
            continue
        if a[nx][ny] and not check[nx][ny]:
            dfs(nx, ny)

def solve():
    ans = 0
    for i in range(n):
        for j in range(m):
            if a[i][j] and not check[i][j]:
                dfs(i, j)
                ans += 1
    print(ans)

for _ in range(int(input())):
    m, n, k = map(int, input().split())
    a = [[0]*m for _ in range(n)]
    check = [[False]*m for _ in range(n)]
    for _ in range(k):
        x, y = map(int, input().split())
        a[y][x] = 1
    solve()

참고

백준 온라인 저지 : BOJ 1012

BOJ 17070 · 파이프 옮기기 1

레바스 — Mon, 8 Apr 2019 17:26:34 +0900

알고리즘 분류 : 백트래킹

파이프를 옮겨서 한쪽 끝을 (N, N)으로 이동시키는 방법의 개수를 구해야 한다. 파이프는 2칸을 차지하지만, 파이프의 끝만 고려하면 된다.

파이프의 상태는 3가지로 나눌 수 있다.
1. 가로로 놓여있는 상태 (0) : 가로(0) → 가로(0) 또는 대각선(2)
2. 세로로 놓여있는 상태 (1) : 세로(1) → 세로(1) 또는 대각선(2)
3. 대각선으로 놓여있는 상태 (2) : 대각선(2) → 가로(0) 또는 세로(1) 또는 대각선(2)
가로(0)에서 세로(1)로 곧바로 이동할 수 없고, 세로(1)에서 가로(0)로 곧바로 이동할 수 없다.

재귀 함수의 인자는 (X 좌표, Y 좌표, 파이프 상태) 이다.
현재 파이프 상태에 따라서 다음 이동의 파이프 상태를 위의 3가지 조건에 따라 구현한다.
또한, 다음 이동 좌표가 벽(1)인지 확인하고, 벽이라면 이동하지 않도록 한다. 빈칸(0)으로만 이동할 수 있다.
마지막 좌표에 도착하면 정답에 +1 카운트한다.

C++ 소스코드

#include <cstdio>

int n, ans;
int a[16][16];
int dx[] = {0, 1, 1}, dy[] = {1, 0, 1};

void solve(int x, int y, int z) {
    if (x == n-1 && y == n-1) {
        ans += 1;
        return;
    }
    for (int i=0; i<3; i++) {
        if (i+z == 1) continue;
        int nx = x+dx[i], ny = y+dy[i];
        if (nx >= n || ny >= n || a[nx][ny]) continue;
        if (i == 2 && (a[x][y+1] || a[x+1][y])) continue;
        solve(nx, ny, i);
    }
}

int main() {
    scanf("%d", &n);
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    solve(0, 1, 0);
    printf("%d\n", ans);
    return 0;
}

PyPy3 소스코드

dx, dy = (0, 1, 1), (1, 0, 1)
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]

def solve(x, y, z):
    res = 0
    if x == n-1 and y == n-1:
        return 1
    for i in range(3):
        if i+z == 1:
            continue
        nx, ny = x+dx[i], y+dy[i]
        if nx >= n or ny >= n or a[nx][ny]:
            continue
        if i == 2 and (a[x][y+1] or a[x+1][y]):
            continue
        res += solve(nx, ny, i)
    return res

print(solve(0, 1, 0))

✓ Python 3로 제출하면 시간 초과가 나오므로, PyPy3로 제출해야 한다.

참고

백준 온라인 저지 : BOJ 17070

BOJ 2156 · 포도주 시식

레바스 — Sun, 7 Apr 2019 22:54:22 +0900

알고리즘 분류 : 다이나믹 프로그래밍

N개의 포도주 잔이 있을 때, 최대로 마실 수 있는 포도주의 양을 구해야 한다. DP를 이용하여 포도주 마시는 규칙에 따라 구현하면 된다.

포도주는 연속으로 3잔 이상 마실 수 없다. 즉, 연속하여 마실 수 있는 포도주는 최대 2잔이다.
D[N] : N 번째 잔의 포도주를 마셨을 때, 최대로 마실 수 있는 포도주의 양

D[N]은 3가지 경우의 수로 나눌 수 있으며, 3가지 값 중 가장 큰 값이 D[N]이 된다.
1. N 번째 잔을 마시지 않은 경우 : D[N-1]
2. N 번째 잔이 연속 1잔째 마신 경우 : D[N-2] + P[N] (N-1 번째 잔은 마시지 않아야 한다.)
3. N 번째 잔이 연속 2잔째 마신 경우 : D[N-3] + P[N-1] + P[N-1] (N-2 번째 잔은 마시지 않아야 한다.)

C++ 소스코드

#include <cstdio>
#include <algorithm>
using namespace std;

int n, d[10001], p[10001];

void solve() {
    d[1] = p[1], d[2] = p[1]+p[2];
    for (int i=3; i<=n; i++) {
        d[i] = d[i-1];
        d[i] = max(d[i], d[i-2]+p[i]);
        d[i] = max(d[i], d[i-3]+p[i-1]+p[i]);
    }
    printf("%d\n", d[n]);
}

int main() {
    scanf("%d", &n);
    for (int i=1; i<=n; i++) scanf("%d", &p[i]);
    solve();
    return 0;
}

Python 3 소스코드

def solve():
    d[1], d[2] = p[1], p[1]+p[2]
    for i in range(3, n+1):
        d[i] = d[i-1]
        d[i] = max(d[i], d[i-2]+p[i])
        d[i] = max(d[i], d[i-3]+p[i-1]+p[i])

n = int(input())
d = [0]*(n+2)
p = [0]+[int(input()) for _ in range(n)]+[0]
solve()
print(d[n])

참고

백준 온라인 저지 : BOJ 2156

BOJ 17135 · 캐슬 디펜스

레바스 — Sun, 7 Apr 2019 21:36:01 +0900

알고리즘 분류 : 브루트 포스, 시뮬레이션

궁수를 성에 적절히 배치하여 적을 최대한 많이 죽이도록 구현하는 문제다. 가능한 궁수의 배치를 모두 만들고, 각 배치에서 적을 얼마나 쏴 죽일 수 있는지 카운트하면 된다.

N*M 사이즈의 맵에서 궁수는 N+1번째 줄에 3명이 배치된다.
궁수가 서로 겹치지 않도록, 3중 for문 또는 재귀를 통해 각각 배치한다. 조합 방식으로 구현하면 된다.
그리고 배치한 위치의 인덱스를 별도로 저장한다. 아래의 코드에서는 archer 배열에 Y좌표(열 인덱스)가 저장되어 있다.
각 배치에서 궁수로부터 적이 얼마나 떨어져 있는지 계산하고, 각 적을 죽여야 한다.

1. 궁수의 위치를 (N, K)라고 하고, 적의 위치를 (i, j)라고 하자. 단, (0≤i＜N, 0≤j＜M) 이다.
2. 궁수와 적 사이의 거리는 dist = |N-i| + |K-j| 가 된다.
3. dist가 입력으로 주어진 D 이하라면, 죽일 수 있는 적의 후보가 된다. 이 적의 위치를 우선순위 큐(Min Heap)에 집어넣는다. 우선순위 큐는 거리(dist), Y좌표(j), X좌표(i) 순으로 우선순위를 가진다.
4. 적을 모두 찾은 후, 우선순위 큐에 있는 첫 번째 값을 꺼낸다. 이 값은 가장 먼저 죽여야 하는 적의 위치이다. 이 위치를 별도의 리스트 V에 저장한다.
세 명의 궁수에 대해서 1~4과정을 진행하고, 리스트 V에서 값을 꺼낸다. 이 리스트에는 중복된 좌표가 존재할 수 있다. 해당 좌표에 있는 적을 모두 죽인다.
한 턴이 종료되었으므로, 적을 한 칸씩 모두 내린다. 적은 최대 N개의 줄에 존재하므로, N번만 내리면 모두 사라지게 된다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
using namespace std;

struct castle {
    int x, y, z;
    bool operator < (const castle &t) const {
        if (z == t.z) return y > t.y;
        else return z > t.z;
    }
};

int n, m, d, ans;
int a[15][15], archer[3];

void kill() {
    int b[15][15], cnt=0, t=n;
    memcpy(b, a, sizeof(a));
    while (t--) {
        // Find enemies.
        vector<castle> v;
        for (int k=0; k<3; k++) {
            priority_queue<castle> q;
            for (int i=0; i<n; i++) {
                for (int j=0; j<m; j++) {
                    if (b[i][j]) {
                        int dist = abs(n-i)+abs(archer[k]-j);
                        if (dist <= d) q.push({i, j, dist});
                    }
                }
            }
            if (q.size()) {
                int x = q.top().x, y = q.top().y;
                v.push_back({x, y});
            }
        }
        // Kill enemies.
        for (int i=0; i<(int)v.size(); i++) {
            int x = v[i].x, y = v[i].y;
            if (b[x][y]) {
                b[x][y] = 0;
                cnt += 1;
            }
        }
        // Enemies move to down.
        for (int i=n-2; i>=0; i--) {
            for (int j=0; j<m; j++) {
                b[i+1][j] = b[i][j];
            }
        }
        for (int i=0; i<m; i++) b[0][i] = 0;
    }
    if (ans < cnt) ans = cnt;
}

void solve() {
    for (int i=0; i<m; i++) {
        for (int j=i+1; j<m; j++) {
            for (int k=j+1; k<m; k++) {
                archer[0] = i, archer[1] = j, archer[2] = k;
                kill();
            }
        }
    }
}

int main() {
    scanf("%d %d %d", &n, &m, &d);
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    solve();
    printf("%d\n", ans);
    return 0;
}

Python 3 소스코드

from heapq import heappush, heappop
from copy import deepcopy

n, m, d = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
archer = [0]*3

def kill(b):
    cnt = 0
    for _ in range(n):
        v = []
        for k in range(3):
            q = []
            for i in range(n):
                for j in range(m):
                    if b[i][j]:
                        dist = abs(n-i)+abs(archer[k]-j)
                        if dist <= d:
                            heappush(q, (dist, j, i))
            if q:
                _, y, x = heappop(q)
                v.append((x, y))
        for x, y in v:
            if b[x][y]:
                b[x][y] = 0
                cnt += 1
        for i in range(n-2, -1, -1):
            for j in range(m):
                b[i+1][j] = b[i][j]
        for i in range(m):
            b[0][i] = 0
    return cnt

ans = 0
for i in range(m):
    for j in range(i+1, m):
        for k in range(j+1, m):
            archer[0], archer[1], archer[2] = i, j, k
            b = deepcopy(a)
            ans = max(ans, kill(b))
print(ans)

참고

백준 온라인 저지 : BOJ 17135

BOJ 9465 · 스티커

레바스 — Sun, 7 Apr 2019 18:09:08 +0900

알고리즘 분류 : 다이나믹 프로그래밍

스티커를 떼어내어 얻을 수 있는 최대 점수를 DP를 이용하여 구해야 한다.

D[N][M] : N번째 열에서 스티커를 M했을 때, 2xN 개의 스티커에서 얻을 수 있는 최대 점수
M = 0 (위쪽 스티커를 뜯음), M = 1 (아래쪽 스티커를 뜯음), M = 2 (둘 다 뜯지 않음)
D[1][0] = P[1][0], D[1][1] = P[1][1], D[1][2] = 0
D[N][0] : N번째 열에서 위쪽 스티커를 뜯어서 얻은 최대 점수
D[N][1] : N번째 열에서 아래쪽 스티커를 뜯어서 얻은 최대 점수
D[N][2] : N번째 열에서 둘 다 뜯지 않고 얻은 최대 점수

C++ 소스코드

#include <cstdio>
#include <algorithm>
using namespace std;

int n, d[100001][3], p[100001][2];

void solve() {
    d[1][0] = p[1][0], d[1][1] = p[1][1], d[1][2] = 0;
    for (int i=2; i<=n; i++) {
        d[i][0] = max(d[i-1][1], d[i-1][2]) + p[i][0];
        d[i][1] = max(d[i-1][0], d[i-1][2]) + p[i][1];
        d[i][2] = max(max(d[i-1][0], d[i-1][1]), d[i-1][2]);
    }
    printf("%d\n", max(max(d[n][0], d[n][1]), d[n][2]));
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        for (int i=0; i<2; i++) {
            for (int j=1; j<=n; j++) {
                scanf("%d", &p[j][i]);
            }
        }
        solve();
    }
    return 0;
}

Python 3 소스코드

def solve():
    d[1][0], d[1][1] = p[0][1], p[1][1]
    for i in range(2, n+1):
        d[i][0] = max(d[i-1][1], d[i-1][2]) + p[0][i]
        d[i][1] = max(d[i-1][0], d[i-1][2]) + p[1][i]
        d[i][2] = max(d[i-1][0], d[i-1][1], d[i-1][2])

for _ in range(int(input())):
    n = int(input())
    p = [[0]+list(map(int, input().split())) for _ in range(2)]
    d = [[0]*3 for _ in range(n+1)]
    solve()
    print(max(d[n]))

참고

백준 온라인 저지 : BOJ 9465

BOJ 2193 · 이친수

레바스 — Sun, 7 Apr 2019 17:06:43 +0900

알고리즘 분류 : 다이나믹 프로그래밍

N자리 이친수를 DP를 통해 만들어야 한다.

D[N] : N자리 이친수의 개수
D[1] = 1, D[2] = 1
D[N] = 0으로 끝나는 N-1자리 이친수 + 01로 끝나는 N-2자리 이친수

C++ 소스코드

#include <cstdio>

int n;
long long int d[91];

void solve() {
    d[1] = d[2] = 1;
    for (int i=3; i<=n; i++) {
        d[i] = d[i-1] + d[i-2];
    }
    printf("%lld\n", d[n]);
}

int main() {
    scanf("%d", &n);
    solve();
    return 0;
}

Python 3 소스코드

n = int(input())
d = [1]*(n+1)

def solve():
    for i in range(3, n+1):
        d[i] = d[i-1] + d[i-2]

solve()
print(d[n])

참고

백준 온라인 저지 : BOJ 2193

BOJ 11057 · 오르막 수

레바스 — Sat, 6 Apr 2019 19:09:20 +0900

알고리즘 분류 : 다이나믹 프로그래밍

오르막 수를 DP로 구현하는 문제다. 오르막 수란 각 자리의 수가 오름차순을 이루는 숫자를 말한다. 0으로 시작할 수 있으며, 인접한 자리의 숫자가 같아도 오르막 수이다.

D[N][M] : M으로 끝나는 N자리 오르막 수
D[1][0] = 1, D[1][1] = 1, ‥‥ , D[1][9] = 1
D[N][0] = D[N-1][0] : 0으로 끝나는 N자리 오르막 수
D[N][1] = D[N-1][0] + D[N-1][1]
D[N][2] = D[N-1][0] + D[N-1][1] + D[N-1][2]
‥‥
D[N][9] = D[N-1][0] + D[N-1][1] + ‥‥ + D[N-1][9]

C++ 소스코드

#include <cstdio>

int n, ans;
int d[1001][10];
const int mod = 10007;

void solve() {
    for (int i=0; i<=9; i++) d[1][i] = 1;
    for (int i=2; i<=n; i++) {
        for (int j=0; j<=9; j++) {
            for (int k=0; k<=j; k++) {
                d[i][j] += d[i-1][k];
            }
            d[i][j] %= mod;
        }
    }
    for (int i=0; i<=9; i++) ans += d[n][i];
    printf("%d\n", ans%mod);
}

int main() {
    scanf("%d", &n);
    solve();
    return 0;
}

Python 3 소스코드

n = int(input())
d = [[0]*10 for _ in range(n+1)]
mod = 10007

def solve():
    for i in range(10):
        d[1][i] = 1
    for i in range(2, n+1):
        for j in range(10):
            for k in range(j+1):
                d[i][j] += d[i-1][k]
            d[i][j] %= mod

solve()
print(sum(d[n])%mod)

참고

백준 온라인 저지 : BOJ 11057

삼성 SW 역량 테스트 문제 리스트

레바스 — Sat, 6 Apr 2019 17:39:46 +0900

+ 삼성 소프트웨어 역량 테스트란?

삼성(삼성전자, 삼성 SDS 등) 채용 단계에서 S직군이 보는 오프라인 코딩 테스트(직무적성검사)이다.
SW 개발 직무에 지원한다면, GSAT 대신 소프트웨어 역량테스트를 봐야 한다.

+ SW 역량테스트 준비

프로그래밍 언어를 익힌다. C/C++, Java, Python3 중 (C++ 추천)
자료구조(큐, 스택, 덱, 그래프 등)와 알고리즘 이론(DFS, BFS, 힙, 백트래킹 등)을 배운다.
알고리즘 스킬(재귀 구현, 비트 연산, STL 사용법 등)을 익힌다.
백준 온라인 저지와 SW Expert Academy에서 알고리즘 문제를 풀면서 연습한다.
역대 기출은 시뮬레이션, BFS, DFS, 브루트 포스 등의 문제로 출제되었으므로, 이러한 유형을 집중적으로 푼다.
SWEA에서 모의 역량 SW 테스트 문제를 풀어본다.

+ 필수 문제

+ 추천 문제

BOJ 16194 · 카드 구매하기 2

레바스 — Sat, 6 Apr 2019 16:21:24 +0900

알고리즘 분류 : 다이나믹 프로그래밍

DP를 통해 카드를 구매하기 위해 지불하는 금액의 최솟값을 구해야 한다. BOJ 11052번 '카드 구매하기'에서 최댓값 대신 최솟값을 구하면 된다.

D[N] : 카드 N장을 구입하기 위한, 지불 금액의 최솟값
D[0] = 0, D[1] = P[1]
D[N-1] + P[1] : 카드 1개 들어있는 카드팩을 구매하고, 카드 N-1장을 구매한 지불 금액의 최솟값
D[N-2] + P[2]
‥‥
D[0] + P[N] : 카드 N개 들어있는 카드팩을 구매하고, 카드 0장을 구매한 지불 금액의 최솟값

C++ 소스코드

#include <cstdio>
#include <algorithm>
using namespace std;

int n, d[1001], p[1001];

void solve() {
    d[0] = 0, d[1] = p[1];
    for (int i=2; i<=n; i++) {
        for (int j=1; j<=i; j++) {
            d[i] = min(d[i], d[i-j]+p[j]);
        }
    }
}

int main() {
    scanf("%d", &n);
    for (int i=1; i<=n; i++) scanf("%d", &p[i]);
    fill(d, d+n+1, 1e9);
    solve();
    printf("%d\n", d[n]);
    return 0;
}

Python 3 소스코드

n = int(input())
d = [10**9]*(n+1)
p = [0]+list(map(int, input().split()))

def solve():
    d[0], d[1] = 0, p[1]
    for i in range(2, n+1):
        for j in range(1, i+1):
            d[i] = min(d[i], d[i-j]+p[j])

solve()
print(d[n])

참고

백준 온라인 저지 : BOJ 16194
카드 구매하기

BOJ 11052 · 카드 구매하기

레바스 — Sat, 6 Apr 2019 16:15:44 +0900

알고리즘 분류 : 다이나믹 프로그래밍

DP를 통해 카드를 구매하기 위해 지불하는 금액의 최댓값을 구해야 한다.

D[N] : 카드 N장을 구입하기 위한, 지불 금액의 최댓값
D[0] = 0, D[1] = P[1]
D[N-1] + P[1] : 카드 1개 들어있는 카드팩을 구매하고, 카드 N-1장을 구매한 지불 금액의 최댓값
D[N-2] + P[2]
‥‥
D[0] + P[N] : 카드 N개 들어있는 카드팩을 구매하고, 카드 0장을 구매한 지불 금액의 최댓값

C++ 소스코드

#include <cstdio>
#include <algorithm>
using namespace std;

int n, d[1001], p[1001];

void solve() {
    d[0] = 0, d[1] = p[1];
    for (int i=2; i<=n; i++) {
        for (int j=1; j<=i; j++) {
            d[i] = max(d[i], d[i-j]+p[j]);
        }
    }
}

int main() {
    scanf("%d", &n);
    for (int i=1; i<=n; i++) scanf("%d", &p[i]);
    solve();
    printf("%d\n", d[n]);
    return 0;
}

Python 3 소스코드

n = int(input())
d = [0]*(n+1)
p = [0]+list(map(int, input().split()))

def solve():
    d[0], d[1] = 0, p[1]
    for i in range(2, n+1):
        for j in range(1, i+1):
            d[i] = max(d[i], d[i-j]+p[j])

solve()
print(d[n])

참고

백준 온라인 저지 : BOJ 11052

BOJ 10844 · 쉬운 계단 수

레바스 — Sat, 6 Apr 2019 15:36:29 +0900

알고리즘 분류 : 다이나믹 프로그래밍

DP를 통해 계단 수의 총개수를 구하는 문제다.

D[N][M] : M으로 끝나는 N자리 계단 수의 총개수
D[1][1] = 1, D[1][2] = 1, ‥‥ , D[1][9] = 1 (한 자릿수)
D[N][0] = D[N-1][1] : 0으로 끝나는 N자리 계단 수의 총개수
D[N][1] = D[N-1][0] + D[N-1][2] : 1로 끝나는 N자리 계단 수의 총개수
‥‥
D[N][8] = D[N-1][7] + D[N-1][9]
D[N][9] = D[N-1][8]

C++ 소스코드

#include <cstdio>

const int mod = 1000000000;
int n;
long long ans, d[101][10];

void solve() {
    for (int i=1; i<10; i++) d[1][i] = 1;
    for (int i=2; i<=n; i++) {
        for (int j=0; j<10; j++) {
            if (j > 0) d[i][j] += d[i-1][j-1];
            if (j < 9) d[i][j] += d[i-1][j+1];
            d[i][j] %= mod;
        }
    }
    for (int i=0; i<10; i++) ans += d[n][i];
    printf("%lld\n", ans%mod);
}

int main() {
    scanf("%d", &n);
    solve();
    return 0;
}

Python 3 소스코드

n = int(input())
d = [[0]*10 for _ in range(n+1)]
ans, mod = 0, 1000000000

def solve():
    for i in range(1, 10):
        d[1][i] = 1
    for i in range(2, n+1):
        for j in range(0, 10):
            if j > 0:
                d[i][j] += d[i-1][j-1]
            if j < 9:
                d[i][j] += d[i-1][j+1]
            d[i][j] %= mod

solve()
print(sum(d[n])%mod)

참고

백준 온라인 저지 : BOJ 10844

BOJ 15988 · 1, 2, 3 더하기 3

레바스 — Fri, 5 Apr 2019 17:05:04 +0900

알고리즘 분류 : 다이나믹 프로그래밍

숫자 N을 1, 2, 3의 합으로 나타내는 방법의 수를 구해야 한다. BOJ 9095번 '1, 2, 3 더하기'에서 범위가 확장된 문제다.

D[N] : 숫자 N을 1, 2, 3의 합으로 나타내는 방법의 수
D[1] = 1
D[2] = 2 (1+1, 2)
D[3] = 4 (1+1+1, 1+2, 2+1, 3)
D[N-1] : 마지막에 1을 더한 방법의 수
D[N-2] : 마지막에 2를 더한 방법의 수
D[N-3] : 마지막에 3을 더한 방법의 수

C++ 소스코드

#include <cstdio>

int n;
long long d[1000001];

void solve() {
    d[1] = 1, d[2] = 2, d[3] = 4;
    for (int i=4; i<1000001; i++) {
        d[i] = d[i-1]+d[i-2]+d[i-3];
        d[i] %= 1000000009;
    }
}

int main() {
    int t;
    scanf("%d", &t);
    solve();
    while (t--) {
        int n;
        scanf("%d", &n);
        printf("%lld\n", d[n]);
    }
    return 0;
}

Python 3 소스코드

d = [0, 1, 2, 4]
for i in range(4, 1000001):
    d.append((d[i-1]+d[i-2]+d[i-3])%1000000009)
for _ in range(int(input())):
    print(d[int(input())])

참고

백준 온라인 저지 : BOJ 15988
1, 2, 3 더하기

BOJ 9095 · 1, 2, 3 더하기

레바스 — Fri, 5 Apr 2019 15:37:18 +0900

알고리즘 분류 : 다이나믹 프로그래밍

기초적인 DP 문제이다. 숫자 N을 1, 2, 3의 합으로 나타내는 방법의 수를 구해야 한다.

D[N] : 숫자 N을 1, 2, 3의 합으로 나타내는 방법의 수
D[1] = 1
D[2] = 2 (1+1, 2)
D[3] = 4 (1+1+1, 1+2, 2+1, 3)
D[N-1] : 마지막에 1을 더한 방법의 수
D[N-2] : 마지막에 2를 더한 방법의 수
D[N-3] : 마지막에 3을 더한 방법의 수

C++ 소스코드

#include <cstdio>

int n, d[11];

void solve() {
    d[1] = 1, d[2] = 2, d[3] = 4;
    for (int i=4; i<11; i++) {
        d[i] = d[i-1]+d[i-2]+d[i-3];
    }
}

int main() {
    int t;
    scanf("%d", &t);
    solve();
    while (t--) {
        int n;
        scanf("%d", &n);
        printf("%d\n", d[n]);
    }
    return 0;
}

Python 3 소스코드

d = [0, 1, 2, 4]
for i in range(4, 11):
    d.append(d[i-1]+d[i-2]+d[i-3])
for _ in range(int(input())):
    print(d[int(input())])

참고

백준 온라인 저지 : BOJ 9095

BOJ 11727 · 2×n 타일링 2

레바스 — Fri, 5 Apr 2019 15:14:23 +0900

알고리즘 분류 : 다이나믹 프로그래밍

기초적인 DP 문제이다. BOJ 11726번 '2×n 타일링'에서 살짝 변경해주면 된다.

D[N] : 2xN 사이즈의 직사각형을 2x2, 2x1 사각형으로 채우는 방법의 수
D[0] = D[1] = 1
D[N-1] : 마지막 조각을 2x1 사각형으로 채운 방법의 수
D[N-2] : 마지막 조각을 2x2 사각형 또는 2x1 사각형 2개로 채운 방법의 수

C++ 소스코드

#include <cstdio>

int d[1001];

int solve(int n) {
    d[0] = d[1] = 1;
    for (int i=2; i<=n; i++) {
        d[i] = d[i-1]+2*d[i-2];
        d[i] %= 10007;
    }
    return d[n];
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solve(n));
    return 0;
}

Python 3 소스코드

def solve(n):
    d = [0]*(n+1)
    d[0] = d[1] = 1
    for i in range(2, n+1):
        d[i] = d[i-1]+2*d[i-2]
        d[i] %= 10007
    print(d[n])

solve(int(input()))

참고

백준 온라인 저지 : BOJ 11727
2×n 타일링

BOJ 11726 · 2×n 타일링

레바스 — Fri, 5 Apr 2019 14:59:46 +0900

알고리즘 분류 : 다이나믹 프로그래밍

기초적인 DP 문제이다. 그림 이해를 통해 점화식을 만들고 구현하면 된다.

D[N] : 2xN 사이즈의 직사각형을 1x2, 2x1 사각형으로 채우는 방법의 수
D[0] = D[1] = 1
D[N-1] : 마지막 조각을 2x1 사각형으로 채운 방법의 수
D[N-2] : 마지막 조각을 1x2 사각형 2개로 채운 방법의 수

C++ 소스코드

#include <cstdio>

int d[1001];

int solve(int n) {
    d[0] = d[1] = 1;
    for (int i=2; i<=n; i++) {
        d[i] = d[i-1]+d[i-2];
        d[i] %= 10007;
    }
    return d[n];
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solve(n));
    return 0;
}

Python 3 소스코드

def solve(n):
    d = [0]*(n+1)
    d[0] = d[1] = 1
    for i in range(2, n+1):
        d[i] = d[i-1]+d[i-2]
        d[i] %= 10007
    print(d[n])

solve(int(input()))

참고

백준 온라인 저지 : BOJ 11726

BOJ 1463 · 1로 만들기

레바스 — Fri, 5 Apr 2019 13:48:37 +0900

알고리즘 분류 : 다이나믹 프로그래밍

기초적인 DP문제이다. 3가지 조건을 따져서 점화식을 만들고, 이를 구현하면 된다.

D[N] : N을 1로 만드는 최소 연산 횟수
D[1] = 0
D[N-1] + 1 : N에서 1을 뺀 경우
D[N/3] + 1 : N을 3으로 나눈 경우
D[N/2] + 1 : N을 2로 나눈 경우

C++ 소스코드

#include <cstdio>

int d[1000001];

int solve(int n) {
    d[1] = 0;
    for (int i=2; i<=n; i++) {
        d[i] = d[i-1]+1;
        if (i%3 == 0) {
            int temp = d[i/3]+1;
            if (d[i] > temp) d[i] = temp;
        }
        if (i%2 ==0) {
            int temp = d[i/2]+1;
            if (d[i] > temp) d[i] = temp;
        }
    }
    return d[n];
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solve(n));
    return 0;
}

Python 3 소스코드

def solve(n):
    d = [0]*(n+1)
    for i in range(2, n+1):
        d[i] = d[i-1]+1
        if i%3 == 0:
            temp = d[i//3]+1
            d[i] = min(d[i], temp)
        if i%2 == 0:
            temp = d[i//2]+1
            d[i] = min(d[i], temp)
    print(d[n])

solve(int(input()))

참고

백준 온라인 저지 : BOJ 1463

BOJ 16509 · 장군

레바스 — Thu, 4 Apr 2019 16:45:23 +0900

알고리즘 분류 : BFS

장기 말을 옮기는 최소 횟수를 구하는 문제다. BFS를 통해 상(象)을 옮겨서 왕을 먹어야 한다.

장기판에서 상을 옮겨서 왕의 위치로 도달하는 최소 횟수를 구해야 한다.
상은 그림처럼 움직이며, 움직이는 경로에 다른 말이 있으면 해당 위치로 옮길 수 없다. 다른 말은 존재하지 않기 때문에, 왕의 위치가 상의 이동 경로에 있는지만 고려하면 된다.
별도로 이동 좌표를 만들고, 움직이는 경로에 왕이 있다면 상을 움직이지 않는다.
이동이 가능하다면 옮긴다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

struct grid {
    int x, y;
};

int sx, sy, ex, ey;
int dist[10][9];
const int dx[8][3] = {
    {-1, -2, -3}, {-1, -2, -3}, {0, -1, -2}, {0, -1, -2},
    {0, 1, 2}, {0, 1, 2}, {1, 2, 3}, {1, 2, 3} };
const int dy[8][3] = {
    {0, -1, -2}, {0, 1, 2}, {-1, -2, -3}, {1, 2, 3},
    {-1, -2, -3}, {1, 2, 3}, {0, -1, -2}, {0, 1, 2} };

bool move(int i, int &x, int &y) {
    int nx = x, ny = y;
    for (int j=0; j<3; j++) {
        nx = x+dx[i][j], ny = y+dy[i][j];
        if (nx < 0 || nx >= 10 || ny < 0 || ny >= 9) return false;
        if (j < 2 && nx == ex && ny == ey) return false;
    }
    x = nx, y = ny;
    return true;
}

void bfs() {
    queue<grid> q;
    q.push({sx, sy});
    dist[sx][sy] = 0;
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y; q.pop();
        if (x == ex && y == ey) {
            printf("%d\n", dist[x][y]);
            return;
        }
        for (int i=0; i<8; i++) {
            int nx = x, ny = y;
            if (move(i, nx, ny) && dist[nx][ny] == -1) {
                q.push({nx, ny});
                dist[nx][ny] = dist[x][y]+1;
            }
        }
    }
    printf("-1\n");
}

int main() {
    memset(dist, -1, sizeof(dist));
    scanf("%d %d", &sx, &sy);
    scanf("%d %d", &ex, &ey);
    bfs();
    return 0;
}

Python 3 소스코드

from collections import deque
sx, sy = map(int, input().split())
ex, ey = map(int, input().split())
dist = [[-1]*9 for _ in range(10)]
dx = [(-1, -2, -3), (-1, -2, -3), (0, -1, -2), (0, -1, -2),
      (0, 1, 2), (0, 1, 2), (1, 2, 3), (1, 2, 3)]
dy = [(0, -1, -2), (0, 1, 2), (-1, -2, -3), (1, 2, 3),
      (-1, -2, -3), (1, 2, 3), (0, -1, -2), (0, 1, 2)]

def move(i, x, y):
    nx, ny = x, y
    for j in range(3):
        nx, ny = x+dx[i][j], y+dy[i][j]
        if nx < 0 or nx >= 10 or ny < 0 or ny >= 9:
            return -1, -1
        if j < 2 and nx == ex and ny == ey:
            return -1, -1
    return nx, ny

def bfs():
    q = deque()
    q.append((sx, sy))
    dist[sx][sy] = 0
    while q:
        x, y = q.popleft()
        if x == ex and y == ey:
            print(dist[x][y])
            return
        for i in range(8):
            nx, ny = move(i, x, y)
            if nx != -1 and dist[nx][ny] == -1:
                q.append((nx, ny))
                dist[nx][ny] = dist[x][y]+1
    print(-1)

bfs()

참고

백준 온라인 저지 : BOJ 16509

BOJ 16469 · 소년 점프

레바스 — Thu, 4 Apr 2019 14:43:39 +0900

알고리즘 분류 : BFS

세 명의 사람이 한곳에 모이는 최단 거리와, 그 최단 거리의 수를 구해야 하는 문제다. 주어진 3명의 좌표를 큐에 집어넣고, 각각 BFS를 돌리면 된다.

3명의 사람을 0번, 1번, 2번이라고 하자.
dist 배열은 이동 거리를 저장하고, 방문 여부를 체크한다.
dist의 인덱스는 [X 좌표] [Y 좌표] [사람 번호] 이다. dist의 모든 값은 -1로 초기화해둔다.
큐에 0~2번 사람의 좌표를 모두 넣고, dist[X][Y][번호]를 0으로 초기화한다.
BFS를 통해 완전 탐색을 하면, dist 배열에 각 사람의 이동 거리가 업데이트되어있다.
dist배열을 N*M 순서로 탐색하면서 dist[X][Y][0], dist[X][Y][1], dist[X][Y][2]의 값이 모두 -1이 아닌 위치를 찾는다.
모두 -1이 아니라면, 3명이 만날 수 있는 장소이다.
이 장소 중에서 가장 최단 거리로 만날 수 있는 곳을 찾고, 같은 최단 거리가 존재한다면 수를 센다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

struct grid {
    int x, y, z;
};

int n, m;
char a[101][101];
int dist[100][100][3];
queue<grid> q;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};

void bfs() {
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y, z = q.front().z; q.pop();
        for (int i=0; i<4; i++) {
            int nx = x+dx[i], ny = y+dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (a[nx][ny] == '0' && dist[nx][ny][z] == -1) {
                q.push({nx, ny, z});
                dist[nx][ny][z] = dist[x][y][z]+1;
            }
        }
    }
}

int main() {
    memset(dist, -1, sizeof(dist));
    scanf("%d %d", &n, &m);
    for (int i=0; i<n; i++) scanf("%s", a[i]);
    for (int i=0; i<3; i++) {
        int x, y;
        scanf("%d %d", &x, &y);
        q.push({x-1, y-1, i});
        dist[x-1][y-1][i] = 0;
    }
    bfs();
    int ans=1e9, cnt=0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            int x = dist[i][j][0], y = dist[i][j][1], z = dist[i][j][2];
            int k = max(max(x,y),z);
            if (min(min(x,y),z) != -1) {
                if (ans > k) {
                    ans = k;
                    cnt = 1;
                } else if (ans == k) {
                    cnt += 1;
                }
            }
        }
    }
    if (cnt) printf("%d\n%d\n", ans, cnt);
    else printf("-1\n");
    return 0;
}

Python 3 소스코드

from collections import deque
n, m = map(int, input().split())
a = [list(input().strip()) for _ in range(n)]
dist = [[[-1]*3 for _ in range(m)] for _ in range(n)]
dx, dy = (-1, 0, 1, 0), (0, 1, 0, -1)
q = deque()

def bfs():
    while q:
        x, y, z = q.popleft()
        for i in range(4):
            nx, ny = x+dx[i], y+dy[i]
            if nx < 0 or nx >= n or ny < 0 or ny >= m:
                continue
            if a[nx][ny] == '0' and dist[nx][ny][z] == -1:
                q.append((nx, ny, z))
                dist[nx][ny][z] = dist[x][y][z]+1

for i in range(3):
    x, y = map(int, input().split())
    q.append((x-1, y-1, i))
    dist[x-1][y-1][i] = 0
bfs()
ans, cnt = 1e9, 0
for i in range(n):
    for j in range(m):
        k = max(dist[i][j])
        if min(dist[i][j]) != -1:
            if ans > k:
                ans = k
                cnt = 1
            elif ans == k:
                cnt += 1
if cnt:
    print("%d\n%d" % (ans, cnt))
else:
    print(-1)

참고

백준 온라인 저지 : BOJ 16469

BOJ 16441 · 아기돼지와 늑대

레바스 — Thu, 4 Apr 2019 12:34:19 +0900

알고리즘 분류 : BFS

늑대가 가지 못하는 위치를 찾는 문제다. 갈 수 있는 곳을 모두 탐색해야 하므로, BFS를 사용하면 된다.

늑대(W)는 여러 마리가 주어질 수 있고, 각 늑대는 맵에 갈 수 있는 모든 곳을 가야 한다.
늑대의 이동을 크게 2가지로 구분해서 처리해야 한다.

1. 다음 이동 위치가 초원('.')인 경우
초원에서는 인접한 상하좌우로 한 칸씩 움직인다.
움직인 후 방문 체크를 하고, 큐에 좌표를 집어넣는다.

2. 다음 이동 위치가 초원('.')이 아닌 경우 : 산('#'), 빙판('+')
while 반복문을 통해 늑대를 이동시켜야 한다.
1) 이동한 곳이 산이라면, 위치를 되돌리고 반복문을 빠져나온다.
2) 산이 아니라면 빙판이므로, 다음 좌표로 한 칸 앞으로 간다.
3) 다음 이동 좌표가 초원이라면, 반복문을 빠져나온다. 아니라면 1) ~ 2) 과정을 산에 부딪히거나, 초원에 도착할 때까지 반복한다.
반복문을 빠져나온 후, 현재 좌표를 방문 체크하고 큐에 집어넣는다.

C++ 소스코드

#include <cstdio>
#include <queue>
using namespace std;

struct wolf {
    int x, y;
};

int n, m;
char a[100][100];
bool check[100][100];
queue<wolf> q;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};

void bfs() {
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y; q.pop();
        for (int i=0; i<4; i++) {
            int nx = x+dx[i], ny = y+dy[i];
            if (a[nx][ny] == '.' && !check[nx][ny]) {
                q.push({nx, ny});
                check[nx][ny] = true;
            } else {
                while (a[nx][ny] != '.') {
                    if (a[nx][ny] == '#') {
                        nx -= dx[i], ny -= dy[i];
                        break;
                    }
                    nx += dx[i], ny += dy[i];
                }
                if (!check[nx][ny]) {
                    q.push({nx, ny});
                    check[nx][ny] = true;
                }
            }
        }
    }
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            scanf(" %1c", &a[i][j]);
            if (a[i][j] == 'W') {
                q.push({i, j});
                check[i][j] = true;
            }
        }
    }
    bfs();
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            if (a[i][j] == '.' && !check[i][j]) printf("P");
            else printf("%c", a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

Python 3 소스코드

from collections import deque
n, m = map(int, input().split())
a = [list(input().strip()) for _ in range(n)]
check = [[False]*m for _ in range(n)]
dx, dy = (-1, 0, 1, 0), (0, 1, 0, -1)
q = deque()

def bfs():
    while q:
        x, y = q.popleft()
        for i in range(4):
            nx, ny = x+dx[i], y+dy[i]
            if a[nx][ny] == '.' and not check[nx][ny]:
                q.append((nx, ny))
                check[nx][ny] = True
            else:
                while a[nx][ny] != '.':
                    if a[nx][ny] == '#':
                        nx, ny = nx-dx[i], ny-dy[i]
                        break
                    nx, ny = nx+dx[i], ny+dy[i]
                if not check[nx][ny]:
                    q.append((nx, ny))
                    check[nx][ny] = True

for i in range(n):
    for j in range(m):
        if a[i][j] == 'W':
            q.append((i, j))
            check[i][j] = True
bfs()
for i in range(n):
    for j in range(m):
        if a[i][j] == '.' and not check[i][j]:
            print("P", end='')
        else:
            print(a[i][j], end='')
    print()

참고

백준 온라인 저지 : BOJ 16441

BOJ 16397 · 탈출

레바스 — Thu, 4 Apr 2019 01:04:57 +0900

알고리즘 분류 : BFS

숫자 N을 숫자 G로 만드는 최소 버튼 횟수를 구하는 문제다. BFS를 통해 최소 횟수를 구하면 된다.

숫자 N을 큐에 집어넣는다.
현재 숫자를 X라고 할 때, 다음 숫자는 X+1 또는 X*2 - 10^(X*2의 자릿수-1)가 된다.
최대 T번까지 BFS로 숫자를 탐색한다.
숫자 G에 도달하면 값을 출력한다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
using namespace std;

int n, t, g;
int dist[100000];

void bfs() {
    queue<int> q;
    q.push({n});
    dist[n] = 0;
    while (!q.empty()) {
        int x = q.front(); q.pop();
        if (dist[x] > t) break;
        if (x == g) {
            printf("%d\n", dist[x]);
            return;
        }
        int dx[] = {x+1, x*2};
        for (int i=0; i<2; i++) {
            int nx = dx[i];
            if (nx > 99999) continue;
            if (i && nx) {
                string s = to_string(nx);
                s[0] -= 1;
                nx = stoi(s);
            }
            if (dist[nx] == -1) {
                q.push(nx);
                dist[nx] = dist[x]+1;
            }
        }
    }
    printf("ANG\n");
}

int main() {
    memset(dist, -1, sizeof(dist));
    scanf("%d %d %d", &n, &t, &g);
    bfs();
    return 0;
}

Python 3 소스코드

from collections import deque

def bfs():
    q = deque()
    q.append(n)
    dist[n] = 0
    while q:
        x = q.popleft()
        if dist[x] > t:
            break
        if x == g:
            print(dist[x])
            return
        dx = [(x+1), (x*2)]
        for i in range(2):
            nx = dx[i]
            if nx > 99999:
                continue
            if i and x:
                nx -= 10**(len(str(nx))-1)
            if dist[nx] == -1:
                q.append(nx)
                dist[nx] = dist[x]+1
    print("ANG")

n, t, g = map(int, input().split())
dist = [-1]*100000
bfs()

참고

백준 온라인 저지 : BOJ 16397

BOJ 16174 · 점프왕 쩰리 (Large)

레바스 — Wed, 3 Apr 2019 23:16:15 +0900

알고리즘 분류 : BFS

(0, 0)부터 출발하여 점프를 하면서 (N-1, N-1) 도착하는 것을 구현하는 문제다. BFS를 통해 맵을 탐색하면서, 밟은 위치에 쓰여있는 숫자만큼 이동하면 된다. 유사한 문제로 BOJ 16173번 '점프왕 쩰리 (Small)'이 있다. N 범위만 더 적은 문제이므로, 같은 코드로 해결할 수 있다.

(0, 0)를 큐에 넣고 BFS를 시작한다.
아래 방향(↓)과 오른쪽 방향(→)으로만 이동할 수 있으므로 구현이 간단하다.
현재 위치에 쓰여있는 숫자만큼 이동한다.
방문 여부를 체크하면서 마지막 좌표(N-1, N-1)까지 이동할 수 있는지 확인한다.

C++ 소스코드

#include <cstdio>
#include <queue>
using namespace std;

struct jump {
    int x, y;
};

int n, a[64][64];
bool check[64][64];
const int dx[] = {1, 0}, dy[] = {0, 1};

void bfs() {
    queue<jump> q;
    q.push({0, 0});
    check[0][0] = true;
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y; q.pop();
        int k = a[x][y];
        if (x == n-1 && y == n-1) {
            printf("HaruHaru\n");
            return;
        }
        for (int i=0; i<2; i++) {
            int nx = x+dx[i]*k, ny = y+dy[i]*k;
            if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
            if (!check[nx][ny]) {
                q.push({nx, ny});
                check[nx][ny] = true;
            }
        }
    }
    printf("Hing\n");
}

int main() {
    scanf("%d", &n);
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    bfs();
    return 0;
}

Python 3 소스코드

from collections import deque

def bfs():
    q = deque()
    q.append((0, 0))
    check[0][0] = True
    while q:
        x, y = q.popleft()
        k = a[x][y]
        if x == n-1 and y == n-1:
            print("HaruHaru")
            return
        for dx, dy in (1,0), (0,1):
            nx, ny = x+dx*k, y+dy*k
            if 0 <= nx < n and 0 <= ny < n and not check[nx][ny]:
                q.append((nx, ny))
                check[nx][ny] = True
    print("Hing")

n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
check = [[False]*n for _ in range(n)]
bfs()

참고

백준 온라인 저지 : BOJ 16174
백준 온라인 저지 : BOJ 16173

BOJ 14940 · 쉬운 최단거리

레바스 — Wed, 3 Apr 2019 11:09:17 +0900

알고리즘 분류 : BFS

맵에 주어진 목표지점에서 각 지점에 대한 거리를 구하는 문제다. BFS를 통해 각 점에 대한 최단 거리를 모두 출력하면 된다.

N*M 사이즈의 맵에서 목표지점(2)로부터 각 지점까지의 최단 거리를 구한다.
벽(0)으로는 이동할 수 없다.

C++ 소스코드

#include <cstdio>
#include <queue>
using namespace std;

struct grid {
    int x, y;
};

int n, m, sx, sy;
int a[1000][1000];
const int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, 1, -1};

void bfs() {
    queue<grid> q;
    q.push({sx, sy});
    a[sx][sy] = 2;
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y; q.pop();
        for (int i=0; i<4; i++) {
            int nx = x+dx[i], ny = y+dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (a[nx][ny] == 1) {
                q.push({nx, ny});
                a[nx][ny] = a[x][y]+1;
            }
        }
    }
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            scanf("%d", &a[i][j]);
            if (a[i][j] == 2) sx = i, sy = j;
        }
    }
    bfs();
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            int d = a[i][j];
            printf("%d ", d ? d-2 : 0);
        }
        printf("\n");
    }
    return 0;
}

Python 3 소스코드

from sys import stdin, stdout
from collections import deque
input = stdin.readline
print = stdout.write

n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
dx, dy = (-1, 0, 1, 0), (0, 1, 0, -1)
q = deque()

def bfs():
    while q:
        x, y = q.popleft()
        for i in range(4):
            nx, ny = x+dx[i], y+dy[i]
            if 0 <= nx < n and 0 <= ny < m and a[nx][ny] == 1:
                q.append((nx, ny))
                a[nx][ny] = a[x][y]+1

for i in range(n):
    for j in range(m):
        if a[i][j] == 2:
            q.append((i, j))
            a[i][j] = 2
            break
bfs()
for i in range(n):
    for j in range(m):
        d = a[i][j]
        print("%d " % (d-2 if d else 0))
    print("\n")

참고

백준 온라인 저지 : BOJ 14940

BOJ 14923 · 미로 탈출

레바스 — Wed, 3 Apr 2019 10:36:52 +0900

알고리즘 분류 : BFS

벽을 하나 뚫고 미로를 탈출하는 것을 구현해야 한다. BOJ 2206번 '벽 부수고 이동하기'와 유사한 문제이다.

입력으로 주어진 출발점(HX, HY)부터 탈출 위치(EX, EY)까지 BFS 탐색을 통해 이동한다.
이동 거리 저장과 방문 여부를 체크할 배열 dist를 3차원 배열로 선언한다.
dist의 인덱스는 [X 좌표] [Y좌표] [벽 부순 횟수] 이다.
벽(1)을 만나면, 벽을 아직 부수지 않은 경우 벽을 부수고 이동한다. 벽을 이미 부순 경우 이동하지 않는다.
빈칸(0)은 그대로 이동한다.

C++ 소스코드

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

struct maze {
    int x, y, z;
};

int n, m, hx, hy, ex, ey;
int a[1000][1000];
int dist[1000][1000][2];
const int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, 1, -1};

void bfs() {
    queue<maze> q;
    q.push({hx-1, hy-1, 0});
    dist[hx-1][hy-1][0] = 0;
    while (!q.empty()) {
        int x = q.front().x, y = q.front().y, z = q.front().z; q.pop();
        if (x == ex-1 && y == ey-1) {
            printf("%d\n", dist[x][y][z]);
            return;
        }
        for (int i=0; i<4; i++) {
            int nx = x+dx[i], ny = y+dy[i], nz = z;
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (a[nx][ny]) {
                if (nz) continue;
                else nz = 1;
            }
            if (dist[nx][ny][nz] == -1) {
                q.push({nx, ny, nz});
                dist[nx][ny][nz] = dist[x][y][z]+1;
            }
        }
    }
    printf("-1\n");
}

int main() {
    memset(dist, -1, sizeof(dist));
    scanf("%d %d", &n, &m);
    scanf("%d %d", &hx, &hy);
    scanf("%d %d", &ex, &ey);
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    bfs();
    return 0;
}

Python 3 소스코드

from sys import stdin
from collections import deque
input = stdin.readline

n, m = map(int, input().split())
hx, hy = map(int, input().split())
ex, ey = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
dist = [[[-1, -1] for _ in range(m)] for _ in range(n)]
dx = (-1, 0, 1, 0)
dy = (0, 1, 0, -1)

def bfs():
    q = deque()
    q.append((hx-1, hy-1, 0))
    dist[hx-1][hy-1][0] = 0
    while q:
        x, y, z = q.popleft()
        if x == ex-1 and y == ey-1:
            return dist[x][y][z]
        for i in range(4):
            nx, ny, nz = x+dx[i], y+dy[i], z
            if nx < 0 or nx >= n or ny < 0 or ny >= m:
                continue
            if a[nx][ny]:
                if nz:
                    continue
                else:
                    nz = 1
            if dist[nx][ny][nz] == -1:
                dist[nx][ny][nz] = dist[x][y][z]+1
                q.append((nx, ny, nz))
    return -1

print(bfs())

참고

백준 온라인 저지 : BOJ 14923
벽 부수고 이동하기

BOJ 14716 · 현수막

레바스 — Wed, 3 Apr 2019 09:44:03 +0900

알고리즘 분류 : DFS

현수막에 쓰여있는 문자의 개수를 출력하는 문제다. 전형적인 플러드 필 문제이며, 인접한 8방향을 처리하면 된다.

M*N 사이즈의 맵을 DFS로 탐색하면서 연결된 글자(1)를 따라 이동하면 된다.
인접한 8방향(상, 하, 좌, 우, 대각선)으로 이동한다.
글자의 개수를 카운트한다.

C++ 소스코드

#include <cstdio>

int m, n, ans;
int a[250][250];
bool check[250][250];
const int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};

void dfs(int x, int y) {
    check[x][y] = true;
    for (int i=0; i<8; i++) {
        int nx = x+dx[i], ny = y+dy[i];
        if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
        if (!check[nx][ny] && a[nx][ny]) dfs(nx, ny);
    }
}

int main() {
    scanf("%d %d", &m, &n);
    for (int i=0; i<m; i++) {
        for (int j=0; j<n; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    for (int i=0; i<m; i++) {
        for (int j=0; j<n; j++) {
            if (!check[i][j] && a[i][j]) {
                dfs(i, j);
                ans += 1;
            }
        }
    }
    printf("%d\n", ans);
    return 0;
}

Python 3 소스코드

import sys
sys.setrecursionlimit(100000)

m, n = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(m)]
check = [[False]*n for _ in range(m)]
ans = 0

def dfs(x, y):
    check[x][y] = True
    for dx, dy in (-1,0), (1,0), (0,-1), (0,1), (-1,-1), (-1,1), (1,-1), (1,1):
        nx, ny = x+dx, y+dy
        if nx < 0 or nx >= m or ny < 0 or ny >= n:
            continue
        if not check[nx][ny] and a[nx][ny]:
            dfs(nx, ny)

for i in range(m):
    for j in range(n):
        if not check[i][j] and a[i][j]:
            dfs(i, j)
            ans += 1
print(ans)

참고

백준 온라인 저지 : BOJ 14716