for IF

@SpringBootTest, @MockBean, Mockito, Junit 등 테스트에 대해서…

이-프 — Sun, 15 Dec 2024 15:15:48 +0900

MockMvc?

MockMvc란
- MVC에 관련된 Mock 가짜 객체
- 웹 어플리케이션을 서버에 배포하지않고, 테스트용 MVC 환경을 만들어서 요청 및 전송, 응답 기능을 제공해주는 객체
- MockMvc를 통해 @Autowired로 주입받아서 사용 가능

@SpringBootTest

SpringApplication을 통해서 테스트에서 사용할 ApplicationContext를 쉽게 생성할 수 있습니다.
그러므로, @SpringBootAplication이 붙은 어노테이션을 찾아 하위의 모든 빈들을 scan하기 때문에 애플리케이션에 정의된 모든 빈을 생성하여 ‘실행 시 느려질 수 있으므로, 단위 테스트에서는 적합하지 않다.’

@SpringBootTest
@AutoConfigureMockMvc //SpringBootTest에서는 MockMvc 객체를 사용하려면 해당 어노테이션 선언 필요
class SpringBootTest {

    @Autowired
    MockMvc mockMvc; // 주입 O
}

@SpringBootTest
@AutoConfigureMockMvc
class SpringBootTest {

    @Autowired
    MockMvc mockMvc; // 주입 O

    @Autowired
    UserController userController; // 주입 O

    @Autowired
    UserRepository userRepository; // 주입 O

    @Autowired
    UserService userService; // 주입 O
}

@WebMvcTest

Web Layer 관련 빈들만 등록하므로, @Component로 등록된 리포지토리와 서비스는 주입이 되지 않는다.
Web Layer = Security, Filter, Interceptor, Handling, Controller
그러므로, 이외는 @MockBean 을 통해 주입받아야한다.
@MockBean = Spring Application Context에 Mock 객체를 빈으로 등록하는데 사용되는 annotation

@WebMvcTest
class SpringBootTest {

		@Autowired
		MockMvc mockMvc; // 주입 O

		@Autowired
		UserController userController; // 주입 O

		//@Autowired
		@MockBean
		UserRepository userRepository; // 주입 X

		//@Autowired
		@MockBean
		UserService userService; // 주입 X
}

Java 단위의 Unit Test (단위 테스트)

JUnit5 : 자바 단위 테스트를 지원하는 ‘테스팅 프레임워크’
AseertJ : .. ‘라이브러리’

given/when/then 패턴

given : 어떤 데이터가 준비되었을 때
when : 어떠한 함수를 실행하면
then : 어떠한 결과가 나와야한다

Mockito

개발자가 동작을 직접 제어할 수 있는 ‘가짜 객체’를 지원하는 테스트 프레임워크

Spring은 여러 객체들 간의 의존성이 발생하는데, 이러한 의존성은 단위 테스트 작성을 어렵게 한다.
이를 해결하기 위해, 가짜 객체를 주입시키는 Mockito 라이브러리를 활용할 수 있다.
가짜 객체에 원하는 결과를 Stub (하향식 테스트) 단위 테스트 가능
- => 가짜 객체를 주입하여 어떤 결과를 반환하라고 준비해야함
- doReturn() : 가짜 객체가 특정한 값을 반환하는 경우
- doNothing() : 가짜 객체가 아무 것도 반환하지 않는 경우 (void)
- doThrow() : 가짜 객체가 예외를 발생시키는 경우

@Mock : 가짜 객체를 만들어 반환
@InjectMocks : 가짜 객체를 자동으로 주입시켜주는 어노테이션
example) @Mock을 통해 가짜 서비스 생성 후, @InjectMocks 를 통해 Controller에 이를 주입할 수 있다.

SpringBoot 2.2.0부터 공식적으로 JUnit5를 지원함에 따라, 이제부터는 @ExtendedWith(MockitoExtension.class)를 사용해야 결합이 가능하다.

@Transactional
@ExtendWith(MockitoExtension.class)
class ProductServiceTest {

    @InjectMocks //@Mock으로 생성된 가짜 객체들을 주입받음 (테스트해야할 서비스)
    private ProductService productService; 
    @Mock
    private MemberService memberService;
    @Mock
    private MemberRepository memberRepository;
    @Mock
    private ReservationRepository reservationRepository;
    @Mock
    private ProductRepository productRepository;
    @Mock
    private SecurityUtil securityUtil;

각 Layer 별 Test 범위

Controller: @WebMvcTest는 웹 계층을 테스트하며, 유닛 테스트라기보다는 웹 통합 테스트에 가까운 테스트입니다.
Repository: @DataJpaTest는 JPA 리포지토리와 데이터베이스의 상호작용을 테스트하며, 이는 통합 테스트에 속합니다.
Service: @ExtendWith(MockitoExtension.class)와 @Mock을 사용하는 서비스 계층 테스트는 유닛 테스트로, 비즈니스 로직만 검증하는 데 중점을 둡니다.

	WebMvcTest	SpringBootTest	Junit 단위(클래스/메소드) 테스트
목적	웹 계층(Controller)만 테스트	전체 애플리케이션(서비스, 리포지토리 등) 통합 테스트	단위(클래스/메소드) 테스트
테스트 범위	Controller, 필터 등 웹 관련 구성 요소만 테스트	전체 Spring 컨텍스트 로드, 실제 서버 및 DB와 연동 가능	특정 클래스나 메소드만 테스트, 외부 의존성 모킹
속도	빠름, 웹 계층만 로드	느림, 전체 애플리케이션 로드	매우 빠름, 독립적 테스트
주요 사용 목적	HTTP 요청과 응답 처리 테스트 (컨트롤러 테스트)	애플리케이션 전체 통합 동작 테스트 (서비스, DB 등)	특정 비즈니스 로직, 메소드 동작 검증
외부 의존성	외부 서비스는 @MockBean을 사용하여 모킹	실제 DB 및 외부 시스템과 통합될 수 있음	외부 의존성은 모킹하여 격리

[백준][자바] 1149 - RGB거리 - DP

이-프 — Sun, 8 Dec 2024 11:19:25 +0900

문제

백준 | RGB거리 | SILVER 1 | DP

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

문제 탐색하기

RGB 거리에는 집이 N개 존재
- 거리는 ‘선분’
- 1~N번 집 존재
- 빨, 초, 파 중 하나의 색
⇒ 각 비용이 존재할 때, 모든 집을 칠하는 비용의 MIN 값 구하기

규칙 :
- 1번 집 색상 ≠ 2번 집 색상
- N번 집 색상 ≠ N-1번 집 색상
- i 번 집 색상 ≠ i-1 (2≤i≤n-1)
- i 번 집 색상 ≠ i+1 (2≤i≤n-1)
입력 :
- N (집의 수)
- 집을 빨, 초, 파로 칠하는 비용 (1~N번 순서로)
출력 :
- 모든 집을 칠하는 비용의 MIN 값

알고리즘

이전의 계산 결과가 이 후의 계산에 영향을 주므로, DP를 활용해서 문제를 풀어야한다.
DP를 풀땐, 규칙이 가장 중요한데…
- 이 문제에서는 빨, 초, 파 3가지 경우가 존재하므로 3가지 모두 선정된다는 가정 하에 계산을 모두 진행하면서
- 최종 행의 MIN값이 답이 될 것이다.

즉, 자기자신을 기준으로 나머지 2개에서 최소값을 더하면서 열3을 갱신해 나아가야한다.

코드 설계하기

n, rgb, dp 초기화
rgb 배열 입력
dp 배열 입력 (rgb 자기자신 + 이전 행의 다른 열 중 최소값)

시도 회차 수정 사항

1회차

배열의 크기를 처음에는 n으로 잡으니, 0일때 이전의 값을 불러 올 수 없어 문제가 발생했음 → n+1로 행의 크기를 넓히기

정답 코드

import java.util.*;
import java.io.*;

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

        int n = Integer.parseInt(br.readLine());
        int[][] rgb = new int[n+1][3];
        int[][] dp = new int[n+1][3];

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

        for(int i = 1; i<=n; i++){
            dp[i][0] = rgb[i][0] + Math.min(dp[i-1][1], dp[i-1][2]);
            dp[i][1] = rgb[i][1] + Math.min(dp[i-1][0], dp[i-1][2]);
            dp[i][2] = rgb[i][2] + Math.min(dp[i-1][0], dp[i-1][1]);
        }

        int answer = Math.min(dp[n][0], dp[n][1]);
        answer = Math.min(answer, dp[n][2]);

        System.out.println(answer);
    }
}

DP 문제에서는 은근히 배열의 크기가 중요할 때가 많은 것 같다.

문제에 나온 예시를 근거로 차근차근 풀어보잣

[백준][자바] 14430 - 자원캐기 - DP

이-프 — Sat, 7 Dec 2024 12:53:28 +0900

문제

백준 | 자원캐기 | SILVER 2 | DP

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

문제 탐색하기

제한된 범위 내에서 자원을 탐색
(1,1) 부터 (N,M)까지 자원을 탐색
오른쪽, 아래쪽으로 한칸 이동 가능
(x,y)에 자원이 있는 경우에만 해당 자원을 채취 가능

입력 :
- n (세로길이 = 행), m(가로길이 = 열)
- n행 m열에 걸쳐 탐사영역
- 자원 = 1, 땅 = 0
출력 : 탐색할 수 있는 자원의 최대 숫자를 구하기

알고리즘

N과 M이 최대 300이므로, 땅의 크기는 최대 90000까지 가능
만약, 완전탐색으로 접근할 경우, N,M까지 가는 경우 O(300^2) + 최대 가지의 수임
DP를 통해서, 최대 광석의 개수를 계속해서 업데이트한다면?
example) DP[i][j] =grid[i][j] + Math.max(DP[i][j-1], DP[i-1][j])

코드 설계하기

n,m, grid 입력
dp 갱신 (DP[i][j] =grid[i][j] + Math.max(DP[i][j-1], DP[i-1][j]))

단, i-1과 j-1이 계산에 필요하므로 기존 n,m보단 +1씩 큰 배열을 만들어서 outOfRange 에러를 방지한다.

정답 코드

import java.util.*;
import java.io.*;

public class Main {

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

        st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        int[][] grid = new int[n+1][m+1];
        int[][] dp = new int[n+1][m+1];

        for(int i = 1; i<=n; i++){
            st = new StringTokenizer(br.readLine());
            for(int j = 1; j<=m; j++){
                grid[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        for(int i = 1; i <= n; i++){
            for(int j = 1; j<=m; j++){
                dp[i][j] = grid[i][j] + Math.max(dp[i][j-1], dp[i-1][j]);
            }
        }

        System.out.println(dp[n][m]);
    }
}

이전에 프로그래머스에서도 이와 비슷한 문제를 풀었던 기억이 난다.

DP는 코드보단 알고리즘 생각에 대한 문제이니, 잘 복습해두자 !!

[백준][자바] 9095 - 1, 2, 3 더하기 - DP

이-프 — Fri, 6 Dec 2024 09:58:08 +0900

문제

백준 | 1, 2, 3 더하기 | SILVER 3 | DP

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

문제 탐색하기

n이 있을 때, 1,2,3의 합으로 나타내는 방법의 수를 찾기
합은 1개 이상 사용해야한다.

알고리즘

방법이 존재하는 경우들을 모두 세야하므로, DP를 활용해야한다.
DP는 그 이전의 결과값을 바탕으로 쓸 수 있으므로, 해당 값을 이용해야한다.

DP[0] = 0

DP[1] = 1

DP[2] = 2

DP[3] = 4

DP[4] = 7 (=1+2+4)

DP[5] = 13 (=2+4+7)

DP[6] = 24 (=4+7+13)

DP[7] = 44 (=7+13+24)

DP[10] = 274

즉, DP[i] = DP[i-1] + DP[i-2] +DP[i-3] (i ≽ 4)

코드 설계하기

t, 케이스 입력
dp 배열 구현
t 케이스에 따른 답변 출력

정답 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main{

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

        int t = Integer.parseInt(br.readLine());

        int[] dp = new int[12];
        dp[1] = 1;
        dp[2] = 2;
        dp[3] = 4;

        for (int i = 4; i < 12; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }

        for (int i = 0; i < t; i++) {
            int num = Integer.parseInt(br.readLine());
            System.out.println(dp[num]);
        }
    }
}

이전에 풀어봤던 문제랑 비슷해서, 생각보다 빠르게 풀 수 있었다!

DP는 진짜.. 알고리즘 싸움보단 수학적 사고를 어떻게 빠르게 하냐의 싸움인 것 같아 문제를 많이 풀어야겠다

[백준][자바] 10026 - 적록색약 - BFS(완전탐색)

이-프 — Thu, 5 Dec 2024 10:26:53 +0900

문제

백준 | 적록색약 | GOLD 5 | 완전탐색

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

문제 탐색하기

N*N크기의 그리드
- R, G, B 가 그리드에 존재
- 구역이 나뉘어 있고, 같은 색으로 있음
- 같은 색상이 상하좌우로 인접 ⇒ 두 글자는 같은 구역에 속함
적록색약 = 빨간색과 초록색의 차이를 거의 느끼지 못함 (빨강과 초록을 하나로 보는 것)

example)

RRRBB
GGBBB
BBBRR
BBRRR
RRRRR

적록색약 x = 4구역

적록색약 o = 3구역

출력 : 적록색약 아닌 사람이 본 구역의 수, 적록색약인 사람이 본 구역의 수

알고리즘

적록색약 및 적록색약 x 사람이 보는 색의 구역을 모두 확인해야하므로, ‘BFS’ 완전탐색을 사용한다.
N이 100이하이므로, 2차배열을 사용하는 BFS에서 100 ^ 2 ≤ 1초 로 BFS 알고리즘이 사용 가능하다.

코드 설계하기

N, 그리드 입력
완전탐색 BFS 코드 구현
1. 코드 구현은 여느 BFS 문제나 같음 BUT, canGo메소드의 차이 존재

시도 회차 수정

1회차

적록색약 grid를 g 제외하고 나머지일 경우, 똑같이 grid에 입력받도록 해야하는데, 이부분을 제외시켰다.

수정 후, 정답 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;


public class Main {

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

        int n = Integer.parseInt(br.readLine());

        String[][] gridDiff = new String[n][n]; //적록색약 x
        String[][] gridDiffNo = new String[n][n]; //적록색약 o
        int[][] visited = new int[n][n];
        for (int i = 0; i < n; i++) {
            String line = br.readLine();
            for (int j = 0; j < n; j++) {
                String color = String.valueOf(line.charAt(j));
                gridDiff[i][j] = color;
                if (color.equals("G")) {
                    gridDiffNo[i][j] = "R";
                } else {
                    gridDiffNo[i][j] = color;
                }
            }
        }

        String[] color = {"R", "G", "B"};
        int redGreenDiff = 0; //적록색약 x
        for (String c : color) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (gridDiff[i][j].equals(c) && visited[i][j] == 0) {
                        bfs(i, j, gridDiff, visited);
                        redGreenDiff++;
                    }
                }
            }
        }

        color = new String[]{"R", "B"};
        visited = new int[n][n];
        int redGreenSame = 0; //적록색약 o
        for (String c : color) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (gridDiffNo[i][j].equals(c) && visited[i][j] == 0) {
                        bfs(i, j, gridDiffNo, visited);
                        redGreenSame++;
                    }
                }
            }
        }


        System.out.print(redGreenDiff + " " + redGreenSame);


    }

    public static void bfs(int x, int y, String[][] grid, int[][] visited) {
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        Queue<GridPoint> queue = new LinkedList<>();
        queue.offer(new GridPoint(x, y));
        visited[x][y] = 1;

        while (!queue.isEmpty()) {
            GridPoint cur = queue.poll();

            for (int i = 0; i < 4; i++) {
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];

                if (canGo(nx, ny, grid, visited, grid[cur.x][cur.y])) {
                    queue.offer(new GridPoint(nx, ny));
                    visited[nx][ny] = 1;
                }
            }
        }
    }

    public static boolean canGo(int x, int y, String[][] grid, int[][] visited, String color) {
        if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length) {
            return false;
        } else if (visited[x][y] == 1 || !grid[x][y].equals(color)) {
            return false;
        }
        return true;
    }

}

class GridPoint {
    int x;
    int y;

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

GOLD 5여서 처음엔 조금 두려웠지만, 어쨌든 BFS 문제는 정형화되어있어서 풀이가 상대적으로 쉬웠다.

다만, 시간 복잡도 면에서 적록색약 유무의 코드를 병합시키는 리팩토링이 필요할 듯 하다.

[백준][자바] 27737 - 버섯농장 - BFS(완전탐색)

이-프 — Wed, 4 Dec 2024 16:09:06 +0900

문제

백준 | 버섯농장 | SILVER 1 | 완전탐색

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

문제 탐색하기

N * N 칸으로 이루어진 나무판
- 버섯이 자랄 수 있는 칸
- 버섯이 자랄 수 없는 칸
M개의 버섯포자 (자랄 수 있는 칸에 배치)
포자가 심어진 칸을 포함해 최대 K개의 연결된 칸에 버섯이 자람
- 상하좌우로 적어도 한 변을 공유하는 칸들
한 칸에 여러개 겹쳐서 심을 수 있음
ex) x개의 버섯 포자 겹쳐서 = x * K개의 연결된 칸에 버섯

입력 : N(크기), M(버섯 포자 개수), K(연결)
- 0 : 버섯 자랄 수 O
- 1 : 버섯 자랄수 X
출력 : 농사가 가능할 경우, 남은 버섯 포자의 개수
- 농사 가능 = 버섯이 자랄 수 있는 모든 칸에 버섯이 전부 자랐을 때 농사가 가능

알고리즘

나무 판에서 ‘버섯이 자랄 수 있는’ 공간들을 연결하는 것이 핵심이므로, 완전탐색(BFS)을 통해 방문하는 것이 적합하다고 판단했습니다.

코드 설계하기

N,M,K 입력
배열 입력 초기화 (grid)
BFS 로직 작성
1. Queue를 활용하여 상하좌우 이동한 노드들 연결
2. 다만, 이동 시 grid를 벗어나지 않는지 및 재방문하지 않는 노드인지 확인 필요
3. 문제에서 땅의 크기를 k로 나눠서 이를 ‘올림’한 값을 M에서 제거하므로 땅의 크기를 return (size)
ex) 예를들어 땅의 크기 4, K 3이면 최소 2개의 포자가 필요 : 4/3 = 1.3333 (올림 → 2)
반환받은 size를 바탕으로 최소 1개의 포자사용 여부 파악
1. 사용 시, possible & m - size
2. 사용 x , impossible

시도 회차 수정

1회차

문제에서 '버섯 포자를 하나라도 사용하고' 라는 조건이 있었는데 이 조건을 놓쳐서 틀렸음을 확인함
⇒ flag를 추가해서 포자 사용 여부를 체크해야한다.

###틀린 1차 코드###
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {

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

        st = new StringTokenizer(br.readLine());

        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

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

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0 && visited[i][j] == 0) {
                    double size = bfs(i, j, visited, grid);
                    size = (int) Math.ceil(size / k);
                    m -= size;
                }
            }
        }

        if(m >=0){
            System.out.println("POSSIBLE");
            System.out.println(m);
        } else {
            System.out.println("IMPOSSIBLE");
        }
    }

    public static double bfs(int x, int y, int[][] visited, int[][] grid) {
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        Queue<Point> queue = new LinkedList<>();
        queue.offer(new Point(x,y));
        visited[x][y] = 1;

        int size = 1;
        while(!queue.isEmpty()){
            Point cur = queue.poll();

            for(int i = 0; i<4; i++){
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];

                if(canGo(nx, ny, grid, visited)){
                    visited[nx][ny] = 1;
                    queue.offer(new Point(nx, ny));
                    size++;
                }
            }
        }
        return size;
    }

    public static boolean canGo(int x, int y, int[][] grid, int[][] visited){
        if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length){
            return false;
        } else if(grid[x][y] == 1 || visited[x][y] == 1){
            return false;
        }
        return true;
    }
}


class Point {
    int x;
    int y;

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

정답 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {

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

        st = new StringTokenizer(br.readLine());

        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

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

        boolean isChanged = false;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0 && visited[i][j] == 0) {
                    double size = bfs(i, j, visited, grid);
                    size = (int) Math.ceil(size / k);
                    m -= size;
                    isChanged = true;
                }
            }
        }

        if(isChanged && m >=0){
            System.out.println("POSSIBLE");
            System.out.println(m);
        } else {
            System.out.println("IMPOSSIBLE");
        }
    }

    public static double bfs(int x, int y, int[][] visited, int[][] grid) {
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        Queue<Point> queue = new LinkedList<>();
        queue.offer(new Point(x,y));
        visited[x][y] = 1;

        int size = 1;
        while(!queue.isEmpty()){
            Point cur = queue.poll();

            for(int i = 0; i<4; i++){
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];

                if(canGo(nx, ny, grid, visited)){
                    visited[nx][ny] = 1;
                    queue.offer(new Point(nx, ny));
                    size++;
                }
            }
        }
        return size;
    }

    public static boolean canGo(int x, int y, int[][] grid, int[][] visited){
        if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length){
            return false;
        } else if(grid[x][y] == 1 || visited[x][y] == 1){
            return false;
        }
        return true;
    }
}


class Point {
    int x;
    int y;

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

최근에 bfs 문제를 계속 풀고 있는데, 문제는 정형화되어 있으므로 반복된 풀이가 필요할 듯 하다.

다만, 이번 문제에서 '1번 이상의 사용' 과 같은 트릭이 있을 수 있으니, 문제를 구체적으로 읽는 연습을 통해 실수를 줄이는 것이 필요할 것 같다. ⭐

[백준][자바] 1326 - 폴짝폴짝 - BFS(완전탐색)

이-프 — Mon, 2 Dec 2024 14:46:52 +0900

문제

백준 | 폴짝폴짝 | SILVER 2 | 완전탐

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

문제 탐색하기

징검다리에 숫자 존재
징검다리에 쓰여 있는 수의 배수만큼 떨어져 있는 곳으로 감
a번째 징검다리에서 b번째 징검다리로 이동
출력 : 최소 몇 번 점프를 하여 b번까지 가는지

알고리즘

‘최소’ 의 점프를 구해야하므로, 완전탐색(DFS/BFS)를 사용할 예정
- DP와 같은 경우에는 ‘누적’된 정보들을 바탕으로 풀어야하는데, 이전 상태값에 의존하는 것은 아니므로 DP로 하지 않아도 될 것이라 생각했다.
징검다리의 개수 N이 10,000까지 존재하므로 O(N^2) = 100,000,000 < 2초 가능

코드 설계하기

N, A, B 입력받기
BFS를 통해
1. 앞으로 가는 경우
2. 뒤로 가는 경우
→ 2가지 방법으로 가능한 경우들을 Queue에 입력받도록 구현
(2 방법 모두 visited를 활용해서 이미 지나간 돌은 제외한다.)

정답 코드

import java.util.*;
import java.io.*;

public class Main {
    static int n;
    static int[] stones;

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

        int answer = 1;

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

        stones = new int[n+1];
        st = new StringTokenizer(br.readLine());

        for(int i = 1; i<n+1; i++){
            stones[i] = Integer.parseInt(st.nextToken());
        }

        String[] ab = br.readLine().split(" ");

        int a = Integer.parseInt(ab[0]);
        int b = Integer.parseInt(ab[1]);

        System.out.println(bfs(a,b));

    }

    public static int bfs(int start, int end){
        int[] visited = new int[n+1];

        visited[start] = 1;

        Queue<Frog> queue = new LinkedList<>();

        queue.offer(new Frog(start, 0));

        while(!queue.isEmpty()){
            Frog frog = queue.poll();

            if(frog.pos == end){
                return frog.cnt;
            }

            int jump = stones[frog.pos];

            //앞으로가는경우
            for(int i = frog.pos; i< n+1; i+= jump){
                if(visited[i] == 1){
                    continue;
                }
                visited[i] = 1;
                queue.offer(new Frog(i, frog.cnt+1));
            }

            //뒤로가는경우
            for(int i = frog.pos; i>=1; i-= jump){
                if(visited[i] == 1){
                    continue;
                }
                visited[i] = 1;
                queue.offer(new Frog(i, frog.cnt + 1));
            }

        }
        return -1;

    }
}

class Frog {
    int pos;
    int cnt;

    public Frog(int pos, int cnt){
        this.pos = pos;
        this.cnt = cnt;
    }
}

처음에 뭔가 '최소' 라는 키워드에 꽂혀서 BFS인것은 눈치를 챘으나.. 확연하게 문제 푸는 방식이 떠오르지 않아 당황했다.

또한 A B 우리 뇌리속에선 A가 먼저, B가 이후인데 이에 대한 정보도 문제에선 주어지지 않았으니 ..... (당황)

앞으로는 문제 접근을 할 때 내 상상보단, '문제'에 집중을 해야겠다

[백준][JAVA] 1713 - 후보 추천하기 - 시뮬레이션

이-프 — Fri, 29 Nov 2024 16:21:24 +0900

문제

백준 | 후보 추천하기 | SILVER 1 | 시뮬레이션

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

문제 탐색하기

학생회장 후보 = 일정기간동안 전체 학생의 추천 수
홈페이지 사진틀의 수 = 후보의 수
- 모든 사진틀 empty
- 어떤 학생 → 특정 학생 추천 : 추천받은 학생이 사진틀에 게시
- 모두 full → 추천받은 횟수가 가장 적은 학생의 사진을 삭제 & 새롭게 추천받은 학생 게시 (OS 페이징 기법 중, LFU)
  - 만약, 2명 이상 = 게시된 지 가장 오래된 사진을 삭제(OS 페이징 기법중, LRU)
- 게시된 학생이 다른 학생의 추천을 ‘또’ 받으면, 추천 횟수 +1
- if 삭제되는 경우 = 추천횟수는 0으로 변경
출력 : 최종 후보 (제일 추천이 많은 후보)

example)

2 1 4 3 5 6 2 7 2

2 0 0

2 1 0

2 1 4

1 4 3

4 3 5

3 5 6

5 6 2

6 2 7

6 2 7 (받은 개수 : 1,2,1)

⇒ 출력 : 2, 6, 7 (오름차순으로 표현)

알고리즘

N ≤ 20
총 추천횟수 ≤1000
학생번호 ≤100

⇒ 20 * 1000 * 100 = 1초 이내로 가능할 듯!

객체를 먼저 만든다 (횟수 cnt, 사진에 등록된 시간(오래됨을 판별))
이를 바탕으로 PriorityQueue를 이용해서 매번 sorting을 진행해준다.

시도 회차 수정 사항

1회차

런타임에러 발생
그도그럴것이… queue를 막상 사용해보니 너무 비효율적임
- 매번 time을 +1해주는 것과 num을 찾아 돌리고 다시 넣어주는 것이 비효율적
⇒ cntPlus와 timePlus 메소드 변경 필요

import java.util.*;
import java.io.*;


public class q1713_silver1 {

    static PriorityQueue<Person> pq = new PriorityQueue<>((o1,o2) -> {
        if(o1.cnt != o2.cnt){
            return o1.cnt - o2.cnt;
        } else {
            return o2.time - o1.time;
        }
    });

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

        int n = Integer.parseInt(br.readLine());
        int cnt = Integer.parseInt(br.readLine());
        st = new StringTokenizer(br.readLine());
        for(int i = 0; i<cnt; i++){
            int person = Integer.parseInt(st.nextToken());
            if(!cntPlus(person)) {
                if(pq.size() == n){
                    pq.poll();
                    pq.offer(new Person(person, 1, 0));
                } else {
                    pq.offer(new Person(person, 1, 0));
                }
            }
            timePlus();
        }


        List<Person> list = new ArrayList<>();
        while(!pq.isEmpty()){
            Person person = pq.poll();
            list.add(person);
        }

        Collections.sort(list, (o1, o2) -> o1.num - o2.num);

        for(Person p : list){
            System.out.print(p.num + " ");
        }
    }

    public static boolean cntPlus(int num){
        Queue<Person> queue = new LinkedList<>();
        boolean isCntChanged = false;
        while(!pq.isEmpty()){
            Person person = pq.poll();
            if(person.num == num){
                queue.offer(new Person(person.num, person.cnt+1, person.time));
                isCntChanged = true;
            } else {
                queue.offer(person);
            }
        }

        while(!queue.isEmpty()){
            pq.offer(queue.poll());
        }

        return isCntChanged;
    }

    public static void timePlus(){
        Queue<Person> queue = new LinkedList<>();
        while(!pq.isEmpty()){
            Person person = pq.poll();
            queue.offer(new Person(person.num, person.cnt, person.time+1));
        }

        while(!queue.isEmpty()){
            pq.offer(queue.poll());
        }
    }
}

class Person  {
    int num;
    int cnt;
    int time;

    public Person(int num, int cnt, int time){
        this.num = num;
        this.cnt = cnt;
        this.time = time;
    }
}

2회차 변경사항

List<Person> tmpList = new ArrayList<>(pq);

=> PriorityQueue와 같은 Queue 구현체는 Collection 인터페이스를 상속하므로, 이를 ArrayList 같은 리스트로 변환 가능

public static boolean cntPlus(int num){
    boolean isCntChanged = false;
    List<Person> tmpList = new ArrayList<>(pq);
    pq.clear();
    for(Person person : tmpList){
        if(person.num == num){
            person.cnt +=1;
            isCntChanged = true;
        }
        pq.offer(person);
    }
    return isCntChanged;
}

public static void timePlus(){
    List<Person> tmpList = new ArrayList<>(pq);
    pq.clear();
    for(Person person : tmpList){
        person.time += 1;
        pq.offer(person);
    }
}

정답 코드

import java.util.*;
import java.io.*;

public class Main{

    static PriorityQueue<Person> pq = new PriorityQueue<>((o1,o2) -> {
        if(o1.cnt != o2.cnt){
            return o1.cnt - o2.cnt; //추천횟수는 적을수록 삭제가능성 up
        } else { 
            return o2.time - o1.time; //시간은 오래될수록(클수록) 삭제가능성 up
        }
    });

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

        int n = Integer.parseInt(br.readLine());
        int times = Integer.parseInt(br.readLine());

        st = new StringTokenizer(br.readLine());
        for(int i = 0; i<times; i++){
            int person = Integer.parseInt(st.nextToken());
            if(!cntPlus(person)) {
			            //number가 같은지 확인함 (같다면 시간만 +1, 다르다면 pq 크기에 따라 다르게)
                 if(pq.size() == n){
                     pq.poll();  
                 } 
                 pq.offer(new Person(person, 1, 0));
            }
            timePlus();
        }


        List<Person> list = new ArrayList<>(pq);

        Collections.sort(list, (o1, o2) -> o1.num - o2.num); //num 기준 오름차순으로 수행

        for(Person p : list){
            System.out.print(p.num + " ");
        }
    }

    public static boolean cntPlus(int num){
        boolean isCntChanged = false;
        List<Person> tmpList = new ArrayList<>(pq);
        pq.clear();
        for(Person person : tmpList){
            if(person.num == num){
                person.cnt +=1;
                isCntChanged = true;
            }
            pq.offer(person);
        }
        return isCntChanged;
    }

    public static void timePlus(){
        List<Person> tmpList = new ArrayList<>(pq);
        pq.clear();
        for(Person person : tmpList){
            person.time += 1;
            pq.offer(person);
        }
    }
}

class Person  {
    int num;
    int cnt;
    int time;

    public Person(int num, int cnt, int time){
        this.num = num;
        this.cnt = cnt;
        this.time = time;
    }
}

Silver1문제인데,, 생각보다 어렵게 푼 듯하다.

다른 분들 풀이 참고했을때는 LinkedHashMap으로 푸셨는데, 이부분도 추후 참고해서 다시 풀어봐야겠다.

또한, Queue를 바로 List로 변경할 수 있는지 알게되서 시간초과를 해결할 수 있었다. 앞으로도 차근차근 배워야지 !

[프로그래머스][JAVA] 신규아이디 추천 - 문자열

이-프 — Fri, 29 Nov 2024 14:58:14 +0900

문제

프로그래머스 | 신규아이디 추천 | level1 | 문자열

https://school.programmers.co.kr/learn/courses/30/lessons/72410

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 탐색하기

규칙에 맞지 않는 아이디 입력시, 규칙에 맞는 아이디를 추천
- 3~15 자 아이디
- 소문자, 숫자, - , _, . 만 사용 가능
  - .는 처음과 끝에 사용 x
  - 연속 x (.. x)

코드 설계하기

단계별로 수행하기!
Key Point는 최대한 깔끔하게 코드 설계해서 문자열 정리하는 것

시도 회차 진행 방향

1회차

3단계, 4단계, 6단계에서 틀림
- 3단계 | ..이 2개 이상 나타날 때니까, 2개만 나타나도 해당 (.indexOf())
- 4단계 | 맨 앞에 . 이나, 맨 뒤의 .이나 둘 다 똑같이 if문으로 진행해야함(if else로 진행 xxx)
- 6단계 | str.substring(a,b) = a이상, b미만

2회차 (정답)

import java.util.*;
import java.io.*;

class Solution {
    public String solution(String new_id) {
        String answer = "";
        
        //1단계 : new_id의 모든 대문자를 대응되는 소문자로 치환
        new_id = new_id.toLowerCase();
        
        //2단계 : new_id에서 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 모든 문자를 제거합니다.
        for (int i = 0; i < new_id.length(); i++) {
            char ch = new_id.charAt(i);
            if (Character.isAlphabetic(ch) || 
                Character.isDigit(ch) || 
                ch == '-' || ch == '_' || ch == '.')
                answer += ch;
        }
        
        //3단계 : new_id에서 마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환합니다.
        while (answer.indexOf("..") != -1)
            answer = answer.replace("..", ".");
        
        //4단계 : new_id에서 마침표(.)가 처음이나 끝에 위치한다면 제거합니다.
        if(!answer.isEmpty() && answer.charAt(0) == '.'){
            answer = answer.substring(1);
        } 
        if (!answer.isEmpty() && answer.charAt(answer.length()-1) == '.'){
            answer = answer.substring(0, answer.length()-1);
        }
        
        
        
        //5단계 : new_id가 빈 문자열이라면, new_id에 "a"를 대입합니다.
        if(answer.isEmpty()){
            answer += "a";
        }
        
        //6단계 : new_id의 길이가 16자 이상이면, new_id의 첫 15개의 문자를 제외한 나머지 문자들을 모두 제거합니다.
                 //만약 제거 후 마침표(.)가 new_id의 끝에 위치한다면 끝에 위치한 마침표(.) 문자를 제거합니다.

        if(answer.length() > 15){
            answer = answer.substring(0, 15);
            if(answer.charAt(answer.length()-1) == '.'){
                answer = answer.substring(0, answer.length()-1);
            }
        }
        
        
        //7단계 : new_id의 길이가 2자 이하라면, new_id의 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙입니다.         
        while(answer.length() < 3){
            char last = answer.charAt(answer.length()-1);
            answer += String.valueOf(last);
        }

        return answer;
    }
}

문자열 문제에서 암기하면 좋을 메소드 정리

(1) 소문자 <-> 대문자
String tmp = "apPLe";
tmp.toUpperCase //APPLE
tmp.toLowerCase //apple


(2) .indexOf() 
특정 '문자'나, '문자열'이 앞에서부터 처음 발견되는 인덱스를 반환
만약, 찾지 못한다면 '-1' 반환
String tmp = "apPLe";
tmp.indexOf("a") //0
tmp.indexOf("pP") //1
tmp.indexOf("A") //-1


(3) .substring(int startIdx) .substring(int startIdx, int endIdx)
startIdx 이상 또는 startIdx 이상 endIdx 미만으로 특정 부분을 잘라냄
String tmp = "apPLe";
tmp.substring(2) // PLe
tmp.substring(1,3) //pP

(4) .isEmpty()
문자열이 빈 문자열일 경우에 true를 반환하는 함수
tmp = "";
tmp.isEmpty() //true
tmp2 = "apple"
tmp.isEmpty() //false


(5) .replace(CharSequence target, CharSequence replacement)
target부분을 replacement로 대치
String tmp = "apppple"
tmp.replace("pppp", "PP") //aPPle
-> 만약에 tmp.replace("pp", "PP") 로 하면, aPPpple가 된다 (replace는 첫 번째 매칭만!)
-> 그러므로, 만약 pppp를 다 바꾸고 싶으면 tmp.replaceAll("pp", "PP"); replaceAll로 해야함 (aPPPPPPPPle)

코테를 보다보면, 문자열 문제가 빈번하게 출제되는데 쉬운것 같으면서도 메소드에 대한 지식에 없으면 풀기가 난처하다 ㅠㅠ
쉬운 부분도 결코 놓치지 않고.. 꼭 맞아서 합격까지 !!! ⭐⭐⭐⭐⭐

[백준][JAVA] 2631 - 줄세우기 - DP, 이진탐색

이-프 — Thu, 28 Nov 2024 16:17:17 +0900

문제

백준 | 줄세우기 | GOLD 4 | DP, 이진탐

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

문제 탐색하기

일반적인 정렬 알고리즘은 최대 O(NlogN) ~ O(N^2) 까지 될 수 있어서… 비추하는 방법일 것 같은데
문제에서 N이 고작 200이하의 정수라고 주어졌고
시간제한이 1초라면, 최대 40000 즉, 1초도 안넘을 것임 ⇒ 그러므로 일반 정렬 사용해도 괜찮다.
근데 문제는,,, ‘정렬’을 하는 것이 아니라, ‘최소 몇 번으로 이동 가능’이므로 ‘DP’로 풀어야할 것.

3 7 5 2 6 1 4 - 3 5 6
3 7 4 5 2 6 1 (4번 이동) - 3456
3 4 5 2 6 1 7 (7번 이동) - 34567
1 3 4 5 2 6 7 (1번 이동) - 1 3 4 5 6 7
1 2 3 4 5 6 7 (2번 이동) - 1234567

⇒ 지금 문제를 보면, 총 4번의 이동에서 LIS (최장 증가 부분수열) 법칙이 쓰였음을 알 수 있음

알고리즘

LIS

1️⃣ DP 활용 (O(n^2))

ARR[] = 3 7 5 2 6 1 4

DP = [1,1,1,1,1,1,1] : 최소 1개는 존재 (자기자신)

DP[1] =3< 7 : DP[1] = DP[1] + 1 = 2;

DP[2] = 3 < 5 , 7 < 5(X) = DP[2] + 1 = 2;

DP[3] = 아무것도 X = DP[3] = 1;

DP[4] = 3 < 6, 5 < 6, 2 < 6 = DP[4] + 3 = 4;

⇒ 여기서 이렇게 생각했는데 이러면 3, 5 2 이런식으로 되서 안됨 !!! 그래서 Math.max로 되는걸 확인해줘야함

⭐그렇다면 ?

i = 4 (arr[4] = 6)

- j = 0: arr[0] < arr[4] (3 < 6) → dp[4] = dp[0] + 1 = 2

- j = 1: arr[1] > arr[4] (7 > 6) → 갱신 X ⇒ dp[i] < dp[j] + 1

- j = 2: arr[2] < arr[4] (5 < 6) → dp[4] = dp[2] + 1 = 3

- j = 3: arr[3] < arr[4] (2 < 6) → dp[4] = dp[3] + 1 = 2 (이미 3이므로 갱신 X)

이 방식대로 계속 이어나가면 됨!!

2️⃣ 이진 탐색 활용 (Binary Search) (O(nlogn))

수열의 크기가 크게 주어진다면, 시간 초과가 발생할 수 있으므로 효율성을 올리기 위해서는 ‘이진탐색’으로 최적화 작업을 이뤄 시간복잡도를 줄인다.

근데,,, 이진탐색은 공식이 ‘오름차순 정렬’이 되어있는 수열에서 가능한데 어떻게 구현할까 ?

⇒ LIS의 형태를 유지하기 위해서 주어진 배열의 인덱스를 하나씩 살피며 숫자가 들어갈 위치를 이분탐색으로 탐색 !!

⇒ 단, 이진 탐색을 활용한 LIS는 ‘길이’에만 집중을 하는 것 (NOT 실제 답)

example

(1) LIS의 마지막 요소 < ARR[i] : LIS의 마지막에 부착

(2) LIS의 마지막 요소 > ARR[i] : 이분탐색을 활용해서 해당 요소가 어디 들어갈지 확인 & 대체

ARR[] = 3 7 5 2 6 1 4

LIS[] = 3

LIS[] = 3 7 → (1)

LIS[] = 3 5 (2) 이분탐색을 통해 해당 INDEX에 대체함

LIS[] = 2 5 (2)

LIS[] = 2 5 6 (1)

⇒ 즉, 길이가 3인 LIS가 나올 것

코드 설계하기

아이들의 수 N, 1~n명의 줄 숫자 입력
LIS 코드 작성

정답 코드

##dp##
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main{

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

        int n = Integer.parseInt(br.readLine());
        int[] children = new int[n];
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        for (int i = 0; i < n; i++) {
            children[i] = Integer.parseInt(br.readLine());
        }

        int maximum = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (children[i] > children[j] && dp[i] < dp[j] + 1) {
                    dp[i] = dp[j] + 1;
                }
            }
            maximum = Math.max(maximum, dp[i]);
        }

        System.out.println(n - maximum);
    }
}

## 이진탐색 ##
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class q2631_gold4_2 {

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

        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];
        int[] lis = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        int idx = 0;
        lis[idx++] = arr[0];

        for (int i = 1; i < n; i++) {
            if (lis[idx - 1] < arr[i]) {
                lis[idx++] = arr[i];
            } else {
                int start = 0;
                int end = idx - 1;

                while (start <= end) {
                    int mid = start + (end - start) / 2;
                    if (lis[mid] < arr[i]) {
                        start = mid + 1;
                    } else {
                        end = mid - 1;
                    }
                }

                lis[start] = arr[i];
            }
        }

        int cnt = 0;
        for (int i = 0; i < n; i++) {
            if (lis[i] > 0) {
                cnt++;
            }
        }

        System.out.println(n - cnt);
    }
}

실제로 코드 길이 대비 확실히 이진탐색이 더 메모리가 적게 들어가긴 했다.

근데 문제의 N크기가 그렇게 큰편이 아니라 그런지 차이가 미미한듯 하다.

그럼에도 불구하고, 각 알고리즘의 시간복잡도에 따른 구현의 차이를 배운 것 같아 다행이다