달팽이 개발자 Blog

[C++] 개발환경 구축

2022-02-22T00:00:00+00:00

C++을 위한 개발환경 구축

개발환경 구축 개요

개발환경: VSCode
개발언어: C++
구축환경: Windows 10

VSCode 설치

첫번째로, VSCode를 설치한다.
공식 홈페이지에 접속하면 아래의 사진처럼 체크된 항목을 클릭하여 설치한다. VSCode의 장점은 Window, linux, Mac에 상관없이 개발환경을 지원한다. 그외에도 원하는 언어를 환경설정만 하면 사용할 수 있어 편리하다. 나는 C++과 Python을 함께 사용하기 위해 VSCode 환경을 구축했다.

컴파일러 설치

두번째는 컴파일러를 설치해야 한다.
링크에 접속하여 MinGW-W64 GCC-8.1.0 항목에 있는 x86_64-posix-seh를 다운로드한다. 64비트 컴파일러다. 만약 32비트 컴파일러가 필요할 경우 i686-posix-dwarf를 받으면 된다.

그리고 하기의 이미지처럼 압축을 풀어 C:\mingw64에 복사해줍니다.

환경변수 설정

컴파일러에 대한 환경변수를 설정해야한다. 환경변수에 들어가서 시스템 변수의 path에 새로 만들기를 클릭하여 아까 압축을 풀었던 C:\mingw64\bin의 경로를 써줍니다.

위의 설정이 잘 되었는지 확인하기 위해 CMD를 켜서 gcc -v가 되는지 확인한다. gcc -v 명령을 통해 버전이 나오면 환경변수 설정이 잘 된것이다.

VSCODE 내 C/C++ 언어 지원 설치

VSCode에서 C/C++을 제대로 사용하려면 C/C++ 확장을 설치해줘야 한다. 먼저 프로젝트를 하나 만들어서 .c파일을 생성한다. 파일을 생성하면 아래의 이미지처럼 C 설치 창이 뜨고, 마찬가지로 .cpp파일을 생성하면 아래의 이미지처럼 C++ 설치 창이 뜬다.

설치한 확장을 적용시키기 위해서는 VSCode를 종료시켰다가 다시 실행한다.

[JAVA]백준 11399 ATM

2021-02-01T00:00:00+00:00

JAVA로 풀이했습니다.
출처 : 백준 알고리즘 https://www.acmicpc.net

문제 개요

11399번 문제 👉 https://www.acmicpc.net/problem/11399
배열을 조합하여 각자의 시간을 최소로 하는 경우 찾기
난이도 👉 실버 3

풀이과정

배열을 조합하여 각자의 시간을 최소로 하려면 배열을 정렬시켜서 가장 걸리는 시간이 작은 사람부터 업무를 보게하면 된다.

나만의 방법

처음에 순열로 모든 경우의 수를 탐색하여 순서에 따른 값을 계산하려고 설계하였다. 결과는 시간복잡도 초과 그래서 다시 N의 범위를 확인하니 1000이었다. 나의 계산은 1000!만큼의 시간복잡도를 사용하였기 때문에 시간초과가 날수 밖에 없었다. 따라서 그리디라는 것을 인지하였고, 수학적으로 각자의 시간이 최소가 되는 경우를 생각해보니 정렬된 경우라는 것을 생각하여 문제를 해결할 수 있었다.

소스코드

public class baek_11399 {
	static int N, arr[];

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		st = new StringTokenizer(br.readLine());
		arr = new int[N];
		for (int i = 0; i < N; i++) {
			arr[i] = Integer.parseInt(st.nextToken());
		}
		Arrays.sort(arr);
		int sum = 0;
		int t = 0;
		for(int i=0;i<N;i++) {
			sum+=arr[i]+t;
			t+=arr[i];
		}
		System.out.println(sum);
	}

}

[JAVA]백준 11279 최대 힙

2021-01-27T00:00:00+00:00

JAVA로 풀이했습니다.
출처 : 백준 알고리즘 https://www.acmicpc.net

문제 개요

11279번 문제 👉 https://www.acmicpc.net/problem/11279
최대 힙 활용하는 프로그램 만들기
난이도 👉 실버 2

풀이과정

단순히 자료구조 중 최대 힙을 사용하는 문제입니다. 최대 힙에 대한 개념은 알지만, 사용법을 잘 몰라서 이번 기회에 공부했습니다.

나만의 방법

우선순위큐는 힙으로 구조되어 있으므로 우선순위큐를 활용하여 문제를 해결하였습니다. 또한, 기본적인 우선순위큐를 사용하면 최소 힙을 사용하기 때문에 최대 힙을 사용하도록 변경해주었습니다.

소스코드

public class baek_11279 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1);
		int N = Integer.parseInt(br.readLine());
		for (int i = 0; i < N; i++) {
			int now = Integer.parseInt(br.readLine());
			if (now == 0 && heap.isEmpty()) {
				System.out.println(0);
			} else if (now == 0) {
				System.out.println(heap.remove());
			} else {
				heap.add(now);
			}
		}
	}
}

[JAVA]백준 17144 미세먼지 안녕!

2021-01-26T00:00:00+00:00

JAVA로 풀이했습니다.
출처 : 백준 알고리즘 https://www.acmicpc.net

문제 개요

17144번 문제 👉 https://www.acmicpc.net/problem/17144
미세먼지를 제거하는 공기청정기 시뮬레이션
난이도 👉 골드 5

풀이과정

단순히 시뮬레이션 문제입니다. 문제를 이해하고 이해한 내용을 바탕으로 구현하는 것을 목표로 하였습니다.

나만의 방법

전략으로는 함수 단위로 문제를 구분하여 풀었습니다. 먼저 미세먼지가 확장하는 spread 함수, 공기청정기에서 바람이 부는 함수 blow, 바람이 불면서 미세먼지를 이동시키는 turn 함수로 구성하여 각각의 기능을 구현하였습니다.

spread 함수는 배열의 원소를 queue에 넣습니다.(배열값 -1, 0 제외) 그리고 큐에 들어간 순서대로 탐색하면서 확산하는 과정을 거칩니다. 퍼질수 있으면 함수값/5만큼 퍼지고 퍼질 수 없으면 continue, 그리고 퍼지는 과정을 마치면 퍼진만큼 함수값에서 빼주는 과정을 포함했습니다.

blow함수는 편의상 만들었습니다. blow함수는 공기청정기 작동횟수만큼 공기청정기를 작동시키며, 공기청정기를 윗부분 아랫부분 분리하여 작동합니다.

turn 함수는 시작점으로부터 반시계방향, 시계방향으로 이동시키는 것을 고려하여 코드를 작성하였습니다.

소스코드

public class baek_17144 {
	static int R, C, T, arr[][];
	static int[] dr = { 0, -1, 0, 1, 0, 1, 0, -1 };
	static int[] dc = { 1, 0, -1, 0, 1, 0, -1, 0 };
	static Queue<int[]> queue;

	static void spread() {
		for (int i = 0; i < R; i++) {
			for (int j = 0; j < C; j++) {
				if (arr[i][j] != 0 && arr[i][j] != -1) {
					queue.add(new int[] { i, j, arr[i][j] });
				}
			}
		}
		while (!queue.isEmpty()) {
			int[] now = queue.poll();
			int x = now[0];
			int y = now[1];
			int n = now[2];
			int count = 0;
			for (int i = 0; i < 4; i++) {
				int nx = x + dr[i];
				int ny = y + dc[i];
				if (nx < 0 || nx >= R || ny < 0 || ny >= C || arr[nx][ny]==-1) {
					continue;
				}
				count++;
				arr[nx][ny] = arr[nx][ny] + n / 5;
			}
			arr[x][y] = arr[x][y] - count * (n / 5);
		}
	}

	static void blow() {
		for (int i = 0; i < R; i++) {
			if (arr[i][0] == -1) {
				turn(i, 0);
				turn(i + 1, 1);
				break;
			}
		}
	}

	static void turn(int row, int d) {
		int dx = row;
		int dy = 0;
		int now = 0;
		int temp = 0;
		for (int i = d * 4 + 0; i < d * 4 + 4; i++) {
			while (true) {
				dx = dx + dr[i];
				dy = dy + dc[i];

				if (dx < 0 || dx >= R || dy < 0 || dy >= C) {
					dx = dx - dr[i];
					dy = dy - dc[i];
					break;
				}
				if (arr[dx][dy] == -1) {
					break;
				}
				temp = arr[dx][dy];

				arr[dx][dy] = now;
				now = temp;

			}
		}
	}

	static void print() {
		for (int i = 0; i < R; i++) {
			for (int j = 0; j < C; j++) {
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println();
	}

	static int sum() {
		int sum = 0;
		for (int i = 0; i < R; i++) {
			for (int j = 0; j < C; j++) {
				if (arr[i][j] == -1) {
					continue;
				}
				sum += arr[i][j];
			}
		}
		return sum;
	}

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(in.readLine());
		R = Integer.parseInt(st.nextToken());
		C = Integer.parseInt(st.nextToken());
		T = Integer.parseInt(st.nextToken());
		arr = new int[R][C];

		for (int i = 0; i < R; i++) {
			st = new StringTokenizer(in.readLine());
			for (int j = 0; j < C; j++) {
				arr[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		for (int i = 0; i < T; i++) {
			queue = new LinkedList<>();
			spread();
			blow();
		}
		System.out.println(sum());
	}
}

[JAVA]백준 2630 색종이 만들기

2020-12-31T00:00:00+00:00

JAVA로 풀이했습니다.
출처 : 백준 알고리즘 https://www.acmicpc.net

문제 개요

2630번 문제 👉 https://www.acmicpc.net/problem/2630
색종이를 나누어 만들 수 있는 색종이 수 구하기
난이도 👉 실버 3

풀이과정

접근 방식은 재귀를 사용했습니다. 설계방식은 색종이에 접근하는 함수, 주어진 색종이가 온전한 색깔을 가지고 있는지 확인하는 함수로 구성하였습니다.

나만의 방법

먼저 색종이에 접근하는 함수는 인자로 처음 시작위치(i,j)와 가로,세로가 얼만큼의 너비를 가지고 있는지(w,h)를 인자로 가지고 있습니다. 이 함수는 주어진 색종이가 온전한 색깔을 가지고 있는지 확인하고 온전한 색깔을 가지고 있다면 counting을 하고, 아닌경우 더 작은 색종이에 접근하도록 자기자신을 호출하는 구조로 되어있습니다.

check하는 함수는 2중 for문으로 전체를 탐색하여 첫 원소와 나머지 원소가 같은지 비교하여 중간에 하나라도 아닌것이 발견되면 false, 이외에는 true처리를 했습니다.

소스코드

public class baek_2630 {
	static int N, arr[][], white, blue;

	static void paper(int i, int j, int w, int h) {
		if (check(i, j, w, h)) {
			if (arr[i][j] == 1) {
				blue++;
			} else if (arr[i][j] == 0) {
				white++;
			}
		} else {
			paper(i, j, w / 2, h / 2);
			paper(i + w / 2, j, w / 2, h / 2);
			paper(i, j + h / 2, w / 2, h / 2);
			paper(i + w / 2, j + h / 2, w / 2, h / 2);
		}
	}

	static boolean check(int i, int j, int w, int h) {
		int temp = arr[i][j];
		for(int k=i;k<i+w;k++) {
			for(int f=j;f<j+h;f++) {
				if(arr[k][f]!=temp) {
					return false;
				}
			}
		}
		return true;
	}

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(in.readLine());
		N = Integer.parseInt(st.nextToken());
		arr = new int[N][N];
		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(in.readLine());
			for (int j = 0; j < N; j++) {
				arr[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		paper(0, 0, N, N);
		System.out.println(white);
		System.out.println(blue);
	}
}

[JAVA]백준 11053 가장 긴 증가하는 부분 순열

2020-11-26T00:00:00+00:00

JAVA로 풀이했습니다.
출처 : 백준 알고리즘 https://www.acmicpc.net

문제 개요

11053번 문제 👉 https://www.acmicpc.net/problem/11053
수열 A의 가장 긴 증가하는 부분 수열의 길이
난이도 👉 실버 2

풀이과정

처음에는 부분집합으로 접근했습니다. 가장 긴 증가하는 부분 수열을 만들기 위해서 증가하는 원소를 가진 부분 집합을 만들려고 했습니다. 하지만 시간 복잡도에서 O(2^N)이 나오므로 주어진 시간 안에 해결하는 것은 불가능합니다.

두번째로 접근한 방법은 Dynamic Programming을 통해 접근했습니다. 왜냐면 N이 최대 1000이므로 O(NlogN)이 되도록 코드를 작성하였습니다.

나만의 방법

먼저 DP배열에 1000가지의 공간을 미리 만들고 1부터 N까지 순차적으로 계산한다. 이때 두가지 조건을 모두 만족시켜야한다. 비교 대상 숫자의 이전값들을 비교하며 증가하는지 확인한다. 그리고 이전까지의 최대 길이(DP배열에 저장된 최대값)를 계속 업데이트해준다. 마지막 비교 시에 증가한다면 이전까지의 최대값보다 1이 더 긴 증가 수열임을 확인할 수 있다.

소스코드

import java.util.Arrays;
import java.util.Scanner;

public class baek_11053 {
	static int N, arr[], answer, dp[];
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		//N is array size, arr is array with size N
		N = sc.nextInt();
		arr = new int[N+1];

		//input
		for(int i=1;i<=N;i++) {
			arr[i] = sc.nextInt();
		}

		//variable initialization
		answer = 0;
		dp = new int[1001];

		//algorightm
		for(int i=1;i<=N;i++) {
			int max = 0;
			for(int j=0;j<i;j++) {
				if(arr[j]<arr[i]) {
					if(max<dp[j]) {
						max = dp[j];
					}
				}
			}
			dp[i] = max+1;
			answer = Math.max(answer, dp[i]);
		}
		System.out.println(answer);
	}
}