호텔을 운영 중인 코니는 최소한의 객실만을 사용하여 예약 손님들을 받으려고 합니다. 한 번 사용한 객실은 퇴실 시간을 기준으로 10분간 청소를 하고 다음 손님들이 사용할 수 있습니다.
예약 시각이 문자열 형태로 담긴 2차원 배열 book_time이 매개변수로 주어질 때, 코니에게 필요한 최소 객실의 수를 return 하는 solution 함수를 완성해주세요.

제한사항

• 1 ≤ book_time의 길이 ≤ 1,000
  

• book_time[i]는 ["HH:MM", "HH:MM"]의 형태로 이루어진 배열입니다
  
• [대실 시작 시각, 대실 종료 시각] 형태입니다.
  
• 시각은 HH:MM 형태로 24시간 표기법을 따르며, "00:00" 부터 "23:59" 까지로 주어집니다.
  
• 예약 시각이 자정을 넘어가는 경우는 없습니다.
  
• 시작 시각은 항상 종료 시각보다 빠릅니다.

입출력 예

정답코드

import java.util.LinkedList;
import java.util.Collections;

class room implements Comparable<room>{

    int start;
    int end;

    public room(int start , int end){
        this.start = start;
        this.end = end;
    }

    public int compareTo(room o){
        if(this.start != o.start)return this.start-o.start;
        else return this.end-o.end;
    }
}


class Solution {
    public int solution(String[][] book_time) {
        int answer = 0;

        LinkedList<room>roomList = new LinkedList<>();
        LinkedList<Integer>endTime = new LinkedList<>();


        for(int i = 0; i < book_time.length; i++){
            String[] start = book_time[i][0].split(":");
            String[] end = book_time[i][1].split(":");

            int sTime = Integer.parseInt(start[0])*60+Integer.parseInt(start[1]);
            int eTime = Integer.parseInt(end[0])*60+Integer.parseInt(end[1]);

            room r = new room(sTime,eTime);
            roomList.add(r);
        }

        Collections.sort(roomList);

        while(!roomList.isEmpty()){
            room now = roomList.poll();
            int diff = Integer.MAX_VALUE;
            int idx = -1;

            if(endTime.isEmpty())endTime.add(now.end+10);
            else{
                for(int i = 0; i < endTime.size(); i++){
                    if(now.start >= endTime.get(i) && now.start-endTime.indexOf(i)<diff){
                        diff = now.start-endTime.indexOf(i);
                        idx = i;
                    }
                }
                if(idx == -1)endTime.add(now.end+10);
                else {
                    endTime.remove(idx);
                    endTime.add(idx,now.end+10);
                }
            }

        }

        return endTime.size();
    }
}

피드백

강의실 배정과 비슷한 그리디 문제 시작시간 기준 정렬과, 자료구조를 활용하는 문제 걸린시간: 30분 난이도 5/10

1 x 1 크기의 칸들로 이루어진 직사각형 격자 형태의 미로에서 탈출하려고 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽으로 된 칸은 지나갈 수 없고 통로로 된 칸으로만 이동할 수 있습니다.
통로들 중 한 칸에는 미로를 빠져나가는 문이 있는데, 이 문은 레버를 당겨서만 열 수 있습니다. 레버 또한 통로들 중 한 칸에 있습니다.
따라서, 출발 지점에서 먼저 레버가 있는 칸으로 이동하여 레버를 당긴 후 미로를 빠져나가는 문이 있는 칸으로 이동하면 됩니다. 이때 아직 레버를 당기지 않았더라도 출구가 있는 칸을 지나갈 수 있습니다. 미로에서 한 칸을 이동하는데 1초가 걸린다고 할 때, 최대한 빠르게 미로를 빠져나가는데 걸리는 시간을 구하려 합니다.
미로를 나타낸 문자열 배열 maps가 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 만약, 탈출할 수 없다면 -1을 return 해주세요.

제한사항

• 5 ≤ maps의 길이 ≤ 100, 5 ≤ maps[i]의 길이 ≤ 100
  
• maps[i]는 다음 5개의 문자들로만 이루어져 있습니다. S : 시작 지점 E : 출구 L : 레버 O : 통로 X : 벽
  
• 시작 지점과 출구, 레버는 항상 다른 곳에 존재하며 한 개씩만 존재합니다. 출구는 레버가 당겨지지 않아도 지나갈 수 있으며, 모든 통로, 출구, 레버, 시작점은 여러 번 지나갈 수 있습니다.

입출력 예

정답코드

import java.util.Queue;
import java.util.LinkedList;

class Node{

    int x;
    int y;
    int depth;

    Node(int x, int y, int depth){
        this.x = x;
        this.y = y;
        this.depth = depth;
    }
}


class Solution {
    static char [][] map;
    static int N = 0;
    static int M = 0;
    static int startX = 0;
    static int startY = 0;
    static int leverX = 0;
    static int leverY = 0;
    static int endX = 0;
    static int endY = 0;
    static int answer = 0; 
    static int [] dx = {-1,1,0,0};
    static int [] dy = {0,0,-1,1};

    public int solution(String[] maps) {

        N = maps.length;
        M = maps[0].length();

        map = new char[N][M]; 

        for(int i = 0; i < N; i++){
            String input = maps[i];
            for(int j = 0; j < M; j++){
                map[i][j] = input.charAt(j);
                if(input.charAt(j) == 'S'){
                    startX = i;
                    startY = j;
                }
                else if(input.charAt(j) == 'L'){
                    leverX = i;
                    leverY = j;
                }
                else if(input.charAt(j) == 'E'){
                    endX = i;
                    endY = j;
                }
            }
        }

        int StoL = bfs(startX,startY,'L');
        if(StoL == -1)return -1;
        answer+=StoL;

        int LtoE = bfs(leverX,leverY,'E');

        if(LtoE == -1)return -1;
        else{
            System.out.println(LtoE);
            return answer+=LtoE;
        }

    }

    public static int bfs(int Bx, int By,  char c){

        Queue<Node>queue = new LinkedList<>();
        Node nd = new Node(Bx,By,0);
        queue.offer(nd);
        boolean [][] visited = new boolean[N][M];
        visited[Bx][By] = true;


        while(!queue.isEmpty()){ 
            Node nowNode = queue.poll();
            int x = nowNode.x;
            int y = nowNode.y;
            int depth = nowNode.depth;
            if(map[x][y] == c)return nowNode.depth;

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

                if(nx<0||ny<0||nx>=N||ny>=M||map[nx][ny]=='X'||visited[nx][ny])continue;

                Node newNode = new Node(nx,ny,depth+1);
                queue.offer(newNode);
                visited[nx][ny] = true;
            }
        }

        return -1;
    }
}

피드백

최단거리 문제는 BFS를 이용하는데 굳이 Depth별로 할 필요가 없다면 일반적인 버전으로 풀자, 그리고 distance를 직접 안 새고 visited에 한번에 처리해서 visited[nx][ny] = visited[x][y]+1 식으로도 가능 걸린시간 40분, 난이도 : 4/10

스프링부트 RestAPI 서버를 배포하기 위한 전처리 과정이 필요. swagger이외에 AWS EC2, Netlify, Heroku 등등 서버에 배포하려면 프로젝트를 war또는 jar파일로 export해야한다.

JAR, WAR 파일

기본적으로 JAR, WAR 모두 Java의 jar 옵션 (java -jar)을 이용해 생성된 압축(아카이브) 파일로, 애플리케이션을 쉽게 배포하고 동작시킬 수 있도록 관련 파일(리소스, 속성 파일 등)을 패키징 한 것

JAR (Java Archive)

• JAVA 어플리케이션이 동작할 수 있도록 자바 프로젝트를 압축한 파일
• Class (JAVA리소스, 속성 파일), 라이브러리 파일을 포함함 JRE(JAVA Runtime Environment)만 있어도 실행 가능함 (java -jar 프로젝트네임.jar)

WAR (Web Application Archive)

• Servlet / Jsp 컨테이너에 배치할 수 있는 웹 애플리케이션(Web Application) 압축파일 포맷 웹 관련 자원을 포함함 (JSP, Servlet, JAR, Class, XML, HTML, Javascript)

• 사전 정의된 구조를 사용함 (WEB-INF, META-INF) 별도의 웹서버(WEB) or 웹 컨테이너(WAS) 필요

• JAR파일의 일종으로 웹 애플리케이션 전체를 패키징 하기 위한 JAR 파일이다.

어떤 걸 써야하는가?

• SpringBoot를 사용한다면 Jar

• JAR, WAR 파일 애플리케이션 리소스를 패키징 하는 방법에 차이가 있을 뿐, 뭘 사용해야 하느냐는 개발자의 판단에 따름.

• 꼭 WAR를 사용해야만 하는 이유(꼭 JSP를 사용하여 화면을 구성해야 한다 / 외장 WAS를 이용할 계획이 있다)가 아니라면 뭘 사용할지에 대한 완벽한 해답은 없다.

하지만 Sprinag boot에서 가이드하는 표준은 JAR(JSP, 외장톰켓을 안사용)이니까 JAR를 사용하여 서비스하는 것이 좋다.

인텔리제이 프로젝트 -> war파일 만들기

상위 탭에 view -> Tool Windows -> Maven 클릭

clean -> complie -> install을 순서대로 누른다

.m2 폴더에 내 패키지 폴더를 보면 war파일이 만들어져있다.

인텔리제이 프로젝트 -> jar파일 만들기

File -> Project Structure -> Artifacts -> + 버튼 -> JAR -> From modules with dependences 클릭

Build -> Build Artifacts 클릭

Action -> Build 클릭

out폴더 -> artifacts -> project.jar 파일 생성

org.springframework.context.ApplicationContextException: Failed to start bean'documentationPluginsBootstrapper'; nested exception is java.lang.NullPointerException
at org.springframework.context.support.DefaultLifecycleProcessor.doStart(DefaultLifecycleProcessor.java:181) ~[spring-context-5.3.13.jar:5.3.13]
at org.springframework.context.support.DefaultLifecycleProcessor.access 200(DefaultLifecycleProcessor.java:54) ~[spring-context-5.3.13.jar:5.3.13]
at org.springframework.context.support.DefaultLifecycleProcessorLifecycleGroup.start(DefaultLifecycleProcessor.java:356) ~[spring-context-5.3.13.jar:5.3.13] at java.lang.Iterable.forEach(Iterable.java:75) ~[na:1.8.0_311]
at org.springframework.context.support.DefaultLifecycleProcessor.startBeans(DefaultLifecycleProcessor.java:155) ~[spring-context-5.3.13.jar:5.3.13]
at org.springframework.context.support.DefaultLifecycleProcessor.onRefresh(DefaultLifecycleProcessor.java:123) ~[spring-context-5.3.13.jar:5.3.13]
at org.springframework.context.support.AbstractApplicationContext.finishRefresh(AbstractApplicationContext.java:935) ~[spring-context-5.3.13.jar:5.3.13]
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:586) ~[spring-context-5.3.13.jar:5.3.13]
at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:145) ~[spring-boot-2.6.1.jar:2.6.1]
at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:730) ~[spring-boot-2.6.1.jar:2.6.1]
at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:412) ~[spring-boot-2.6.1.jar:2.6.1]
at org.springframework.boot.SpringApplication.run(SpringApplication.java:302) ~[spring-boot-2.6.1.jar:2.6.1]
at com.ej.batchtest.BatchTestApplication.main(BatchTestApplication.java:18) [main/:na]
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_311]
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_311]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_311] at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_311]
at org.springframework.boot.devtools.restart.RestartLauncher.run(RestartLauncher.java:49) [spring-boot-devtools-2.6.1.jar:2.6.1] Caused by: java.lang.NullPointerException: null
at springfox.documentation.spring.web.WebMvcPatternsRequestConditionWrapper.getPatterns(WebMvcPatternsRequestConditionWrapper.java:56) ~[springfox-spring-webmvc-3.0.0.jar:3.0.0]
at springfox.documentation.RequestHandler.sortedPaths(RequestHandler.java:113) ~[springfox-core-3.0.0.jar:3.0.0]
at springfox.documentation.spi.service.contexts.Orderings.lambda$byPatternsCondition$3(Orderings.java:89) ~[springfox-spi-3.0.0.jar:3.0.0]

환경

인텔리제이
jdk11 SpringBoot 2.6.1 gradle Swagger 3.0.0 SwaggerUI 3.0.0

해결방법

1. 스웨거 설정한 class에 WebMvcConfiguationSupport 를 확장시킨다.

• 오류가 난 코드에는 extends를 따로 안 했었음

2. 새로운 경로를 잡아준다 (extends한 거 Override)

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
   registry.addResourceHandler("/swagger-ui/**").addResourceLocations("classpath:/META-INF/resources/webjars/springfox-swagger-ui/");
   registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/springfox-swagger-ui/");
}

마인은 곡괭이로 광산에서 광석을 캐려고 합니다. 마인은 다이아몬드 곡괭이, 철 곡괭이, 돌 곡괭이를 각각 0개에서 5개까지 가지고 있으며, 곡괭이로 광물을 캘 때는 피로도가 소모됩니다. 각 곡괭이로 광물을 캘 때의 피로도는 아래 표와 같습니다.
예를 들어, 철 곡괭이는 다이아몬드를 캘 때 피로도 5가 소모되며, 철과 돌을 캘때는 피로도가 1씩 소모됩니다. 각 곡괭이는 종류에 상관없이 광물 5개를 캔 후에는 더 이상 사용할 수 없습니다.
마인은 다음과 같은 규칙을 지키면서 최소한의 피로도로 광물을 캐려고 합니다.

• 사용할 수 있는 곡괭이중 아무거나 하나를 선택해 광물을 캡니다.
• 한 번 사용하기 시작한 곡괭이는 사용할 수 없을 때까지 사용합니다.
• 광물은 주어진 순서대로만 캘 수 있습니다.
• 광산에 있는 모든 광물을 캐거나, 더 사용할 곡괭이가 없을 때까지 광물을 캡니다.
  즉, 곡괭이를 하나 선택해서 광물 5개를 연속으로 캐고, 다음 곡괭이를 선택해서 광물 5개를 연속으로 캐는 과정을 반복하며, 더 사용할 곡괭이가 없거나 광산에 있는 모든 광물을 캘 때까지 과정을 반복하면 됩니다.
  마인이 갖고 있는 곡괭이의 개수를 나타내는 정수 배열 picks와 광물들의 순서를 나타내는 문자열 배열 minerals가 매개변수로 주어질 때, 마인이 작업을 끝내기까지 필요한 최소한의 피로도를 return 하는 solution 함수를 완성해주세요.

제한사항

picks는 [dia, iron, stone]과 같은 구조로 이루어져 있습니다.

• 0 ≤ dia, iron, stone ≤ 5
• dia는 다이아몬드 곡괭이의 수를 의미합니다.
• iron은 철 곡괭이의 수를 의미합니다.
• stone은 돌 곡괭이의 수를 의미합니다.
• 곡괭이는 최소 1개 이상 가지고 있습니다.
  
  
• 5 ≤ minerals의 길이 ≤ 50
• minerals는 다음 3개의 문자열로 이루어져 있으며 각각의 의미는 다음과 같습니다.
• diamond : 다이아몬드
• iron : 철
• stone : 돌

입출력 예

정답코드

import java.util.*;

class fiveMin implements Comparable<fiveMin>{
    int dia;
    int iron;
    int stone;

    public fiveMin(int dia, int iron, int stone){
        this.dia = dia;
        this.iron = iron;
        this.stone = stone;
    }

    //다이아>철>돌이 많은 미네랄 수로 정렬 
    @Override
    public int compareTo(fiveMin o){
        if(o.dia == this.dia){
            if(o.iron == this.iron){
                return o.stone - this.stone;
            }
            return o.iron - this.iron;
        }
        return o.dia - this.dia;
    } 
}


class Solution {
    public int solution(int[] picks, String[] minerals) {
        int answer = 0;

        ArrayList<fiveMin>minList = new ArrayList<>();

        int total = picks[0]+picks[1]+picks[2]; //총 곡괭이 수
        int d = 0;
        int ir = 0;
        int s = 0;

         //광물 5개씩 나눠서 객체 생성하기 
        int numOfFiveMin = 0;
        if(minerals.length % 5 == 0) numOfFiveMin = (int)minerals.length/5;
        else numOfFiveMin = (int)minerals.length/5+1;

        //min(곡괭이 갯수,전체를 5로 나눈 갯수)만큼의 광물 세트가 생긴다 
        numOfFiveMin = Math.min(numOfFiveMin,total);

        int cnt = 1;
        for(int i = 0; i < minerals.length; i++){
            if(minerals[i].equals("diamond"))d++;
            if(minerals[i].equals("iron"))ir++;
            if(minerals[i].equals("stone"))s++;

            if(i > numOfFiveMin*5)break;

            if(i!=0 && (cnt%5==0||i==minerals.length-1)){
                fiveMin fm = new fiveMin(d,ir,s); 
                minList.add(fm);
                d = 0;
                ir = 0;
                s = 0;
            }  
            cnt++;
        }

        Collections.sort(minList); 

        int pickNum = 0;
        loop:
        for(int i = 0; i < minList.size(); i++){
            fiveMin fm = minList.get(i);
            //System.out.println(fm.dia+" "+fm.iron+" "+fm.stone);

            //현재 곡괭이를 다 쓴 경우 
            if(picks[pickNum] == 0){
                if(pickNum == 2)break;

                else if(pickNum == 1){
                     if(picks[2] == 0)break;
                     else pickNum = 2;
                }

                else if(pickNum == 0){
                    if(picks[1] == 0 && picks[2] != 0) pickNum = 2;
                    else if(picks[1] == 0 && picks[2] == 0)break;
                    else pickNum = 1;
                }
            }

            //다이아 곡괭이인 경우
            if(pickNum == 0){
                answer+= fm.dia + fm.iron +fm.stone;
                picks[0]--;
            }

            //철 곡괭이인 경우
            else if(pickNum == 1){
                answer+= 5*fm.dia + fm.iron +fm.stone;
                picks[1]--;
            }

            //돌 곡괭이인 경우
            else {
                answer+= 25*fm.dia + 5*fm.iron +fm.stone;
                picks[2]--;
            }
        }
        return answer;
    }
}

피드백

5개로 묶어서 sorting 하는데 문제 조건에서는 광물 순서대로 캐야한다고 나와있다 여기서 문제가 되는 케이스 -> 곡괭이 갯수가 부족해서 뒤에는 못 캐는데 얘를 sorting 해버려서 우선순위에 들어오는 경우가 발생할 수 있다. 문제 조건을 제대로 읽자

아이디어를 떠올리는 건 어렵지 않지만 자잘한 조건 처리가 조금 까다로운 문제 난이도 5.5/10, 걸린시간 1시간

과제를 받은 루는 다음과 같은 순서대로 과제를 하려고 계획을 세웠습니다.
과제는 시작하기로 한 시각이 되면 시작합니다.
새로운 과제를 시작할 시각이 되었을 때, 기존에 진행 중이던 과제가 있다면 진행 중이던 과제를 멈추고 새로운 과제를 시작합니다.
진행중이던 과제를 끝냈을 때, 잠시 멈춘 과제가 있다면, 멈춰둔 과제를 이어서 진행합니다.
만약, 과제를 끝낸 시각에 새로 시작해야 되는 과제와 잠시 멈춰둔 과제가 모두 있다면, 새로 시작해야 하는 과제부터 진행합니다.
멈춰둔 과제가 여러 개일 경우, 가장 최근에 멈춘 과제부터 시작합니다.
과제 계획을 담은 이차원 문자열 배열 plans가 매개변수로 주어질 때, 과제를 끝낸 순서대로 이름을 배열에 담아 return 하는 solution 함수를 완성해주세요.

제한사항

• 3 ≤ plans의 길이 ≤ 1,000

• plans의 원소는 [name, start, playtime]의 구조로 이루어져 있습니다.
• name : 과제의 이름을 의미합니다.
• 2 ≤ name의 길이 ≤ 10
• name은 알파벳 소문자로만 이루어져 있습니다.
• name이 중복되는 원소는 없습니다.
• start : 과제의 시작 시각을 나타냅니다.
• "hh:mm"의 형태로 "00:00" ~ "23:59" 사이의 시간값만 들어가 있습니다.
• 모든 과제의 시작 시각은 달라서 겹칠 일이 없습니다.
• 과제는 "00:00" ... "23:59" 순으로 시작하면 됩니다. 즉, 시와 분의 값이 작을수록 더 빨리 시작한 과제입니다.
• playtime : 과제를 마치는데 걸리는 시간을 의미하며, 단위는 분입니다.
• 1 ≤ playtime ≤ 100
• playtime은 0으로 시작하지 않습니다.
• 배열은 시간순으로 정렬되어 있지 않을 수 있습니다.
• 진행중이던 과제가 끝나는 시각과 새로운 과제를 시작해야하는 시각이 같은 경우 진행중이던 과제는 끝난 것으로 판단합니다.

입출력 예

정답코드

//1. 시간이 빠른 순으로 진행해야 하니까 시간을 ":"을 기준으로 split 해서 분으로 바꿔서 sort
//2. 가장 최근에 멈춘 과제부터 다시 시작하니까 LIFO Stack을 사용한다
//3. 현재 과제를 하면서 그 다음 과제의 시작시간이 언제인지 tracking 한다. 
//4. 완료가 된 순서대로 ArrayList에 넣는다 

import java.util.*;

class homework implements Comparable<homework> {

    String name;
    int startTime;
    int time;

    public homework(String name, int startTime, int time){
        this.name = name;
        this.startTime = startTime;
        this.time = time;
    }

    public int compareTo(homework o){
        return this.startTime - o.startTime;
    }
}

class rest {

    String name;
    int restTime;

    public rest(String name, int restTime){
        this.name = name;
        this.restTime = restTime;
    }
}

class Solution {
    public String[] solution(String[][] plans) {
        String[] answer = {};

        PriorityQueue<homework>pq = new PriorityQueue<>();
        ArrayList<String>result = new ArrayList<>();
        Stack<rest>restStack = new Stack<>();


        for(String [] plan : plans){
            String name = plan[0];
            int time = Integer.parseInt(plan[2]);

            String [] temp = plan[1].split(":");
            int startTime = Integer.parseInt(temp[0])*60 + Integer.parseInt(temp[1]);
            pq.offer(new homework(name, startTime, time));
        }


        int nextStart = 0;
        int nowEnd, diff;

        while(!(pq.isEmpty()&&restStack.isEmpty())){

            //List에 할 일이 남아있을 때
            if(!pq.isEmpty()){
                homework now = pq.poll();
                nowEnd = now.startTime+now.time;

                if(!pq.isEmpty())nextStart = pq.peek().startTime;
                else if(pq.isEmpty()){
                    result.add(now.name);
                    continue;
                }

                //지금 하는 과제 중간에 다른 과제를 시작해야한다면 stack에 남은시간과 함께 추가하기 
                if(nowEnd > nextStart){
                    diff = nowEnd - nextStart;
                    rest task = new rest(now.name,diff);
                    restStack.push(task);
                }

                //지금하는 일을 다음 과제 시작전에 마칠 수 있을 때 
                else{ 
                    result.add(now.name);
                    if(restStack.isEmpty()||nowEnd == nextStart||pq.isEmpty())continue;

                    //과제를 하고 남은 시간 
                    diff = nextStart - nowEnd;

                    //남은 시간을 다 써도 stack 첫번째 일을 못 끝내는 경우
                    if(diff < restStack.peek().restTime){
                        restStack.peek().restTime-=diff;
                    }

                    //남은 시간 동안 1개 이상의 과제를 할 수 있을 때
                    else{                   
                        //과제를 모두 끝낼 수 있을 때 까지 stack에서 꺼내 과제를 한다
                        while (diff > 0){
                            if(restStack.isEmpty())break;
                            rest nowRest = restStack.pop();

                            //하나를 끝내고 이 다음 과제도 수행이 가능하면
                            if(diff - nowRest.restTime >= 0){
                                diff -= nowRest.restTime;
                                result.add(nowRest.name);
                                continue;
                            }

                            //이번 과제를 모두 끝내지 못하는 경우 
                            if(diff - nowRest.restTime < 0){
                                rest addRest = new rest(nowRest.name,nowRest.restTime-diff);
                                restStack.push(addRest);
                                break;
                            }
                        }
                    }  
                }
            }

            //List에 할 일이 없을 때 stack에 남은 일들을 처리 
            else{
                while(!restStack.isEmpty()){
                    rest nowRest = restStack.pop();
                    result.add(nowRest.name);
                }
            }
        }

        answer = new String[result.size()];
        for(int i = 0; i < result.size(); i++){
            answer[i] = result.get(i);
        }

        return answer;
    }
}

피드백

문제 자체는 쉬움(딱히 큰 알고리즘이 있는 건 아님) 하지만 구현 난이도가 높고 자료구조를 잘 활용해야하는 문제. 실수 없이 잘 훑어보자. 난이도 6/10, 걸린시간 1시간 30분

비내림차순으로 정렬된 수열이 주어질 때, 다음 조건을 만족하는 부분 수열을 찾으려고 합니다. 기존 수열에서 임의의 두 인덱스의 원소와 그 사이의 원소를 모두 포함하는 부분 수열이어야 합니다. 부분 수열의 합은 k입니다.
합이 k인 부분 수열이 여러 개인 경우 길이가 짧은 수열을 찾습니다.
길이가 짧은 수열이 여러 개인 경우 앞쪽(시작 인덱스가 작은)에 나오는 수열을 찾습니다.
수열을 나타내는 정수 배열 sequence와 부분 수열의 합을 나타내는 정수 k가 매개변수로 주어질 때, 위 조건을 만족하는 부분 수열의 시작 인덱스와 마지막 인덱스를 배열에 담아 return 하는 solution 함수를 완성해주세요. 이때 수열의 인덱스는 0부터 시작합니다.

제한사항

5 ≤ sequence의 길이 ≤ 1,000,000
1 ≤ sequence의 원소 ≤ 1,000
sequence는 비내림차순으로 정렬되어 있습니다.
5 ≤ k ≤ 1,000,000,000
k는 항상 sequence의 부분 수열로 만들 수 있는 값입니다.

입출력 예

정답코드

//1. k보다 작은 원소까지만 탐색한다 
//2. 투포인터 이용해서 앞+뒤로 따로 탐색 값이 커지면 뒤를 당기고 값이 작아지면 앞을 민다
//3. 백준 회전초밥 문제와 동일

class Solution {
    public int[] solution(int[] sequence, int k) {
        int[] answer = {};

        int min_left = 0;
        int min_right = sequence.length;

        int left = 0;
        int right = 0;
        int sum = sequence[0];

        while(left < sequence.length && right < sequence.length) {

            if (sequence[left] > k) {
                break;
            }

            //부분 수열의 합이 k일 때는 조건에 따라 업데이트
            if (sum == k) {
                if (min_right - min_left > right-left) {
                    min_left = left;
                    min_right = right;
                } else if (min_right - min_left == right - left) {
                    if (min_left > left) {
                        min_left = left;
                        min_right = right;
                    }
                }
            }

            //부분 수열의 합이 k보다 작다면 오른쪽을 민다
            if (sum <= k) {
                right++;
                if (right < sequence.length) {
                    sum += sequence[right];
                }
            } 

            //부분 수열의 합이 k보다 크다면 왼쪽을 당긴다
            else {
                sum -= sequence[left];
                left++;
            }
        }

        answer = new int[]{min_left, min_right};
        return answer;
    }
}

피드백

완전 탐색으로 풀 경우 O(n^2)이 나오기 때문에 1,000,000^2은 안 됨 즉 최대 O(nlogn)으로 접근해야하는데 연속된 수열의 합은 투포인터로 접근이 가능하다 난이도 7/10 걸린시간 1시간 <다시 한 번 풀어보가>

A 나라가 B 나라를 침공하였습니다. B 나라의 대부분의 전략 자원은 아이기스 군사 기지에 집중되어 있기 때문에 A 나라는 B 나라의 아이기스 군사 기지에 융단폭격을 가했습니다.
A 나라의 공격에 대항하여 아이기스 군사 기지에서는 무수히 쏟아지는 폭격 미사일들을 요격하려고 합니다. 이곳에는 백발백중을 자랑하는 요격 시스템이 있지만 운용 비용이 상당하기 때문에 미사일을 최소로 사용해서 모든 폭격 미사일을 요격하려 합니다.
A 나라와 B 나라가 싸우고 있는 이 세계는 2 차원 공간으로 이루어져 있습니다. A 나라가 발사한 폭격 미사일은 x 축에 평행한 직선 형태의 모양이며 개구간을 나타내는 정수 쌍 (s, e) 형태로 표현됩니다. B 나라는 특정 x 좌표에서 y 축에 수평이 되도록 미사일을 발사하며, 발사된 미사일은 해당 x 좌표에 걸쳐있는 모든 폭격 미사일을 관통하여 한 번에 요격할 수 있습니다. 단, 개구간 (s, e)로 표현되는 폭격 미사일은 s와 e에서 발사하는 요격 미사일로는 요격할 수 없습니다. 요격 미사일은 실수인 x 좌표에서도 발사할 수 있습니다.
각 폭격 미사일의 x 좌표 범위 목록 targets이 매개변수로 주어질 때, 모든 폭격 미사일을 요격하기 위해 필요한 요격 미사일 수의 최솟값을 return 하도록 solution 함수를 완성해 주세요.

제한 사항

1 ≤ targets의 길이 ≤ 500,000 targets의 각 행은 [s,e] 형태입니다. 이는 한 폭격 미사일의 x 좌표 범위를 나타내며, 개구간 (s, e)에서 요격해야 합니다. 0 ≤ s < e ≤ 100,000,000

입출력 예

정답코드

import java.util.*;

class missile implements Comparable<missile> {
    int start;
    int end; 

    public missile(int start, int end){
        this.start = start;
        this.end = end;
    }

    public int compareTo(missile m){
        if(this.start != m.start)return this.start - m.start;
        return this.end - m.end;
    }

}


class Solution {
    public int solution(int[][] targets) {
        int answer = 0;

        PriorityQueue<missile>pq = new PriorityQueue<>();

        //시작 순서가 빠른 순으로, 같다면 끝나는 지점이 빠른 순으로
        for(int i = 0; i < targets.length; i++){
            missile m = new missile(targets[i][0],targets[i][1]);
            pq.add(m);
        }


        int end = -1; 

        while(!pq.isEmpty()){
            missile m = pq.poll(); 

            //다음 미사일의 시작 지점이 앞의 끝 지점을 넘는다면 새로운 미사일로 요격해야한다
            if(m.start >= end){
                answer++;
                end = m.end;
                continue;
            }

            //미사일 길이의 끝이 짧은 걸로 업데이트 이전 미사일로 요격은 가능 but 끝지점이 줄어든다
            if(m.end < end){
                end = m.end;
            }

        }

        return answer;
    }
}

백준에 회의실 배정문제와 비슷한 그리디 문제. 딱 보자마자 그리디 인 것을 눈치채야한다. 전형적인 유형이긴 함 난이도 6/10 걸린시간 1시간 10분

너무 한번에 해결할려고 하니까 로직도 꼬이고 복잡해짐, 그냥 차근차근 갯수 구하면 되는 문제였음. 완탐으로 가능한 거 같으면 최적화를 너무 생각하지 말고 일단 완탐답게 구현하자 걸린시간 1시간 난이도 4/10

/*  Set 자료구조 이용해서 하나씩 차근차근 확인하기 
    1개일 때 -> 그냥 확인 
    2개일 때 -> 완탐으로 확인
    3개일 때 -> 완탐 돌리면서 총 금액 - 2개 합을 뽑을 수 
    있는지 확인하기 
/*

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.StringTokenizer;

public class BlackFriday {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int c = Integer.parseInt(st.nextToken());
        int[] arr = new int[n];

        HashSet<Integer> hs = new HashSet<>();
        st = new StringTokenizer(br.readLine());

        //1개로 가능한지 확인
        for (int i = 0; i < n; i++) {
            int cur = Integer.parseInt(st.nextToken());
            arr[i] = cur;
            hs.add(cur);
            if (cur == c) {
                System.out.println(1);
                return;
            }
        }

        //2개로 가능한지 확인
        for (int i = 0; i < n; i++) {
            int remain = c-arr[i];
            if (arr[i] == remain) continue;
            if (hs.contains(remain)) {
                System.out.println(1);
                return;
            }
        }               

        //3개로 가능한지 확인
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                int remain = c-(arr[i]+arr[j]);

                //같은 무게는 들어있지 않으니까
                if (remain == arr[i] || remain == arr[j]) continue;
                if (hs.contains(remain)) {
                    System.out.println(1);
                    return;
                }
            }
        }
        System.out.println(0);
    }
}

분명 쉬운 문제였는데 좀 해맨 문제였다 일단 ~~한 순으로 가 나온다면 무지성 PQ박지 말고 그냥 arrayList나 다른 방법 생각하기 & 최대한 간단하고 쉽게 구현하자 걸린시간 1시간 10분, 난이도 5.5/10

/*
 * 쉬운 BFS, 정렬 문제일 수록 정확하고 빨리 풀자
 * 너무 복잡하게 구현하고 있다는 생각이 든다면 제대로 구현하고 있는지 확인하자
 * 
 */

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

class virus implements Comparable<virus> {
    int x;
    int y;
    int num;

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

    @Override
    public int compareTo(virus o) {
        return this.num - o.num;
    }

}

public class CompetitiveInfection {
    static int N, K, S, X, Y;
    static int[][] map;
    static int[] dx = { -1, 1, 0, 0 };
    static int[] dy = { 0, 0, -1, 1 };
    static List<virus> VirusList;

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

        N = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());
        VirusList= new LinkedList<>();
        map = new int[N][N];

        for (int i = 0; i < N; i++) {
            String[] in = br.readLine().split(" ");
            for (int j = 0; j < N; j++) {    
                int input = Integer.parseInt(in[j]);
                map[i][j] = input;
                if(input!= 0) {
                    virus v = new virus(i, j, input);
                    VirusList.add(v);
                }
            }
        }

        Collections.sort(VirusList);

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

        S = Integer.parseInt(st.nextToken());
        X = Integer.parseInt(st.nextToken())-1;
        Y = Integer.parseInt(st.nextToken())-1;

        if(map[X][Y]!=0) {
            System.out.println(map[X][Y]);
            System.exit(0);
        }

        if(S==0) {
            System.out.println(0);
            System.exit(0);
        }
        spread();
    }

    public static void spread() {
        int cnt = 0;
        Queue<virus>VirusQ = new LinkedList<>();

        for(int i = 0; i < VirusList.size(); i++) {
            VirusQ.offer(VirusList.get(i));
        }

        while (!VirusQ.isEmpty()) {
            int size = VirusQ.size();
            for (int n = 0; n < size; n++) {
                virus nowVirus = VirusQ.poll();
                int x = nowVirus.x;
                int y = nowVirus.y;
                int num = nowVirus.num;

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

                    if (nx < 0 || nx >= N || ny < 0 || ny >= N || map[nx][ny] != 0)
                        continue;

                    if(nx == X && ny == Y) {
                        System.out.println(num);
                        System.exit(0);
                    }

                    map[nx][ny] = num;
                    virus nextVirus = new virus(nx, ny, num);
                    VirusQ.add(nextVirus);
                }
            }

            cnt++;
            if(cnt==S) {
                System.out.println(0);
                System.exit(0);
            }
        }

    }

}

• Vue.js application에 대한 상태관리패턴 + 라이브러리

• application 모든 component들의 중앙 저장소 역할(데이터 관리)

• 상위(부모) 하위(자식)의 단계가 많이 복잡해 진다면 데이터의 전달하는 부분이 매우 복잡해 짐

• application이 여러 구성 요소로 구성되고 더 커지는 경우 데이터를 공유하는 문제가 발생

부모-자식 컴포넌트간의 data 전달

동위 컴포넌트 간의 data 전달

vuex

상태관리패턴

vuex 핵심컨셉

vuex 구성요소 - state

vuex 구성요소 - actions

vuex 구성요소 - mutations

vuex 구성요소 - getters

저장소 - vuex

• State: 단일 상태 트리를 사용. application마다 하나의 저장소를 관리 (data)

• Getters: Vue Instance의 Copmuted와 같은 역할. State를 기반으로 계산(computed)

• Mutations: State의 상태를 변경하는 유일한 방법 (동기 methods)

• Actions: 상태를 변이 시키는 대신 액션으로 변이에 대한 커밋 처리 (비동기 methods)

vuex 설정

• module 시스템과 함께 사용시 Vue.use()를 통해 Vuex 설정

저장소 - state

vuex 단계별 이해하기

• step01: vuex 사용

저장소 (Store) - state

• 저장소에서 data 속성의 역할

• application에서 공유해야 할 data를 관리

• state에 접근하는 방식: this.$store.state.data_name

저장소 - getters

저장소 - Getters

• Component가 vuex의 state를 직접 접근하는 코드가 중복된다면?

• 해결: Store의 State를 참조하는 Getters를 활용

• 정의

• 사용

• step02 Getters 등록

저장소 - mapGetters

• getters를 조금 더 간단하게 호출

• 주의: Babel 관련 에러 발생시 해결

저장소 - mapGetters

• step 03

저장소 - mutations

저장소(store) - Mutations

• State의 값을 변결하기 위해서 사용

• 각 컴포넌트에서 State의 값을 직접 변경하는 것은 권장하지 않는 방식

• State의 값의 추적을 위해 동기적 기능에 사용

• Mutations는 직접 호출이 불가능하고 store.commit('정의된 이름')으로 호출

• step 04 Mutations 등록

• step 05

저장소 - actions

저장소(Store) - Actions

• 비동기 작업의 결과를 적용하려고 할 때 사용

• Mutations는 상태 관리를 위해 동기적으로 처리하고 비동기적인 처리는 Actions가 담당

• Actions는 비동기 로직의 처리가 종료되면 Mutations를 호출

• step 06

• step 07 mapActions

전통적인 그리디 문제 but 아이디어가 좋은 문제였음 풀이시간: 30분 난이도 5/10

package algo;


/*
 * 1. 양수 음수 나누기 
 * 2. 각 부호별로 절대값이 높은 N개씩 묶기 절대값이 큰 거리만 가면 된다
 * 3. 절대값이 제일 큰 1그룹은 제일 마지막에 추가 
 * 
 * 7 2
 * -39 -37 -29  -28  -6  2  11 
 * (-39,-37) (-29,-28) (11,2), -6
 * (11+29+6)*2 + 39
 * 46*2+39 = 131
 * 
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Library {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        int sum = 0;

        String [] in = br.readLine().split(" ");
        int [] books = new int[N];

        //음수 양수를 기준으로 나누고 절대값이 높은 순부터 정렬
        PriorityQueue<Integer>minus = new PriorityQueue<>((o1,o2) -> (o2-o1));
        PriorityQueue<Integer>plus = new PriorityQueue<>((o1,o2) -> (o2-o1));


        for(int i = 0; i< N; i++) {
            int Now = Integer.parseInt(in[i]);
            books[i] = Now;
            if(Now<0)minus.offer(Math.abs(Now));
            else plus.offer(Now);
        }

        ArrayList<Integer>total = new ArrayList<>();

        int cnt = 0;

        //양수 음수 별로 거리가 먼 것들 부터 M개 만큼 묶어서 전체 리스트에 추가 
        //여기서 묶음별 가장 큰 값 만큼만 가면 된다 -> 가는 길에 놔두면 되니까
        while(!minus.isEmpty()) {
            int temp = minus.poll();
            if(cnt == 0)total.add(temp);
            cnt++;
            if(cnt == M)cnt = 0; 
        }

        cnt = 0;
        while(!plus.isEmpty()) {
            int temp = plus.poll();
            if(cnt == 0)total.add(temp);
            cnt++;
            if(cnt == M)cnt = 0; 
        }

        Collections.sort(total);

        //가장 먼 책을 제외하고는 책을 다시 가지러 와야함
        for(int i = 0; i < total.size()-1; i++) {
            sum += 2*total.get(i);
        }

        //가장 거리가 먼 책은 1번만 더하고
        sum += total.get(total.size()-1);

        System.out.println(sum);
    }

}

자료구조 + 문자열 + BFS 결합 문제였다 DP로도 푸는 거 같았는데 익숙한 BFS로 구현함 차근차근 케이스 따져가면서 푸는게 쉽지많은 않았음 걸린시간 1시간 난이도 5.5/10

/*
 * softwarecontest
 * 9
 * so
 * ware
 * softftware
 * con
 * conte
 * test
 * t
 * s
 * 
 * queue에 넣어서 가능한 것들 판별 
 * 뒤에서 부터 판별 
 * 
 * depth 1:
 * test -> 가능 replace => "softwarecon" Q in
 * t -> 가능 replace => "softwarecontes" Q in
 * 
 * depth 2:
 * con -> 가능 replace => "software" Q in
 * s -> 가능 replace => "softwareconte" Q in
 * 
 * depth 3:
 * ware -> 가능 replace => "soft" Q in
 * ftware -> 가능 replace => "so" Q in
 * conte -> software set에 의해 걸러짐
 * 
 * 부분 문자열 == 목표 문자열 이면 만들 수 있다 
 * 
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;

public class StringCheck {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String target = br.readLine();
        int N = Integer.parseInt(br.readLine());
        Set<String>wordSet = new HashSet<>();

        ArrayList<String> words = new ArrayList<>();

        for (int i = 0; i < N; i++) {
            words.add(br.readLine());
        }

        Queue<String> wordQ = new LinkedList<>();
        wordQ.offer(target);

        //BFS로 접근
        while (!wordQ.isEmpty()) {
            int Qsize = wordQ.size();
            for (int q = 0; q < Qsize; q++) {
                String now = wordQ.poll();
                loop: for (int i = 0; i < N; i++) {
                    int wordSize = words.get(i).length();
                    if(wordSize>now.length())continue;

                    // 끝 글자가 같을 때
                    if (words.get(i).charAt(wordSize - 1) == now.charAt(now.length() - 1)) {
                        //해당글자가 부분문자열이 되는지 확인 
                        for (int j = 1; j <= wordSize; j++) {
                            if (words.get(i).charAt(wordSize - j) != now.charAt(now.length() - j))
                                continue loop;
                        }
                        String newWord = now.substring(0, now.length() - wordSize);

                        //현재 문자열과 부분 문자열이 같다면 가능하다
                        if (now.length() == wordSize ) {
                            System.out.println(1);
                            System.exit(0);
                        }

                        //set에 넣어가면서 중복되는 문자는 추가하지 않는다 
                        if(wordSet.contains(newWord))continue;
                        wordQ.add(newWord);
                        wordSet.add(newWord);
                    }
                }
            }
        }

        System.out.println(0);

    }

}

이분탐색, 투포인터의 대표적인 문제 아이디어도 금방 떠올랐고 쉽게 풀었음 걸린시간 15분 난이도 2/10

/*
 * 1. 용액을 정렬 N이 최대 100000이므로 NlogN으로 가능 
 * 2. 양쪽 끝에서 시작 음수이면 앞에서 땡겨오기 양수이면 뒤에서 밀기 => 최솟값 갱신
 * 3. 0이되면 출력하고 끝내기
 * 4. left_idx == right_idx이면 종료
 */

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

public class TwoSolution {

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int [] solution = new int[N];
        int sol1= 0;
        int sol2= 0;
        int diff = Integer.MAX_VALUE;

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

        for(int i = 0; i < N; i++) {
            solution[i] = Integer.parseInt(in[i]);
        }

        //배열정렬
        Arrays.sort(solution);

        int left = 0;
        int right = N-1;

        //범위를 넘어가지 않는 선에서 
        while(left < right) {
            int sum = solution[left]+solution[right]; 
            if(Math.abs(sum)<diff) {
                sol1 = solution[left];
                sol2 = solution[right];
                diff = Math.abs(sum);
            }

            if(sum==0) {
                System.out.println(sol1+" "+sol2);
                System.exit(0);
            }
            //음수이면 앞에서 밀어준다
            else if(sum<0) {
                left++;
            }
            //양수이면 뒤에서 민다
            else {
                right--;
            }
        }

        System.out.println(sol1+" "+sol2);
    }
}

생각보다 규칙 찾기 어려웠음, 단순히 주어진 input, output만 보고 식을 구할 수 없는 경우도 생각해야한다. + 어떤 부분이 중복되는지 잘 찾아주자 걸린시간 40분 난이도 6.5/10

/*
 * 알약 0개 dp[0] = 1
 * 알약 1개 dp[1] = 1
 * 알약 2개 dp[2] = 2
 * 
 * 작은 알약은 경우의 수가 생기지 않음 
 * 큰거 2개 작은 거 1개가 남음 
 * 
 * 작은 알약 -> 큰 알약 -> 큰 알약 
 * 작은 알약을 먹고나면 나머지 큰알약들을 먹는 수와 동일 
 * dp[0]*dp[2] = 2
 * 
 * 큰 알약 먹고 나면 dp[1] 작은 알약 2개 큰 알약 1개 dp[1]가 남음 
 * 큰 알약 -> 작은 알약 -> 큰 알약 
 * dp[1]*dp[1] = 1
 * 
 * 앞에 큰 알약 2개 먹는 거는 dp[2]
 * 큰 알약 -> 큰 알약 -> 작은 알약
 * dp[2]*dp[0] = 2

 */

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

public class Pill {

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        long [] dp = new long [31];
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;

        for(int i = 3; i < 31; i++) {
            for(int j = 0; j < i; j++) {
                dp[i] += dp[j]*dp[i-j-1];
            }
        }

        while(true) {
            int N = Integer.parseInt(br.readLine());
            if(N==0) {
                bw.flush();
                bw.close();
                System.exit(0);
            }
            bw.write(dp[N]+"\n");
        }    
    }
}

전통적인 BFS 문제, 문제 이해는 쉽게 했는데 마지막 조건 처리랑 visited처리로 시간을 좀 날려먹었다. 걸린 시간 45분 난이도 3/10

/*
 * BFS depth 별로 수행하는 기본문제 
 * 대신 조건에 따라서 depth를 비교해가며 업데이트 해줘야한다
 * 1개만 있을 때 조건 다르게 수행 
 */


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

class Node {
    int x;
    int y;

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

public class EscapeRoom {
    static int N, M;
    static int[][] map;
    static boolean[][] visited;
    static int[] dx = { -1, 1, 0, 0 };
    static int[] dy = { 0, 0, -1, 1 };
    static int answer = 0;
    static int maxDepth = 0;

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

        map = new int[N][M];


        // input 받기
        for (int i = 0; i < N; i++) {
            String[] in = br.readLine().split(" ");
            for (int j = 0; j < M; j++) {
                map[i][j] = Integer.parseInt(in[j]);
            }
        }

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (map[i][j] == 0)
                    continue;
                bfs(i, j);
            }
        }

        System.out.println(answer);
    }

    public static void bfs(int a, int b) {

        visited = new boolean[N][M];

        int result = map[a][b];
        Deque<Node> q = new LinkedList<>();
        Node start = new Node(a, b);
        q.add(start);
        visited[a][b] = true;

        int depth = 0;
        int max = -1;

        //depth별 BFS
        while (!q.isEmpty()) {
            int size = q.size();
            max = -1;
            depth++;
            for (int n = 0; n < size; n++) {
                Node now = q.poll();
                int x = now.x;
                int y = now.y;
                max = Math.max(max,map[x][y]);
                for (int i = 0; i < 4; i++) {
                    int nx = x + dx[i];
                    int ny = y + dy[i];
                    if (nx < 0 || nx >= N || ny < 0 || ny >= M || map[nx][ny] == 0 || visited[nx][ny])
                        continue;
                    Node newNode = new Node(nx, ny);
                    visited[nx][ny] = true;
                    q.offer(newNode);
                }
            }
        }

        //1칸짜리가 비밀번호가 될 수 있는 경우
        if(maxDepth<=1 && depth==1) {
            answer =  Math.max(answer,result);
            return;
        }

        //depth가 더 깊은 경우엔 무조건 업데이트 
        if(maxDepth<depth) { 
            maxDepth = depth;
            answer = result+max;
        }
        //depth가 같은 경우엔 최댓값을 업데이트
        else if(maxDepth==depth) {
            answer = Math.max(answer,result+max);
        }

    }
}

Vue-router

• 라우팅: 웹 페이지 간의 이동 방법

• Vue.js의 공식 라우터

• 라우터는 컴포넌트와 매핑

• Vue를 이용한 SPA를 제작할 때 유용

• URL에 따라 컴포넌트를 연결하고 설정된 컴포넌트를 보여준다

Vue-router 연결

• 'routes' 옵션과 함께 router instance 생성

vue-router 이동 및 렌더링

• 네비게이션을 위해 route-link 컴포넌트를 사용

• 속성은 'to' prop을 사용

• 기본적으로 '<router-link>' 는 '<a>' 태그로 렌더링

• 현재 라우트에 맞는 컴포넌트가 렌더링 된다

• app.js

// 라우트 컴포넌트
import Main from './components/Main.js';
import Board from './components/Board.js';
import QnA from './components/QnA.js';
import Gallery from './components/Gallery.js';

// 라우터 객체 생성
const router = new VueRouter({
  routes: [
    {
      path: '/',
      component: Main,
    },
    {
      path: '/board',
      component: Board,
    },
    {
      path: '/qna',
      component: QnA,
    },
    {
      path: '/gallery',
      component: Gallery,
    },
  ],
});

// Vue 인스턴트 라우터 주입
const app = new Vue({
  el: '#app',
  router,
});

$router, $route

• board.js

export default {
  template: `<div>
    자유 게시판
    <ul>
      <li v-for="i in 5">
        <router-link :to="'/board/' + i">{{i}}번 게시글</router-link>
      </li>
    </ul>
  </div>`,
};

• BoardView.js

이름을 가지는 라우트

• 라우트는 연결하거나 탐색을 수행할 때 이름이 있는 라우트를 사용

• Router Instance를 생성하는 동안 routes 옵션에 지정

프로그래밍 방식 라우터

• router-link를 사용하여 선언적 네비게이션 anchor 태그를 만드는 것 외에도 라우터의 instance method를 사용하여 프로그래밍으로 수행

중첩된 라우트

• 앱 UI는 일반적으로 여러 단계로 중첩 된 컴포넌트 구조임

• URL의 세그먼트가 중첩 된 컴포넌트의 특정 구조와 일치하는 것을 활용

• 등록폼

• 수정폼

라우트 리다이렉트

Vue method

• Vue Instance는 생성과 관련된 data 및 method 정의 가능

• method 안에서 data를 "this.데이터이름" 으로 접근가능

<body>
    <div id="app">
      <div>data : {{message}}</div>
      <div>method kor : {{helloKor()}}</div>
      <div>method eng : {{helloEng()}}</div>
    </div>
    <script>
      new Vue({
        el: '#app',
        data: {
          message: 'Hello 안녕하세요',
          name: '홍길동',
        },
        methods: {
          helloEng() {
            return 'Hello ' + this.name;
          },
          helloKor() {
            return '안녕 ' + this.name;
          },
        },
      });
    </script>
  </body>

• 결과

data : Hello 안녕하세요
method kor : 안녕 홍길동
method eng : Hello 홍길동

Vue method

Vue filter

• 뷰의 필터는 화면에 표시되는 텍스트의 형식을 쉽게 변환해주는 기능

• filter를 이용하여 표현식에 새로운 결과 형식을 적용

• 중괄호 보간법 [{{}}] 또는 v-bind 속성에서 사용이 가능

Vue filter 사용 예

• 천단위마다 ',' 찍기 전화 번호에 '-' 넣기

Vue computed 속성

• 특정 데이터의 변경사항을 실시간으로 처리

• 캐싱을 이용하여 데이터의 변경이 없을 경우 캐싱된 데이터를 반환. >> 값

• Setter와 Getter를 직접 지정할 수 있음

• 작성은 method 형태로 작성하면서 Vue에서 proxy 처리하여 property처럼 사용

<body>
  <div id="app">
    <input type="text" v-model="message" />
    <p>원본 메시지: "{{ message }}"</p>
    <p>역순으로 표시한 메시지1: "{{ reversedMsg }}"</p>
    <p>역순으로 표시한 메시지2: "{{ reversedMsg }}"</p>
    <p>역순으로 표시한 메시지3: "{{ reversedMsg }}"</p>
  </div>
  <script>
    var vm = new Vue({
      el: '#app',
      data: {
        message: '안녕하세요 여러분',
      },
      computed: {
        reversedMsg: function () {
          console.log('꺼꾸로 찍기');
          return this.message.split('').reverse().join('');
        },
      },
    });
  </script>
</body>

안녕하세요 여러분
원본 메시지: "안녕하세요 여러분"

역순으로 표시한 메시지1: "분러여 요세하녕안"

역순으로 표시한 메시지2: "분러여 요세하녕안"

역순으로 표시한 메시지3: "분러여 요세하녕안"

----------------------------------------
거꾸로 찍기
test21.html:61 Live reload enabled.

<body>
  <div id="app">
    <input type="text" v-model="message" />
    <p>원본 메시지: "{{ message }}"</p>
    <p>역순으로 표시한 메시지1: "{{ reversedMsg() }}"</p>
    <p>역순으로 표시한 메시지2: "{{ reversedMsg() }}"</p>
    <p>역순으로 표시한 메시지3: "{{ reversedMsg() }}"</p>
  </div>
  <script>
    var vm = new Vue({
      el: '#app',
      data: {
        message: '안녕하세요 여러분',
      },
      methods: {
        reversedMsg: function () {
          console.log('꺼꾸로 찍기');
          return this.message.split('').reverse().join('');
        },
      },
    });
  </script>
</body>

안녕하세요 여러분
원본 메시지: "안녕하세요 여러분"

역순으로 표시한 메시지1: "분러여 요세하녕안"

역순으로 표시한 메시지2: "분러여 요세하녕안"

역순으로 표시한 메시지3: "분러여 요세하녕안"

test21_1.html:27 거꾸로 찍기 3번 실행 
test21_1.html:61 Live reload enabled.

Vue watch 속성

• Vue Instance의 특정 property가 변경될 때 실행할 콜백 함수 설정

원본 메시지: "Hello Everyone"

역순으로 표시한 메시지: "enoyrevE olleH"

Hello Everyone

• Computed는 종속된 data가 변경되었을 경우 그 data를 다시 계산하여 캐싱한다

• Watch의 경우는 data가 변경되었을 경우 다른 data를 변경하는 작업을 한다

Vue Event

• DOM Event를 청취하기 위해 v-on directive 사용

• inline event handling

• method를 이용한 event handling

Vue Event 청취: v-on

• v-on directive를 사용하여 DOM 이벤트를 듣고 트리거 될 때 JavaScript를 실행할 수 있다

method event handler

• 이벤트 발생시 처리 로직을 v-on에 넣기 힘들다. 이 때문에 v-on에서는 이벤트 발생시 처리해야 하는 method의 이름을 받아 처리

Inline method handler

• 메소드 이름을 직접 바인딩 하는 대신 인라인 JavaScript 구문에 메소드를 사용할 수도 있다

• 원본 DOM 이벤트에 엑세스 해야 하는 경우 특별한 $event 변수를 사용해 메소드에 전달할 수도 있다

이벤트 수식어 (Event Modifier)

• method 내에서 작업도 가능하지만 method는 DOM의 이벤트를 처리하는 것 보다 data 처리를 위한 로직만 작업하는 것이 좋다

• 이 문제를 해결하기 위해 Vue는 v-on 이벤트에 이벤트 수식어를 제공한다

• 수식어는 점으로 표시된 접미사이다

키 수식어 (Key Modifier)

• Vue는 이벤트를 수신할 때 v-on에 대한 키 수식어를 추가할 수 있다

ref, $refs

• 뷰에서는 $refs 속성을 이용해 DOM에 접근할 수 있다

• 단, 뷰의 가장 중요한 목적 중 하나는 개발자가 DOM을 다루지 않게 하는 것이므로, 되도록 ref를 사용하는 것을 피하는 것이 좋다

CSS class binding

class binding

• element의 class와 style을 변경

• v-bind:class는 조건에 따라 class를 적용할 수 있다

form input binding

폼 입력 바인딩

• v-model directive를 사용하여 폼 input과 textarea element에 양방향 데이터 바인딩을 생성할 수 있다

  • text와 textarea 태그는 value 속성과 input 이벤트를 사용한다

  • 체크박스들과 라디오 버튼들은 checked 속성과 change이벤트를 사용한다

  • Select 태그는 value를 prop으로, change를 이벤트로 사용한다

form-text, textarea

form-checkbox

form-radio

• radio의 경우 선택된 항목의 value 속성의 값을 관리

form - select

• select box일 경우 선택된 항목의 value 속성의 값을 관리

• v-model 표현식의 초기 값이 어떤 옵션에도 없으면 <select> element는 선택없음 상태로 렌더링 된다

• v-for를 이용한 동적 option 렌더링

form - 수식어

Component

컴포넌트

• Vue의 가장 강력한 기능 중 하나

• HTML Element를 확장하여 재사용 가능한 코드를 캡슐화

• Vue Component는 Vue Instance이기도 하기 때문에 모든 옵션 객체를 사용 가능

• Life Cycle Hook 사용 가능

• 전역 컴포넌트와 지역 컴포넌트

전역 컴포넌트 등록

• 전역 컴포넌트를 등록하려면 Vue.component(tagName, options)를 사용

• 권장하는 컴포넌트 이름: 케밥 표기법(전부 소문자 -)

지역 컴포넌트 등록

• 컴포넌트를 Components 인스턴스 옵션으로 등록함으로써 다른 인스턴스/컴포넌트 범위에서만 사용할 수 있는 컴포넌트를 만들 수 있다

Component Template

Component data 공유 문제 & 해결

Component간 통신

컴포넌트간 통신

• 상위(부모)-하위(자식) 컴포넌트 간의 data 전달 방법

• 부모에서 자식: props라는 특별한 속성을 전달 (Pass Props)

• 자식에서 부모: event로만 전달 가능 (Emit Event)

상위에서 하위 컴포넌트로 data 전달

• 하위 컴포넌트는 상위 컴포넌트의 값을 직접 참조 불가능

• data와 마찬가지로 props 속성의 값을 template에서 사용이 가능

Literal props

랜더링 과정

동적 props

• v-bind를 사용하여 부모의 데이터에 props를 동적으로 바인딩 할 수 있다

• 데이터가 상위에서 업데이트 될 때 마다 하위 데이터로도 전달 된다

• v-bind에 대한 단축 구문을 사용하는 것이 더 간단함

<div id="app">
    <child-comp area="부산" v-bind:msg="msg[parseInt(Math.random() * 5)]"></child-comp>
    <child-comp area="광주" v-bind:msg="msg[parseInt(Math.random() * 5)]"></child-comp>
    <child-comp area="구미" v-bind:msg="msg[parseInt(Math.random() * 5)]"></child-comp>
    <child-comp area="대전" v-bind:msg="msg[parseInt(Math.random() * 5)]"></child-comp>
    <child-comp area="서울" v-bind:msg="msg[parseInt(Math.random() * 5)]"></child-comp>
  </div>
  <template id="childcomp">
    <div>
      <h2> {{area}} {{msg}}</h2>
    </div>
  </template>
  <script>
    Vue.component("child-comp", {
      props: ["area", "msg"],
      template: "#childcomp",
    });
    new Vue({
      el: "#app",
      data: {
        msg: ["굿^^", "최고!!", "실화냐?", "좋아요*", "짱!!"],
      },
    });
  </script>

<div id="app">
    <child-comp v-for="(area, i) in areas" :key="i" :area="area" 
                        v-bind:msg="msg[parseInt(Math.random() * 5)]">
    </child-comp>
  </div>
  <template id="childcomp">
    <div>
      <h2> {{area}}지역 {{msg}}</h2>
    </div>
  </template>
  <script>
    Vue.component("child-comp", {
      props: {
        area: String,
        msg: {
          type: String,
          require: true,
        },
      },
      template: "#childcomp",
    });
    new Vue({
      el: "#app",
      data: {
        areas: ["부산", "광주", "구미", "대전", "서울"],
        msg: ["굿^^", "최고!!", "실화냐?", "좋아요*", "짱!!"],
      },
    });
  </script>

객체의 속성(properties)전달 props

• 오브젝트의 모든 속성을 전달 할 경우, v-bind:prop-name 대신 v-bind 만 작성함으로써 모든 속성을 prop으로 전달할 수 있다

사용자 정의 이벤트

• 이벤트 이름

  • 컴포넌트 및 props와는 달리, 이벤트는 자동 대소문자 변환을 제공하지 않는다.
    
  • 대소문자를 혼용하는 대신에 emit할 정확한 이벤트 이름을 작성하는 것을 권장
    
  • v-on 이벤트 리스너는 항상 자동으로 소문자 변환되기 때문에 v-on:myEvent는 자동으로 v-on:myevent로 변환 된다. 이름이 my-event일 경우 myEvent 이벤트를 들을 수 없다
    
  • 이러한 이유로, 이벤트 이름에는 kebab-case를 사용하는 것이 권장됨

하위에서 상위 컴포넌트로 event 전달

• 하위 컴포넌트에서 상위 컴포넌트가 지정한 이벤트를 발생($emit)

• 상위 컴포넌트는 하위 컴포넌트가 발생한 이벤트를 수신(on)하여 data처리

비 상하위간 통신

• 비어 있는 Vue Instance 객체를 Event Bus로 사용

• 복잡해질 경우 상태관리 라이브러리인 Vuex 사용 권장

생각보다 아이디어 생각해내는데 조금 오래 걸림 -> 문제 해석에 시간이 걸림 문제 구현 난이도 자체는 쉬운편 걸린시간 40분 난이도 5/10

/*
    만약에 집중국의 수가 센서수보다 많으면 0이 나온다 
    중복되는 센서 처리 해주기 (처음 초기화 할 때)
    집중국 갯수-1개 많큼 거리를 무시해줄 수 있다 

    original 1 3 6 7 9     
    diff     2 3 1 2  여기서 집중국이 2개 -> 최댓값 1개 제외가능 

    original 3 6 7 8 10 12 14 15 18 20
    diff      3 1 1 2 2 2 1 3 2 집중국이 5개 -> 최댓값 4개 제외가능 
    sum(dif) = 17 - 10 = 7
 */

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

public class Sensor {

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int K = Integer.parseInt(br.readLine());

        int[] nums = new int[N];
        int[] diff = new int[N-1];

        if(N<=K) {
            System.out.println(0);
            System.exit(0);
        }

        String [] input = br.readLine().split(" ");
        for(int i = 0; i < N; i++) {
            nums[i] = Integer.parseInt(input[i]);
        }


        Arrays.sort(nums);

        for(int i = 1; i< N; i++) {
            diff[i-1] = nums[i] - nums[i-1];
        }

        Arrays.sort(diff);

        int sum = 0;
        for(int i = 0; i < (N-1)-(K-1); i++) {
            sum+=diff[i];
        }

        System.out.println(sum);
    }

}

간선이 양수인 그래프에서 최단 사이클을 찾는 문제 -> 플로이드 워셜 구현도 간단하고 시간도 얼마 안 걸림 걸린시간 20분, 난이도 2.5/10

/*
 * 다익스트라의 경우 한 지점에서 다른 특정 지점까지의 최단 경로를 구하는 알고리즘이다. 
 * 그러나 모든 지점에서 다른 모든 지점까지의 최단 경로를 모두 구해야하는 경우 플로이드 워셜 알고리즘 이용
 * 이 문제는 싸이클을 구해야하니까 MST (x), n to n 최소거리, 간선은 양수 FW이용
 * 만약에 음수인 간선이 존재했다면 Bellman-Ford를 이용해야함 
 */

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

public class Exercise {
    static int INF = 10000000;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());    
        int V = Integer.parseInt(st.nextToken());
        int E = Integer.parseInt(st.nextToken());

        int[][] adj = new int[V+1][V+1];

        for(int i = 0; i < V+1; i++) {
            for(int j = 0; j < V+1; j++) {
                adj[i][j] = INF;
            }
        }

        //인접리스트 초기화 
        for(int i = 0; i < E; i++) {
            st = new StringTokenizer(br.readLine());
            int s = Integer.parseInt(st.nextToken());
            int e = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());
            adj[s][e] = c;
        }


        //플로이드 워셜
        for(int i = 1; i < V+1; i++) {
            for(int j = 1; j < V+1; j++) {
                for(int k = 1; k < V+1; k++) {
                    adj[j][k] = Math.min(adj[j][k],adj[j][i]+adj[i][k]);
                }
            }
        }

        //사이클을 찾는 문제이므로 1->1 2->2 ... n -> n인 경우를 찾는다 
        int result = INF;
        for(int i = 1; i < V+1; i++) {
            result = Math.min(result, adj[i][i]);
        }

        if(result==INF)System.out.println(-1);
        else System.out.println(result);
    }
}