밍의 기록들

altiora petamus -

민쓰 — Fri, 28 Sep 2018 21:56:01 +0900

altiora petamus -

더 높은 곳을 찾게 하소서

[문제] 벽 부수고 이동하기

민쓰 — Mon, 17 Sep 2018 16:10:27 +0900

문제

소스코드

import java.util.*;

class Pair2{
	int x;
	int y;
	boolean c ; // 부쉈다면 ture, 부수지 않았다면 false
	
	Pair2(int x, int y, boolean c){
		this.x = x;
		this.y = y;
		this.c = c;
	}
}
public class Maze2 {
	public static final int[] dx = {0,0,1,-1};
	public static final int[] dy = {1,-1,0,0};
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String[] input = sc.nextLine().split(" ");
		int n = Integer.parseInt(input[0]); 
		int m = Integer.parseInt(input[1]); 
		
		int[][] map = new int[n][m];
		for(int i=0; i<n; i++){
			String[] line = sc.nextLine().split(" ");
			for(int j=0; j<m; j++){
				map[i][j] = Integer.parseInt(line[j]);
			}
		}
		int[][] dist = new int[n][m]; // 거리
		boolean[][] check = new boolean[n][m]; // 벽을 부수지 않은 차원
		boolean[][] check2 = new boolean[n][m]; // 벽을 부순 후의 차원
		
		Queue<Pair2> q = new LinkedList<Pair2>(); //bfs
		q.add(new Pair2(n-1, 0, false));
		check[n-1][0] = true;
		dist[n-1][0] = 0;
		
		while(!q.isEmpty()){
			if(dist[0][m-1] != 0){ // 지점에 도착했다면 while문을 멈춤
				break;
			}
			Pair2 p = q.remove();
			int x = p.x;
			int y = p.y;
			boolean c = p.c;
			for(int k=0; k<4; k++){
				int nx = x+dx[k];
				int ny = y+dy[k];
				if(0<=nx && nx<n && 0<=ny && ny<m){ // 길이 있을 경우
					if(c == true){ // 벽을 이미 1번 부쉈을 경우
						if(check[nx][ny] == false && check2[nx][ny] == false  && map[nx][ny] == 0){
							q.add(new Pair2(nx, ny, c)); // 벽을 이미 부쉈기 때문에 그대로 
							dist[nx][ny] = dist[x][y] + 1; // 거리를 1 더해줌
							check2[nx][ny] = true; // 벽을 부순 후의 차원에 갔던 길을 true로 표시					
						}
					}
					else{ // 벽을 부순 적이 없을 경우
						if(check[nx][ny] == false){ // 가지 않았던 길일 경우
							if(map[nx][ny] == 0){ // 벽이 없는 경우
								q.add(new Pair2(nx, ny, c)); // 벽을 수지 않았기 때문에 그대로 
							}
							if(map[nx][ny] ==1){ // 벽이 있는 경우
								q.add(new Pair2(nx, ny, true)); // 벽을 부쉈기 때문에 true
							}
							dist[nx][ny] = dist[x][y] + 1; // 거리를 1 더해줌
							check[nx][ny] = true; // 갔던 길을 true로 표시
						}
					}
				}
			}
		}
		System.out.println(dist[0][m-1]);
	}
}

풀이

미로 찾기 문제와 동일한 방식으로 풀었지만 벽을 한 번 부술 수 있기 때문에 조금 더 생각이 필요한 문제였다.

1. 벽 부수기를 사용한 경우 c == true

2. 벽 부수기를 사용하지 않은 경우 c == false

1. 벽을 부순 후에 차원 check2[]

2. 벽을 부수지 않은 차원 check[]

가장 먼저 벽을 부수기를 사용했는지 안했는지를 알기 위해 기존의 미로 찾기보다 Pair2에 c를 사용하여 표시를 할 수 있도록 해두었다. 다음 중요한 개념은 지나온 길을 알려주는 check[] 배열을 2개를 만들어서 차원을 2개로 나누었다. 벽을 부수지 않았을 때는 check[]에 지나온 길을 표시하고, 벽을 부순 후부터는 check2[]에 지나온 길을 표시하여 벽을 부순 후에 차원이 벽을 부수지 않은 차원에 영향을 미치지 못하도록 하였다.

[문제] 미로찾기

민쓰 — Fri, 14 Sep 2018 14:42:10 +0900

문제

소스코드

import java.util.*;

class Pair{
	int x;
	int y;
	Pair(int x, int y){
		this.x = x;
		this.y = y;
	}
}
public class Maze {
	public static final int[] dx = {0,0,1,-1};
	public static final int[] dy = {1,-1,0,0};
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String[] input = sc.nextLine().split(" ");
		int n = Integer.parseInt(input[0]); 
		int m = Integer.parseInt(input[1]); 
		
		int[][] map = new int[n][m];
		for(int i=0; i<n; i++){
			String[] line = sc.nextLine().split(" ");
			for(int j=0; j<m; j++){
				map[i][j] = Integer.parseInt(line[j]);
			}
		}
		int[][] dist = new int[n][m]; //distance
		boolean[][] check = new boolean[n][m]; //check
		Queue<Pair> q = new LinkedList<Pair>(); //bfs
		q.add(new Pair(n-1, 0));
		check[n-1][0] = true;
		dist[n-1][0] = 0;
		while(!q.isEmpty()){
			Pair p = q.remove();
			int x = p.x;
			int y = p.y;
			for(int k=0; k<4; k++){
				int nx = x+dx[k];
				int ny = y+dy[k];
				if(0<=nx && nx<n && 0<=ny && ny<m){
					if(check[nx][ny] == false && map[nx][ny] == 0){
						q.add(new Pair(nx, ny));
						dist[nx][ny] = dist[x][y] + 1;
						check[nx][ny] = true;
					}
				}
			}
		}
		System.out.println(dist[0][m-1]);
	}
}

풀이

[정렬] 퀵 정렬 (Quick Sort) - 개념, 시간복잡도, 구현

민쓰 — Mon, 10 Sep 2018 16:56:35 +0900

퀵 정렬 개념

원소(pivot(기둥/중심))를 하나 정하여, 해당 원소보다 작은 수들과 큰 수들로 나눈다.

1. pivot의 위치는 확정된 것

2. pivot의 왼쪽과 오른쪽의 자리는 바뀌지 않는다. (= 왼쪽과 오른쪽을 따로 정렬해도 된다.)

퀵 정렬의 시간복잡도

재귀적으로 구해야 한다.

1. pivot을 정한다. = O(1)

2. 작거나 같은 값과 큰 값을 분류한다. = O(n)

3. 각각을 퀵정렬 한다.

* T(n) = n개의 숫자를 퀵 정렬로 정렬하는데 걸리는 시간

* T(n) = T(left) + T(right) + O(n) // 점화식

// left = pivot보다 작거나 같은 원소의 개수

// right = pivot보다 큰 원소의 개수

* pivot이 원소의 개수를 절반으로 나눈다고 가정하자

* T(n) = 2T(n/2) + O(n) => 합병 정렬과 같음

* 퀵 정렬은 평균적으로 걸린다고 말함

* 퀵 정렬은 최악의 경우에는 이 걸림

(pivot을 어떤 식으로 결정하느냐에 따라 시간복잡도가 달라짐)

퀵 정렬 구현 코드

import java.util.Scanner;

public class SortQuick {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] data = new int [100];
		
		for(int i=0; i<n; i++){ // 데이터 입력
			data[i] = sc.nextInt();
		}		
		quickSort(data, 0, n-1); // 퀵 정렬
		for(int i=0; i<n; i++){ // 데이터 출력
			System.out.print(data[i]+" ");
		}
	}
	
	// data[]를 start부터 end까지 퀵 정렬하는 함수
	private static void quickSort(int[] data, int start, int end) {
		if(start >= end) // 기저조건 => 숫자가 하나밖에 남아 있지 않은 경우
			return;
		
		int pivot = data[start]; // 데이터의 맨 앞의 숫자
		int[] left = new int[100];
		int[] right = new int[100];
		
		// pivot 다음 숫자(start+1) ~ 끝까지(end) 중 pivot보다 같거나 작은 값
		int leftCnt = getLeft(data, start+1, end, pivot, left); // left 값 개수 반환받음
		// pivot 다음 숫자(start+1) ~ 끝까지(end) 중 pivot보다 큰 값
		int rightCnt = getRight(data, start+1, end, pivot, right);  // right 값 개수 반환받음
		
		for(int i=0; i<leftCnt; i++){ // 정렬된 왼쪽 값 삽입
			data[start+i] = left[i];
		}
		data[start+leftCnt] = pivot; // pivot 삽입
		for(int i=0; i<rightCnt; i++){ // 정렬된 오른쪽 값 삽입
			data[start+leftCnt+1+i] = right[i];
		}
		
		quickSort(data, start, start+leftCnt-1); // 왼쪽 퀵 정렬
		quickSort(data, start+leftCnt+1, end); // 오른쪽 퀵 정렬
	}
	
	// data[]의 start부터 end까지 숫자들 중에서 
	// pivot보다 작거나 같은 값을 result[]에 채우고 개수 반환하는 함수
	private static int getLeft(int[] data, int start, int end, int pivot, int[] result) {
		int index = 0;
		for(int i=start; i<=end; i++){
			if(data[i] <= pivot){
				result[index++] = data[i];
			}
		}
		return index;
	}
	
	// data[]의 start부터 end까지 숫자들 중에서
	// pivot보다 큰 값을 result[]에 채우고 개수 반환하는 함수
	private static int getRight(int[] data, int start, int end, int pivot, int[] result) {
		int index = 0;
		for(int i=start; i<=end; i++){
			if(data[i] > pivot){
				result[index++] = data[i];
			}
		}		
		return index;
	}
}

[정렬] 합병 정렬 (Merge Sort) - 개념, 시간복잡도, 구현

민쓰 — Mon, 10 Sep 2018 16:56:20 +0900

합병 정렬 개념

배열을 절반으로 나누어 각각을 정렬한 후, 합친다.

합병 정렬의 시간복잡도

재귀적으로 구해야 한다.

1. 왼쪽 합병정렬 = T(n/2)

2. 오른쪽 합병정렬 = T(n/2)

3. 합친다 = O(n)

* T(n) = n개의 숫자를 합병정렬할 때의 시간복잡도

* T(n) = 2 x T(n/2) + O(n) // 점화식

= 2(2T(n/4) + O(n/2)) + O(n)

= 4T(n/4) + 2O(n) // 1번 대입

= 4(2T(n/8) + O(n/4)) + 2O(n)

= 8T(n/8) + 3O(n) // 2번 대입

...... // k번 대입 k+1 = log n

= n x T(1) + log n x O(n)

= n x O(1) + O(n log n)

= O(n) + O(n log n)

합병 정렬 구현 코드

import java.util.Scanner;

public class SortMerge {
	// 합병정렬 : 배열을 절반으로 나누어 각각을 정렬한 후, 합침
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] data = new int [100];
		
		for(int i=0; i<n; i++){
			data[i] = sc.nextInt();
		}		
		mergeSort(data, 0, n-1);
		
		for(int i=0; i<n; i++){
			System.out.print(data[i]+" ");
		}
	}

	// data의 start부터 end까지를 합병정렬하는 함수
	private static void mergeSort(int[] data, int start, int end) {
		if(start >= end) // 숫자가 한 개 남았을 때
			return;
		else{
			int mid = (start+end)/2;
			mergeSort(data, start, mid); // 1. 왼쪽 절반 합병정렬
			mergeSort(data, mid+1, end); // 2. 오른쪽 절반 합병정렬
			merging(data, start, mid, mid+1, end);// 3. 둘을 합침
		}
	}

	// 정렬된 반쪽들을 정렬해서 하나로 합치는 함수
	private static void merging(int[] data, int s1, int e1, int s2, int e2) {
		int p, q; // 현재 최솟값을 가리키는 변수들
		int [] temp = new int[100]; // 합쳐진 결과를 저장하는 임시배열
		int tempIndex = 0;
		
		p = s1; // 왼쪽 절반의 시작점
		q = s2; // 오른쪽 절반의 시작점
		
		while(p <= e1 && q <= e2) {
			if(data[p] <= data[q]){
				temp[tempIndex++] = data[p];
				p++;
			}
			else{
				temp[tempIndex++] = data[q];
				q++;
			}			
		}
		if(p > e1){// q에 남은 숫자가 있는 경우
			for(int i=q; i<=e2; i++){
				temp[tempIndex++] = data[i];
			}
		}
		else{// p에 남은 숫자가 있는 경우
			for(int i=p; i<=e1; i++){
				temp[tempIndex++] = data[i];
			}
		}
		
		// temp[] 완성이 되었으니 data[]에 복사
		for(int i=s1; i<=e2; i++){
			data[i] = temp[i-s1]; //data[] 는 0부터 시작하는 것이 아님, temp는 0부터 시작
		}
	}
}

[정렬] 선택 정렬, 삽입 정렬, 버블 정렬의 구현

민쓰 — Mon, 10 Sep 2018 16:55:48 +0900

선택 정렬 구현 코드

import java.util.Scanner;

public class SortSelection { // 선택 정렬
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] data = new int [100];
		
		for(int i=0; i<n; i++){
			data[i] = sc.nextInt();
		}
		// i : 앞의 정렬이 되어 있는 값들의 다음 위치
		// index : (비교대상 1)으로 최솟값이 담김(i부터 n까지의)
		// j : (비교대상 2) 순차적으로 뒤로 가면서 index와 비교함
		for(int i=0; i<n; i++){
			int index = i; 
			for(int j=i+1; j<n; j++){
				if(data[index] > data[j]){ // index값이 j값보다 크다면
					index = j; // index 값이 최솟값이 됨
				}
			}
			int temp;
			temp = data[i];
			data[i] = data[index];
			data[index] = temp;
		}
		for(int i=0; i<n; i++){
			System.out.print(data[i]+" ");
		}
	}
}

삽입 정렬 구현 코드

import java.util.Scanner;

public class SortInsertion { //삽입 정렬

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] data = new int [100];
		
		for(int i=0; i<n; i++){
			data[i] = sc.nextInt();
		}
		
		// i가 가리키고 있는 값이 왼쪽 정렬되어 있는 값과 비교 후 자리에 들어감
		// i : 앞의 정렬되어 있는 값들의 다음 위치 (비교대상 1)
		// j : (비교 대상 2) 순차적으로 앞으로 가면서 i와 비교함
		for(int i=1; i<n; i++){
			for(int j=i; j>=1; j--){
				if(data[j-1] > data[j]){
					int temp;
					temp = data[j-1];
					data[j-1] = data[j];
					data[j] = temp;
				}
				else break;
			}
		}
		for(int i=0; i<n; i++){
			System.out.print(data[i]+" ");
		}
	}
}

버블 정렬 구현 코드

import java.util.Scanner;

public class SortBubble { // 버블 정렬

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] data = new int [100];
		
		for(int i=0; i<n; i++){
			data[i] = sc.nextInt();
		}
		
		// j가 가리키고 있는 값과 오른쪽 값 비교를 n번함
		for(int i=0; i<n; i++){
			for(int j=0; j<n-i-1; j++){
				if(data[j] > data[j+1]){
					int temp;
					temp = data[j];
					data[j] = data[j+1];
					data[j+1] = temp;
				}
			}
		}
		for(int i=0; i<n; i++){
			System.out.print(data[i]+" ");
		}
	}
}

[트리] 트리의 순회

민쓰 — Sun, 9 Sep 2018 21:54:34 +0900

트리의 순회(Tree Traversal)

트리의 모든 노드를 방문하는 순서
트리 내에 어떠한 자료가 담겨있는지를 알기 위함
그래프의 경우 DFS와 BFS가 있음
트리에서도 위의 두 방법을 사용가능 하지만, 트리에서만 사용할 수 있는 방법이 3가지 있음
1) 프리오더 = 전위 순회
2) 인오더 = 중위 순회
3) 포스트오더 = 후위 순회
세 방법의 차이는 노드 방문을 언제 하냐의 차이임

전위 순회, 프리오더(Pre-order)

Root - L - R
노드 방문 - 왼쪽 서브 트리 순회 - 오른쪽 서브 트리 순회
순서 : A-B-D-E-C-F-G
그래프의 DFS의 순서와 같음

노드 방문

왼쪽 서브 트리 순회

오른쪽 서브 트리 순회

중위 순회, 인오더(In-order)

L - Root - R
왼쪽 서브 트리 순회 - 노드 방문 - 오른쪽 서브 트리 순회
순서 : D-B-E-A-F-C-G

후위 순회, 포스트오더(Post-order)

L - R - Root
왼쪽 서브 트리 순회 - 오른쪽 서브 트리 순회 - 노드 방문
순서 : D-E-B-F-G-C-A

코드

import java.util.Scanner;

public class treeTraversal {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); //node
		sc.nextLine();
		
		int[][] a = new int[n][2];
		for(int i=0; i<n; i++){
			String[] line = sc.nextLine().split(" ");
			int x = Integer.parseInt(line[0]);
			a[x][0] = Integer.parseInt(line[1]);
			a[x][1] = Integer.parseInt(line[2]);
		}
		
		preorder(a,0);
		System.out.println();
		inorder(a,0);
		System.out.println();
		postorder(a,0);
		System.out.println();
	}

	private static void preorder(int[][] a, int x) {
		if(x == -1) return;
		System.out.print(x+ " ");
		preorder(a, a[x][0]);
		preorder(a, a[x][1]);
	}
	
	private static void inorder(int[][] a, int x) {
		if(x == -1) return;
		inorder(a, a[x][0]);
		System.out.print(x+ " ");
		inorder(a, a[x][1]);
	}
	
	private static void postorder(int[][] a, int x) {
		if(x == -1) return;
		postorder(a, a[x][0]);
		postorder(a, a[x][1]);
		System.out.print(x+ " ");
	}
}

[트리] 트리의 표현

민쓰 — Sun, 9 Sep 2018 21:54:16 +0900

트리의 표현

트리는 그래피이기 때문에, 그래프의 표현과 같은 방식으로 저장할 수 있음
트리의 모든 노드는 부모를 하나 또는 0개만 가지기 때문에 부모만 저장하는 방식으로 저장 가능
부모가 0개인 경우는 트리의 루트인데, 이 경우 부모를 -1이나 0으로 처리하는 방식을 사용함

트리의 부모만 저장하는 방식

이진 트리

이진 트리의 경우는 배열로 표현 가능
부모의 노드가 x인 경우
자식의 노드는 2*x, 2*x+1로 나타냄

이진 트리의 경우는 배열로 표현 가능
A[i][0]에 i의 왼쪽 자식, A[i][1]에 i의 오른쪽 자식을 저장

* 백준 알고리즘 참고

[트리] 트리의 기본

민쓰 — Sun, 9 Sep 2018 21:54:02 +0900

트리(Tree)

자료구조의 일종
사이클이 없는 그래프
정점(Node, Vertex)
간선(Edge) : 정점간의 관계를 나타냄
정점의 개수 : V / 간선의 개수 : V-1

루트가 있는 트리

1번이 루트(root)임
루트부터 아래로 방향을 정할 수 있음

루트 노드, 리프 노드, 단말 노드, 가지 노드

1번은 루트 노드(root node) 즉, 부모가 없는 최상위 노드
4, 5, 6, 7번은 리프 노드(leaf node) 즉, 맨 마지막 끝 노드
4, 5, 6, 7번은 단말 노드(terminal node)도 됨. 가지를 가지지 않는 노드. 즉 degree가 0인 노드
1, 2, 3번은 가지 노드(branch node) 가지를 가지는 노드. 즉, degree가 0이 아닌 노드

부모와 자식

부모노드(Parent)와 자식노드(Child)
1의 자식은 2와 3
2의 자식은 4와 5
3의 자식은 6과 7

형제

형제 노드(Sibling)
4와 5는 형제
6과 7은 형제
2와 3도 형제
같은 부모를 가지면 형제

깊이, 높이, 레벨

깊이(Depth) : 루트에서 어떤 노드까지의 경로 길이
4의 깊이는 2
높이(Height) : 가장 긴 깊이. 즉 가장 긴 경로 길이
트리의 높이는 2
레벨(Level) : 트리의 특정 깊이를 가지는 노드의 집합
루트의 레벨은 0으로 하는 경우와 1로 하는 경우가 있음
1 노드의 레벨은 1
2와 3 노드의 레벨은 2
4, 5, 6, 7 노드의 레벨은 3

조상과 자손

p->q로 갈 수 있을 때
p가 q보다 루트에 가까우면
p는 q의 조상
q는 p의 자손

[문제] 깊이우선탐색과 너비우선탐색

민쓰 — Sun, 9 Sep 2018 21:26:26 +0900

문제

소스코드

import java.util.*;

public class bfsdfs {
	static ArrayList<Integer>[] a;
	static boolean[] check;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		String[] input = sc.nextLine().split(" ");
		int n = Integer.parseInt(input[0]);
		int m = Integer.parseInt(input[1]);

		a = (ArrayList<Integer>[]) new ArrayList[n+1];
		for(int i=1; i<=n; i++){
			a[i] = new ArrayList<Integer>();
		}
		for(int i=0; i<m; i++){
			String line = sc.nextLine();
			int u = line.charAt(0)-'@';
			int v = line.charAt(2)-'@';
			a[u].add(v);
			a[v].add(u);
		}
		for(int i=1; i<=n; i++){
			Collections.sort(a[i]);
		}
		int start = sc.next().charAt(0)-'@';
		
		check = new boolean[n+1];
		dfs(start);
		System.out.println();
		
		check = new boolean[n+1];
		bfs(start);
		System.out.println();
	}

	private static void bfs(int start) {
		Queue<Integer> q = new LinkedList<Integer>();
		q.add(start);
		check[start] = true;
		while(!q.isEmpty()){
			int x = q.remove(); // head return
			System.out.print((char)(x+'@'));
			for(int y : a[x]){
				if(check[y] == false){
					check[y] = true;
					q.add(y);
				}
			}
		}
	}

	private static void dfs(int x) {
		check[x] = true;
		System.out.print((char)(x+'@'));
		for(int y : a[x]){
			if(check[y] == false){
				dfs(y);
			}
		}
	}
}

풀이