[C++ 20] Study 001 - visual C++에서 모듈 임포트 (module import), 균일 초기화 (uniform initialization), std::numeric_limits 클래스 템플릿 기초

C++20부터 추가된 모듈 기능을 이용하기. visual C++를 사용한다. 모듈 import를 사용하기 위해 다음을 수행해야한다.

1. main.cpp 파일을 만들고 속성 페이지에 들어간다. Alt + p, p

2. "C/C++ --> 언어"에서 "C++ 언어 표준"을 "ISO C++ 20 표준(/std:c++20)"으로 바꾼다.

3. "실험용 C++ 표준 라이브러리 모듈 사용"을 "예(/experimental:module)"로 바꾼다.

4. "C/C++ --> 고급"으로 들어간다.

5. "컴파일 옵션"을 "C++ 모듈 내부 파티션으로 컴파일(/internalPartition)"으로 변경한다.

import <iostream>;
// 기존에는 include <iostream>
// 세미콜론을 끝에 붙여야 한다.

어떤 모듈을 사용하고 싶다면 import 문으로 불러온다. C++ 표준 라이브러리에서 제공하는 모든 기능은 모듈로 제공된다. 직접 모듈을 정의하는 것도 가능하다.

C 표준 라이브러리 헤더는 import로 불러오지 못할 수 있음. #include <abc.h>와 같이 작성한다.

용어정리

directive: 전처리기에 전달할 사항 표현. # 문자로 시작함.

초기화 시 기존 대입 문법 대신 균일 초기화(unifrom initalization)를 사용하는 것이 바람직하다.

// 기존 대입 문법 초기화
int initialized = 1;
// 균일 초기화 사용
int initialized_by_ui { 1 };
// long long 형의 경우 LL을 붙인다.
long long longlong_var { 135LL };
// unsigned 의 경우 U를 붙인다. ULL
unsigned long long ulonglong_var { 135ULL };
// bool 타입은 true나 false로 초기화
bool bool_var { true };
// 문자열이 아닌 바이트를 다루기 위해서는 
// 헷갈리지 않게 std::byte를 사용하면 좋다.
std::byte byte_var { 20 };

숫자 경곗값과 특별한 부동소수점수를 구할 때 std::numeric_limits 클래스 템플릿을 활용할 수 있다.

cout << numeric_limits<int>::max();
cout << numeric_limits<int>::min();
cout << numeric_limits<int>::lowest();

// 특별한 부동소수점수: NaN (Not a Number) 인지 
// 혹은 무한인지 알아내기
std::isnan();
std::isinf();
std::numeric_limits<double>::infinity

외워두면 좋은 간단한 연산자 우선순위. 위에 있을수록 더 높은 우선순위임을 뜻한다.

++ -- (사후 증가/감소)
! ++ -- (사전 증가/감소)
/ * %
+ -
// 다음 순서대로 비트 연산
// 비트 연산의 우선순위가 낮음을 인지할 것
<< >>
&
^
|
= += -= *= /= %= &= |=^= <<= >>=

[C++] Study - namespace, reference 기본

이름공간(namespace)

std: C++ 표준 라이브러리의 모든 함수, 객체 등이 정의된 namespace

중복된 이름을 가진 객체를 구분하기 위해 쓰임.

참조자(reference): 변수나 상수를 가리키는 포인터 이외의 방식

int a1 = 2;
int& a2 = a1;

a2 = 4;
// a1 값과 a2의 값은 4로 똑같다.

포인터와의 차이점: 정의 시에 누구의 참조인지 명시해야 함. 참조 대상은 변할 수 없음. 레퍼런스는 메모리 상에 존재하지 않을 수 있음.

int x;
int& y = x;
int& z = y;	// int& z = x; 와 동일
// y와 z는 모두 x의 참조자임.

예를 들어 cin은 레퍼런스로 값을 받아들인다.

상수도 레퍼런스를 가질 수 있지만 상수는 변하는 값이 아니기 때문에 const로 선언 시에만 레퍼런스를 가질 수 있다.

const int& ref = 5;

레퍼런스 배열은 존재할 수 없지만 배열의 레퍼런스는 가능하다.

// 다음은 불가능
// int& ref[2] = {arr1, arr2};
// 다음은 가능
int arr[2] = {1, 2};
int(&ref)[2] = arr;

ref[1] = 5;

생리학 공부(001)

취미로 생리학 공부를 시작하려한다. 용어가 워낙 익숙치 않아서 용어 정리를 하면서 글을 작성할 예정이다.

physiology at a galnce 를 보고 공부하려 한다.

1. Homeostasis (항상성) and the physiology of proteins

• The internal environment of body remained remarkably constant
• homeostasis (is Greek for 'staying the same'): the ability of physiological systems to maintain conditions within the body in a relatively constant state of equilibrium.
• Examples
• maintains H+ ion concentrations of body fluids within narrow limits
• blood glucose by the release of insulin
• body temperature
• heart rate and blood pressure
• Organ 내부에서 operate 하기도 하고 organ 간에 interaction 하여 이루어지기도 한다.
• 각 세포들이 항상성으로부터 이득을 얻으며, 각 세포들은 항상성 유지를 위해 공헌한다.
• 하나 이상의 functional systems이 lose their ability 하게 되기 전까지 continuity of life를 제공한다.

읽을 차례 15p Negative feedback control

hydrophobic 소수성의

hydrophilic 친수성의, 물을 잘 흡수하는

membrane 세포막

lipid 지질, 지방질

intricate 복잡한

reciprocal 상호간의

interplay 상호 작용

intracellular 세포 내의, 세포 간의

extracellular 세포 밖의

dysfunction 기능 장애

[코딩테스트] DFS, BFS 중 탐색 알고리즘 고르는 팁

아래 팁이 절대적인 기준은 아니다. 많은 문제를 풀어보면서 스스로 익히는 것이 최고이지만 시간이 부족하다면 팁이 필요할 것이다.

1. 탐색의 깊이(depth)가 깊다면 BFS일 가능성이 높다.

2. 위와 같은 이유로 2차원 맵이 크다면 BFS일 가능성이 높다.

3. 마찬가지로 탐색 가지(자식)수가 많아도 BFS일 가능성이 있다.

4. 반대로 깊이가 그리 깊지 않다면 DFS일 가능성이 있다 (대략 30이하 정도이려나요).

5. 이동이 제한적인 경우 DFS일 가능성이 있다. 예를 들어 sparse 한 2D array인 경우. 혹은 탐색 가지수(자식수)가 적은 경우.

6. 가지치기할 여지가 많다면 DFS일 가능성이 있다.

7. 2차원 배열에서 단순히 최소거리를 재는 것이라면 BFS로 하면 된다 (최소를 저장할 필요도 없다.).

8. 중복해서 visit해야하는 문제인 경우 DFS일 가능성이 있다.

본인은 PS 고수가 아니기 때문에 잘못된 내용일 수 있지만... 3개월 동안 전력을 다해 깨달은 결과입니다. 문제에서 탐색의 depth와 width를 고려하여 DFS와 BFS를 신중히 선택해야 합니다. 예를 들어, 경험상 2D array에서 단순 최소거리를 구하는 경우 BFS를 사용해야 합니다.

추가팁: DFS 문제 풀 시에 상태 원상복구를 항상 신경써야 합니다. 변하는 상태는 파라미터로 넘겨주는 것이 상책일 때가 있습니다.

[코딩테스트] 2차원 격자 DFS, BFS 문제 팁 (C++)

3개월 정도 코딩테스트를 준비하면서 얻은 팁을 공유하고자 한다. 2차원 격자(배열)에 대해 DFS, BFS로 문제를 풀 때 사용할 수 있는 팁을 써보겠다.

먼저 격자의 좌표를 나타낼 때에는 변수명으로 x,y 혹은 y,x 보다 r, c를 사용하는 것이 낫다. 개인차가 있을 것 같지만 y, x를 사용하면 직관적으로 행,열을 구분하는게 뇌에서 한 번 걸리는 느낌이 들었다. 하지만 row(행), column(열)의 앞문자인 r, c를 사용하니 한 번도 헷갈린 적이 없다. 특히 선형대수학을 이수했다면 r, c 표현이 익숙할 것이다.

//  	   c == 0 c == 1 c == 2 c == 3 ...
// r == 0
// r == 1
// r == 2
// r == 3
//  ...
#include <iostream>

using namespace std;

int MAP[100][100];
int N;

int main()
{
    cin >> N;
    for (int r = 0; r < N; r++) {
        for (int c = 0; c < N; c++) {
            cin >> MAP[r][c];
        }
    }
}

또 2차원 배열에서 상하좌우 이동 시에 다음 테크닉을 사용하면 코드가 간결해진다 (간결해질뿐 아니라 가독성도 올라간다.). dr과 dc 배열을 사용하여 상하좌우를 나타냈다. DFS() 내에서 for 문으로 4가지 경우를 순회하여 상하좌우를 나타낼 수 있다. 이렇게 dr, dc 배열을 사용하면 상하좌우 이동 뿐만아니라 대각선 이동이나 체스에서 knight의 이동 등의 더 복잡한 이동도 표현할 수 있다.

#include <iostream>

using namespace std;

int MAP[100][100];
bool visit[100][100];
int N;
bool arrival;

// dr, dc 배열을 이용하여 상하좌우 표현. 이 경우 정확히는 좌우상하이다.
// 문제에 따라 특정 방향으로 먼저 향해야 이득인 경우가 있다
// (pruning을 통해 DFS 탐색 횟수가 줄어드는 경우).
// 이 경우 해당 방향으로 먼저 이동하도록 dr, dc 배열의 값을 변경해야한다.
int dr[4] = { 0, 0, -1, 1 };
int dc[4] = { -1 ,1, 0, 0 };

void DFS(int r, int c);

int main()
{
    freopen("input.txt", "r", stdin);
    cin >> N;
    for (int r = 0; r < N; r++) {
        for (int c = 0; c < N; c++) {
            cin >> MAP[r][c];
        }
    }
    DFS(0, 0);	// (0, 0)에서 출발하는 문제

    return 0;
}

void DFS(int r, int c)
{
    if (arrival) return;
    
    if (r == N - 1 && c == N - 1) {
        cout << "N-1, N-1에 도달하였습니다.";
        arrival = true;
        return;
    }
    visit[r][c] = true;

    // 네 방향에 대해 탐색
    for (int d = 0; d < 4; d++) {
        int nextr = r + dr[d];
        int nextc = c + dc[d];

        if (nextr < 0 || nextr >= N || nextc < 0 || nextc >= N) {
            // 경계를 넘어서는 경우
            continue;
        }

        if (visit[nextr][nextc] == false)
            DFS(nextr, nextc);
    }
    visit[r][c] = false;
}

경계를 표시하는 다른 방법으로 특정 숫자로 배열을 감싸는 방법이 있다. 아래 코드에서 init()을 참고하자. 문제에 따라 이것이 더 효과적일 수 있을 듯 하다 (예를 들어 벽이 0, 길이 1인 경우, 0으로 배열을 감싸고 0을 만나면 더 진행하지 못하게 하면 된다.). 이 경우 배열의 1부터 N 엔트리까지 값을 입력받는다. 다만 MAP의 내용에 포함되는 숫자를 경계값으로 사용하지 않도록 주의하자.

#include <iostream>

using namespace std;

int MAP[102][102];
bool visit[102][102];
int N;
bool arrival;

int dr[4] = { 0, 0, -1, 1 };
int dc[4] = { -1 ,1, 0, 0 };

void DFS(int r, int c);
void init();

int main()
{
    freopen("input.txt", "r", stdin);
    cin >> N;
    for (int r = 1; r <= N; r++) {
        for (int c = 1; c <= N; c++) {
            cin >> MAP[r][c];
        }
    }

    init();

    DFS(1, 1);	// (0, 0)이 아닌 (1, 1)에서 출발한다.

    return 0;
}

void init()
{
    for (int i = 0; i <= N + 1; i++) {
        MAP[i][0] = 0;
        MAP[i][N + 1] = 0;
        MAP[0][i] = 0;
        MAP[N + 1][i] = 0;
    }
}

void DFS(int r, int c)
{
    if (arrival) return;

    if (r == N && c == N) {
        cout << "N, N에 도달하였습니다.";
        arrival = true;
        return;
    }

    visit[r][c] = true;

    // 네 방향에 대해 탐색
    for (int d = 0; d < 4; d++) {
        int nextr = r + dr[d];
        int nextc = c + dc[d];

        // MAP[][]이 0이 아닌지 확인한다. 경계를 일일이 검사할 필요가 없다.
        if (MAP[nextr][nextc] != 0 && visit[nextr][nextc] == false)
            DFS(nextr, nextc);
    }

    visit[r][c] = false;
}