2096번: 내려가기

첫째 줄에 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 숫자가 세 개씩 주어진다. 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 중의 하나가 된다.

www.acmicpc.net

 


 

 

 

  • 생각

왼쪽 끝과 오른쪽 끝은 내려갈 수 있는 곳이 2곳으로 한정되어 있고, 중간은 세 곳 모두 갈 수 있으므로 연산을 최대값, 최소값만 찾아서 구해주면 답은 나온다.

 

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

public class Main {
	static int N;
	static int[][] dp;

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		SetData();
		System.out.print(dp[N-1][5] + " " + dp[N-1][0]);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);
		
		N =  in.nextInt();
		int[] input = new int[3];
		dp = new int[N][6];

		for (int i = 0; i < 3; i++)
			input[i] =  in.nextInt();

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

		for (int i = 1; i < N; i++) {
			for (int j = 0; j < 3; j++)
				input[j] =  in.nextInt();

			int preIndex = i - 1;

			dp[i][0] = Integer.min(dp[preIndex][0], dp[preIndex][1]) + input[0];
			dp[i][1] = Integer.min(dp[preIndex][0], Math.min(dp[preIndex][1], dp[preIndex][2])) + input[1];
			dp[i][2] = Integer.min(dp[preIndex][1], dp[preIndex][2]) + input[2];

			dp[i][3] = Integer.max(dp[preIndex][3], dp[preIndex][4]) + input[0];
			dp[i][4] = Integer.max(dp[preIndex][3], Math.max(dp[preIndex][4], dp[preIndex][5])) + input[1];
			dp[i][5] = Integer.max(dp[preIndex][4], dp[preIndex][5]) + input[2];
		}

		Arrays.sort(dp[N - 1]);
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

1987번: 알파벳

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다. 말은 상하좌우로 인접한 네 칸 중의 한 칸으

www.acmicpc.net

 

 


 

 

  • 생각

백트래킹 문제이다. 해당문자가 체크된적 있으면 가장 큰값을 answer에 저장해준다. 체크가 안되있다면 방향을 바꿔주면서 다시 체크한다.

 

내가 짠 코드는 메모리는 적게들지만 시간이 오래걸린다.

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int R, C, answer, array[][];
	static boolean[] check;
	static int[] x = { 0, 1, 0, -1 };
	static int[] y = { 1, 0, -1, 0 };

	public static void main(String[] args) throws Exception {
		SetData();
		dfs(0, 0, 0);
		System.out.println(answer);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		R = in.nextInt();
		C = in.nextInt();
		check = new boolean[26];
		array = new int[R][C];
		answer = 0;

		for (int i = 0; i < R; i++) {
			String s = in.nextLine();
			for (int j = 0; j < C; j++) {
				array[i][j] = s.charAt(j) - 'A';
			}
		}
	}

	public static void dfs(int a, int b, int count) {
		if (check[array[a][b]]) {
			answer = Math.max(answer, count);
			return;
		}

		check[array[a][b]] = true;
		for (int i = 0; i < 4; i++) {
			int r = a + x[i];
			int c = b + y[i];

			if (r < 0 || c < 0 || r >= R || c >= C)	continue;

			dfs(r, c, count + 1);
		}
		check[array[a][b]] = false;

	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

 

 

  • 다른 사람 코드를 보고 좀 더 보완한 코드(재귀식을 queue를 사용하여 비재귀식으로 바꿈)

 

import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int R, C, answer, alphas[][];
	static char[][] array;
	static Queue<int[]> queue;
	static boolean[] check;
	static int[] x = { 0, 1, 0, -1 };
	static int[] y = { 1, 0, -1, 0 };

	public static void main(String[] args) throws Exception {
		SetData();
		dfs();
		System.out.println(answer);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		R = in.nextInt();
		C = in.nextInt();
		check = new boolean[26];
		array = new char[R][C];
		alphas = new int[R][C];
		answer = 0;

		for (int i = 0; i < R; i++)
			array[i] = in.nextLine().toCharArray();

		queue = new LinkedList<>();

		queue.add(new int[] { 0, 0, 1 << (array[0][0] - 'a'), 1 });
	}

	public static void dfs() {
		while (!queue.isEmpty()) {

			int[] location = queue.poll();
			if (alphas[location[0]][location[1]] == location[2])	continue;
			alphas[location[0]][location[1]] = location[2];
			answer = location[3];

			for (int i = 0; i < 4; i++) {
				int r = location[0] + x[i];
				int c = location[1] + y[i];

				if (r < 0 || c < 0 || r >= R || c >= C)		continue;

				int next = 1 << (array[r][c] - 'a');

				if ((location[2] & next) == 0) {
					queue.add(new int[] { r, c, location[2] | next, location[3] + 1 });
				}

			}
		}
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

16194번: 카드 구매하기 2

첫째 줄에 민규가 구매하려고 하는 카드의 개수 N이 주어진다. (1 ≤ N ≤ 1,000) 둘째 줄에는 Pi가 P1부터 PN까지 순서대로 주어진다. (1 ≤ Pi ≤ 10,000)

www.acmicpc.net

 

 

 


 

 

 

  • 생각

 

카드 N개를 구매하는데 최소 비용을 고르는 문제이다.

 

그래서 카드 N개를 구하는 비용을 카드가 N개 들어있는 카드팩으로 초기 설정해주면 쉽게 풀 수 있다.문제를 해석해보면

  • 카드 N개를 구매해야한다.
  • 카드팩에 들어있는 카드가 적은 것부터 산다.
  • 카드 N개를 구매하는데 드는 비용의 최소를 구하는 문제이다.

 

DP를 풀때 일반항 형태로 정의하는 것이 중요하다.

 

일단, 케이스 단위로 생각해보자.

카드 i개를 구매하는 방법은?

  • 카드 1개가 들어있는 카드팩을 구매하고, 카드 i-1개를 구입한다.
  • 카드 2개가 들어있는 카드팩을 구매하고, 카드 i-2개를 구입한다.
  • 카드 3개가 들어있는 카드팩을 구매하고, 카드 i-3개를 구입한다.

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int N, dp[], array[];

	public static void main(String[] args) throws Exception {
		SetData();
		dp();
		System.out.println(dp[N]);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		N = in.nextInt();
		array = new int[N + 1];
		dp = new int[N + 1];

		for (int i = 1; i <= N; i++) 
			array[i] = in.nextInt();
	}

	private static void dp() {
        for(int i = 1; i <= N; i++){
            dp[i] = array[i];
            for(int j = 1; j <= i; j++){
                dp[i] = Math.min(dp[i], dp[i-j]+array[j]);
            }
        }
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

2146번: 다리 만들기

여러 섬으로 이루어진 나라가 있다. 이 나라의 대통령은 섬을 잇는 다리를 만들겠다는 공약으로 인기몰이를 해 당선될 수 있었다. 하지만 막상 대통령에 취임하자, 다리를 놓는다는 것이 아깝다

www.acmicpc.net

 


 

 

  • 생각

 

dfs방식으로 풀면 될 것 같다라고 생각한다.

 

dfs방식

1. 모든 섬의 칸을 queue에 넣는다.

2. bfs를 돌린다. (0을 만나면 시작)

3. 섬을 만나면 return하면서 지나온 0의 칸수와 지금까지 가장 짧았던 0의 칸수로 비교
==> 문제가 되는 것은 bfs를 돌면서 같은 섬으로 갈 수 있다는 것

 

 

 

참고)

 

백준 2146 / 다리 만들기 / BFS / JAVA / 골드 3

오늘은 오랜만에 BFS 문제를 풀어보려 한다. 백준 2146번 다리 만들기 문제이다. https://www.acmicpc.net/problem/2146 2146번: 다리 만들기 여러 섬으로 이루어진 나라가 있다. 이 나라의 대통령은 섬을 잇는

devowen.com

이제 문제를 보도록 하자. N X N의 배열이 주어지고 섬이 있는 곳은 1, 없는 곳은 0으로 input 값이 들어온다. 나는 이 값을 받는 inputArr 행렬을 하나 만들고, 각 섬들을 그룹화한 groupArr, 섬으로부터의 거리를 나타낸 distArr 이렇게 세 개의 배열을 만들어서 문제를 풀었다. groupArr는 섬을 한 그룹씩 순서대로 인덱싱을 해서 1,2,3, .. 이런식으로 같은 섬은 같은 숫자를 입력해 주었다. 그리고 distArr는 섬인 경우는 초기값을 0으로 나머지는(섬이 아닌 곳) -1로 해서 구분을 해 주었다. (그림에서 빈 칸은 모두 초기값 0이며 생략했다)

 

 

이렇게 만들고 나서 distArr에서 BFS를 통해 모든 점에 대해 섬에서부터 거리가 얼마나 되는지를 계산한다. 섬 위에 있다면 당연히 그 값은 0이다. 그리고 그 섬에서 인접한 값들은 1이고 그 값에서 인접한 값은 2일 것이다. 그런식으로 -1로 초기에 설정된 점들은 섬들로부터 최단거리를 계산해서 그 값을 넣어 준다.

 

 

이렇게 거리를 계산하다보면 인접한 점의 distArr 배열값이 이미 자연수로 정해진 경우가 있다. 그 경우는 값을 갱신해 주지 않는다. 즉, distArr에서 모든 점을 탐색하고 나면 각각의 점은 섬으로부터의 최단 거리가 되는 것이다. 그렇게 계산을 마치면, distArr에서 임의의 한 점과 그 인접한 점의 합이 최소가 되는 점을 찾는다. 그 값이 최단거리가 되는 것이다.

 

 

물론 BFS로 계산을 하는 것이니, 거리가 1인 점들을 다 찾고 그 다음 거리가 2인 점을 찾을 것이다. 즉 값을 입력하는 순서가 거리 오름차순이라는 의미이다. 따라서 인접한 두 점이 발견되면 바로 그 순간 두 섬 사이의 거리를 계산해서 리턴해 주어도 된다.

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

public class Algorithm {
	static int N, answer, array[][], distanceArray[][], groupArray[][];
	static int[] x = { 0, 0, 1, -1 };
	static int[] y = { 1, -1, 0, 0 };

	public static void main(String[] args) throws Exception {
		SetData();
		bfs();
		System.out.println(answer);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		N = in.nextInt();
		array = new int[N][N];
		distanceArray = new int[N][N];
		groupArray = new int[N][N];
		answer = Integer.MAX_VALUE;

		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				array[j][i] = in.nextInt();
			}
		}
	}

	private static void bfs() {
		int count = 0;
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				if (array[i][j] != 1 || groupArray[i][j] != 0)
					continue; // array가 1이고 g를 초기화 안했다면

				Queue<int[]> queue = new LinkedList<>();
				groupArray[i][j] = ++count; // g를 초기화
				queue.add(new int[] { i, j });
				while (!queue.isEmpty()) {
					int[] location = queue.remove();

					for (int k = 0; k < 4; k++) {
						int r = location[0] + x[k];
						int c = location[1] + y[k];
						if (r < 0 || r >= N || c < 0 || c >= N)
							continue;

						if (array[r][c] == 1 && groupArray[r][c] == 0) {
							queue.add(new int[] { r, c });
							groupArray[r][c] = count;
						}
					}
				}
			}
		}

		Queue<int[]> queue = new LinkedList<>();
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				distanceArray[i][j] = -1;
				if (array[i][j] == 1) {
					queue.add(new int[] { i, j });
					distanceArray[i][j] = 0;
				}
			}
		}
		while (!queue.isEmpty()) {
			int[] location = queue.remove();

			for (int k = 0; k < 4; k++) {
				int r = location[0] + x[k];
				int c = location[1] + y[k];

				if (r < 0 || r >= N || c < 0 || c >= N)
					continue;

				if (distanceArray[r][c] == -1) {
					distanceArray[r][c] = distanceArray[location[0]][location[1]] + 1;
					groupArray[r][c] = groupArray[location[0]][location[1]];
					queue.add(new int[] { r, c });
				}
			}
		}

		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				for (int k = 0; k < 4; k++) {
					int r = i + x[k];
					int c = j + y[k];
					if (r < 0 || r >= N || c < 0 || c >= N)
						continue;

					if (groupArray[i][j] != groupArray[r][c])
						answer = Math.min(answer, distanceArray[i][j] + distanceArray[r][c]);

				}
			}
		}
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

 

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

 

 

 


 

 

 

  • 생각

 

 

dfs 알고리즘을 통해서 모든 모양을 테스트해본다.

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;

public class Main {
	static int M, N, answer, array [][];

	public static void main(String[] args) throws Exception {
		SetData();
		System.out.println(answer);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		int N = in.nextInt();
		int M = in.nextInt();
		array = new int[M+6][N+6];
		for(int i = 3; i<N+3; i++){
			for(int j = 3; j<M+3; j++){
				array[j][i] = in.nextInt();
			}
		}
		
		for(int i=0; i<M+3; i++){
			for(int j=0; j<N+3; j++){
				dfs(i, j);
			}
		}
	}
	
	private static void dfs(int a, int b){		
		// 직선 (세로 놓기)
		int sum=0;
		sum += array[a][b];
		sum += array[a+1][b];
		sum += array[a+2][b];
		sum += array[a+3][b];
		if(answer<sum){
			answer = sum;
		}
		
		// 직선 (가로 놓기)
		sum=0;
		sum += array[a][b];
		sum += array[a][b+1];
		sum += array[a][b+2];
		sum += array[a][b+3];
		if(answer<sum){
			answer = sum;
		} 
		
		// 네모
		sum=0;
		sum += array[a][b];
		sum += array[a+1][b];
		sum += array[a+1][b+1];
		sum += array[a][b+1];
		if(answer<sum){
			answer = sum;
		}
		// ㄴ  // 왼상단시작 오른 하단 종료. (반시계방향)
		sum=0;
		sum += array[a][b];
		sum += array[a+1][b];
		sum += array[a+2][b];
		sum += array[a+2][b+1];
		if(answer<sum){
			answer = sum;
		}
		// ㄴ case // 왼상단시작 오른 하단 종료. (반시계방향)의 대칭.
		sum=0;
		sum += array[a][b+1];
		sum += array[a+1][b+1];
		sum += array[a+2][b+1];
		sum += array[a+2][b];
		if(answer<sum){
			answer = sum;
		}

		// ㄴ  // 왼하단시작 오른 상단 종료.
		sum=0;
		sum += array[a][b];
		sum += array[a+1][b];
		sum += array[a][b+1];
		sum += array[a][b+2];
		if(answer<sum){
			answer = sum;
		}
		// ㄴ  // 왼하단시작 오른 상단 종료.
		sum=0;
		sum += array[a][b];
		sum += array[a+1][b+2];
		sum += array[a][b+1];
		sum += array[a][b+2];
		if(answer<sum){
			answer = sum;
		}


		// ㄴ  // 왼상단시작 오른 하단 종료 (시계방향) 
		sum=0;
		sum += array[a][b];
		sum += array[a][b+1];
		sum += array[a+1][b+1];
		sum += array[a+2][b+1];
		if(answer<sum){
			answer = sum;
		}
		// ㄴ  // 왼상단시작 오른 하단 종료 (시계방향) 의 대칭
		sum=0;
		sum += array[a][b];
		sum += array[a][b+1];
		sum += array[a+1][b];
		sum += array[a+2][b];
		if(answer<sum){
			answer = sum;
		}
		//  ㄴ  // 오른 상단시작  왼 하단 종료
		sum=0;
		sum += array[a][b+2];
		sum += array[a+1][b+2];
		sum += array[a+1][b+1];
		sum += array[a+1][b];
		if(answer<sum){
			answer = sum;
		}
		// ㄴ  // 오른 상단시작  왼 하단 종료 의 대칭  
		sum=0;
		sum += array[a+1][b+2];
		sum += array[a+1][b+1];
		sum += array[a+1][b];
		sum += array[a][b];
		if(answer<sum){
			answer = sum;
		}
		
		// ㄴㄱ  // 왼상단시작 오른 하단 종료
		sum=0;
		sum += array[a][b];
		sum += array[a+1][b];
		sum += array[a+1][b+1];
		sum += array[a+2][b+1];
		if(answer<sum){
			answer = sum;
		}
		// ㄴㄱ  // 오른 상단시작  하단 종료. 
		sum=0;
		sum += array[a][b+2];
		sum += array[a][b+1];
		sum += array[a+1][b+1];
		sum += array[a+1][b];
		if(answer<sum){
			answer = sum;
		}
		// ㄴㄱ  // 왼하단시작 오른 상단 종료. 
		sum=0;
		sum += array[a+2][b];
		sum += array[a+1][b];
		sum += array[a+1][b+1];
		sum += array[a][b+1];
		if(answer<sum){
			answer = sum;
		}
		// ㄴㄱ  // 왼상단시작 오른 하단 종료.  (ㄱㄴ꼴)
		sum=0;
		sum += array[a][b];
		sum += array[a][b+1];
		sum += array[a+1][b+1];
		sum += array[a+1][b+2];
		if(answer<sum){
			answer = sum;
		}
		// ㅗ   //  ㅜ
		sum=0;
		sum += array[a][b];
		sum += array[a][b+1];
		sum += array[a][b+2];
		sum += array[a+1][b+1];
		if(answer<sum){
			answer = sum;
		}
		// ㅗ   // ㅓ  
		sum=0;
		sum += array[a][b+1];
		sum += array[a+1][b+1];
		sum += array[a+2][b+1];
		sum += array[a+1][b];
		if(answer<sum){
			answer = sum;
		}
		// ㅗ   //  ㅗ  
		sum=0;
		sum += array[a+1][b];
		sum += array[a+1][b+1];
		sum += array[a+1][b+2];
		sum += array[a][b+1];
		if(answer<sum){
			answer = sum;
		}	
		// ㅗ   //  ㅏ  
		sum=0;
		sum += array[a][b];
		sum += array[a+1][b];
		sum += array[a+2][b];
		sum += array[a+1][b+1];
		if(answer<sum){
			answer = sum;
		}


	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

 

 

15684번: 사다리 조작

사다리 게임은 N개의 세로선과 M개의 가로선으로 이루어져 있다. 인접한 세로선 사이에는 가로선을 놓을 수 있는데, 각각의 세로선마다 가로선을 놓을 수 있는 위치의 개수는 H이고, 모든 세로선

www.acmicpc.net

 

 


 

 

  • 생각

 

선을 3개 이하로 만들어서 모든 세로 선들이 사라디를 탄 뒤, 자신의 선에 위치하게 만드는 문제이다.

 

dfs방식으로 백트래킹하면서 풀면 될 것 같다. 단, 모두 맞지않으면 -1 출력

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;

public class Main {
	static int[][] array;
	static int N, M, H, answer;

	public static void main(String[] args) throws Exception {
		SetData();
		System.out.println(answer);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		N = in.nextInt();
		M = in.nextInt();
		H = in.nextInt();
		array = new int[H + 1][N];
		answer = -1;

		for (int i = 0; i < M; i++) {
			int a = in.nextInt() - 1;
			int b = in.nextInt() - 1;
			array[a][b] = 1;
			array[a][b + 1] = -1;
		}

		if (searchOddNumber() > 3)	return;

		for (int i = 0; i <= 3; i++)
			if(dfs(0, 0, 0, i)) break;
	}

	private static boolean dfs(int x, int y, int cnt, int size) {
		if (cnt == size) {
			if (checkLadder()) {
				answer = size;
				return true;
			}
			return false;
		}

		for (int i = x; i < H; i++) {
			for (int j = y; j < N - 1; j++) {
				if (array[i][j] != 0 || array[i][j + 1] != 0)
					continue;

				array[i][j] = 1;
				array[i][j + 1] = -1;
				if (dfs(i, j + 2, cnt + 1, size))
					return true;
				array[i][j] = 0;
				array[i][j + 1] = 0;
			}
			y = 0;
		}
		return false;
	}

	private static boolean checkLadder() {
		for (int j = 0; j < N; j++) {
			int r = 0, c = j;

			while (r <= H) {
				if (array[r][c] == 1)
					c++;
				else if (array[r][c] == -1)
					c--;
				r++;
			}
			if (c != j)
				return false;
		}
		return true;
	}

	private static int searchOddNumber() {
		int oddNumber = 0;
		for (int j = 0; j < N - 1; j++) {
			int num = 0;
			for (int i = 0; i < H; i++)
				if (array[i][j] == 1)
					num++;
			if (num % 2 == 1)
				oddNumber++;
		}
		return oddNumber;
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

 

 

1083번: 소트

크기가 N인 배열 A가 있다. 배열에 있는 모든 수는 서로 다르다. 이 배열을 소트할 때, 연속된 두 개의 원소만 교환할 수 있다. 그리고, 교환은 많아봐야 S번 할 수 있다. 이때, 소트한 결과가 사전

www.acmicpc.net

 

 


 

 

  • 생각

 

1. 앞에서부터 숫자가 작은 경우 S번 만큼 교환?? ==>> 정확하게 정렬되지 않음

 

2. 맨 앞에있는 값 부터 정렬하면 좋다. index 0부터 S까지 확인했는데 index 0보다 큰 경우가 없는 경우는 index 1을 정렬을 해야한다. index 1부터 S+1까지 큰 수가 있으면 가장 큰 수의 index와 가장 큰 수의 index-1과 교환하는 방법을 사용하면 어떨까?? 시간이 괜찮을 까??

 

2번 방법을 사용했는데 시간이 잘 통과가 됐다.

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

public class Algorithm {
	static int N, S;
	static int[] number;
	static StringBuilder sb;

	public static void main(String[] args) throws Exception {
		SetData();
		Sort();
		System.out.println(sb);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);

		N = in.nextInt();
		number = new int[N];
		sb = new StringBuilder();
		
		for(int i = 0; i < N; i++)
			number[i] = in.nextInt();
		S = in.nextInt();
	}

	private static void Sort() {
		for(int i = 0; i < N; i++) {
			int x = number[i];
			int y = i;
			int temp;
			
			// j-i <= S 해주는 이유 (시간) - j부터 i까지 최대 S번 바꿀 수 있는데 j-i가 S보다 크면 못 바꿈.
			for(int j = i + 1; j < N && j-i <= S; j++) {
				if(x < number[j]) {
					x = number[j];
					y = j;
				}	
			}
			
			// 현재 j-i중에 가장 큰 값을 그 전의 값과 바꿔주는 작업
			for(S -= (y-i); y > i; y--) {
				temp = number[y];
				number[y] = number[y-1];
				number[y-1] = temp;
			}
			
			if(S <= 0) break;		// S 가 0이하이면 바꿀 수 있는게 없으니 반복문 나옴
		}

		for(int i = 0; i < N; i++)
			sb.append(number[i] + " ");
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

2812번: 크게 만들기

N자리 숫자가 주어졌을 때, 여기서 숫자 K개를 지워서 얻을 수 있는 가장 큰 수를 구하는 프로그램을 작성하시오.

www.acmicpc.net

 

 


 

 

 

  • 생각

1. N-K부터 0까지 가장 큰 값을 string으로 더 해준다. 더 해줄 때 K는 +1이 되서 해당 값보다 뒤까지 포함 시킬 수 있게하고 포함된 값은 뒤에 값을 포함할때 포함 못하게 해주면 될 것 같다.  ==>> 시간 초과 

 

2. stack으로 구현.

 

 

stack으로 구현한 코드이다. 앞의 수 부터 push 해주며 stack에 맨 앞의 수가 현재 수보다 작은 경우 pop을 해주며 K값을 1씩 빼준다. 이렇게 해줘야지 앞에 작은 수가 있는 경우 포함되지 않음. 이렇게 push를 해주면 가장 앞에있는 큰 수부터 stack에 남게되는데 문제는 입력한 수가 내림차순으로 되어있는 경우 출력해야되는 수보다 stack에 많이들어가게 된다. 이 경우는 맨앞에서부터 N-K개의 수만큼 출력해주었다.

 

 

재채점 결과 위 코드가 틀렸다고 나와서 stack 부분을 deque로 고쳐 정답을 도출함.

 

 

 

  • 코드

 

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {
	static int N, K;
	static char[] number;

	public static void main(String[] args) throws Exception {
		SetData();
		FindMaxValue();
	}

	private static void SetData() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken());
		K = Integer.parseInt(st.nextToken());
		number = br.readLine().toCharArray();
	}

	private static void FindMaxValue() {
		int temp = K;
		Stack<Character> stack = new Stack<Character>();
		for (int i = 0; i < number.length; i++) {
			// 스택의 맨 뒤의 값이 number[i]보다 작으면 삭제한다.
			// 아래 조건을 만족할 때까지 반복.
			while (temp > 0 && !stack.isEmpty() && stack.peek() < number[i]) {
				stack.pop();
				temp--;
			}
			stack.push(number[i]);
		}

		StringBuilder sb = new StringBuilder();
		if (stack.size() <= K) {
			for (int i = 0; i < stack.size(); i++) {
				sb.append(stack.get(i));
			}
		} else {   		// 앞의 수가 커서 pop을 하지 못한 경우
			for(int i = 0; i < N-K;i++) {
				sb.append(stack.get(i));
			}
		}

		System.out.println(sb);
	}
}

 

 

 

  • 수정 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int N, K;
	static char[] number;
	static StringBuilder sb;

	public static void main(String[] args) throws Exception {
		SetData();
		FindMaxValue();
		System.out.println(sb);
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);
		
		N = in.nextInt();
		K = in.nextInt();
		number = in.nextLine().toCharArray();
		sb = new StringBuilder();
	}

	private static void FindMaxValue() {
        Deque<Character> deque = new ArrayDeque<>();
		for (int i = 0; i < number.length; i++) {
			// 스택의 맨 뒤의 값이 number[i]보다 작으면 삭제한다.
			// 아래 조건을 만족할 때까지 반복.
			while (K > 0 && !deque.isEmpty() && deque.getLast() < number[i]) {
        		deque.removeLast();
				K--;
			}
			deque.addLast(number[i]);
		}

	    while(deque.size() > K) {
	       	sb.append(deque.removeFirst());
	    }
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

 

 

  • 더 좋은 다른 사람코드

 

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int N, K;
	static String number;
	static StringBuilder sb;

	public static void main(String[] args) throws Exception {
		SetData();
		FindMaxValue();
		System.out.println(sb.delete(sb.length() - K, sb.length()));
	}

	private static void SetData() throws Exception {
		InputReader in = new InputReader(System.in);
		
		N = in.nextInt();
		K = in.nextInt();
		number = in.nextLine();
		sb = new StringBuilder();
	}

	private static void FindMaxValue() {
		for (int i = 0; i < N; i++) {
			if (K == 0) {
				sb.append(number.substring(i));
				break;
			}
			char left = number.charAt(i);
			if (left == '9') {
				sb.append(left);
				continue;
			}
			boolean isReduced = false;
			for (int j = i + 1; j < N && j < i + K + 1; j++) {
				char right = number.charAt(j);
				
				if (left < right) {
					K -= j - i;
					i = j - 1;
					isReduced = true;
					break;
				}
			}
			if (!isReduced) {
				sb.append(left);
			}
		}
	}
}

class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

+ Recent posts