KiTFOx's Notepad 📝

문제

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

예를 들어 백준이가 동생에게 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'/*

문제

1. 먼저 뱀은 몸길이를 늘려 머리를 다음칸에 위치시킨다.
2. 만약 이동한 칸에 사과가 있다면, 그 칸에 있던 사과가 없어지고 꼬리는 움직이지 않는다.
3. 만약 이동한 칸에 사과가 없다면, 몸길이를 줄여서 꼬리가 위치한 칸을 비워준다. 즉, 몸길이는 변하지 않는다.

사과의 위치와 뱀의 이동경로가 주어질 때 이 게임이 몇 초에 끝나는지 계산하라.

*처음 봤을때 턴에 관한 개념이 잘 생성되지 않았는데 턴은 무조건 한번만 실행되는 시스템이다.

입력 1

6
3
3 4
2 5
5 3
3
3 D
15 L
17 D

출력 1

9

입력 2

10
4
1 2
1 3
1 4
1 5
4
8 D
10 D
11 D
13 L

출력 2

21

입력 3

10
5
1 5
1 3
1 2
1 6
1 7
4
8 D
10 D
11 D
13 L

출력 3

13

코드

#include<iostream>
//#include<Windows.h>
#include<deque>
#include<vector>

using namespace std;

int main() {
    
    int N, K,L;     //N : 보드의 크기, K : 다음 줄에 사과의 개수, L : 뱀의 방향 변환 횟수
    int column, row;
    int currentX=0, currentY=0;
    int arrIdx = 0, turnIdx=0;          //arrIdx : 방향배열 인덱스, turnIdx : 방향 회전배열 인덱스
    int arrow[4][2] = { {1,0},              //오른쪽
                        {0,1},              //아래
                        {-1,0},             //왼쪽
                        {0,-1} };           //위
    deque<vector<int>> body;

    cin >> N;

    //해당 배열만큼 2차원 행렬 만들기
    int** board = new int* [N];
    for (int i = 0; i < N; i++) {
        board[i] = new int[N];
    }
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            board[i][j] = 0;
        }
    }

    board[0][0] = 1;
    vector<int> point;
    point.push_back(0);
    point.push_back(0);
    body.push_back(point);

    cin >> K;
    for (int i = 0; i < K; i++) {
        cin >> row >> column;
        board[row-1][column-1] = 2;
    }
    cin >> L;
    int* turn = new int[L];
    int* direction = new int[L];
    int lValue;
    char rValue;

    for (int i = 0; i < L; i++) {
        cin >> lValue >> rValue;
        turn[i] = lValue;
        direction[i] = rValue;
    }

    int time = 0;

    while (time < 10000) {
    
        /* {
            Sleep(1000);
            system("cls");

            cout << "Time :" << time+1 << endl;
            //출력해서 확인하기
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    cout << board[i][j] << " ";
                }
                printf("\n");
            }
        }*/
        
        if (time == turn[turnIdx] && time != 0) {
            if (direction[turnIdx] == 'D') {
                arrIdx++;
            }
            if (direction[turnIdx] == 'L') {
                arrIdx--;
            }
            turnIdx++;
        }


        if (arrIdx > 3)
            arrIdx = arrIdx % 4;
        if (arrIdx < 0) {
            arrIdx = 4 + arrIdx;
        }

        //오른쪽으로 이동하는 것
        currentX += arrow[arrIdx][0];
        currentY += arrow[arrIdx][1];
       
        if ((currentX < 0 || currentX >= N) ||(currentY < 0 || currentY >= N))
            break;
        if (board[currentY][currentX] == 1)
            break;

        if (board[currentY][currentX] == 2) {
            //만약 사과가 있다면
            point.clear();
            point.push_back(currentY);
            point.push_back(currentX);
            body.push_front(point);

            for (size_t i = 0; i < body.size(); i++) {
                board[body[i][0]][body[i][1]] = 1;
            }
        }
        else {
            //맨끝의 값의 자리를 0으로 바꿔주기
            board[body.back()[0]][body.back()[1]] = 0;
            //처음의 값을 뒤로 밀어주기

            for (size_t  i = body.size() - 1; i >0 ; i--) {
                int temp = body[i-1][0];
                body[i][0] = temp;
                temp = body[i-1][1];
                body[i][1] = temp;
            }

            //첫번째 머리움직이기
            body[0][0]= currentY;
            body[0][1]= currentX;

            for (size_t i = 0; i < body.size(); i++) {
                board[body[i][0]][body[i][1]] = 1;
            }
        }

        time++;
    }

    cout << time + 1;

    //할당 해제
    for (int i = 0; i < N; i++)
        delete[] board[i];

    return 0;
}

*간단한 해설*

턴에 관한 개념이 처음에 잡히지 않아서 반복적으로 생성되는 줄 알고 시간을 많이 사용했다.

    Sleep(1000);
    system("cls");

    cout << "Time :" << time+1 << endl;
    //출력해서 확인하기
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cout << board[i][j] << " ";
        }
        printf("\n");
    }

이부분의 주석처리를 빼면 어떻게 실행되는지 확인해볼 수 있다.

예제의 3개의 출력 과정은 아래와 같다.

0이 빈칸이고 1은 뱀, 2는 사과이다.

사실 여기까지 와서 예제를 넣어보았을 때 제출을 하니까 틀린것으로 나왔었다.

테스트 케이스를 여러개 해보지 않아서 그런데 반례 케이스를 모아놓은 사이트를 찾았다.

https://www.acmicpc.net/board/view/56469

나의 경우 맨 처음 반례 케이스의 5번째까지 통과를 하니 통과를 할 수 있었다.

다른 분의 알고리즘을 찾아보니 이분꺼가 깔끔하게 정리되어 있었다.

내 코드는 for문을 많이 쓰는데 for문을 많이 쓰지 않도록 생각하는 힘을 좀 더 길러야겠다.

https://velog.io/@nacean/%EB%B0%B1%EC%A4%803190-%EB%B1%80-C-%ED%92%80%EC%9D%B4

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

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

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

문제

1에서부터 6까지의 눈을 가진 3개의 주사위를 던져서 다음과 같은 규칙에 따라 상금을 받는 게임이 있다.

1. 같은 눈이 3개가 나오면 10,000원+(같은 눈)×1,000원의 상금을 받게 된다. 
2. 같은 눈이 2개만 나오는 경우에는 1,000원+(같은 눈)×100원의 상금을 받게 된다. 
3. 모두 다른 눈이 나오는 경우에는 (그 중 가장 큰 눈)×100원의 상금을 받게 된다.  

예를 들어, 3개의 눈 3, 3, 6이 주어지면 상금은 1,000+3×100으로 계산되어 1,300원을 받게 된다. 또 3개의 눈이 2, 2, 2로 주어지면 10,000+2×1,000 으로 계산되어 12,000원을 받게 된다. 3개의 눈이 6, 2, 5로 주어지면 그중 가장 큰 값이 6이므로 6×100으로 계산되어 600원을 상금으로 받게 된다.

3개 주사위의 나온 눈이 주어질 때, 상금을 계산하는 프로그램을 작성 하시오.

입력 1

3 3 6

출력 2

1300

입력 2

2 2 2

출력 2

12000

입력 3

6 2 5

출력 3

600

코드

#include<iostream>

using namespace std;

bool equals(int rValue,int lValue, int* outValue) {
    if (rValue == lValue) {
        *outValue = rValue;
        return true;
    }
    else
        return false;
}

int main() {
    
    int firstDice, secondDice, thirdDice;
    int value=0;
    cin >> firstDice >> secondDice >> thirdDice;
    
    if (firstDice == secondDice&& secondDice == thirdDice) {     //만약 세개가 같은 값이면
        cout << 10000 + firstDice * 1000;
    }
    else if (equals(firstDice,secondDice,&value)
        || equals(secondDice, thirdDice, &value)
        || equals(firstDice, thirdDice, &value)) {     //만약 두개가 같은 값이면
        cout<<1000+ value *100;
    }
    else {
        //그 중 가장 큰눈
        value = max(max(firstDice, secondDice), thirdDice);
        cout << value * 100;
    }

    return 0;
}

*간단한 해설*

단계별로 풀어보기에서 if문 주제로 추가 분류된 문제여서 풀어보았다.

말그대로 간단하게 if-else if-else문을 통하여 총 3가지로 분류하면 된다.

 if (firstDice == secondDice&& secondDice == thirdDice)

이부분은 첫번째 주사위와 두번째 주사위의 숫자가 같고 두번째 주사위와 세번째 주사위의 숫자가 같을때, 'A와 B가 같고 B와 C가 같으면 A와 C는 같다'라는 공리를 통해 두가지의 원리가 true값을 반환한다면 자연스럽게 세 가지의 값이 모두 같음을 의미한다.

bool equals(int rValue,int lValue, int* outValue) {
    if (rValue == lValue) {
        *outValue = rValue;
        return true;
    }
    else
        return false;
}

equals()함수의 경우 else if문 안에서 만약 두개가 같은 값이면 value에 그 값을 집어넣어서 출력할때 쓸수 있게끔 제작하였다. 그중 outValue만 포인터를 사용한 이유는 rValue와 lValue의 경우 얕은 복사를 통해 숫자값만 들고와서 비교하면 되지만 outValue의 경우 해당 값을 넣어줘야하기때문에 깊은 복사가 필요해서 포인터를 사용하였다.

else {
        //그 중 가장 큰눈
        value = max(max(firstDice, secondDice), thirdDice);
        cout << value * 100;
    }

마지막으로 세개의 값이 모두 다른 경우 max()함수를 통해 먼저 첫번째 수와 두번째 수의 크기를 비교하고, 그 다음 비교한 큰 값과 세번째 수의 값을 비교하여 제일 큰 수를 value에 넣어서 출력하도록 하였다.

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

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

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

문제

첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다. 어떤 두 정점 사이에 여러 개의 간선이 있을 수 있다. 입력으로 주어지는 간선은 양방향이다.

입력

4 5 1
1 2
1 3
1 4
2 4
3 4

출력

1 2 4 3
1 2 3 4

코드

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

// 1260번 DFS와 BFS

//깊이 우선 탐색
void dfs(vector<int> inputGraph[], bool *visited,int index) {
	visited[index] = true;		//방문했음을 표시
	cout << index<<" ";
	//dfs 탐색 순서
	int grphSize = inputGraph[index].size();
	for (int i = 0; i < grphSize; i++) {
		int connectIdx = inputGraph[index][i];
		if (!visited[connectIdx])
			dfs(inputGraph, visited, connectIdx);
	}
}

//너비 우선 탐색
void bfs(vector<int> inputGraph[],bool *visited,int index) {
	queue<int> que;
	que.push(index);
	visited[index] = true;
	//bfs 탐색 순서
	while (!que.empty()) {
		int visitIdx = que.front();
		que.pop();
		cout << visitIdx<<" ";
		int grphSize = inputGraph[visitIdx].size();
		for (int i = 0; i < grphSize; i++) {
			//방문한 Idx와 연결된 원소들을 que에 넣기
			int connectIdx = inputGraph[visitIdx][i];
			if (!visited[connectIdx]) {		//만약 연결된 원소를 방문하지 않았다면
				que.push(connectIdx);		//방문할 노드로 선정
				visited[connectIdx] = true;
			}
		}
	}
	
	
}

int main() {

	int N, M, V;		//정점의 개수, 간선의 개수, 탐색을 시작할 정점의 번호

	cin >> N >> M >> V;

	int size = N + 1;
	//N개만큼의 배열 만들기
	bool* visited = new bool[size] {false, };			//방문 유무를 저장하는 배열
	vector<int>* graph = new vector<int>[size];
	graph->push_back(1);

	for (int i = 0; i < M; i++) {
		int origin, connect;
		cin >> origin >> connect;
		graph[origin].push_back(connect);
		graph[connect].push_back(origin);
	}

	//정렬
	for (int i = 0; i < size; i++) {
		sort(graph[i].begin(),graph[i].end());
	}

	dfs(graph,visited, V);
	cout << endl;
	visited = new bool[size]{ false, };		//방문유무를 다시 초기화해줌(재사용 위해)
	bfs(graph, visited,V);

	delete [] visited;		//메모리 해제 
	//vector 메모리 해제
	graph->clear();
	vector<int>().swap(*graph);

	return 0;
}

*간단한 해설*

DFS와 BFS를 구현하였다. DFS는 모든 노드를 탐색하도록 작성하였고, BFS는 연결된 노드를 통해서 해당 노드와 연결된 노드 중 방문하지 않은 노드만 다시 탐색해서 탐색이 끝나면 종료되도록 작성하였다. DFS와 BFS의 경우 

https://better-tomorrow.tistory.com/entry/DFS-BFS-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0

해당 포스팅을 통해 자세하게 배울 수 있었다. DFS와 BFS에 대해 알고싶으면 위의 블로그를 참조하면 좋을듯하다.

for (int i = 0; i < M; i++) {
    int origin, connect;
    cin >> origin >> connect;
    graph[origin].push_back(connect);
    graph[connect].push_back(origin);
}

연결된 노드들을 입력받는 과정에서 연결된 2개를 입력 받을시 서로 각자의 노드에 연결 정보를 입력시키도록 한다.

//정렬
for (int i = 0; i < size; i++) {
    sort(graph[i].begin(),graph[i].end());
}

입력시킨 정보들을 sort를 통해 정렬을 시켜준다. 정렬을 하지 않으면 원하는대로 결과값이 나오지 않기 때문에 정렬을 꼭 해준다.

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

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

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

문제

정수를 저장하는 큐를 구현한 다음, 입력으로 주어지는 명령을 처리하는 프로그램을 작성하시오.

명령은 총 여섯 가지이다.

• push X: 정수 X를 큐에 넣는 연산이다.
• pop: 큐에서 가장 앞에 있는 정수를 빼고, 그 수를 출력한다. 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력한다.
• size: 큐에 들어있는 정수의 개수를 출력한다.
• empty: 큐가 비어있으면 1, 아니면 0을 출력한다.
• front: 큐의 가장 앞에 있는 정수를 출력한다. 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력한다.
• back: 큐의 가장 뒤에 있는 정수를 출력한다. 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력한다.

입력

15
push 1
push 2
front
back
size
empty
pop
pop
pop
size
empty
pop
push 3
empty
front

출력

1
2
2
0
1
2
-1
0
1
-1
0
3

코드

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

// 10845번 큐

//큐 구현
class QueueS {
public:
	int front;
	int back;
	int size;
	int *values;		//모든 값들을 담은 배열을 가리키는 포인터

	//생성자
	QueueS() {
		size = 10001;		//큐의 사이즈 
		values = new int[size];
		front = 0;
		back=0;
	}
	//소멸자
	~QueueS() {
		delete[] values;
	}

	void push(int data) {
		if ((back+1)%size!=front) {
			values[back] = data;
			back = (back + 1) % size;
		}
	}

	void pop() {
		front = (front + 1) % size;
	}

	bool empty() {
		if (back == front)
			return true;
		else
			return false;
	}
};

QueueS st;

void getNumSize(string str) {
	int temp;

	if (str == "back") {
		if (st.back - st.front != 0) {
			cout << st.values[st.back - 1] << "\n";
		}
		else cout << "-1\n";
	}
	else if (str == "front") {
		if (st.back - st.front != 0) {
			cout << st.values[st.front] << "\n";
		}
		else cout << "-1\n";
	}
	else if (str == "size") {
		cout << st.back-st.front << "\n";
	}
	else if (str == "empty") {
		cout << ((st.back - st.front==0)?true:false) << "\n";
	}
	else if (str == "pop") {
		if (st.back - st.front!=0) {
			cout << st.values[st.front] << "\n";
			st.pop();
		}
		else {
			cout << "-1\n";
		}
	}
	else if (str == "push")
	{
		cin >> temp;
		st.push(temp);
	}
}

int main() {

	int n;
	string str;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> str;
		getNumSize(str);
	}

	return 0;
}

*간단한 해설*

큐를 클래스를 이용하여 구현하였다. 큐 클래스의 front,back은 일종의 맨 앞의 index 번호를 말하는 것이고, back은 맨 뒤의 index번호를 말하는 것이다. 그리고 int* values를 통해서 입력 받은 값들을 back을 늘려가면서 저장하였다.

C 구조체와 C++의 queue 라이브러리를 이용하여 구현하신 분도 있었다.

https://blockdmask.tistory.com/119

내 코드는 헤더를 추가하지 않는데 시간이 너무 길어서.. 블로그 글을 참고하다 보니 아무래도 cout문제도 있을 것 같아서 printf로 한번 다 바꿔보았다.

그렇게까지 영향을 준건 아닌가보다 싶어서 좀 더 찾아보니

https://coding-insider.tistory.com/entry/cin-cout-%EC%9E%85%EC%B6%9C%EB%A0%A5-%EC%86%8D%EB%8F%84-%EB%B9%A0%EB%A5%B4%EA%B2%8C%ED%95%98%EB%8A%94-%EB%B0%A9%EB%B2%95

cin의 속도가 생각보다 엄청 느리다는것! 

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

이 코드를 추가해주면 빨라진다고는 하나 scanf,printf와 같이 사용하면 안되고 싱글쓰레드 영역에서만 사용 가능해서 실제 코드 영역에서는 사용하는 것을 지양하라고 한다.

일단 싱글 쓰레드 영역이니 쟤들을 추가해서 한번 돌려보았다.

속도는 빨라졌지만 메모리는 늘어났다.. 그러면 scanf,printf로 다 바꿔보겠다.

결과적으로는 메모리도 줄어들었다. 아무래도 scanf,printf로 출력하는 방식으로 앞으로도 써야겠다.

코드(scanf,printf)

#include<iostream>
#include<string.h>
using namespace std;

// 10845번 큐
//큐 구현
class QueueS {
public:
	int front;
	int back;
	int size;
	int *values;		//모든 값들을 담은 배열을 가리키는 포인터

	//생성자
	QueueS() {
		size = 10001;		//큐의 사이즈 
		values = new int[size];
		front = 0;
		back = 0;
	}
	//소멸자
	~QueueS() {
		delete[] values;
	}

	void push(int data) {
		if ((back + 1) % size != front) {
			values[back] = data;
			back = (back + 1) % size;
		}
	}

	void pop() {
		front = (front + 1) % size;
	}

	bool empty() {
		if (back == front)
			return true;
		else
			return false;
	}
};

QueueS st;

void getNumSize(char str[]) {
	int temp;

	if (!strcmp(str, "back")) {
		if (st.back - st.front != 0) {
			printf("%d\n", st.values[st.back - 1]);
		}
		else printf("-1\n");
	}
	else if (!strcmp(str,"front")) {
		if (st.back - st.front != 0) {
			printf("%d\n", st.values[st.front]);
		}
		else printf("-1\n");
	}
	else if (!strcmp(str ,"size")) {
		printf("%d\n", st.back - st.front);
	}
	else if (!strcmp(str,"empty")) {
		printf("%d\n", ((st.back - st.front == 0) ? true : false));
	}
	else if (!strcmp(str, "pop")) {
		if (st.back - st.front != 0) {
			printf("%d\n", st.values[st.front]);
			st.pop();
		}
		else {
			printf("-1\n");
		}
	}
	else if (!strcmp(str,"push"))
	{
		scanf("%d", &temp);
		st.push(temp);
	}
}

int main() {

	int n;
	char str[6];
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%s", str);
		getNumSize(str);
	}

	return 0;
}

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

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

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

문제

알파벳 대소문자로 된 단어가 주어지면, 이 단어에서 가장 많이 사용된 알파벳이 무엇인지 알아내느 프로그램을 작성하시오. 대,소문자 구분 X

예제 입출력

입력

Mississipi

출력

?

코드

*간단한 해설*

알파벳갯수만큼의 배열을 만들어서 문자열을 체크하여 갯수만큼 저장한 후 45~56번 라인에서 제일 큰 알파벳을 뽑는다

나머지는 주석을 통해 설명해놓았다

이 코드보다 훨씬 빠른 방법이 있지 않을까 싶긴하다

*메모리*

2840KB

*시간*

36ms

*언어*

C++14

*코드길이*

1878B

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

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

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