KiTFOx's Notepad 📝

문제

1은 이동할 수 있는 칸, 0은 이동할 수 없는 칸을 나타낸다.

(1,1)에서 출발하여 (N,M)의 위치로 이동할 때 지나야 하는 최소 칸의 수를 구하는 프로그램 작성하시오.

입력 1

4 6
101111
101010
101011
111011

출력 1

15

코드

#include<iostream>
#include<queue>
#include<algorithm>
#define MAX 101

using namespace std;

int MAP[MAX][MAX];
int visited[MAX][MAX];
int dist[MAX][MAX];
int arrow[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };
int N, M;
pair<int, int> startP, endP;

queue < pair<int, int>> Q;

void BFS() {
    
    Q.push(make_pair(startP.first, startP.second));

    dist[startP.first][startP.second]++;
    visited[startP.first][startP.second] = 1;

    while (!Q.empty()) {
        int y = Q.front().first;
        int x = Q.front().second;
        Q.pop();
        //좌우위아래 탐색
        for (int i = 0; i < 4; i++) {
            int ny = y + arrow[i][0];
            int nx = x + arrow[i][1];


            if ((nx >= 0 &&nx < M) && (ny >= 0 && ny < N)
                && MAP[ny][nx] == 1 &&!visited[ny][nx]) {
                visited[ny][nx] = 1;
                Q.push(make_pair(ny, nx));
                dist[ny][nx] = dist[y][x] + 1;
            }
        }
    }
    cout << dist[endP.first-1][endP.second-1];
}


void input() {
    string num;
    for (int i = 0; i < N; i++) {
        cin >> num;
        for (int j = 0; j < M; j++) {
            MAP[i][j] = num[j]-'0';
        }
    }
}

int main() {

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

    int tmp;
    cin >> N>>M;
    startP = make_pair(0, 0);
    endP = make_pair(N, M);
    
    input();
    BFS();

    return 0;
}

*간단한 해설*

저 input 함수에서 cin을 통해 MAP을 받아옵니다.

주의할 점은 한 줄당 붙어있는 상태로 받아와서 cin으로 받은 다음 끊어서 저장해주어야합니다.

void input() {
    string num;
    for (int i = 0; i < N; i++) {
        cin >> num;
        for (int j = 0; j < M; j++) {
            MAP[i][j] = num[j]-'0';
        }
    }
}

string으로 받은 다음 string에서 인자로 접근해주면 char 형이여서 char형을 int로 바꾸려면 '0'의 숫자를 빼주면 됩니다.

그런다음 BFS 탐색을 통해 최단 경로를 찾아주면 되는데 BOJ 6087번 레이저 통신과 문제가 매우 흡사합니다.

https://dana3711.tistory.com/90

다만 다른점은 목표 지점까지 가는데 걸리는 비용을 출력해야한다는 점입니다. 따라서

if ((nx >= 0 &&nx < M) && (ny >= 0 && ny < N)&& MAP[ny][nx] == 1 &&!visited[ny][nx]) 
{
    visited[ny][nx] = 1;
    Q.push(make_pair(ny, nx));
    dist[ny][nx] = dist[y][x] + 1;
}

4방향 탐색을 할때 만약 맵 안에 있고((nx >= 0 &&nx < M) && (ny >= 0 && ny < N)), 그 칸이 이동할 수 있는 칸이라면(MAP[ny][nx] == 1) 해당 칸을 방문하지 않았을 때

해당 칸으로 자리를 이동하고 가는 비용을 +1 해줍니다.

*이 방법만이 맞는 정답은 아닙니다.

훨씬 좋고 빠른 다른 알고리즘을 구현할 수 있습니다.

알고리즘 공부하시는 분들 화이팅! '0'/*

문제

거울을 설치하면 방향을 90도 회전시킬 수 있다.

*은 벽으로 뚫고 지나갈 수 없다.

거울을 최소로 설치하여서 처음 시작지점 C에서 끝지점 C에 도달할때까지 가야한다.

최소로 설치할 수 있는 거울 수를 출력하라

입력 1

7 8
.......
......C
......*
*****.*
....*..
....*..
.C..*..
.......

출력 1

3

코드

#include<iostream>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>

using namespace std;

//6087번 레이저 통신

char MAP[101][101];
int visited[101][101];
int w, h;
int arrow[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };

pair<int, int> startP, endP;
queue<pair<int,int>> cntDir;
queue < pair<int, int>> Q;
void BFS() {
    for (int i = 0; i < 4; i++) {
        Q.push(make_pair(startP.first, startP.second));
        cntDir.push(make_pair(0, i));
    }
    visited[startP.first][startP.second] = 0;

    while (Q.empty() == 0) {
        int y = Q.front().first;
        int x = Q.front().second;
        int cnt = cntDir.front().first;
        int dir = cntDir.front().second;
        Q.pop();
        cntDir.pop();
        //좌우위아래 탐색
        for (int i = 0; i < 4; i++) {
            int ny = y + arrow[i][0];
            int nx = x + arrow[i][1];
            int nCnt = cnt;

            if (nx <0 || nx >= w || ny < 0 || ny >=h) continue;
            if (MAP[ny][nx] == '*') continue;
            if (dir != i) nCnt++;
            if (visited[ny][nx] >= nCnt) {
                visited[ny][nx] = nCnt;
                Q.push(make_pair(ny, nx));
                cntDir.push(make_pair(nCnt, i));
            }
        }
    }
    cout << visited[endP.first][endP.second];
}

void input() {
    bool isFirst = true;
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            cin >> MAP[i][j];
            if (MAP[i][j] == 'C') {
                (isFirst) ? startP = make_pair(i, j) : endP = make_pair(i, j);
                isFirst = false;
            }
            visited[i][j] = 10001;
        }
    }
}

int main() {

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

    cin >> w >> h;
    
    input();
    BFS();


    return 0;
}

*간단한 해설*

void input() {
    bool isFirst = true;
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            cin >> MAP[i][j];
            if (MAP[i][j] == 'C') {
                (isFirst) ? startP = make_pair(i, j) : endP = make_pair(i, j);
                isFirst = false;
            }
            visited[i][j] = 10001;
        }
    }
}

먼저 input 함수에서 cin을 통해 MAP을 받아옵니다.

그 중 만약 C가 입력되었다면 처음인지 아닌지를 판단해서 처음이라면 startP에 해당 위치를 넣고, 처음이 아니라면 endP에 해당 위치를 넣는다.

void BFS() {
    for (int i = 0; i < 4; i++) {
        Q.push(make_pair(startP.first, startP.second));
        cntDir.push(make_pair(0, i));
    }
    visited[startP.first][startP.second] = 0;

    while (Q.empty() == 0) {
        int y = Q.front().first;
        int x = Q.front().second;
        int cnt = cntDir.front().first;
        int dir = cntDir.front().second;
        Q.pop();
        cntDir.pop();
        //좌우위아래 탐색
        for (int i = 0; i < 4; i++) {
            int ny = y + arrow[i][0];
            int nx = x + arrow[i][1];
            int nCnt = cnt;

            if (nx <0 || nx >= w || ny < 0 || ny >=h) continue;
            if (MAP[ny][nx] == '*') continue;
            if (dir != i) nCnt++;
            if (visited[ny][nx] >= nCnt) {
                visited[ny][nx] = nCnt;
                Q.push(make_pair(ny, nx));
                cntDir.push(make_pair(nCnt, i));
            }
        }
    }
    cout << visited[endP.first][endP.second];
}

탐색을 시작할 위치인 startP의 위치를 4번 Q에 옮겨담습니다. 시작 위치에서 위,아래,왼쪽,오른쪽 방향을 탐색하는 방향을 저장해줍니다. 방향이 다르다면 거울의 갯수를 더해줘야하기 때문입니다. 

그 다음 Q가 빌때까지 while문을 돌립니다. Q의 첫번째 인자를 변수에 담고 좌우위아래 탐색을 시작합니다. 탐색에서 *인 벽을 만나거나 맵을 벗어나면 탐색을 건너뛰고, 만약 가던 방향과 현재 방향이 맞지 않다면 거울을 더해줍니다. 현재 방문한 위치에서의 거울을 사용한 갯수를 visited[][] 배열에 저장하기에 만약 사용한 갯수가 현재 카운트보다 높다면 최소로 사용해야하기때문에 변경해줍니다. 이것을 끝지점에 도달할때까지 계속 반복하여서 visited[끝지점.y][끝지점.x] 의 값을 출력하면 답이 됩니다.

*이 방법만이 맞는 정답은 아닙니다.

훨씬 좋고 빠른 다른 알고리즘을 구현할 수 있습니다.

알고리즘 공부하시는 분들 화이팅! '0'/*

문제

첫째 줄에 n이 주어진다. n은 1,000,000,000,000,000,000보다 작거나 같은 자연수이다.

입력 1

1000

출력 1

228875

코드

#include<iostream>
#include<cmath>

using namespace std;

//2749번 피보나치 수 3
//피사노 주기를 이용

long long arr[1500050];     //메모이제이션
int m = 1000000;            //나누는 수
int cycle;

int cycle_func() {
    int k=0,tmp=m;
    while (tmp > 1) {
        tmp /= 10;
        k++;
    }

    return 15 * pow(10, k - 1);
}

void pisano_fibo() {
    arr[0] = 0;
    arr[1] = 1;
    //파사노 주기에 의하여 1500000의 값들이 반복된 후에 다시 재 반복됨
    cycle = cycle_func();
    for (int i = 0; i < cycle; i++) {
        arr[i + 2] = (arr[i+1]+arr[i])%m;
    }
}

int main() {

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

    long long n;
    cin >> n;
    pisano_fibo();
    cout << arr[n % cycle];

    return 0;
}

*간단한 해설*

피사노 주기를 이용하여 푸는 문제이다 기본적으로 n의 범위가 1,000,000,000,000,000,000보다 작거나 같은 자연수 이기 때문에 기존에 쓰던 재귀함수를 이용하여서 푸는 방법은 시간이 매우 오래 걸리므로 쓸수가 없다. 따라서 피사노 주기를 통해 반복 주기를 찾고 그 주기동안의 피보나치 수열에서 m으로 나눈 나머지 값들을 배열에 저장한다. 그 후 저장한 배열에서 찾고자 하는 n번째가 주기에서 몇번째 숫자인지 찾아내서 해당 배열의 값을 출력하면 된다. 피사노 주기는

나누는 값을 M이라고 지칭했을 때,

M=10^k , cycle = 15 x 10^(k-1)

이다.

*이 방법만이 맞는 정답은 아닙니다.

훨씬 좋고 빠른 다른 알고리즘을 구현할 수 있습니다.

알고리즘 공부하시는 분들 화이팅! '0'/*

문제

두 다각형이 주어졌을 때, 두 다각형의 민코프스키 합을 구하는 프로그램을 작성하시오. 만약 민코프스키 합이 여러 개의 다각형으로 이루어진다면 다음의 우선순위에 따라 하나의 다각형만을 구하도록 한다. 번호가 작은 것이 우선순위가 높은 것이다.

입력 1

3 3
0 0
1 0
1 1
0 1
0 0
1 0

출력 1

5
0 0
2 0
2 1
1 2
0 1

코드

#include<iostream>
#include<algorithm>
#include<vector>
#define x first
#define y second
using namespace std;

//2244번 민코프스키 합
//Convex Hull(CCW(Counter Clock Wise)) 사용

typedef pair<long long, long long> Point2f;
Point2f a[1010];
Point2f b[1010];

//counter clock wise : 좌회전하는지 판단
//벡터 AB와 벡터 AC의 CW/CCW
// 0보다 크면 반시계방향으로 도는 것, 0보다 작으면 시계방향으로 도는 것
//int에 1LL을 곱해주면 long long으로 형변환을 쉽게 할 수 있음
int ccw(Point2f a, Point2f b, Point2f c) {
    long long res = a.x * b.y + b.x * c.y + c.x * a.y;
    res -= b.x * a.y + c.x * b.y + a.x * c.y;
    if (res > 0) return 1;          //시계 반대방향
    if (res) return -1;             //시계 방향
    return 0;                           //평면상
}

long long dist(Point2f a, Point2f b) {
    long long dx = 1LL*a.x - b.x;
    long long dy = 1LL * a.y - b.y;
    return dx * dx + dy * dy;
}

int main() {

    vector<Point2f> arr;
    int aNum, bNum;
    int xTmp, yTmp;
    int pIdx = 0;
    cin >> aNum >> bNum;
    pIdx = aNum * bNum;
    for (int i = 0; i < aNum; i++) {
        cin >> xTmp >> yTmp;
        a[i].x = xTmp; a[i].y = yTmp;
    }
    for (int i = 0; i < bNum; i++) {
        cin >> xTmp >> yTmp;
        b[i].x = xTmp; b[i].y = yTmp;
    }
    //모든 가능성이 있는 점들 vector 제작
    for (int i = 0; i < aNum; i++) {
        for (int j = 0; j < bNum; j++) {
            arr.push_back(Point2f{ a[i].x + b[j].x,a[i].y + b[j].y });
        }
    }

    //arr의 최소 값을 찾아서 0번 자리와 바꿈(0번을 제일 작은 값으로 설정)
    swap(arr[0], *min_element(arr.begin(), arr.end()));
    //0번을 제외한 점들을 반시계 방향으로 정렬
    //[&]{}는 람다식으로써 해당 함수에따라서 sort를 할지 말지 결정함
    sort(arr.begin() + 1, arr.end(), [&](Point2f& a, Point2f& b) {
        int cw = ccw(arr[0], a, b);
        //cw가 0 이상이면 반시계 방향이고 true를 반환 0이면 false 반환, cw가 -1인 경우(시계 방향) if문을 들어오지 않음
        if (cw) return cw > 0;          
        return dist(arr[0], a) < dist(arr[0], b); //cw가 -1인 경우 기준점 arr[0]에서의 거리순으로 정렬
        });

    vector<Point2f> hull;
    for (int i = 0; i < arr.size();i++) {
        while (hull.size() >= 2 && ccw(hull[hull.size() - 2], hull.back(), arr[i]) <= 0) {
            hull.pop_back();
        }
        hull.push_back(arr[i]);
    }
    cout << hull.size() << "\n";
    for (int i = 0; i < hull.size(); i++) {
        cout << hull[i].x << " " << hull[i].y << "\n";
    }

    return 0;
}

*간단한 해설*

convex hull로 구현하면 되는 문제이다.

convex hull은 주어진 점에서 외곽선을 이루는 점들을 찾는 알고리즘인데 민코프스키의 합 또한 공간의 합을 계산하는 것이기 때문에 convex hull 알고리즘을 사용하여 구현하면 된다.

코드의 핵심적인 부분은 https://justicehui.github.io/ioi/2019/05/21/BOJ2244/ 에서 따왔다.

몇가지 람다식이라던지 auto와 같은 것들이 나에게 어려워서 for문으로 바꾸거나 주석을 달아서 진행해보았다. 기존의 다른곳에서 찾아서 convex hull을 구현해서 넣어보았는데 예제를 넣어보았을 때는 출력 결과가 잘나왔었다. 하지만 백준에서 테스트 할때마다 

이러한 런타임 에러나 출력 초과가 나와서 뭐가 문제인지 몰라서 다른 분 블로그를 보고 참고해서 해보았는데 아마 sorting하는 과정에서 에러가 난게 아닐까 싶다..

convex hull 알고리즘에 대한 글은 https://kbw1101.tistory.com/50 여기 블로그에 아주 친절하게 설명되어 있다.

*이 방법만이 맞는 정답은 아닙니다.

훨씬 좋고 빠른 다른 알고리즘을 구현할 수 있습니다.

알고리즘 공부하시는 분들 화이팅! '0'/*

문제

동굴에 있는 미네랄의 모양과 두 사람이 던진 막대의 높이가 주어진다. 모든 막대를 던지고 난 이후에 미네랄 모양을 구하는 프로그램을 작성하시오.

입력 1

5 6
. . . . . .
. . X X . .
. . X . . .
. X X X X .
1
3

출력 1

. . . . . .
. . . . . .
. . X X . .
. . X X . .
. X X X X .

코드

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#define y first
#define x second
using namespace std;

//2933번 미네랄

//2차원 배열 선언
char arr[101][101];
int visited[101][101];      //dfs를 위한 방문 배열
int R, C;
vector<pair<int,int>> cluster;
int arrow[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };

void DFS(int yIdx, int xIdx) {
    if (arr[yIdx][xIdx] == '.' || visited[yIdx][xIdx]) return;
    visited[yIdx][xIdx] = true;
    cluster.push_back({yIdx,xIdx});
    //좌우위아래 탐색
    for (int i = 0; i < 4; i++) {
        int ny = yIdx + arrow[i][0];
        int nx = xIdx + arrow[i][1];    
        if (nx >= 0 && nx < C && ny >= 0 && ny < R)
            DFS(ny, nx);
    }
}

void checkCluster() {
    memset(visited, 0, sizeof(visited));
    for (int a = 0; a < R; a++) {
        for (int b = 0; b < C; b++) {
            if (arr[a][b] == '.' || visited[a][b]) continue;
            cluster.clear();
            DFS(a,b);
            vector<int> low(C, -1);     //vector(컨테이너 크기, 각각 할당될 값)
            for (int z = 0; z < cluster.size(); z++) {
                pair<int, int> p= cluster[z];
                low[p.x] = max(low[p.x], p.y);
                arr[p.y][p.x] = '.';
            }

            //얼마나 밑으로 옮길지 i에 넣기
            int lowmove = R;
            for (int i, j = 0; j < C; j++) {
                if (low[j] == -1) continue;
                i = low[j];

                //'.'이 아닌경우, 탐색 높이가 높이보다 작은 경우
                while (i < R &&arr[i][j] == '.') {
                    i++;
                }
                lowmove = min(lowmove, i - low[j] - 1);
            }

            for (int i = 0; i < cluster.size(); i++) {
                pair<int, int> p = cluster[i];
                p.y += lowmove;
                arr[p.y][p.x] = 'x';
                visited[p.y][p.x] = true;
            }
        }
    }
    
}

void shoot(int orderNum,int height) {
    //왼쪽인지 오른쪽인지 판단
    height = R - height;
    if (orderNum % 2 == 0) {
        for (int i = 0; i < C; i++) {
            if (arr[height][i] == 'x') {
                arr[height][i] = '.';
                break;
            }
        }
    }
    else {
        for (int i = C-1; i >= 0; i--) {
            if (arr[height][i] == 'x') {
                arr[height][i] = '.';
                break;
            }
        }
    }
    
    checkCluster();
}

int main() {
    
    cin.tie(NULL);
    cout.tie(NULL);
    ios::sync_with_stdio(false);


    cin >> R >> C;

    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            cin >> arr[i][j];
        }
    }
    int N,height=0;
    cin >> N;
    for (int i = 0; i < N; i++) {
        cin >> height;
        shoot(i, height);
    }

    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            cout << arr[i][j];
        }
        cout << "\n";
    }

    return 0;
}

*간단한 해설*

checkCluster() 함수 부분은 https://100100e.tistory.com/152 이 블로그 분의 글을 참고하여서 제작하였다. 제일 나랑 생각이 비슷하기도 했고 알기 쉽게 작성되어있어서 좋았다. checkCluster() 부분을 자세하게 설명해볼까 싶다.

 memset(visited, 0, sizeof(visited));
    for (int a = 0; a < R; a++) {
        for (int b = 0; b < C; b++) {

checkCluster는 부메랑을 던진 후에 떨어지는 클러스터들을 판단하기 위한 함수로써 실행된다. 따라서 DFS를 다시 사용하려면 visited 배열을 초기화 시켜줘야한다. 그를 위해 memset 함수를 이용하였다. 나머지 for문은 R x C 크기의 맵을 for문을 통해 돌린다.

if (arr[a][b] == '.' || visited[a][b]) continue;
cluster.clear();
DFS(a,b);

그 다음에는 해당 맵의 칸이 . 으로 비어있는 칸이거나 이미 방문한 배열일 경우 그대로 밑의 계산을 하지 않고 넘어간다. 그렇지 않은 경우 DFS 함수를 통해서 해당 클러스터를 기준으로 좌우위아래를 탐색해서 cluster 벡터에 넣는다.

vector<int> low(C, -1);     //vector(컨테이너 크기, 각각 할당될 값)
for (int z = 0; z < cluster.size(); z++) {
    pair<int, int> p= cluster[z];
    low[p.x] = max(low[p.x], p.y);
    arr[p.y][p.x] = '.';
}

그 후에  low 라는 땅에 가장 가까운 클러스터를 저장하는 벡터 배열을 선언한다. low(C,-1) 이렇게 선언하면 C 크기 만큼을 -1의 값으로 할당한다는 말이다. 그 다음 for문을 통해서 저장된 cluster만큼 돌려주고 만약 해당 클러스터의 높이 값인 p.y 값이 만약에 기존에 저장된 높이 값인 low[p.x]와 비교했을 때 큰 값을 low[p.x]에 저장해준다. 저장한 다음에는 해당 값은 나중에 다시 떨어진 클러스터 값으로 변경해줄 것임으로 미리 .으로 변경 시켜준다.

int lowmove = R;
for (int i, j = 0; j < C; j++) {
    if (low[j] == -1) continue;
    i = low[j];

    //'.'이 아닌경우, 탐색 높이가 높이보다 작은 경우
    while (i < R &&arr[i][j] == '.') {
        i++;
    }
    lowmove = min(lowmove, i - low[j] - 1);
}

얼만큼 밑으로 옮길지 계산하는 부분이다. lowmove 변수에는 가장 많이 내려갈 수 있는 값 높이 R값을 넣은 다음 비교해가면서 작으면 변경하는 형식이다. if(low[j]==-1) continue; 의 경우 땅에 가장 가까운 클러스터가 없는 경우에는 연산을 하지 않고 넘어간다. 그렇지 않을 경우 i = low[j];로 땅에 가장 가까운 클러스터의 높이를 넣는다. 그 후 while문을 통해서 만약 해당 좌표의 클러스터가 빈공간인 경우 내려가야할 칸의 값인 i를 ++해준다. 해당 while문이 긑나고 나면 min 함수를 통해 기존의 lowmove 값과 i-low[j]-1을 비교한다. arr[i][j]의 경우 아까 위에서 .으로 만들어놓았기 때문에 한개가 더 세어진다. 따라서 내려가야할 칸의 수 i 에서 -1을 한 다음 기존 높이인 low[j]를 빼주면 내려가야할 칸의 갯수가 나온다.

for (int i = 0; i < cluster.size(); i++) {
                pair<int, int> p = cluster[i];
                p.y += lowmove;
                arr[p.y][p.x] = 'x';
                visited[p.y][p.x] = true;
}

마지막으로 클러스터의 갯수 만큼 for문을 돌려서 lowmove 만큼 모든 클러스터를 옮겨준다.

*이 방법만이 맞는 정답은 아닙니다.

훨씬 좋고 빠른 다른 알고리즘을 구현할 수 있습니다.

알고리즘 공부하시는 분들 화이팅! '0'/*

문제

백준이는 동생에게 "가운데를 말해요" 게임을 가르쳐주고 있다. 백준이가 정수를 하나씩 외칠때마다 동생은 지금까지 백준이가 말한 수 중에서 중간값을 말해야 한다. 만약, 그동안 백준이가 외친 수의 개수가 짝수개라면 중간에 있는 두 수 중에서 작은 수를 말해야 한다.

예를 들어 백준이가 동생에게 1, 5, 2, 10, -99, 7, 5를 순서대로 외쳤다고 하면, 동생은 1, 1, 2, 2, 2, 2, 5를 차례대로 말해야 한다. 백준이가 외치는 수가 주어졌을 때, 동생이 말해야 하는 수를 구하는 프로그램을 작성하시오.

입력 1

7
1
5
2
10
-99
7
5

출력 1

1
1
2
2
2
2
5

코드

#include<iostream>
#include<queue>
#include<vector>

using namespace std;

//1655번 가운데를 말해요
//최소힙, 최대힙 사용
int main() {
    
    cin.tie(NULL);
    cout.tie(NULL);

    int N,temp;
    priority_queue<int> max;        //최대힙       우선순위 큐는 default로 less<in>를 사용
    priority_queue<int,vector<int>,greater<int>> min;       //최소힙
    cin >> N;
    for (int i = 0; i < N; i++) {
        cin >> temp;

        (max.size() == min.size()) ? max.push(temp) : min.push(temp);

        if (!max.empty() && !min.empty()&& max.top() > min.top()) {
            //중간 값의 순서가 달라진다면 값 바꾸기
            int maxVal, minVal;
            maxVal = max.top();
            minVal = min.top();
            max.pop();
            min.pop();
            max.push(minVal);
            min.push(maxVal);
        }

        cout << max.top()<<"\n";
    }
    
    return 0;
}

*간단한 해설*

여러가지 알고리즘 중에서 무엇을 왜 쓰는지가 핵심인데 여기서는 최소힙, 최대힙을 사용한다.

그 이유는 힙은 여러개의 값 중 최댓값 또는 최솟값을 찾아내는 연산이 빠르기 때문에 여기서 사용하면 빠른 연산이 가능하다.

힙은 일반적으로 완전 이진트리이므로 배열을 이용하여 구현한다.

최대 힙은 루트 노드로 올라갈수록 저장된 값이 커지는 구조이다. 

최소 힙은 루트 노드로 올라갈수록 값이 작아지는 구조이다.

이 문제의 경우 배열을 반틈으로 나누어서 한쪽은 최소 힙, 한쪽은 최대 힙을 사용하여 빠르게 연산하는 문제이다. 이 경우 priority_queue를 이용하여 구현할 수 있다. priority_queue는 힙을 이용하여 구현되어 있고 옵션을 이용하여 greater<int> 및 less<int>를 이용하여 위와같은 최소힙, 최대힙 구조를 만들 수 있다. 따라서 이를 통해서 중간값을 찾는 것이라 반틈을 나누어서 오름차순, 내림차순으로 정렬되는 최소힙, 최대힙을 이용하면 빠르게 통과하는 코드를 만들 수 있다.

*이 방법만이 맞는 정답은 아닙니다.

훨씬 좋고 빠른 다른 알고리즘을 구현할 수 있습니다.

알고리즘 공부하시는 분들 화이팅! '0'/*