구르는 돌에는 이끼가 끼지 않는다

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

package com.ji.beakjoon.dp;

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

/**
 * 
 * @author ji
 *
 */
public class ConsecutiveSum {

	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));

		Integer numberCount = Integer.valueOf(br.readLine());

		int[] dp = new int[numberCount];
		int[] numbersArr = new int[numberCount];

		String[] inputNumbers = br.readLine().split(" ");
		for (int i = 0; i < numberCount; i++)
			numbersArr[i] = Integer.valueOf(inputNumbers[i]);
		
		dp[0] = numbersArr[0];
		int max = numbersArr[0];
		//bottom-up
		for(int i =1 ; i<numberCount; i++ ) {
				dp[i] = Math.max(dp[i-1]+numbersArr[i], numbersArr[i]);
				
				max = Math.max(max, dp[i]);
		}

		bw.write(String.valueOf(max));

		br.close();
		bw.flush();
		bw.close();
	}

}

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

package com.ji.beakjoon;

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

/**
 * 공유기 설치
 * @author ji
 *
 */
// 설치 가능한 경우에 수
// 3개가 주어지면 좌표에서 설치 가능한 경우의 수
public class InstallWifi {
	
	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

		String[] info = br.readLine().split(" ");
		int homeCount = Integer.valueOf(info[0]);
		int wifiCount = Integer.valueOf(info[1]);
		
		int[] homePoints = new int[homeCount];
		for (int i = 0; i < homeCount; i++) {
			homePoints[i] = Integer.valueOf(br.readLine());
		}
		
		Arrays.sort(homePoints);
		int ans = 1;
		int start = 1;
		int end = homePoints[homeCount-1]-homePoints[0];//최대거리
		
		while(start <= end) {
			//이분 탐색 
			int mid=(start+end)/2;
			//mid기준으로 범위안에 wifiCount 갯수 이상 설치가 가능한지
			// mid의 거리를 좁혀 가면서 검사
			if(check(homePoints, mid, wifiCount)) {
				//인접한 두 공유기 사이의 최대거리 저장
				ans = Math.max(ans, mid);
				start = mid+1;
			}else {
				end = mid-1;
			}
		}
		
		bw.write(String.valueOf(ans));
		
		br.close();
		bw.flush();
		bw.close();

	}

	private static boolean check(int[] homePoints, int dist, int wifiCount) {
		int cnt =1; 
		int last = homePoints[0]+dist; //첫 번쨰 집 + 거리(가운데 값)이 마지막
		for(int i=0; i<homePoints.length; i++) {
			//집의 위치가 중간 거리보다 크면 cnt 값 증가
			//다음 집의 위치가  last 거리보다 끄면 cnt 증가
			if(homePoints[i] >= last) {
				cnt++;
				last = homePoints[i]+dist;//마지막 값 + 거리
			}
		}
		return cnt >= wifiCount;
	}

}

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

package com.ji.beakjoon.bfs;

import java.util.PriorityQueue;
import java.util.Scanner;

public class BabyShark {
	
	static int[] dy = {-1, 0, 0, 1};
    static int[] dx = {0, -1, 1, 0};
    static int[][] map;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();

        map = new int[N][N];
        int[] cur = null;

        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++) {
                map[i][j] = sc.nextInt();
                if (map[i][j] == 9) {
                    cur = new int[]{i, j};
                    map[i][j] = 0;
                }
            }

        int size = 2;
        int eat = 0; // 먹은 물고기 수
        int move = 0; // 움직인 총 거리

        while (true) {
        	// 거리가 가깝거나, 가장 위에 있거나, 가장 왼쪽에 있는 물고기 순
        	// 일반적인 Queue를 사용하면 상,좌,우,하 탐색하다가 규칙에 어긋나게됨
        	// 우선순위를 큐를 사용하여 이를 해결해야함
            PriorityQueue<int[]> que = new PriorityQueue<>((o1, o2) ->
                    o1[2] != o2[2] ? Integer.compare(o1[2], o2[2]) 
                    						: (o1[0] != o2[0] ? Integer.compare(o1[0], o2[0]) 
                    							: Integer.compare(o1[1], o2[1]))
            );
            
            boolean[][] visit = new boolean[N][N];

            que.add(new int[]{cur[0], cur[1], 0}); // y좌표, x좌표, 이동한 거리
            visit[cur[0]][cur[1]] = true;

            boolean ck = false; // 상어가 먹이를 먹었는지 체크할 변수

            while (!que.isEmpty()) {
                cur = que.poll();

                if (map[cur[0]][cur[1]] != 0 && map[cur[0]][cur[1]] < size) { // 먹이가 있으면서 상어의 사이즈보다 작다면?
                    map[cur[0]][cur[1]] = 0; // 물고기를 제거
                    eat++; 
                    move += cur[2]; // 움직인 거리를 총 움직인 거리에 추가
                    ck = true; // 먹이 먹었다고 체크
                    break;
                }

                for (int k = 0; k < 4; k++) {
                    int ny = cur[0] + dy[k];
                    int nx = cur[1] + dx[k];

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

                    que.add(new int[]{ny, nx, cur[2] + 1});
                    visit[ny][nx] = true;
                }
            }

            if (!ck) // 큐가 비워질 때까지 먹이를 먹은적이 없다면, 더 이상 먹은 물고기가 없으므로 탈출
                break;

            if (size == eat) { // 사이즈와 먹이를 먹은 수가 동일하다면 상어의 크기를 증가
                size++;
                eat = 0;
            }
        }

        System.out.println(move);

    }

}