• 카카오 계정을 통해 사용자가 애플리케이션에 로그인할 수 있도록 도와주는 인증 서비스
• 사용자는 카카오 계정으로 인증받고, 애플리케이션은 카카오를 통해 사용자 정보를 안전하게 받을 수 있음

JWT

• 클라이언트와 서버 간 정보를 안전하게 전달하기 위한 토큰
• 사용자 인증 후 서버에서 생성
• API 요청 시 Authorization 헤더에 포함하여 서버에 전송
• 서버는 JWT 검증을 통해 사용자의 인증 상태 확인

OAuth

• 클라이언트가 리소스 소유자의 데이터를 안전하게 접근할 수 있도록 허가하는 프로토콜
• 제 3자 클라이언트가 사용자의 접근 권한을 위임받을 수 있는 표준 프로토콜

Spring Security

• 요청 중간에 필터가 생기는 것

순서

1. 클라이언트가 카카오 로그인 요청
2. 서버가 카카오 인증 서버로 OAuth 인가 코드 요청
3. 사용자에게 인증 요청 및 로그인
4. 카카오 인증 서버에서 인가 코드 발급
5. 서버가 인가 코드를 사용하여 카카오 인증 서버에 접근 토큰 요청
6. 카카오에서 받은 접근 토큰으로 사용자 정보를 요청하고 이 정보를 기반으로 애플리케이션 서버에서 JWT 생성
7. Spring Security를 통한 JWT 저장(로컬 저장소 / 쿠키) 및 관리
8. 클라이언트가 API 요청 시 Authorization 헤더에 JWT를 포함하여 서버에 요청
9. Spring Security에서 요청을 가로채고 JWT의 유효성을 검증
10. Spring Security가 JWT검증을 통과하면 서버에서 접근 권한 허용 및 응답

• HTTP 요청의 일부
• 사용자가 현재 요청을 보내기 전에 방문했던 웹 페이지의 URL을 포함
• 웹 서버가 사용자의 이전 페이지를 알 수 있도록 도와줌
• CORS 정책에 따라 다른 출처의 리소스에 대한 요청에서 Referer 헤더가 제한될 수 있음

용도

1. 트래픽 분석 : 사용자가 어떤 페이지에서 현재 페이지로 유입되었는지를 분석하여 트래픽 소스를 파악할 수 있음
2. 보안 : 요청의 출처를 확인하고, 특정 페이지에서만 접근할 수 있도록 제한하는 등 보안 조치를 취할 수 있음
3. 사용자 경험 개선 : 사용자가 이전에 방문한 페이지에 따라 맞춤형 콘텐츠를 제공하거나, 사용자가 어떤 경로로 사이트를 탐색했는지를 이해하는 데 도움을 줄 수 있음

형식

Referer: https://example.com/previous-page

• 로그인한 사용자의 권한을 이용하여 웹사이트에 악성 요청을 보내는 것(사용자가 이미 로그인 한 상태에서 공격자가 사용자의 권한으로 요청을 보내는 것)
• 서버에서 발생 함
• 권한을 도용당한 클라이언트가 가짜 요청을 서버에게 전송하는 것

순서

1. 사용자가 A 사이트에 로그인
2. A사이트가 세션 쿠키를 브라우저에 저장
3. 사용자가 악성 사이트 B를 방문
4. B사이트에서 악성 코드 실행(사용자의 세션 쿠키를 포함하여 A사이트로 전송)
5. A사이트는 이 요청을 정상적인 사용자로부터 온 요청으로 인식하고 처리

방어법

• 각 요청에 대해 고유한 CSRF 토큰을 생성하고 검증하여 요청의 유효성을 확인
• CSRF 토큰을 HTML 폼에 숨겨진 필드로 추가하여 서버로 요청을 전송한 후 서버에서 세션에 저장된 토큰과 비교
• 쿠키에 SameSite 속성을 설정하여 외부 사이트에서의 요청에 대해 쿠키가 전송되지 않도록 함
• 요청의 Referer 헤더를 확인하여 요청이 신뢰할 수 있는 출처에서 온 것인지 검증

import java.util.*;

class Solution {
    public String solution(int[] numbers) {
        String answer = "";
        String[] arr = new String[numbers.length];
        boolean isZero = true;
        for(int i=0; i<numbers.length; i++){
            arr[i] = numbers[i] + "";
            if(!arr[i].equals("0")){
                isZero = false;
            }
        }
        //문자열 두 개를 이어 붙인 수를 내림차순 정렬
        // Arrays.sort(arr, new Comparator<String>(){
        //    @Override
        //     public int compare(String o1, String o2){ 
        //         return Integer.parseInt(o2+o1) - Integer.parseInt(o1+o2);
        //     }
        // });
        Arrays.sort(arr,(o1,o2)->Integer.parseInt(o2+o1) - Integer.parseInt(o1+o2));
        for(int i=0; i<numbers.length; i++){
            answer += arr[i];
            if(isZero){
                answer = "0";
            }
        }
        return answer;
    }
}

• Java의 Map 인터페이스에서 제공하는 중첩 인터페이스
• 맵의 Key, Value 쌍을 쉽게 다루기 위해 사용
• 주로 Map의 entrySet() 메소드와 함께 사용하여 맵의 모든 엔트리를 반복할 때 유용

기본 문법

Map<K, V> map = new HashMap<>(); //map에 key-value 쌍 추가

for(Map.Entry<K, V> entry : map.entrySet()){
    K key = entry.getKey(); //키 가져오기
    V value = entry.getValue(); //값 가져오기
}

import java.util.*;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        //신고당한 user를 key로, 신고 user를 map으로 -> 신고당한 user의 중복 알아서 제거
        //report : 신고자id 신고한id
        HashMap<String, HashSet<String>> map = new HashMap<>();
        HashSet<String> set;
        HashMap<String, Integer> cnt = new HashMap<>(); //처리 결과를 받은 유저

        for(int i=0; i<report.length; i++){
            String[] input = report[i].split(" ");
            if(!map.containsKey(input[1])){ //신고당한 기록이 없는 경우
                set = new HashSet<>(); //새로운 해시셋 만들기
            }else{
                set = map.get(input[1]); //input[1]의 map 가져오기
            }
            set.add(input[0]); //set에 신고한 유저 추가
            map.put(input[1], set); //신고당한 유저에 set 추가
        }

        //이제 map에서의 value값인 set 탐색
        for(Map.Entry<String, HashSet<String>> entry : map.entrySet()){
            if(entry.getValue().size() >= k){ //신고 횟수가 k 이상인 경우
                for(String s : entry.getValue()){  //값들을 하나씩 순회
                    cnt.put(s, cnt.getOrDefault(s,0)+1);
                }
            }
        }

        int[] answer = new int[id_list.length];
        for(int i=0; i<id_list.length; i++){
            if(cnt.containsKey(id_list[i])){
                answer[i] = cnt.get(id_list[i]);
            }else{
                answer[i] = 0;
            }
        }
        return answer;
    }
}

HashMap 안에 ArrayList를 만드는 것 까지는 괜찮았지만, HashMap을 value값을 기준으로 정렬 하는 것이 어려웠다.

우선, Key에 해당하는 값을 가져와서 ArrayList에 담아야 한다. index에 key값을 저장하고, 각 방에 해당하는 값에 value를 저장하는 것이다.

import java.util.*;

class Solution {
    public ArrayList solution(String[] genres, int[] plays) {
        //속한 노래가 많이 재생된 장르 -> 장르 내에서 재생된 노래 -> 재생 횟수가 같으면 고유 번호가 낮은 노래
        int len = genres.length;
        HashMap<String, Integer> cntMap = new HashMap<>(); //전체 재생 횟수를 구하기 위함
        HashMap<String, ArrayList<int[]>> map = new HashMap<>(); //장르, <재생횟수, 고유번호> 
        ArrayList<Integer> answer = new ArrayList<>();

        for(int i=0; i<len; i++){ 
            if(cntMap.containsKey(genres[i])){
                cntMap.put(genres[i], cntMap.get(genres[i])+plays[i]);
            }else{
                cntMap.put(genres[i], plays[i]);
            }
        }

        for (int i=0; i<len; i++) {
            if (!map.containsKey(genres[i])) { //키가 없으면
                map.put(genres[i], new ArrayList<int[]>()); //빈 배열 생성 -> 이 과정을 안해주면 NullPointerException 발생
            }
            map.get(genres[i]).add(new int[]{plays[i], i}); //재생 횟수, 고유 번호 저장
        }

        //cntMap을 value값을 기준으로 정렬
        ArrayList<String> list = new ArrayList<>(cntMap.keySet());
        Collections.sort(list, new Comparator<String>(){
            @Override
            public int compare(String o1, String o2){
                return cntMap.get(o2) - cntMap.get(o1); //내림차순 정렬
            }
        });

        for(int i=0; i<list.size(); i++){
            ArrayList<int[]> songs = map.get(list.get(i));
            Collections.sort(songs, new Comparator<int[]>(){
                @Override
                public int compare(int[] o1, int[] o2){
                    if(o1[0] == o2[0]){
                        return o1[1] - o2[1];
                    }
                    return o2[0] - o1[0];
                }
            });
            for(int j=0; j<songs.size(); j++){
                if(j >= 2){
                    break;
                }
                answer.add(songs.get(j)[1]);
            }
        }

        return answer;
    }
}

문자열에 x가 들어간다면 그 문자열은 x항인 것이다. 만약, 문자열이랑 x와 같다면 계수가 1인 것이다. 또한, 문자가 isDigit이면, 상수항인 것이다.

isDigit은 String으로 판단할 수 없기 때문에 charAt을 이용하여 그 한 자리 수를 Character로 변경하고 isDigit 메소드를 사용해 주엇다.

마지막으로, numCnt가 1인 경우에는 계수를 생략시켜서 문자열로 출력시켜 주어야 한다.

class Solution {
    public String solution(String polynomial) {
        String[] input = polynomial.split(" ");
        int xCnt = 0; //계수
        int numCnt = 0; //상수항
        String answer = "";
        for(int i=0; i<input.length; i++){
            if(input[i].contains("x")){ //x항일 경우
                if(input[i].equals("x")){ //계수가 1일 경우
                    xCnt = xCnt + 1;
                }else{ //계수가 붙은 경우 -> 계수가 두개인 경우도 생각해야함
                    input[i] = input[i].replace("x", "");
                    xCnt += Integer.parseInt(input[i]);
                }
            }else if(Character.isDigit(input[i].charAt(0))){
                numCnt += Integer.parseInt(input[i]);
            }
        }

        if (numCnt > 0 && xCnt > 0) {
            if(xCnt == 1){
                answer = "x" + " + " + numCnt;
            }else{
                answer = xCnt + "x" + " + " + numCnt;
            }
        } else if (numCnt <= 0 && xCnt > 0) {
            if(xCnt == 1){
                answer = "x";
            }else{
                answer = xCnt + "x";
            }
        } else if (numCnt > 0 && xCnt <= 0) {
            answer = numCnt + "";
        } 
        return answer;
    }
}

Comparator를 사용하면 쉽게 문제가 풀린다. compare메소드 안에 diffA와 diffB를 선언해준 후 문제를 풀면 된다. 이 문제를 풀고 나니 Comparator에 대한 감이 잡힌 것 같다.

import java.util.*;

class Solution {
    public ArrayList solution(int[] numlist, int n) {
        int[] answer = {};
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0; i<numlist.length; i++){
            list.add(numlist[i]);
        }
        Collections.sort(list, new Comparator<Integer>(){
           @Override
            public int compare(Integer a, Integer b){
                int diffA = Math.abs(a-n);
                int diffB = Math.abs(b-n);

                if(diffA == diffB){
                    //같으면 숫자가 큰 게 우선
                    return b-a;
                }
                return diffA - diffB;
            }
        });
        return list;
    }
}

• 정규화된 엔티티, 속성, 관계에 대해 성능 향상과 개발 운영의 단순화를 위해 중복, 통합, 분리 등을 수행하는 데이터 모델링의 기법
• 데이터의 일관성과 무결성을 우선으로 할지, 데이터베이스의 성능과 단순화에 우선순위를 둘 것인지를 비교

장점

• 성능 향상과 관리의 효율성 증가

단점

• 데이터의 일관성 및 정합성 저하
• 유지를 위한 비용 발생 -> 성능에 나쁜 영향을 미칠 수 있음

기법

Math.sqrt()는 return type이 double이다. 이것을 몰라서 테스트 케이스 7,8번 통과를 못했었다. 제곱근의 값을 정수로 강제형변환 한 후 제출하니 모든 테스트 케이스를 통과하였다.

import java.util.*;

class Solution {
    public int solution(int n) {
        int answer = 2;
        //n이 제곱수면 1, 아니면 2
        if(n == (int)Math.sqrt(n) * (int)Math.sqrt(n)){
            answer = 1;
        }
        return answer;
    }
}

각 문자를 k번 반복해 새로운 문자열을 만들고, 그 새로운 문자열을 k번 반복해 ArrayList에 넣어 주면 된다.

import java.util.*;

class Solution {
    public ArrayList solution(String[] picture, int k) {
        int len = picture.length;
        ArrayList<String> list = new ArrayList<>();
        for(int i=0; i<len; i++){
            String newStr = "";
            String[] str = picture[i].split("");
            for(int j=0; j<str.length; j++){
                for(int a=0; a<k; a++){
                    newStr += str[j];
                }
            }
            for(int j=0; j<k; j++){
                list.add(newStr);
            }
        }
        return list;
    }
}

반례

입력

3 1

정답

9 2 3 8 1 4 7 6 5 2 2

위의 반례를 찾지 못해서 시간이 많이 소요되었다. 위의 반례의 경우에는 while문이 돌기 전의 조건(arr[rowStart][colStart] = num++;의 조건)이므로 내가 따로 지정을 해 주어야 한다.

package silver3;

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

public class num1913 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int inputNum = Integer.parseInt(br.readLine());
        int num = 1; // 시작 수
        int[][] arr = new int[N][N];
        int x = 0;
        int y = 0;

        int rowStart = N / 2;
        int colStart = N / 2;

        arr[rowStart][colStart] = num++;
        if (arr[rowStart][colStart] == inputNum) {
            x = N / 2;
            y = N / 2;
        }
        int steps = 1; // 나선의 초기 크기

        while (num <= N * N) {
            for (int i = 0; i < steps; i++) {
                if (num > N * N) {
                    break;
                }
                rowStart--; //위로
                arr[rowStart][colStart] = num++;
                if (arr[rowStart][colStart] == inputNum) {
                    x = rowStart;
                    y = colStart;
                }
            }

            for (int i = 0; i < steps; i++) {
                if (num > N * N) {
                    break;
                }
                colStart++; //오른쪽으로
                arr[rowStart][colStart] = num++;
                if (arr[rowStart][colStart] == inputNum) {
                    x = rowStart;
                    y = colStart;
                }
            }
            steps++;

            for (int i = 0; i < steps; i++) {
                if (num > N * N) {
                    break;
                }
                rowStart++; //아래로
                arr[rowStart][colStart] = num++;
                if (arr[rowStart][colStart] == inputNum) {
                    x = rowStart;
                    y = colStart;
                }
            }

            for (int i = 0; i < steps; i++) {
                if (num > N * N) {
                    break;
                }
                colStart--; //왼쪽으로
                arr[rowStart][colStart] = num++;
                if (arr[rowStart][colStart] == inputNum) {
                    x = rowStart;
                    y = colStart;
                }
            }
            steps++;
        }

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println((x + 1) + " " + (y + 1));
    }
}

우선, n이 4일때를 기준으로 문제를 이해해 보자.

첫 번째 for문을 보면 같은 행에서 시작을 한다. 즉, 0번째 줄에서 시작하는 것이다. 0번째 줄에서 시작해서 열(세로줄)을 하나씩 채우는 것이다. 그러면 배열의 첫 번째 줄에 1,2,3,4가 들어간다. 그 다음, rowStart를 1 증가시켜 시작 행을 1 증가시켜준다.

그 다음, 두 번째 for문을 보면 맨 마지막 열에서 그 아래로 내려가는 로직이다. 그럼 맨 마지막 줄의 세로줄이 4,5,6,7이 채워진다. 그 다음 맨 마지막 열을 채웠으므로 colEnd를 1 줄여주어 끝 열을 하나 단축시켜준다.

그 다음에는 for문을 이용하여 1씩 감소시켜 반복시켜 주면 된다.

정답 코드 1

class Solution {
    public int[][] solution(int n) {
        int[][] answer = new int[n][n];
        int num = 1; //배치할 숫자
        int rowStart = 0; //행(가로)
        int rowEnd = n-1;
        int colStart = 0; //열(세로)
        int colEnd = n-1;
        //처음에는 오른쪽 끝까지 이동
        while(rowStart <= rowEnd && colStart <= colEnd){ //아직 채우지 않은 행과 열이 있는지 판단
            for(int i=colStart; i<=colEnd; i++){ //세로꺼를 하나하나 채워야 함
                answer[rowStart][i] = num++; //0번째 행
            }
            rowStart++; //행 증가

            for(int i=rowStart; i<=rowEnd; i++){
                answer[i][colEnd] = num++; //맨 마지막 가로줄 하나씩 채우기
            }
            colEnd --; //한 칸 왼쪽으로

            if(rowStart <= rowEnd){
                for(int i=colEnd; i>=colStart; i--){
                    answer[rowEnd][i] = num++; //세로 채우기
                }
                rowEnd --; //한 칸 오른쪽으로
            }

            if(colStart <= colEnd){
                for(int i=rowEnd; i>=rowStart; i--){
                    answer[i][colStart] = num++; //가로 채우기
                }
                colStart ++;
            }
        }
        return answer;
    }
}

정답 코드 2

이 코드는 dx, dy를 사용하는 코드이다. 이 코드를 이해하는데 더 어려웠지만, 코드를 이해하고 나니 더 쉬웠다.

way는 방향을 나타내는 변수이다. 즉, dx와 dy를 합쳐 보면 {오른쪽, 아래, 왼쪽, 위}의 순서로 탐색을 진행한다. dx는 x좌표를, dy는 y좌표에 관여한다고 생각하면 이해하기가 쉽다.

좌표를 보면 헷갈리기 때문에 코드로 살펴봐야 한다. 0,0부터 시작이기 때문에 answer[0][0] = 1, visited[0][0] = true가 된다. 이 때 if문의 조건에 부합하지 않기 때문에 if문을 건너뛴다. 그러면 그 다음 while문의 반복에서 마지막 조건인 visited[0][0]==true에서 걸리기 때문에 way를 1 증가시켜준다. 그러면 x=0, y=1이 되고, answer[0][1] = 2, visited[0][1] = true가 되는 것이다.

즉, (0,0) -> (0,1)의 순서로 좌표가 채워지는 것이다.

만약, 나선의 방향을 변경하고 싶다면 dx,dy의 순서를 변경하면 된다.

import java.util.*;

class Solution {
    public int[][] solution(int n) {
        int[] dx = {1,0,-1,0};
        int[] dy = {0,1,0,-1};

        boolean[][] visited = new boolean[n][n];
        int x = 0;
        int y = 0;
        int num = 1;
        int way = 0;
        int[][] answer = new int[n][n];
        while(num <= Math.pow(n,2)){
            answer[x][y] = num;
            visited[x][y] = true;
            if(x + dx[way] < 0 || x + dx[way] >= n || y + dy[way] < 0 || y + dy[way] >= n || visited[x+dx[way]][y+dy[way]]==true){
                way++;
                way %= 4;
            }
            //위의 조건을 모두 통과하는 경우에만 이동
            x = x + dx[way];
            y = y + dy[way];
            num++;
        }
        return answer;
    }
}

import java.util.*;

class Solution {
    public int[][] solution(int[][] arr) {
        int rows = arr.length; //행 -> 가로줄
        int coll = arr[0].length; //열 -> 안의 각각 요소
        int size = Math.max(rows, coll); //둘 중 더 큰 사이즈 찾기
        int[][] answer = new int[size][size];
        for(int i=0; i<size; i++){
            //각 요소를 복사해서 넣기
            if(i < rows){
                answer[i] = Arrays.copyOf(arr[i], size);
            }else{
                Arrays.fill(answer[i], 0);
            }
        }
        return answer;
    }
}

전 날 여태까지 했던 프로젝트인 오목, 축하해요, 그리고 이번 쏠거지까지 전시를 하고 스티커도 제작했었다.

발표장에는 무려 신한 ds 본부장님도 오시고, 그 외에도 정말 많은 높으신 분들이 와 주셨다. 대략 10분정도 되는 것 같았다 ㅎㅎ

심지어 아침에 커피차도 와 있었다. 인당 커피 한 잔에 츄러스까지 주셨다 ㅠㅠ 저 때 먹은 츄러스는 지금도 먹고싶을 정도로 맛있었다..🤤

발표는 옆반까지 총 합쳐서 8팀이서 했는데, 5회차(우리반), 6회차 순서대로 한 팀씩 번갈아가면서 진행하였다. 앞 4팀이 1부, 뒷 4팀이 2부였는데, 우리팀은 2부 두 번째 순서였다.

팀장 언니가 발표를 하고, 팀원 전체가 나가서 질의응답을 받았다. 애초에 발표도 잘했었던지라 분위기가 좋았는데, 질의응답에서 웃음이 많이 터졌다. 이 때 속으로 솔직히 상을 기대했던 것 같다 ㅎㅎ

한 분이 우리 발표에 대한 피드백 및 앞으로 추가하면 좋을 것 같은 기능을 말씀해 주셨는데, 내가 "신한 쏠에 저희 프로젝트 끼워주시면 추진해 보겠습니다!!" 라고 답했다. 이 말에 다들 웃음을 터뜨려 주셔서 너무 감사했다ㅠㅠ

발표 전, 쉬는시간에 우리 팀이 만든 스티커를 나눠드리며 "부자되세요~"라고 외치고 다녔었고, 발표 때도 팀원 모두가 옷에 스티커를 하나씩 붙이고 나갔었다.

전반적으로 우리 팀의 좋았던 분위기가 발표에서도 잘 드러난 것 같아서 너무 뿌듯했다. 이를 좋게 봐주신 덕분인지, 우리 팀은 최우수상을 수상하였다 !!!!

정말 너무 기분이 좋아서 웃음이 감춰지지 않았다ㅠㅠ 우리 팀은 팀원의 평균 나이도 가장 어렸고, 인원수도 가장 적었던 팀이었기에 솔직히 최우수상까지는 기대하지 않았었는데, 놀랍게도 최우수상이었기 때문이다!!ㅠㅠ

이후 시상식이 끝나고, 강점 멘토링을 해 주셨던 분께서 소감을 말씀해 주셨는데, 그 분도 스티커를 옷에 붙이고 나와주셨다. 상당히 기억에 남는 팀이었다면서 스티커를 붙여 주셨는데, 진짜 너무 감동받았고 좋게 봐 주셔서 너무너무 감사드렸다.

그동안 노력했던 것이 헛되지 않았음이 증명되었고, 모두에게 인정받는 기분이었다. 무엇보다 이력서에 추가할 수상 경력이 한 줄 생겨서 너무 행복했고, 학원 수료식이 끝난 지금 시점까지도 너무너무 행복하다.

반례를 찾는 것에서 살짝 시간 소요가 되었다.

class Solution {
    public int solution(int[] date1, int[] date2) {
        int answer = 1;
        if(date1[0] > date2[0]){ //앞에꺼의 연도가 더 크면
            answer = 0;
        }else if(date1[0] == date2[0]){ //연도가 같으면
            if(date1[1] > date2[1]){
                answer = 0;
            }else if(date1[1] == date2[1]){
                if(date1[2] >= date2[2]){
                    answer = 0;
                }
            }
        }
        return answer;
    }
}

이 문제는 dfs를 이용하여 푸는 문제이다. 음식물 쓰레기가 있다고 가정한 후, 상하좌우를 비교하여 연속된 곳에 있으면 그 곳을 찾으면 된다. 즉, 주어진 2차원 배열에서 음식물 쓰레기가 있는 위치를 기준으로 dfs를 수행하며, 인접한 음식물 쓰레기의 개수를 세는 방식인 것이다. 배열을 순회하며 음식물 쓰레기가 있으면 dfs를 호출하고, 상하좌우의 인접한 위치를 탐색하면서 아직 방문하지 않은 음식물 쓰레기가 있는 경우 dfs를 또 호출하여 깊이를 탐색하는 것이다.

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

public class Main {
    public static boolean[][] visited;
    public static int[][] arr;
    public static int N, M, K, answer, max;
    public static int[] dx = {-1, 1, 0, 0};
    public static int[] dy = {0, 0, -1, 1};

    public static void main(String[] args) throws IOException {
        //방문한 적이 없고 쓰레기라면 dfs 탐색
        //가장 큰 음식물 쓰레기의 개수를 구하는 거니까 인접한 경우(위, 아래가 붙은 경우) 1씩 더해주면 됨
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] input1 = br.readLine().split(" ");
        N = Integer.parseInt(input1[0]); //통로의 세로 길이
        M = Integer.parseInt(input1[1]); //통로의 가로 길이
        K = Integer.parseInt(input1[2]); //떨어진 음식물 쓰레기의 개수
        arr = new int[N][M]; //세로 가로
        visited = new boolean[N][M];
        for (int i = 0; i < K; i++) { //음식물 쓰레기가 있는 곳을 입력
            String[] input = br.readLine().split(" ");
            int r = Integer.parseInt(input[0]); //위에서부터(세로)
            int c = Integer.parseInt(input[1]); //왼쪽에서부터(가로)
            arr[r - 1][c - 1] = 1;
        }
        max = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (arr[i][j] == 1 && !visited[i][j]) { //쓰레기이고 방문하지 않은 경우에만 탐색
                    answer = 0;
                    dfs(i, j);
                    if (answer > max) {
                        max = answer;
                    }
                }
            }
        }
        System.out.println(max);
        br.close();
    }

    public static void dfs(int x, int y) {
        visited[x][y] = true;
        answer++;

        for (int i = 0; i < 4; i++) {
            int nowX = x + dx[i];
            int nowY = y + dy[i];

            if (nowX >= 0 && nowY >= 0 && nowX < N && nowY < M) {
                if (!visited[nowX][nowY] && arr[nowX][nowY] == 1) {
                    dfs(nowX, nowY);
                }
            }
        }
    }
}

이 숫자는 앞에 있는 0을 제거하는 문제이다. 처음에는 문자열의 replace, substring을 사용해서 문제를 풀었었는데, 그냥 string값을 int로 변환해 주면 되는 문제였다!!

class Solution {
    public String solution(String n_str) {
        //String을 정수로 변환하면 됨
        int num = Integer.parseInt(n_str);
        return num+"";
    }
}