Wook's

Operating System - Computer System Structure

jujube bat — Fri, 12 Mar 2021 22:15:29 +0900

Computer System Structure

컴퓨터 시스템의 구조

컴퓨터 시스템 구조는 CPU, 메모리와 I/O 장치인 디스크, 키보드, 마우스, 모니터, 네트워크 장치 등으로 구성된다.

메모리 및 I/O 장치 등의 각 하드웨어 장치에는 컨트롤러가 붙어있다.
컨트롤러는 일종의 작은 CPU로서 각 장치를 제어한다.
- ex) 메모리 컨트롤러, 디스크 컨트롤러
프로그램이 수행되려면 그 프로그램은 메모리에 올라가있어야 한다.
운영체제 중 항상 메모리에 올라가 있는 부분은 전체 운영체제 중 핵심적인 부분에 한정되며, 이 부분을 커널(Kernel)이라고 한다.

CPU 연산과 I/O 연산

I/O 장치의 연산은 I/O 장치 컨트롤러가 수행한다.
컴퓨터 내에서 수행되는 연산은 CPU가 담당한다.
입출력 장치와 CPU는 동시 수행이 가능하다.
각 장치에 붙어있는 장치 컨트롤러는 장치로 들어가고 나오는 데이터를 임시 저장하기 위한 작은 메모리를 가지고 있다. 이를 로컬 버퍼(local buffer)라고 부른다.
디스크나 키보드 등에서 데이터를 읽어오는 경우, 우선 로컬버퍼에 데이터가 임시로 저장된 후 메모리에 전달된다.
예를들어 프로그램 B가 수행중에 디스크에서 데이터를 읽어 오라는 명령을 내리면, 디스크 컨트롤러가 물리적인 디스크에서 내용을 읽어드려 이를 로컬 버퍼에 저장한다.
원하는 데이터를 읽어오면 CPU는 다음 일을 수행할 수 있다.
이때 로컬 버퍼로 데이터를 읽어오는 작업이 끝나면 장치에 있는 컨트롤러가 인터럽트를 발생 시켜 CPU에게 보고한다.
CPU는 명령 하나를 수행할 때마다 인터럽트 라인을 확인하며 인터럽트가 발생했는지 확인하고, 발생했으면 다음 명령을 수행하기 전에 인터럽트 처리를 한다.

인터럽트의 일반적 기능

인터럽트는 컴퓨터 작업 도중 CPU의 서비스가 필요할 때 이를 통보하는 것을 말한다.
예를들어 외부 입출력 장치가 요청 받은 데이터를 모두 로컬버퍼로 옮겼을 때, 인터럽트를 발생시켜 CPU에게 보고한다.
인터럽트가 발생하면 CPU 옆에 위치하는 인터럽트 라인이 세팅된다.
CPU는 매 시점 메모리에서 명령을 하나씩 읽어와서 수행할때마다 자신의 옆에있는 인터럽트 라인을 확인하는데, 이때 인터럽트 라인이 세팅 되어있으면 인터럽트가 발생한 것을 알아 차린다.
운영체제 커널에는 인터럽트가 발생했을때 해야할 일이 미리 다 프로그래밍되어 있다.
운영체제 커널 내에 있는 인터럽트 처리루틴은 다양한 인터럽트에 대해 각각 처리해야 할 업무들을 정의하고 있다.
예를들어 디스크 컨트롤러가 인터럽트를 발생시키면, CPU는 하던일을 잠시 멈추고, 이 인터럽트가 발생했을 때 수행하도록 정의된 코드를 찾아서 수행한다. 이를 인터럽트 처리루틴 또는 인터럽트 핸들러라고 한다.
하드웨어 인터럽트는 하드웨어 장치 컨트롤러가 CPU의 인터럽트 라인을 세팅하지만, 소프트웨어 인터럽트는 소프트웨어가 직접 인터럽트 라인을 세팅한다.
인터럽트가 발생하면 CPU는 하던 일을 멈추고 운영체제 커널의 인터럽트 벡터에서 해당 인터럽트에 대한 인터럽트 처리 루틴을 찾는다.
인터럽트 벡터란 인터럽트와 인터럽트에 대한 처리 루틴 정보를 가지고 있는 일종의 테이블이다.
인터럽트 처리 루틴을 통해 인터럽트를 처리하면, 원래 수행하던 작업으로 돌아가 작업을 수행한다.
통상적으로 인터럽트는 하드웨어 인터럽트를 의미한다. 소프트웨어 인터럽트는 트랩(trap)이라고 불린다.
소프트웨어 인터럽트의 예로는 예외상황(exceptio)이나 시스템 콜(system call)등이 있다.
인터럽트를 아래와 같이 분류해볼 수 있다.

외부 인터럽트(Hardware Interrupt)

전원 이상 인터럽트(Power fail interrupt) : 정전, 파워 이상 등
기계 착오 인터럽트(Machine check interrupt) : CPU의 기능적인 오류
외부 신호 인터럽트
- 타이머 인터럽트
- 키보드로 인터럽트 키를 누른 경우(Ctrl + Alt + Del)
- 외부장치로부터 인터럽트 요청이 있는 경우
입출력 인터럽트(I/O Interrupt)
- 입출력장치가 데이터 전송을 요구하거나 전송이 끝나 다음 동작이 수행되어야 할 경우
- 입출력 데이터에 이상이 있는 경우

내부 인터럽트(Exception)

잘못된 명령이나 잘못된 데이터를 사용할때 발생하며 Trap이라 부른다.
프로그램 검사 인터럽트
- Division by zero
- Overflow/Underflow
- 기타 Exception

S/W 인터럽트

System call(Supervisor call) 호출시

인터럽트 동작 절차

인터럽트 핸들링

프로그램 A가 실행되고 있을 때 인터럽트가 발생하면 A의 현재 상태를 먼저 저장한다.
CPU에서 명령이 실행될 때는 CPU 내부에 있는 임시 기억장치인 레지스터(register)에 데이터를 읽거나 쓰면서 작업을 하는데, 인터럽트가 발생하기전에 레지스터 상태를 저장해야한다.
운영체제는프로세스의 상태를 PCB라는 자료구조에 메모리 주소, 레스터 값, 하드웨어 상태 등을 저장한다.

입출력 구조

입출력(I/O)이란 컴퓨터 시스템이 외부 I/O 장치들과 데이터를 주고 받는 것을 말한다.
입출력 방식에는 동기식 입출력과 비동기식 입출력이 있다.
동기식 입출력(synchronous I/O)은 어떤 프로그램이 입출력 요청을 했을 때 입출력 작업이 완료된 후에 그 프로그램이 다음 작업을 수행할 수 있는 방식을 말한다.
동기식 입출력을 요청한 프로그램은 입출력이 완료될 때까지 다음 명령을 수행할 수 없기 때문에 그동안 CPU가 낭비된다.
CPU의 효율적인 사용을 위해 입출력이 수행되는 동안 해당 프로그램은 block 시키고 다른 프로그램에게 CPU를 양도한다.
이렇게 되면 동시에 다수의 입출력이 발생할 수 있는데, 동기화를 해줘야한다. 장치마다 큐를 두어 요청된 순서대로 처리할 수 있도록 한다.
비동기식 입출력(asynchronous I/O)은 입출력 연산을 요청한 후에 연산이 끝나기를 기다리는 것이 아니라 CPU의 제어권을 입출력 연산을 호출한 그 프로그램에게 곧바로 부여한다. 프로그램은 I/O 연산이 필요없는 부분을 먼저 수행한다.
일반적으로는 운영체제에게 입출력을 요청할 경우 해당 프로그램의 입출력이 완료될 때까지 그 프로그램을 block 시키는 동기식 입출력을 사용한다.

DMA

장치의 컨트롤러가 CPU에게 인터럽트를 발생시키면 CPU는 장치 컨트롤러의 로컬버퍼와 메모리 사이에서 데이터를 옮기는 일을 한다.
한편 모든 메모리 접근 연산이 CPU에 의해서만 이루어질 경우, 입출력 장치가 메모리 접근을 원할 때마다 인터럽트에 의해 CPU의 업무가 방해를 받게 되어 CPU 사용의 효율성이 떨어지는 문제가 생긴다.
이러한 비효율을 극복하기 위해 CPU 이외에 메모리 접근이 가능한 장치를 한 더 두는데, 이를 DMA라고 부른다.
DMA는 일종의 컨트롤러로서, CPU가 입출력 장치들의 메모리 접근 요청에 의해 자주 인터럽트 당하는 것을 막아준다.
DMA는 로컬버퍼에서 메모리로 데이터를 읽어오는 작업을 CPU가 담당하는 것이 아니라 DMA가 대행한다.
DMA는 바이트(byte) 단위가 아니라 블록(block)이라는 큰 단위로 메모리로 정보를 읽어온 후, CPU에게 인터럽트를 발생시켜 해당 작업의 완료를 알려준다.
이처럼 DMA를 사용하면, CPU에 발생하는 인터럽트의 빈도를 줄여 CPU를 좀 더 효율적으로 관리하고 입출력 연산을 빠르게 수행할 수 있게 된다.

저장장치의 구조

주기억장치
- 주기억장치는 보통 메인 메모리라고 부르며 전원이 나가면 저장되었던 내용이 모두 사라지는 휘발성(volatile)의 RAM을 매체로 사용하는 경우가 대부분이다.
보조기억장치
- 보조기억장치는 전원이 나가도 저장된 내용을 기억할 수 있는 비휘발성(unvolatile)의 마그네틱 디스크를 주로 사용한다.
- 보조기억장치의 용도는 크게 두 가지로 구분된다.
  - 파일 시스템용 : 전원이 나가도 유지해야할 정보가 있으면 그것을 파일 형태로 보조기억장치에 저장하기된다.
  - 메모리의 연장 공간 : 메모리는 크기가 한정되고 비싸다. 그러므로 다수의 프로그램이 메모리에 올라가 동시에 수행되는 현대의 컴퓨터 환경에서는 메모리 공간이 부족한 경우가 흔히 발생한다. 이 경우 OS는 프로그램 수행에 당장 필요한 부분만 메모리에 올려놓고 그렇지 않은 부분은 디스크의 스왑영역에 내려놓게 된다. 이처럼 디스크에 내려놓는 일을 스왑 아웃(swap out)시킨다고 말한다. 스왑 아웃된 부분이 필요할 때는 다시 메모리 영역으로 올린다.

저장장치의 계층구조

컴퓨터 시스템을 구성하는 저장 장치는 빠른 저장장치부터 느린 저장장치까지 단계적인 계층 구조로 이루어진다.
빠른 저장장치는 가격이 비싸기 때문에 적은 용량을 사용하고, 느린 저장장치는 가격이 저렴해 대용량을 사용한다.
따라서 당장 필요한 정보를 빠른 저장장치에 넣어두어 수행 속도를 높이고 그렇지 않은 정보는 상대적으로 느린 저장장치에 보관하게된다.
저장장치 계층은 최상위의 CPU 내부에 존재하는 레지스터(register)부터 캐시 메모리(cache memory), 메인 메모리(main memory) 등의 휘발성 저장장치로 구성되는 부분이 상위 계층에 존재하며 이 부분에 저장되는 정보는 전원이 나가면 그 내용이 사라진다.
반면 하위 계층을 구성하는 비휘발성 저장장치다.
상위 저장장치는 접근 속도가 월등히 빠르지만 용량은 상대적으로 적다. 하지만 당장 필요한 정보만을 선별적으로 저장하면 하위에 있는 큰 용량의 저장장치를 가지고 있는 것과 비슷한 성능 효과를 낼 수 있다.
예를 들어 캐시 메모리는 레지스터와 메인 메모리 사이에 존재하며, 여러 가지 캐싱 기법을 이용해 적은 용량의 캐시 메모리를 사용해도 메인 메모리와 같이 큰 용량을 가진 것처럼 효율적으로 동작하도록 관리할 수 있다.
캐싱 기법이란 상대적으로 느린 저장장치에 있는 내용 중 당장 사용되거나 빈번히 사용될 정보를 빠른 저장장치에 선별적으로 저장함으로써 두 저장장치의 사이의 속도를 완충 시키는 것이다.
이와 같은 캐싱 기법이 적은 용량으로도 효과를 거둘 수 있는 것은 컴퓨터 내의 데이터나 프로그램을 구성하는 모든 부분이 균일하게 사용되는 것이 아니라 일부분만이 집중적으로 사용되고 특정 부분은 거의 사용되지 않기 때문이다.
예를 들어 프로그램 코드 중에는 많은 횟수 동안 반복되는 코드와, 한 번 수행되고 끝나는 부분이 있을 수 있다. 이런 경우 반복되는 코드를 빠른 저장장치에 올려놓으면 적은 저장공간만으로도 전체 시스템의 평균적인 성능을 향상시킬 수 있다.

하드웨어 보안

우리가 흔히 사용하는 운영체제는 여러 프로그램이 동시에 실행될 수 있는 다중 프로그래밍(multi-programming) 환경에서 동작한다.
그러므로 다른 프로그램이 다른 프로그램의 실행을 발해하거나 프로그램 간에 충돌을 일으키는 문제를 막기 위해 하드웨어에 대한 각종 보안 기법이 필요하다.
하드웨어적인 보안을 유지하기 위해서 운영체제는 기본적으로 커널모드와 사용자모드 두 가지 모드를 지원한다.
어떤 프로그램이 이상한 명령을 수행하여 다른 프로그램의 메모리 영역이나 파일 영역을 침범하는 경우가 발생할 수 있다.
따라서 중요한 정보에 접근해 위험한 상황을 초래할 수 있는 연산은 커널모드에서만 실행되도록 하여 일반 사용자 프로그램이 직접 위험한 명령을 수행하지 못하게 하고, 그렇지 않은 일반적인 연산만 사용자모드에서 사용자 프로그램이 수행하도록 통제하여 보안성을 확보하게 된다.
커널모드는 운영체제가 CPU의 제어권을 가지고 운영체제 코드를 실행하는 모드로써, 이 모드에서는 모든 종류의 명령을 다 실행할 수 있다.
반면 사용자 모드에서는 일반 사용자 프로그램이 실행되며 제한적인 명령만 수행할 수 있다.
시스템에 중요한 영향을 미치는 연산은 커널모드에서만 실행 가능하도록 함으로써 하드웨어의 보안을 유지하는 것이다.
컴퓨터 시스템은 CPU 내부에 모드비트(mode bit)를 두어 사용자 프로그램을 감시한다. 모드비트가 0으로 세팅되어 있으면 커널모드로서 모든 명령을 수행할 수 있고, 모드비트가 1로 세팅되어 있으면 사용자 모드로서 제한된 명령만을 수행할 수 있다.
사용자 프로그램이 수행되다가 하드웨어 접근 등 보안이 필요한 중요한 명령을 수행해야할 경우, 시스템 콜을 통해 운영체제가 대신해줄 것을 요청한다. 그러면 CPU 의 제어권은 다시 운영체제로 넘어가게 된다.
인터럽트가 발생할 때 사용자 프로그램의 모드 비트는 자동으로 0이되고, 운영체제는 서비스에 필요한 모든 종류의 명령을 다 수행할 수 있게된다. 요청된 작업이 모두 끝난 후에는 모드비트를 다시 1로만들어 사용자 프로그램에게 CPU를 넘겨준다.
사용자 프로그램이 디스크에 저장된 파일에 자유롭게 접근할 수 있다면 보안상 문제가 발생할 수 있다. 자신의 소유가 아닌 다른 사람의 파일에 접근할 수 있기 때문이다.
따라서 모든 입출력 명령은 특권명령으로 규정해서 사용자 프로그램이 직접 입출력을 하는 것을 차단한다. 그리고 입출력이 필요할 때는 운영체제에 요청하여 운영체제가 입출력 명령을 대신 수행하게 한다.

메모리 보안

디스크뿐 아니라 메모리의 경우에도 보안이 필요하다. 이는 여러 프로그램이 메모리에 동시에 올라가서 실행되기 때문에 하나의 사용자 프로그램이 다른 사용자 프로그램이나 운영체제가 위치한 메모리 영역을 침범할 수 있기 때문이다.
예를들어 어떤 사용자 프로그램이 C 언어의 포인터 등 메모리 주소 참조 연산을 잘못 사용해 다른 사용자 프로그램의 메모리 영역이나 운영체제 커널이 위치한 영역을 참조하려는 시도를 할 수 있다. 따라서 적어도 인터럽트 벡터와 인터럽트 처리루틴이 있는 곳은 각별한 보안이 필요하다.
사용자 프로그램이 인터럽트 처리루틴을 접근하거나 변경할 수 있을 경우 운영체제만 수행할 수 있는 특권명령을 보안성이 침해되는 이상한 명령으로 변형할 수 있기 때문이다.
이러한 문제를 해결하기 위해 2개의 레지스터를 사용해서 프로그램이 접근하려는 메모리 부분이 합법적인지 체크함으로써 메모리를 보호할 수 있다.
이때 사용되는 2개의 레지스터는 기준 레지스터(base register)와 한계 레지스터(limit register)이다.
사용자 프로그램은 기준 레지스터에 있는 주소부터 기준 레지스터+한계 레지스터 값사이의 주소 영역에만 접근할 수 있으며, 접근하려는 주소가 이 범위 안에 없으면 불법적인 메모리 접근이므로 예외상황이라는 일종의 소프트웨어 인터럽트를 발생시켜 CPU의 제어권을 해당 프로그램으로부터 운영체제로 이양시키고, 운영체제는 예외상황을 발생시킨 프로그램을 강제 종료시킨다.
기준 레지스터는 어떤 프로그램이 수행되는 동안 그 프로그램이 합법적으로 접근할 수 있는 가장 적은 주소를 보관하고 있고, 한계 레지스터는 그 프로그램이 기준 레지스터값부터 접근할 수 있는 메모리의 범위를 보관하고 있다.
메모리 접근 연산은 사용자 프로그램이 CPU를 가지고 있는 동안 수행할 수 있는 연산이므로 특권명령은 아니다. 다만 사용자 프로그램이 메모리에 접근하기 전에 하드웨어적으로 그 접근이 합법적인지를 체크하여 메모리를 보호하게 된다. 하지만 기준 레지스터와 한계 레지스터의 값을 세팅하는 연산은 특권 명령이다.

CPU 보호

CPU가 하나의 프로그램에 의해 독점되는 것을 막기 위해 운영체제는 타이머(timer)라는 하드웨어를 사용한다.
타이머는 정해진 시간이 지나면 인터럽트를 발생시켜 운영체제가 CPU의 제어권을 획득할 수 있도록 하는 역할을 수행한다.
타이머에 의해 발생되는 인터럽트 처리루틴의 역할은 지금 CPU를 점유하고 명령을 실행 중인 프로그램으로부터 CPU를 빼앗아 다른 프로그램에게 CPU를 이양하는 것이다.
타이머는 시분할 시스템에서 현재 시간을 계산하기 위해서도 사용된다.

시스템 콜을 이용한 입출력 수행

입출력에 관련된 명령은 모두 특권 명령이므로 사용자 프로그램이 직접 수행할 수 없다. 이러한 입출력 명령은 운영체제 코드에 구현되어 있으며, 사용자 프로그램은 직접 입출력을 수행하는 대신 운영체제에게 시스템 콜이라는 서비스 대행 요청을 하여 입출력을 수행한다.
시스템 콜은 일종의 소프트웨어적인 인터럽트로서 사용자 프로그램이 시스템 콜을 할 경우 트랩이 발생해 CPU의 제어권이 운영체제로 넘어가게된다. 그러면 운영체제는 해당 시스템 콜을 처리하기 위한 루틴으로 가서 정의된 명령을 수행한다.
예를 들어 시스템 콜이 디스크 입출력 요청이었다면, 디스크 컨트롤러에게 입출력 요청을 수행하도록 명령하고, 추후에 디스크 컨트롤러가 입출력 수행을 마치면 CPU에게 인터럽트를 발생시켜 입출력이 완료되었음을 알려줌으로써 해당 프로그램이 다시 CPU를 할당 받을 수 있도록 한다.

출처 & 더 알아보기

[백준] 3649 로봇 프로젝트

jujube bat — Wed, 3 Jun 2020 21:10:13 +0900

✔️ 문제 링크

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

3649번: 로봇 프로젝트

문제 상근이와 선영이는 학교 숙제로 로봇을 만들고 있다. 로봇을 만들던 중에 구멍을 막을 두 레고 조각이 필요하다는 것을 깨달았다. 구멍의 너비는 x 센티미터이고, 구멍에 넣을 두 조각의 길

www.acmicpc.net

✔️ 문제 이해

◾ 로봇의 구멍을 2개의 레고 조각으로 막아야 한다.

◾ 구멍을 막을 2개의 레고 조각 길이의 합은 구멍의 너비와 정확히 일치해야한다.

◾ 테스트 케이스는 여러개이다.

◾ 각 테스트 케이스마다 구멍의 너비 x, 레고 조각의 개수 n, 각 레고 조각의 길이가 주어진다.

◾ 레고 조각의 길이는 나노미터 단위이다. ( 1cm = 10000000nm )

◾ 각 테스트 케이스마다 결과를 출력한다. 구멍을 막을 수 있는 두 조각이 없다면 "danger"을 출력한다.

◾ 구멍을 완벽하게 막을 수 있는 두 조각이 있다면 "yes 레고조각길이1 레고조각길이2" 를 출력한다.

◾ 정답이 여러개인 경우에는 |레고조각길이1 - 레고조각길이2| 가 가장 큰 것을 출력한다.

✔️ 설계

◾ 주어진 레고 조각들중 하나를 뽑고 다른 조각을 골라서 두 조각의 길이 합이 x가 되는지 확인한다.

◾ 다른 하나의 조각을 고를때 이분탐색을 사용한다.

◾ 이분탐색을 위해 주어진 레고 조각들을 길이 기준으로 오름 차순 정렬한다.

‍ 소스 코드

#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
using namespace std;

int arr[1000000];
int x, n;
vector<int> v;
int ret = -1;


// idx번째 블록과 합쳤을때 길이가 x가 되는 블록을 이분탐색으로 찾는다.
void find(int idx) {
	int low = 0, high = n;
	
	while (low <= high) {
		int mid = (low + high) / 2;
		int size = arr[idx] + arr[mid]; // 두 블록을 합쳤을 경우.

		if (size >= x) {
			if (size == x && idx != mid) { // 두 블록의 합이 x이고, 중복된 블록 선택이 아닐때.
				if (abs(arr[idx] - arr[mid]) > ret) { 
					ret = abs(arr[idx] - arr[mid]);
					v.clear();
					v.push_back(idx);
					v.push_back(mid);
				}
			}
			high = mid - 1;
		}
		else {
			low = mid + 1;
		}
	}

}

int main() {

	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);

	while (cin >> x) {

		// 매 테스트 케이스마다 값 초기화.
		memset(arr, 0, sizeof(arr));
		v.clear();
		ret = -1;

		x *= 10000000; // 나노 단위로 맞춰준다.

		cin >> n;

		for (int i = 0; i < n; i++) {
			cin >> arr[i];
		}

		sort(arr, arr + n); // 이분탐색을 위해 정렬한다.

		for (int i = 0; i < n; i++) { // i번째 블록과 다른 블록 조합을 찾아본다.
			find(i);
		}

		if (v.empty()) // 결과가 없을 경우.
			cout << "danger" << endl;
		else { // 결과가 있을 경우, 오름차순으로 출력한다. 
			sort(v.begin(), v.end());
			cout << "yes " << arr[v[0]] << " " << arr[v[1]] << endl;
		}
	}

	return 0;
}

✔️ 문제 회고

◾ 테스트 케이스 개수가 주어지지 않아서 당황했다. while문에 cin >>x 을 넣음으로서 입력이 종료될때까지 프로그램이 실행되게 했다.

◾ cm 단위를 nm 단위로 맞춰줘야했다.

[백준] 1342 행운의 문자열

jujube bat — Wed, 3 Jun 2020 15:55:54 +0900

✔️ 문제 링크

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

1342번: 행운의 문자열

민식이와 준영이는 자기 방에서 문자열을 공부하고 있다. 민식이가 말하길 인접해 있는 모든 문자가 같지 않은 문자열을 행운의 문자열이라고 한다고 한다. 준영이는 문자열 S를 분석하기 시작�

www.acmicpc.net

✔️ 문제 이해

◾ 주어진 문자열을 재배치해서 행운의 문자열을 몇 개 만들 수 있는지 알아내야한다.

◾ 행운의 문자열이란 인접해 있는 모든 문자가 같지 않은 문자열이다.

✔️ 설계

◾ c++의 next_permuation을 사용하면 매우 쉽게 풀리는 문제이다.

◾ next_permutation은 순열을 만들때 중복을 제거해주기 때문에 중복관련해서 따로 구현하지 않아도 됐다.

◾ 시간복잡도 : 순열을 구하는 경우의수 * 인접한 문자가 중복인지 검사하는 횟수

◾ 최악의 경우 10! * 10 (36,288,000)이므로 제한된 시간내에 가능했다.

‍ 소스 코드

#include<iostream>
#include<string>
#include<algorithm>
#include<set>
using namespace std;

int main() {
	string s;
	int ret = 0;
	cin >> s;

	// 모든 순열을 구하기 위해 정렬해준다. 
	sort(s.begin(), s.end());

	do {
		// 인접한 문자가 같은지 체크한다.
		bool flag = false;
		for (int i = 0; i < s.size() - 1; i++) {
			if (s[i] == s[i + 1]) {
				flag = true;
				break;
			}
		}
		if (flag) continue;
		ret++;

	} while (next_permutation(s.begin(), s.end()));

	cout << ret;
}

✔️ 문제 회고

◾ next_permutation을 사용하여 정말 쉽게 풀었다.

◾ next_permutation의 덕을 많이봐서 양분이 되는 공부는 아녔다.

[백준] 7662 이중 우선순위 큐

jujube bat — Tue, 2 Jun 2020 21:22:26 +0900

✔️ 문제 링크

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

7662번: 이중 우선순위 큐

문제 이중 우선순위 큐(dual priority queue)는 전형적인 우선순위 큐처럼 데이터를 삽입, 삭제할 수 있는 자료 구조이다. 전형적인 큐와의 차이점은 데이터를 삭제할 때 연산(operation) 명령에 따라 우�

www.acmicpc.net

✔️ 문제 이해

◾ 이중 우선순위 큐를 구현하고 사용한 결과를 출력해야한다. 이중 우선순위 큐는 아래와 같이 정의된다.

데이터를 삽입한다.
우선순위가 가장 높은 데이터를 삭제한다.
우선순위가 가장 낮은 데이터를 삭제한다.

◾ 테스트 케이스가 주어지고 명령어들이 주어진다. 명령어는 아래와 같다.

I 숫자 : 숫자를 우선순위 큐에 삽입한다.
D 1 : 우선순위 큐에서 우선순위가 가장 높은 데이터를 삭제한다.
D -1 : 우선순위 큐에서 우선순위가 가장 낮은 데이터를 삭제한다.

◾ 각 테스트 케이스의 명령어들을 수행한 후 우선순위 큐에 들어있는 원소중 최대값과 최소값을 출력한다.

◾ 우선 순위 큐가 비어있으면 "EMPTY" 를 출력한다.

✔️ 설계

◾ max heap과 min heap 두 개의 우선순위 큐를 활용한다.

◾ D 1 명령어를 수행하기 위해 max heap을 활용한다.

◾ D -1 명령어를 수행하기 위해 min heap을 활용한다.

◾ map<숫자, 숫자의 개수>을 사용하여 max heap과 min heap의 데이터를 동기화 한다. ( max heap에서 삭제된 원소는 min heap에서도 삭제돼야한다. 반대도 마찬가지)

◾ map을 이용해 숫자를 조회할때 숫자의 개수가 0이면 삭제된 데이터이다. 자세한 설명은 주석으로 남겼다.

‍ 소스 코드

#include<iostream>
#include<queue>
#include<map>
using namespace std;

int main() {

	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int t;
	cin >> t; // 테스트 케이스 입력.

	while (t--) {

		int k;
		map<long long, int> m; // <숫자, 숫자의 개수> 
		priority_queue<long long> maxHeap;
		priority_queue<long long> minHeap;

		cin >> k; // 명령어 개수 입력.

		for (int i = 0; i < k; i++) { 
			char op; long long num;
			cin >> op >> num; // 명령어 입력.

			if (op == 'I') { // 이중 우선순위 큐에 숫자 삽입.
				m[num]++; // 동기화를 위해 map에 숫자 개수 기록.
				maxHeap.push(num);
				minHeap.push(-num);
			}
			else if (op == 'D') {
				if (num == 1) { 

					// 숫자의 개수가 0이란 뜻은 삭제된 데이터란 뜻으로 모두 삭제한다.
					while (!maxHeap.empty() && m[maxHeap.top()] == 0) {
						maxHeap.pop();
					}

					if (!maxHeap.empty()) { 
						m[maxHeap.top()]--;  // 개수를 빼준다.
						if (m[maxHeap.top()] < 0) m[maxHeap.top()] = 0;
						maxHeap.pop(); // 최대값 삭제.
					}
				}
				else if (num == -1) { 

					while (!minHeap.empty() && m[-minHeap.top()] == 0) {
						minHeap.pop();
					}

					if (!minHeap.empty()) {
						m[-minHeap.top()]--; // 개수를 빼준다.
						if (m[-minHeap.top()] < 0) m[-minHeap.top()] = 0;
						minHeap.pop(); // 최소값 삭제.
					}
				}
			}
		}

		// 위와 마찬가지. 숫자의 개수가 0이란 뜻은 삭제된 데이터란 뜻으로 모두 삭제한다.
		while (!maxHeap.empty() && m[maxHeap.top()] == 0) {
			maxHeap.pop();
		}

		while (!minHeap.empty() && m[-minHeap.top()] == 0) {
			minHeap.pop();
		}

		// 힙이 비어있을 경우.
		if (maxHeap.empty() || minHeap.empty()) {
			cout << "EMPTY" << endl;
		}
		else { // 비어있지 않을 경우 결과 출력.
			cout << maxHeap.top() << " " << -minHeap.top() << endl;
		}
	}

	return 0;
}

✔️ 문제 회고

◾ 아래와 같은 두 가지 문제로 한참 해맸다.

◾ 결과 출력에 개행을 빼먹었다.

◾ 소스 코드를 보면 long long 자료형을 사용한다. 그 이유는 int 값의 범위가 비대칭이기 때문이다.

◾ (signed) int의 범위는 다음과 같다. -2,147,483,648 ~ 2,147,483,647

◾ 만약 -2,147,483,648 라는 숫자가 이중 우선순위 큐에 삽입 된다고 생각해보자. min heap에 삽입 되어질 것인데, 이때 min heap을 사용하기 위해 -를 붙여줬으므로 2,147,483,648 라는 숫자가 min heap에 들어간다. 이는 int 형으로 선언된 min heap일 경우 범위 초과가 발생한다. 따라서 long long 자료형을 사용해야한다.

[백준] 10282 해킹

jujube bat — Tue, 2 Jun 2020 20:30:00 +0900

✔️ 문제 링크

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

10282번: 해킹

문제 최흉최악의 해커 yum3이 네트워크 시설의 한 컴퓨터를 해킹했다! 이제 서로에 의존하는 컴퓨터들은 점차 하나둘 전염되기 시작한다. 어떤 컴퓨터 a가 다른 컴퓨터 b에 의존한다면, b가 감염��

www.acmicpc.net

✔️ 문제 이해

◾ 테스트 케이스의 개수가 주어진다.

◾ 각 테스트 케이스마다 컴퓨터 개수 n, 의존성 개수 d, 해킹당한 컴퓨터의 번호 c가 주어진다.

◾ 이어서 d개의 줄에 정수 a, b, s가 주어진다. 이는 컴퓨터 b가 감염되면 s초 후 컴퓨터 a도 감염됨을 뜻한다.

◾ 각 테스트 케이스마다 총 감염되는 컴퓨터 수, 마지막 컴퓨터가 감염되기까지 걸리는 시간을 출력한다.

✔️ 설계

◾ 다익스트라 알고리즘을 알고 있으면 쉽게 풀 수 있는 문제다. 자세한 설명은 주석으로 남겼다.

◾ 여러개의 테스트 케이스가 있으므로, 인접 리스트 방식으로 표현한 그래프 벡터를 초기화 해줘야한다.

‍ 소스 코드

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

vector<pair<int, int>> adj[10001]; // <정점, 가중치>
int n, d, c;

void dijkstra(int src, vector<int>& dist) { // 다익스트라 알고리즘.

	priority_queue<pair<int, int>> pq; // <가중치, 정점>

	dist[src] = 0; // 시작점 최단거리 0으로 초기화.
	pq.push({ 0, src }); // pq에 넣는다.

	while (!pq.empty()) {
		int cost = -pq.top().first; // 현재까지 구한 최단거리(minHeap 이므로 '-' 를 붙여줌).
		int here = pq.top().second; // 정점.
		pq.pop();

		if (dist[here] < cost) continue; // 이미 더 짧은 최단거리가 구해졌으면, 스킵.

		for (int i = 0; i < adj[here].size(); i++) { // 인접 정점 검사.
			int next = adj[here][i].first; // 다음에 방문할 정점.
			int nextCost = cost + adj[here][i].second; // 다음에 방문할 정점까지의 거리.

			if (dist[next] > nextCost) { // 다음에 방문할 정점까지의 거리가 최단거리라면,
				dist[next] = nextCost; // 최단 거리 갱신.
				pq.push({ -nextCost, next }); // pq에 넣어준다.
			}
		}
	}
}

int main() {
	int t;
	cin >> t; // 테스트 케이스 입력

	while (t--) {

		for (int i = 0; i <= n; i++) { // 인접 리스트 그래프 초기화.
			adj[i].clear();
		}

		cin >> n >> d >> c;
		for (int i = 0; i < d; i++) {
			int a, b, s;
			cin >> a >> b >> s;
			adj[b].push_back({ a,s }); // b 컴퓨터가 감염되면, s초후 a 컴퓨터 감염.
		}

		vector<int> dist(10001, 0x7fffffff); // 최단 거리 배열 초기화.
		dijkstra(c, dist); // 시작점 : 최초 해킹 당한 컴퓨터 c.

		int cnt = 0, time = 0;
		for (int i = 1; i <= n; i++) {
			if (dist[i] < 0x7fffffff) { // 감염된 컴퓨터일 경우.
				cnt++; // 수 증가.
				// 마지막 컴퓨터가 감염되기까지 걸린 시간 = 최단 거리중 가장 큰 값.
				time = max(time, dist[i]); 
			}
		}

		cout << cnt << " " << time << endl; // 결과 출력.
	}

	return 0;
}

✔️ 문제 회고

◾ vector 배열을 초기화 해주는 과정에서 다음과 같은 실수를 했다. adj->clear(); 이렇게 하면 adj[0]만 clear 된다.

◾ 다익스트라 알고리즘 관련 문제를 계속 풀어서 더 익숙해져야겠다.

[Computer Network] SOP & CORS

jujube bat — Tue, 2 Jun 2020 14:18:43 +0900

Same-Origin Policy

◾ 자바스크립트 엔진 표준 스펙에 존재하는 보안 규칙이다.

◾ 브라우저는 스크립트 내(<script></script>)에서 초기화 되는 다른 도메인에 대한 HTTP 요청을 제한한다.

◾ 즉, 사용자가 특정 사이트에 접속중인 동시에 다른 사이트를 접근하는 것을 제한한다.

◾ XSS 기법(웹 사이트에 의도치 않은 스크립트를 넣는 기법)을 사용해 특정 정보를 다른 도메인으로 탈취하는 것을 방지할 수 있다.

CORS (Cross Origin Resource Sharing)

◾ Client가 현재 접속한 사이트의 도메인 외에 다른 도메인에 접근할 수 있도록 처리 해주는 웹 브라우저 표준 기술이다.

◾ 웹 사이트를 백 엔드와 프론트엔드를 분리하여 API 묶는 방식으로 구현한 경우 백엔드 서버에 CORS 설정이 필요하다. ( 응답 HTTP 헤더에 Access-Control-Allow-Origin를 추가한다. )

더 알아보기

◾ SOP, CORS란? : https://java119.tistory.com/67

◾ XSS, CSRF, CORS : https://muang-kim.tistory.com/278?category=866244

[백준] 16938 캠프 준비

jujube bat — Mon, 1 Jun 2020 22:27:42 +0900

✔️ 문제 링크

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

16938번: 캠프 준비

난이도가 10, 30인 문제를 고르거나, 20, 30인 문제를 고르면 된다.

www.acmicpc.net

✔️ 문제 이해

◾ N개의 문제가 있고, 각 문제에 대한 난이도는 정수로 수치화 되어있다. i번째 문제의 난이도는 Ai 이다.

◾ 주어진 N개의 문제에서 캠프에서 사용할 문제를 구해야한다.

◾ 문제를 고르는 조건은 아래와 같다.

캠프에 사용할 문제는 2문제 이상이어야한다.
고른 문제들의 난이도 합은 L보다 크거나 같고, R보다 작거나 같다.
고른 문제중 가장 어려운 문제 가장 쉬운 문제의 난이도 차이는 X보다 크거나 같아야 한다.

◾ 캠프에 사용할 문제를 고르를 방법의 수를 구해야한다.

✔️ 설계

◾ 주어진 문제중 2문제 이상을 골랐을때 조건에 맞는 모든 경우의 수를 모두 찾는 문제이다.

◾ 문제를 고르거나 고르지 않거나 둘 중 하나이다. 최대 15문제이므로 최대 2^15 경우의 수가 나온다.

◾ 비트마스킹으로 모든 경우의 수를 간단히 구하는 방법을 선택했다.

◾ 좀 더 상세한 설명은 주석으로 넣었다.

‍ 소스 코드

#include<iostream>
#include<bitset>
#include<algorithm>
using namespace std;

int p[15];
int n, l, r, x;
int ret = 0;

bool check(int bit) {

	int cnt = 0;
	int score = 0;
	int maxScore = 1, minScore = 10000000;

	for (int i = 0; i < n; i++) {

		// flag를 활용하여 선택된 문제를 선별한다. 
		int flag = bit & (1 << i); 

		// 1로 표시된 bit는 선택된 문제다. 아래 코드로 출력해서 확인해보자.
		// cout << bitset<16>(flag) << endl;

		if (flag != 0) {  // 선택된 문제라면(bit가 1이라면),
			score += p[i]; // 점수를 더한다.
			maxScore = max(maxScore, p[i]); // 최대 점수 값 갱신.
			minScore = min(minScore, p[i]); // 최소 점수 값 갱신.
			cnt++; // 골라진 문제 수 카운트.
		}

	}

	// 조건에 부합하는 경우라면 true 반환.
	if ((score >= l && score <= r)
		&& abs(maxScore - minScore) >= x
		&& cnt >= 2) {
		return true;
	}
	else
		return false;
}

int main() {

	cin >> n >> l >> r >> x;

	for (int i = 0; i < n; i++) { // 문제 정보 입력.
		cin >> p[i];
	}

	for (int bit = 0; bit < (1 << n); bit++) { // 2^n 까지의 모든 경우의 수를 구해본다.
		if (check(bit)) { // 각 경우가 조건에 만족하는지 체크.
			ret++;
		}
	}

	cout << ret;
	return 0;
}

✔️ 문제 회고

◾ 2^n 가지 경우의 수중 조건에 만족하는 모든 경우의 수를 구하는 간단한 문제였다.

◾ 재귀 또는 비트마스킹으로 풀 수 있다. 나중에 재귀로도 풀어봐야겠다.

◾ 비트마스킹에 더 익숙해질 필요가 있다고 느꼈다.

[Programmers] 괄호 변환

jujube bat — Mon, 1 Jun 2020 20:30:05 +0900

✔️ 문제 링크

◾ 2020 카카오 블라인드 채용 기출 문제이다.

https://programmers.co.kr/learn/courses/30/lessons/60058

코딩테스트 연습 - 괄호 변환

카카오에 신입 개발자로 입사한 콘은 선배 개발자로부터 개발역량 강화를 위해 다른 개발자가 작성한 소스 코드를 분석하여 문제점을 발견하고 수정하라는 업무 과제를 받았습니다. 소스를 컴�

programmers.co.kr

✔️ 문제 이해

◾ '(' 와 ')' 로만 이루어진 문자열이 주어진다.

◾ '(' 의 개수와 ')' 의 개수가 같고, '('와 ')'의 괄호의 짝도 모두 맞을 경우에는 이는 올바른 괄호 문자열이다.

◾ 문자열이 주어졌을 때 올바른 괄호 문자열로 변환해서 반환하면 된다.

✔️ 설계

◾ 이 문제는 내가 설계할 필요가 없다. 문제에서 친철하게 올바른 괄호 문자열을 만드는 알고리즘을 알려준다.

◾ 알고리즘을 보고 그대로 구현하면 된다. 아래 소스 코드의 주석은 문제에서 주어진 알고리즘을 그대로 적은 것이다.

‍ 소스 코드

#include <string>
#include <vector>
#include<stack>
using namespace std;

bool isRigt(string s) { // 인자 s가 올바른 문자열인지 판별해준다. 
	stack<char> st;

	for (int i = 0; i < s.size(); i++) {
		if (s[i] == ')') {
			if (!st.empty() && st.top() == '(')
				st.pop();
			else
				st.push(s[i]);
		}
		else {
			st.push(s[i]);
		}
	}

	if (st.empty())
		return true;
	else
		return false;
}

string solve(string w) {
	if (w == "") return ""; // 1. 입력이 빈 문자열인 경우, 빈 문자열을 반환합니다. 
	
	string u, v;
	stack<char> st;
	int idx;

	// 2. 문자열 w를 두 "균형잡힌 괄호 문자열" u, v로 분리합니다.
	// 단, u는 "균형잡힌 괄호 문자열"로 더 이상 분리할 수 없어야 하며, 
	// v는 빈 문자열이 될 수 있습니다.
	int left = 0, right = 0;

	for (int i = 0; w.size(); i++) {
		if (w[i] == '(') left++;
		else if (w[i] == ')') right++;

		if (left != 0 && right != 0) {
			if (left == right) {
				idx = i;
				break;
			}
		}
	}

	u = w.substr(0, idx+1);
	v = w.substr(idx + 1);

	// 3. 문자열 u가 "올바른 괄호 문자열" 이라면 문자열 v에 대해 1단계부터 다시 수행합니다.
	if (isRigt(u)) 
		return u + solve(v); // 3-1. 수행한 결과 문자열을 u에 이어 붙인 후 반환합니다. 
	else{ // 4. 문자열 u가 "올바른 괄호 문자열"이 아니라면 아래 과정을 수행합니다. 
		
		string tmp = "("; // 4 - 1. 빈 문자열에 첫 번째 문자로 '('를 붙입니다.
		// 4 - 2. 문자열 v에 대해 1단계부터 재귀적으로 수행한 결과 문자열을 이어 붙입니다.
		tmp += solve(v); 
		tmp += ")"; // 4-3. ')'를 다시 붙입니다.

		string newU = "";
		// 4-4. u의 첫 번째와 마지막 문자를 제거하고, 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙입니다. 
		for (int i = 1; i < u.size()-1; i++) {
			if (u[i] == '(')
				newU += ")";
			else
				newU += "(";
		}
		return tmp + newU; // 4-5. 생성된 문자열을 반환합니다.
	}
}

string solution(string p) {
	string answer = "";
	answer = solve(p);
	return answer;
}

✔️ 문제 회고

◾ 처음에 어려운 문제인줄 알았지만, 문제에서 주어진 알고리즘을 그대로 구현하니까 쉽게 풀렸다.

◾ 문자열을 다루는 문제, stack 활용이 필요한 괄호쌍 문제에 대해 더 익숙 해져야겠다고 느꼈다.

[백준] 2933 미네랄

jujube bat — Mon, 1 Jun 2020 16:22:40 +0900

✔️ 문제 링크

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

2933번: 미네랄

창영과 상근은 한 동굴을 놓고 소유권을 주장하고 있다. 두 사람은 막대기를 서로에게 던지는 방법을 이용해 누구의 소유인지를 결정하기로 했다. 싸움은 동굴에서 벌어진다. 동굴에는 미네랄��

www.acmicpc.net

✔️ 문제 이해

◾ RxC 크기의 동굴에 미네랄이 존재한다. ( '.'는 빈 칸, 'x'는 미네랄을 나타낸다. )

◾ 높이 h에서 막대기를 던지면 땅과 수평을 이루며 날아간다. ( 왼쪽, 오른쪽에서 번갈아 던진다.)

◾ 이때 막대기가 미네랄에 부디치면, 미네랄은 부숴진다.

◾ 미네랄은 클러스터를 이루고 있다. 클러스터란 인접한 미네랄들의 집합을 뜻한다.

◾ 막대기를 던져서 미네랄이 부숴지면, 클러스터가 분리 될 수 있다.

◾ 이때 새롭게 생성된 클러스터가 공중에 떠있는 경우 중력에 의해 바닥으로 떨어진다.

◾ 클러스터는 땅에 닿거나 다른 클러스터에 닿을때까지 떨어진다.

◾ 동굴에 있는 미네랄들의 정보와, 던져지는 막대기들의 위치 정보가 입력으로 주어진다.

◾ 모든 막대를 던지고 난 이후의 미네랄 모양을 출력하면 된다.

✔️ 설계

◾ 왼쪽, 오른쪽에서 막대기를 던져 미네랄을 부순다.

◾ 공중에 있는 클러스터가 존재하면 중력을 작용한다.

◾ 클러스터는 bfs 또는 dfs로 구분 짓는다.

◾ 땅에 닿아있는 클러스터 정보를 저장해두어 활용한다.

‍ 소스 코드

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;

typedef struct {
	int x, y;
}pos;

char map[100][100];
int visited[100][100];
int r, c, n, cnt = 1;
int stick[100], bottomCluster[101];
int dx[] = { -1, 1, 0, 0 }, dy[] = { 0,0,-1,1 };

// dfs을 사용하여 visited 배열에 번호로 클러스터를 체크한다.
void dfs(int x, int y) { 
	if (!bottomCluster[cnt] && x == r - 1) // 땅에 닿아있는 클러스터를 bottomCluster 배열에 체크.
		bottomCluster[cnt] = true;

	visited[x][y] = cnt;
	for (int i = 0; i < 4; i++) {
		int nx = x + dx[i], ny = y + dy[i];
		if (nx >= r || nx < 0 || ny >= c || ny < 0) continue;
		if (visited[nx][ny]) continue;
		if (map[nx][ny] == '.') continue;
		dfs(nx, ny);
	}
}

void fallMineral() { // 클러스터를 떨어뜨린다. 
	cnt = 1;
	memset(visited, 0, sizeof(visited));
	memset(bottomCluster, 0, sizeof(bottomCluster));

	for (int i = 0; i < r; i++) {
		for (int j = 0; j < c; j++) {
			if (map[i][j] == 'x' && !visited[i][j]) {
				dfs(i, j); // dfs로 각 클러스터를 구분 짓는다. 
				cnt++;
			}
		}
	}

	// 공중에 떠 있는 클러스터가 있는지 확인한다.
	// (땅에 닿지 않아있는 클러스터 체크.)
	bool flag = false;
	for (int i = 1; i < cnt; i++) {
		if (bottomCluster[i] == false) { 
			flag = true;
		}
	}

	if (flag) { // 공중에 떠있는 생긴경우. 중력을 작용한다. 

		vector<pos> v; // 떨어뜨릴 클러스트의 좌표를 저장해둔다. 
		for (int i = 0; i < r; i++) {
			for (int j = 0; j < c; j++) {
				if (visited[i][j] != 0 && !bottomCluster[visited[i][j]]) {
					v.push_back({ i,j });
				}
			}
		}

		bool flag2 = false;

		while (1) { 

			for (int i = 0; i < v.size(); i++) { // 공중에 있는 클러스터를 우선 map에서 지운다.
				map[v[i].x][v[i].y] = '.';
			}

			for (int i = 0; i < v.size(); i++) {
				int nx = v[i].x + 1, ny = v[i].y; // 한 칸 아래 좌표 위치 계산.
				v[i].x = nx, v[i].y = ny; // 좌표 업데이트.
				map[nx][ny] = 'x'; // 배치.

				// 클러스터가 땅에 닿는 경우
				if (nx == r - 1) {
					flag2 = true;
				} // 클러스터가 다른 클러스터에 닿는 경우
				else if (map[nx + 1][ny] == 'x' && (visited[v[i].x][v[i].y] != visited[nx + 1][ny])) {
					flag2 = true;
				}

			}
			if (flag2) return; // 클러스터가 땅에 닿거나 다른 클러스터에 닿으면 탈출.
		}
	}
}

// flag에 따라 왼쪽, 오른쪽을 구분한다.
// h 높이에서 막대기를 던져 미네랄을 부순다.
void breakMineral(bool flag, int h) { 

	h = r - h;
	if (flag) { // 왼쪽 h 높이에서 막대기를 던져 미네랄을 부숨.

		for (int col = 0; col < c; col++) {
			if (map[h][col] == 'x') {
				map[h][col] = '.';
				return;
			}
		}

	}
	else { // 오른쪽 h 높이에서 막대기를 던져 미네랄을 부숨.

		for (int col = c - 1; col >= 0; col--) {
			if (map[h][col] == 'x') {
				map[h][col] = '.';
				return;
			}
		}

	}

}

void solve() {

	bool flag = true; 
	for (int i = 0; i < n; i++) {
		// 왼쪽에서 던지고, 오른쪽에서 던지고 반복.
		breakMineral(flag, stick[i]); 

		if (flag) flag = false; // flag는 왼쪽, 오른쪽을 표현한다.
		else flag = true;

		fallMineral(); // 미네랄을 떨어뜨린다. 
	}


	for (int i = 0; i < r; i++) { // 결과 출력.
		for (int j = 0; j < c; j++) {
			cout << map[i][j];
		}
		cout << endl;
	}

}

int main() {

	cin >> r >> c; // map 정보 입력.
	for (int i = 0; i < r; i++) { 
		for (int j = 0; j < c; j++) {
			cin >> map[i][j];
		}
	}

	cin >> n; // 막대기 투척 정보 입력.
	for (int i = 0; i < n; i++) {
		cin >> stick[i];
	}

	solve();
	return 0;
}

✔️ 문제 회고

◾ bfs/dfs을 활용한 시뮬레이션 문제였다.

◾ 클러스터에 중력을 작용하는 부분을 구현할때 쉽지 않았다.

◾ 떨어뜨려야할 클러스터의 좌표를 vector에 저장해두고, 떨어뜨리는 방식을 적용했다.

◾ 구현력이 아직 많이 부족하다고 느낀 문제였다.

[Computer Network] Web Cache

jujube bat — Mon, 1 Jun 2020 12:50:50 +0900

Web cache

◾ Web Cache는 HTML, JS, CSS, Image 등 Client가 최근에 Request한 자원의 복사본을 Caching(임시 저장) 한다.

◾ User가 자원을 요청 하면 먼저 Web Cache에 해당 자원이 있는지 확인하고 있다면, 자원을 곧장 받는다.

◾ Web Cache를 사용하면, Client 요구에 대한 응답시간을 줄일 수 있고, 트래픽을 줄일 수 있다.

◾ Local DNS는 Web Cache 다. Client가 최근에 호출한 호스트네임에 대한 IP 주소를 Caching 한다.

Web cache 종류

1️⃣ Browser Caches

◾ Client의 Browser에서 최근 요청한 자원을 Caching 한다.

2️⃣ Proxy Server

◾ Proxy Server는 Client와 Server 사이의 중계 Server 이다.

◾ Proxy Server는 최근 Request 된 자원을 Caching 한다.

더 알아보기

생활코딩 Cahing : https://opentutorials.org/course/697/3839