흘러가는 프로그래밍 블로그

[Spring] beforeEach 메서드 + Test 만들기 단축키

yeomss — Mon, 2 Jan 2023 20:09:43 +0900

beforeEach

개념

Test 메서드가 실행되기 전에, 무조건적으로 실행되는 함수

코드

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;


class MemberServiceImplTest {

	MemberRepository memberRepository = new MemberRepositoryImpl();


	@BeforeEach
	void beforeEach() {
		System.out.println("beforeEach 입니다!");
	}


	@Test
	void 멤버찾기() {
		Member member = new Member(1, "member1");

		memberRepository.save(member);

		Integer findMember = memberRepository.findById(member.getMemberId());

		System.out.println(member.getMemberId());
		System.out.println(findMember);

		Assertions.assertThat(member.getMemberId()).isEqualTo(findMember);
	}

}

이렇듯, Test 가 돌아가기 이전에 beforeEach 가 수행되는 것을 확인할 수 있습니다.

Test 만들기 단축키

Mac OS 기준 만들고 싶은 클래스 이름에서 Comand + Shift + T 를 누르면 위와 같이 Create New Test 창이 뜹니다.

Window 기준 Ctrl + Shift + T 를 누르면 됩니다.

창이 뜨면 그대로 OK 하면 됩니다.

#beforeEach Test #beforeEach Spring #spring Test 모두 수행

#spring test 단축키

[BJ11399] ATM

yeomss — Sat, 17 Dec 2022 00:27:55 +0900

백준 - ATM

문제 링크

https://www.acmicpc.net/problem/11399

11399번: ATM

첫째 줄에 사람의 수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄에는 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어진다. (1 ≤ Pi ≤ 1,000)

www.acmicpc.net

문제 입출력

5
3 1 4 3 2

문제 풀이

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;


public class Main {
	static int ans, N;
	static List<Node> list = new ArrayList<>();


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

		// 초기화
		N = Integer.parseInt(br.readLine());

		StringTokenizer st = new StringTokenizer(br.readLine());
		for (int i = 0; i < N; i++) {
			int time = Integer.parseInt(st.nextToken());
			list.add(new Node(i, time));
		}

		// 시간 순으로 정렬
		Collections.sort(list, (e1, e2) -> e1.time - e2.time);

		// 풀이
		sol();

		// 출력
		System.out.println(ans);

	} // end main


	private static void sol() {

		for (int i = 0; i < N; i++) {
			ans += list.get(i).time; // 일단, 현재 시간 더하기

			// 이때까지 기다린 시간 더하기
			for (int j = 0; j < i; j++) ans += list.get(j).time;
		}

	} // end sol


	static class Node {
		int idx;
		int time;


		public Node(int idx, int time) {
			super();
			this.idx = idx;
			this.time = time;
		}


		@Override
		public String toString() {
			return "Node [idx=" + idx + ", time=" + time + "]";
		}

	} // end Node

}

그리디 알고리즘은 보통 정렬을 하면 풀리는 경우가 많다.

처음에는 문제를 보고 순열을 구해서 푸는 줄 알았는데, 그러면 시간 초과가 난다.

문제를 보니 기다리는 시간 배열을 작은 순서대로 정렬한 순서가 -> 최소합이 나오는 손님 번호의 순서가 된다.

따라서, sort() 메서드를 이용하여 정렬을 해준다.

그리고 나서 반복문을 2개 돌아 현재 기다린 시간과 + 이때까지 기다린 시간을 더해주면 최소값을 구할 수 있다.

#백준 ATM 자바 #백준 ATM java

[BJ1446] 지름길

yeomss — Fri, 16 Dec 2022 23:50:48 +0900

백준 - 지름길

문제 링크

https://www.acmicpc.net/problem/1446

1446번: 지름길

첫째 줄에 지름길의 개수 N과 고속도로의 길이 D가 주어진다. N은 12 이하인 양의 정수이고, D는 10,000보다 작거나 같은 자연수이다. 다음 N개의 줄에 지름길의 시작 위치, 도착 위치, 지름길의 길이

www.acmicpc.net

문제 입출력

2 100
10 60 40
50 90 20

문제 풀이

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;


public class Main {
	static int ans, N, D;
	static int[] dp; // 점화식
	static List<Node> shortCuts = new ArrayList<>(); // 지름길 배열

	/*
	 점화식 dp[i]: 해당 i 위치에 도착했을 때의 가장 짧은 운전 거리 
	 dp[0] -> 0
	 dp[1] -> 1
	 ...
	 dp[49] -> 49
	 dp[50] -> 10 으로 갱신 
	 
	 dp[i] = dp[i+1] + 1
	 or
	 dp[i] = dp[s] + (new distance)
	 */


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

		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		D = Integer.parseInt(st.nextToken()); // 고속도로 길이

		// 초기화
		dp = new int[D + 1];

		for (int i = 0; i <= D; i++) dp[i] = i;

		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			int s = Integer.parseInt(st.nextToken());
			int e = Integer.parseInt(st.nextToken());
			int dis = Integer.parseInt(st.nextToken());

			if (s > e) continue; // 역주행
			if (e - s > D) continue; // 지름길이 아닌 경우
			if (s < 0 || e > D) continue; // 범위 넘어가는 경우

			shortCuts.add(new Node(s, e, dis));
		}

		// Collections.sort(shortCuts,
		// (e1, e2) -> e1.s == e2.s ? (e1.e == e2.e ? e1.dis - e2.dis : e1.e - e2.e)
		// : e1.s - e2.s);

		// 탐색
		sol();

		// 출력
		ans = dp[D];
		System.out.println(ans);

	} // end main


	private static void sol() {
		for (int i = 1; i <= D; i++) {
			
			for (Node node : shortCuts) {
				if (i == node.e) { // 만약 지름길이 있는 경우 
					int ndis = dp[node.s] + node.dis;
					dp[i] = Math.min(dp[i], Math.min(dp[i - 1] + 1, ndis));
				} else dp[i] = Math.min(dp[i], dp[i - 1] + 1); // 지름길이 없는 경우 

			}

		}

	} // end sol


	static class Node {
		int s, e;
		int dis;


		public Node(int s, int e, int dis) {
			super();
			this.s = s;
			this.e = e;
			this.dis = dis;
		}


		@Override
		public String toString() {
			return "Node [s=" + s + ", e=" + e + ", dis=" + dis + "]";
		}

	} // end Node
}

맞왜틀 이었던 문제.. 알고보니 dp 배열을 초기화 할때 잘못된 값을 넣어서 발생하는 문제였다.

처음에 초기화로 D + 1 의 값을 넣었는데, 이때문에 dp[i - 1] + 1 과 비교할 시 오답이 발생한 것 같다.

D + 1 이 초기값이면 당연히 dp[i - 1] + 1 이 그보다 작기 때문에 값이 갱신된다.

하지만 사실 순차대로 1을 더해줬을 때가 d[i - 1] + 1 보다 값이 작을 수 있기에 문제가 발생한다.

아무튼간 풀어서 기분은 좋다. 다익스트라 라기보다는 보편적인 유형의 다이나믹프로그래밍 문제 인 것 같다.

길을 돌면서 만약에 지름길이 있다면 (dp[i], dp[i-1] + 1, dp[s] + dis) 중에 min 값을 갱신해준다.

지름길이 없는 경우는 (dp[i], dp[i-1] + 1) 중에 min 값을 갱신해준다.

dp[i] 와 계속 비교하는 이유는 전체 shortCuts 배열을 돌기 때문이다.

동일한 시작 - 도착 위치의 지름길이 있을 수 있기 때문에 기존의 것과 비교해주어야 한다.

#백준 지름길 java dp #백준 지름길 자바 dp #백준 지름길 다익스트라 #bj1446 지름길

[BJ1003] 피보나치 함수

yeomss — Fri, 16 Dec 2022 17:37:31 +0900

백준 - 피보나치 함수

문제 링크

https://www.acmicpc.net/problem/1003

1003번: 피보나치 함수

각 테스트 케이스마다 0이 출력되는 횟수와 1이 출력되는 횟수를 공백으로 구분해서 출력한다.

www.acmicpc.net

문제 입출력

1 0
0 1
1 2

문제 풀이

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;


public class Main {
	static int ans0, ans1, T, N;
	static int[] zeros, ones;


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

		T = Integer.parseInt(br.readLine());
		for (int t = 0; t < T; t++) {
			// 초기화
			N = Integer.parseInt(br.readLine());
			zeros = new int[N + 2]; // i 일떄의 0의 갯수
			ones = new int[N + 2]; // i 일때의 1의 갯수

			// 풀이
			sol();

			// 출력
			System.out.println(zeros[N] + " " + ones[N]);
		}

	} // end main


	private static void sol() {
		// 기저 memoi 값 초기화
		zeros[0] = 1;
		zeros[1] = 0;
		ones[0] = 0;
		ones[1] = 1;

		// bottom-up 방식 (반복문)
		for (int i = 2; i <= N; i++) {
			zeros[i] = zeros[i - 2] + zeros[i - 1];
			ones[i] = ones[i - 2] + ones[i - 1];
		}

	} // end sol

	// 이렇게 하면 시간 초과
	// private static int fibo(int n) {
	// if (n == 0) {
	// ans0++;
	// return 0;
	// } else if (n == 1) {
	// ans1++;
	// return 1;
	// } else return fibo(n - 1) + fibo(n - 2);
	//
	// } // end fibo
}

재귀를 이용하여 피보나치 문제를 풀었을 때, 기저에 다다르는 0과 1의 갯수는 몇개인가를 구하는 문제.

시간 제한이 0.25s 라서 재귀를 이용해서 풀면 시간 초과가 난다.

재귀를 이용해서 푼다면 O(2^N) 이 되고 => 2^40 이 되는데
대략적으로 2^10 == 10^3 이므로
2^40 은 == 10^12 가 되어 가당치도 않게 된다.

따라서 다이나믹 프로그래밍을 이용하여 문제를 풀어야 한다.

bottom-up 방식을 이용하여 작은 문제부터 쌓았다. memoi 배열을 2개 선언해준다. (zeros, ones)

피보나치와 마찬가지로 해당 배열이 쌓이는 점화식도 d[i] = d[i-2] + d[i-1] 이므로 똑같이 쌓으면 된다.

#백준 피보나치함수 자바 #백준 피보나치함수 java #백준 피보나치함수 시간복잡도

[BJ2630] 색종이 만들기

yeomss — Fri, 16 Dec 2022 02:18:32 +0900

SW Expert Academy - 숫자 카드 게임

문제 링크

https://www.acmicpc.net/problem/2630

2630번: 색종이 만들기

첫째 줄에는 전체 종이의 한 변의 길이 N이 주어져 있다. N은 2, 4, 8, 16, 32, 64, 128 중 하나이다. 색종이의 각 가로줄의 정사각형칸들의 색이 윗줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다.

www.acmicpc.net

문제 입출력

4
6

문제 풀이

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class Main {
	static int ansW, ansB, N;
	static int[][] map;


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

		N = Integer.parseInt(br.readLine());
		map = new int[N][N];

		for (int i = 0; i < N; i++) {
			StringTokenizer st = new StringTokenizer(br.readLine());
			for (int j = 0; j < N; j++) map[i][j] = Integer.parseInt(st.nextToken());
		}

		// 풀이
		go(0, N, 0, N);

		// 출력
		System.out.println(ansW);
		System.out.println(ansB);

	} // end main


	// (sy - ey), (sx - ex) 색종이가 다 같은 색으로 칠해져있는지 확인하고
	// 그렇지 않으면 나누는 함수
	private static void go(int sy, int ey, int sx, int ex) {
		// 기저조건: 만약 종이의 너비가 1이라면 return
		if (ey - sy < 1 || ex - sx < 1) return;

		if (!check(sy, ey, sx, ex)) {
			// 만약 전체가 다 같은 색으로 칠해져 있지 않다면
			// 4등분하여 재귀를 탄다. -> 또 다 같은 색으로 칠해져있는지 확인
			go(sy, (sy + ey) / 2, sx, (sx + ex) / 2);
			go(sy, (sy + ey) / 2, (sx + ex) / 2, ex);
			go((sy + ey) / 2, ey, sx, (sx + ex) / 2);
			go((sy + ey) / 2, ey, (sx + ex) / 2, ex);
		} else {
			// 만약 전체가 다 같은 색으로 칠해져 있다면
			// 첫번째 원소를 확인하여 흰색인지/파란색인지 센다.
			if (map[sy][sx] == 0) ansW++;
			else ansB++;
		}

	} // end solution


	private static boolean check(int sy, int ey, int sx, int ex) {
		int prev = map[sy][sx];

		for (int i = sy; i < ey; i++) {
			for (int j = sx; j < ex; j++) {
				if (prev != map[i][j]) return false;
				else prev = map[i][j];
			}

		}

		return true;
	} // end check

}

#백준 색종이만들기 java #백준 색종이 만들기 java

[BJ1931] 회의실 배정

yeomss — Fri, 16 Dec 2022 01:03:35 +0900

백준 - 회의실 배정

문제 링크

https://www.acmicpc.net/problem/1931

1931번: 회의실 배정

(1,4), (5,7), (8,11), (12,14) 를 이용할 수 있다.

www.acmicpc.net

문제 입출력

2
0 1
3 3

문제 풀이

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;


public class Main {
	static int ans, N;
	static Node[] arr;


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

		N = Integer.parseInt(br.readLine());

		// 초기화
		ans = 1;
		arr = new Node[N];

		for (int i = 0; i < N; i++) {
			StringTokenizer st = new StringTokenizer(br.readLine());
			int s = Integer.parseInt(st.nextToken());
			int e = Integer.parseInt(st.nextToken());

			arr[i] = new Node(s, e, e - s);
		}

		// 우선, 끝시간을 기준으로 정렬
		// 끝시간이 같다면 시작시간 순으로 정렬
		Arrays.sort(arr, (e1, e2) -> e1.e == e2.e ? e1.s - e2.s : e1.e - e2.e);

		// 그리디
		solution();

		// 출력
		System.out.println(ans);

	} // end main


	private static void solution() {
		int idx = 1;
		Node prev = arr[0];

		while (idx < N) {
			Node cur = arr[idx];

			// 만약 다음 회의로 넘어갈 수 있다면
			if (prev.e <= cur.s) {
				prev = cur;
				ans++;
			}

			idx++;
		}

	} // end solution


	static class Node {
		int s, e;
		int len;


		public Node(int s, int e, int len) {
			super();
			this.s = s;
			this.e = e;
			this.len = len;
		}


		@Override
		public String toString() {
			return "Node [s=" + s + ", e=" + e + ", len=" + len + "]";
		}

	} // end Node
}

그리디를 이용해서 푸는 문제.

종료 시간을 기준으로 정렬하고, 만약 끝 시간이 같다면 시작 시간이 빠른 순으로 정렬.

그 이유는 종료 시간으로 정렬해야, 어느 회의가 빨리 끝나는지 알 수 있다. 주어진 회의 시간을 좁게 좁게 쓰는 것이 관건이기 때문.

종료 시간이 같을 때, 시작 시간 순으로 정렬하는 이유는

예를 들어,

2
3 3
2 3

이라는 input 이 있다고 가정하자.

이럴 때, 종료 시간으로만 정렬하면 (3, 3) -> (2, 3) 으로 첫번째 회의의 종료시간 보다 두번째 회의의 시작시간이 빨라서 카운팅을 할 수 없다. 하지만 종료 시간이 같을 때, 시작 시간 순으로 정렬을 하면 (2, 3) -> (3, 3) 으로 카운팅을 할 수 있게 된다.

#백준 회의실 배정 이유 #백준 회의실배정 java #bj 회의실 배정 정렬 이유 # bj 회의실 배정 다른 예제

[BJ1764] 듣보잡

yeomss — Wed, 14 Dec 2022 16:06:09 +0900

백준 - 듣보잡

문제 링크

https://www.acmicpc.net/problem/1764

1764번: 듣보잡

첫째 줄에 듣도 못한 사람의 수 N, 보도 못한 사람의 수 M이 주어진다. 이어서 둘째 줄부터 N개의 줄에 걸쳐 듣도 못한 사람의 이름과, N+2째 줄부터 보도 못한 사람의 이름이 순서대로 주어진다.

www.acmicpc.net

문제 입출력

4 3
d
c
b
a
c
b
a

3
a
b
c

문제 풀이

package problem.BJ;


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;


public class BJ1764_듣보잡 {
	static int ansN, N, M;
	static Set<String> ds, bs;
	static List<String> ans = new ArrayList<>();


	public static void main(String[] args) throws Exception {
		System.setIn(new FileInputStream("input.txt"));
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());

		ds = new HashSet<>();
		for (int i = 0; i < N; i++) ds.add(br.readLine());

		bs = new HashSet<>();
		for (int i = 0; i < N; i++) bs.add(br.readLine());

		ds.retainAll(bs); // 교집합 구하기

		// HashSet은 먼저 Collections 으로 변경하고 sorting
		ArrayList<String> dsList = new ArrayList<>(ds);
		Collections.sort(dsList);

		System.out.println(ds.size());
		dsList.forEach(e -> System.out.println(e));

	} // end main
}

# 백준 듣보잡 java

[SW1989] 초심자의 회문 검사

yeomss — Wed, 14 Dec 2022 14:22:10 +0900

SW Expert Academy - 초심자의 회문 검사

문제 링크

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5PyTLqAf4DFAUq

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

문제 입출력

10
level
samsung
eye
exo
ioi
blackpink
hannah
B1A4
linetown
nursesrun

문제 풀이

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;


public class Solution {
	static int ans, T;


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

		T = Integer.parseInt(br.readLine());
		for (int t = 1; t <= T; t++) {
			String str = br.readLine();

			if (check(str)) ans = 1;
			else ans = 0;

			System.out.println("#" + t + " " + ans);
		}

	} // end main


	private static boolean check(String str) {
		char[] c = str.toCharArray();
		int len = str.length();
		int lt = 0, rt = len - 1;

		// 왼쪽 끝과 오른쪽 끝에서 부터 시작하여 비교한다.
		// 만약 비교군이 다른 문자라면 바로 return false (회문이 아니라는 의미)
		while (lt < rt) {
			if (c[lt] != c[rt]) return false;
			else {
				// 같은 문자라면 왼쪽은 ->
				// 오른쪽은 <- 방향으로 
				lt++;
				rt--;
			}

		}

		return true;
	} // end check 
}

# SWEA 초심자의 회문 검사 # SW 초심자의 회문 검사 java

[Spring] Lombok 다운 및 세팅

yeomss — Fri, 2 Dec 2022 10:51:40 +0900

Lombok 이란?

https://projectlombok.org/

Project Lombok

projectlombok.org

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java. Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

Project Lombok은 편집기 및 빌드 도구에 자동으로 연결되어 Java를 향상시키는 Java 라이브러리입니다. 다른 getter 또는 equals 메소드를 다시 작성하지 마십시오. 하나의 주석으로 클래스에 완전한 기능을 갖춘 빌더, 로깅 변수 자동화 등이 있습니다. (Google 번역)

lombok 설치 사이트를 가면 위와 같이 lombok 을 소개합니다.

lombok 은 @Annotaion 을 이용하여 자동 변수 생성, 빌드 등을 해주는 Java 라이브러리 입니다.

자동으로 getter, setter 같은 기능을 제공해주기 때문에 어노테이션만 붙이면 굳이 getter, setter 을 만들 필요가 없습니다.

무척 편리합니다

Lombok 설정

starter 프로젝트 만들 때

만약 sts 에서 설정한다면, 스프링 스타터 프로젝트를 만들 때 lombok 을 체크하면 됩니다.

start.spring.io 에서는 Dependency 에서 lombok 을 검색해서 추가하여 사용하면 됩니다.

기존 프로젝트 에서 설치할 때

만약 기존 프로젝트에서 설치하고 싶다면

https://mvnrepository.com/artifact/org.projectlombok/lombok

Maven 에서 Project Lombok jar 파일을 다운받아서

[Add External JARs] 을 눌러 해당 jar 파일을 추가하거나 혹은

gradle 을 복사하여

해당 프로젝트의 [build.gradle] 파일 dependencies 에 복사 붙여넣기 해주시면 됩니다.

IDE 에 설치하기

lombok 은 IDE 에 설치를 해줘야합니다.

이를 위해 External Dependencies 에서 lombok 라이브러리를 선택하고 Java Application 으로 Run 해줍니다.

그러면 이러한 창이 뜨는데 [Specify Location] 을 눌러서 STS.exe 을 선택하여 로케이션을 잡아주고 설치하거나,

혹은 IDEs 에 체크박스로 IDE 들이 뜨는데

lombok 을 설치하고 싶은 IDE 을 체크하고 똑같이 [Install/Update] 버튼을 눌러 설치해주면 됩니다.

설치가 완료 됐으면 STS 경로에 이런식으로 lombok.jar 이 생깁니다.

맥에서 STS 경로를 확인하고 싶으시다면 응용 프로그램에 들어가 STS.app 을 오른쪽 마우스 클릭하여 패키지 내용 보기를 클릭하시면 됩니다.

Lombok 사용

package com.mycom.myapp.house.dto;


import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;


@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class HouseDto {
	private String houseDealId; // 아파트 매물 코드
	private String dongCore; // dongCode
}

이런식으로 dto 에서 Annotaion 을 이용하여 사용하면 됩니다.

lombok을 사용하면 굳이 getter, setter 을 사용할 필요가 없어집니다.

만들어질 때는 낙타 형식으로 getHouseDealId(), setHouseDealId() 이러한 식으로 명명되어 만들어집니다.

아래는 자주 사용하는 Annotaion 입니다. dto 을 만들 때 기본적으로 깔고 들어갑니다.

생성자 관련 어노테이션은 멤버 변수가 없으면 오류가 나므로, 이 점을 유의하시길 바랍니다.

@Getter → getter 만들어줌
@Setter → setter 만들어줌
@AllArgsConstructor → 모든 멤버변수의 매개변수를 가진 생성자
@NoArgsConstructor → 아무런 매개변수가 없는 생성자
@ToString → ToString 만들어줌

여러가지 feature 같은 경우는 해당 페이지로 가면 더 상세한 정보를 만나보실 수 있습니다.

https://projectlombok.org/features/

Stable

projectlombok.org

#Lombok 사용 #lombok 설치 #lombok sts #lombok 실행

[SW1767] 프로세서 연결하기

yeomss — Wed, 9 Nov 2022 02:14:00 +0900

문제 설명

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV4suNtaXFEDFAUf&categoryId=AV4suNtaXFEDFAUf&categoryType=CODE&problemTitle=%ED%94%84%EB%A1%9C%EC%84%B8%EC%84%9C&orderBy=FIRST_REG_DATETIME&selectCodeLang=ALL&select-1=&pageSize=10&pageIndex=1&&&&&&&&&

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

◾ 가능한 프로세서 코어를 많이 연결할 때, 프로세서 전선의 최소의 합을 구하는 문제

✅ 입출력

변수 설명
T: test case
N: map 크기
return ➡️ 코어를 최대한 많이 연결할 때, 프로세서 전선의 최소합

✔️ 예제 1

1
7    
0 0 1 0 0 0 0
0 0 1 0 0 0 0
0 0 0 0 0 1 0
0 0 0 0 0 0 0
1 1 0 1 0 0 0
0 1 0 0 0 0 0
0 0 0 0 0 0 0

#1 12

문제 풀이

with 자바 (Java)

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;


public class Solution {
	private static int ans, T, N, size, coreMax, lineCnt;
	private static int[][] map;

	private static ArrayList<Core> list = new ArrayList<>();

	// 좌우상하
	private static int[] dx = { -1, 1, 0, 0 };
	private static int[] dy = { 0, 0, -1, 1 };


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

		T = Integer.parseInt(br.readLine());

		for (int t = 1; t <= T; t++) {
			N = Integer.parseInt(br.readLine());
			map = new int[N][N];

			// 초기화
			coreMax = 0;
			ans = Integer.MAX_VALUE;
			list.clear();

			for (int i = 0; i < N; i++) {
				StringTokenizer st = new StringTokenizer(br.readLine());
				for (int j = 0; j < N; j++) {
					int m = map[i][j] = Integer.parseInt(st.nextToken());
					if (m == 1) {
						if ((i == 0 || i == N - 1 || j == 0 || j == N - 1)) continue;
						list.add(new Core(i, j));
					}

				}

			}

			size = list.size();

			// 탐색
			subset(0, 0, 0);

			// 출력
			System.out.println("#" + t + " " + ans);

			// break;
		} // end tc

	} // end main


	// depth
	// coreCnt: 코어의 개수
	// sum: 현재까지의 전선 라인 길이의 총합
	private static void subset(int dep, int coreCnt, int sum) {
		if (dep == size) {
			if (coreMax < coreCnt) {
				coreMax = coreCnt;
				ans = sum;
			} else if (coreMax == coreCnt) {
				if (ans > sum) ans = sum;
			}

			return;
		}

		for (int d = 0; d < 4; d++) {
			Core core = list.get(dep);
			int y = core.y;
			int x = core.x;

			// 현재 코어 위치에서 해당 방향으로 연결이 가능한지 확인
			if (check(y, x, d)) {
				setLine(y, x, d, 2); // 전선 놓기
				subset(dep + 1, coreCnt + 1, sum + lineCnt);
				setLine(y, x, d, 0); // 놓은 전선 제거하기
			}

		}

		subset(dep + 1, coreCnt, sum); // 코어 선택 안함
	} // end dfs


	private static void setLine(int y, int x, int d, int op) {
		int ny = y + dy[d];
		int nx = x + dx[d];

		lineCnt = 0;
		while (true) {
			if (ny < 0 || ny >= N || nx < 0 || nx >= N) break;
			map[ny][nx] = op;
			lineCnt++;

			ny += dy[d];
			nx += dx[d];
		}

	} // end setLine


	private static boolean check(int y, int x, int d) {
		int ny = y + dy[d];
		int nx = x + dx[d];

		while (true) {
			if (ny < 0 || ny >= N || nx < 0 || nx >= N) break;
			if (map[ny][nx] != 0) return false;

			ny += dy[d];
			nx += dx[d];
		}

		return true;
	} // end check


	static class Core {
		int y, x;


		public Core(int y, int x) {
			super();
			this.y = y;
			this.x = x;
		}


		@Override
		public String toString() {
			return "Core [y=" + y + ", x=" + x + "]";
		}

	} // end Core
}

Point

➡️ 부분집합을 이용하여 집합에 포함된 코어 카운트와 전선의 길이 합을 구한다.

// depth
// coreCnt: 코어의 개수
// sum: 현재까지의 전선 라인 길이의 총합
private static void subset(int dep, int coreCnt, int sum) {
    if (dep == size) {
        if (coreMax < coreCnt) {
            coreMax = coreCnt;
            ans = sum;
        } else if (coreMax == coreCnt) {
            if (ans > sum) ans = sum;
        }

        return;
    }

    for (int d = 0; d < 4; d++) {
        Core core = list.get(dep);
        int y = core.y;
        int x = core.x;

        // 현재 코어 위치에서 해당 방향으로 연결이 가능한지 확인
        if (check(y, x, d)) {
            setLine(y, x, d, 2); // 전선 놓기
            subset(dep + 1, coreCnt + 1, sum + lineCnt);
            setLine(y, x, d, 0); // 놓은 전선 제거하기
        }

    }

    subset(dep + 1, coreCnt, sum); // 코어 선택 안함
} // end dfs

◾ 코어가 만약 K개 라고 할때, 0 ~ K 개 까지의 코어를 연결할 수 있다.

◾ 연결된 코어의 개수와 전선 길이의 합을 매개변수로 넣어 부분 집합 재귀를 돈다.

◾ 만약 depth 가 K 개와 같다면, 모든 코어가 연결되는지 안되는지 확인을 해 본 것이므로 return 을 한다.

◾ 여기서 값을 갱신해야한다.

◾ 코어가 최대로 연결되었을 때, 연결되어 있는 전선의 최소의 합을 구해야한다.

for (int d = 0; d < 4; d++) {
    Core core = list.get(dep);
    int y = core.y;
    int x = core.x;

    // 현재 코어 위치에서 해당 방향으로 연결이 가능한지 확인
    if (check(y, x, d)) {
        setLine(y, x, d, 2); // 전선 놓기
        subset(dep + 1, coreCnt + 1, sum + lineCnt);
        setLine(y, x, d, 0); // 놓은 전선 제거하기
    }

}

◾ 방향을 따지면서 현재 코어에서 (depth) 해당 방향으로 전선이 연결이 가능한지 확인을 해본다.

◾ 만약 연결이 가능하다면 -> 전선을 놓는다.

◾ 전선을 놓고, 코어를 카운팅 한다.

◾ 놓은 전선을 다시 제거를 해서 다른 방향을 따져본다.

◾ 이렇게 되면, 모든 코어 카운팅에 대해서 상하좌우 4방향을 따질 수 있게 된다.

private static void setLine(int y, int x, int d, int op) {
    int ny = y + dy[d];
    int nx = x + dx[d];

    lineCnt = 0;
    while (true) {
        if (ny < 0 || ny >= N || nx < 0 || nx >= N) break;
        map[ny][nx] = op;
        lineCnt++;

        ny += dy[d];
        nx += dx[d];
    }

} // end setLine

◾ 전선을 해당 방향으로 쭉 놓는다.

◾ 전선을 놓을 때, 전선의 길이가 결정되므로 길이를 카운팅 한다.

◾ 부분집합의 매개변수로 해당 값이 전선의 총합에 계속 더해진다.

private static boolean check(int y, int x, int d) {
    int ny = y + dy[d];
    int nx = x + dx[d];

    while (true) {
        if (ny < 0 || ny >= N || nx < 0 || nx >= N) break;
        if (map[ny][nx] != 0) return false;

        ny += dy[d];
        nx += dx[d];
    }

    return true;
} // end check

◾ 연결이 가능한지 아닌지 확인하는 함수이다.

◾ 만약, 해당 위치가 0이 아니라면 전선을 놓을 수 없는 것이다. 그렇다면 return false 한다.

◾ 전선을 놓을 수 있다면 쭉 전선을 놓는다.

# SW 프로세서 연결하기 java