14490번: 백대열

n과 m이 :을 사이에 두고 주어진다. (1 <= n, m <= 100,000,000)

www.acmicpc.net

 

 

 

 


 

 

 

 

  • 풀이

 

n과 m을 최대 공약수로 나누어주면 되는 문제이다. 최대 공약수는 재귀형식(유클리드 호제법)으로 구했다.

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static StringBuilder sb;

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

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

		String[] s = in.nextLine().split(":");
		sb = new StringBuilder();
		
		int n = Integer.parseInt(s[0]);
		int m = Integer.parseInt(s[1]);
		int gcd = GCD(n,m);
		
		sb.append(n/gcd+":"+m/gcd);
	}
	
	// 최대 공약수 구하는 재귀메소드
	private static int GCD(int a, int b) {
        if (b == 0) return a;
        return GCD(b, a % b);
    }
}

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

 

11062번: 카드 게임

근우와 명우는 재미있는 카드 게임을 하고 있다. N개의 카드가 일렬로 놓여 있다. 각 카드에는 점수가 적혀있다. 근우부터 시작하여 번갈아가면서 턴이 진행되는데 한 턴에는 가장 왼쪽에 있는

www.acmicpc.net

 

 

 

 


 

 

 

  • 풀이

 

분할 정복을 사용해서 푼 코드이다.

 

왼쪽, 오른쪽의 경우의 수로 재귀형식으로 파고들어 결국엔 가장 큰 경우의 데이터를 가져온다.

 

  • 코드

 

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int T, N;
	static int[] input;
	static int[][][] array;
	static StringBuilder sb;

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

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

		T = in.nextInt();
		sb = new StringBuilder();
		
		for (int t = 0; t < T; t++) {
			N = in.nextInt();

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

			array = new int[2][N][N];
			sb.append(SaveAnswer(0, 0, N-1) + "\n");
		}
	}
	
	static int SaveAnswer(int who, int left, int right) {
		// basecase
		if (left == right) {
			if (who == 0) {
				return array[who][left][right] = input[left];
			}
			else {
				return array[who][left][right] = 0;
			}
		}
		
		if (array[who][left][right] != 0)
			return array[who][left][right];

		// 근우
		if (who == 0) {
			array[who][left][right] = Math.max(SaveAnswer(1, left + 1, right) + input[left], SaveAnswer(1, left, right - 1) + input[right]);
		}
		else {		// 명우
			array[who][left][right] = Math.min(SaveAnswer(0, left + 1, right), SaveAnswer(0, left, right - 1));
		}
		return array[who][left][right];
	}
}

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

 

11723번: 집합

첫째 줄에 수행해야 하는 연산의 수 M (1 ≤ M ≤ 3,000,000)이 주어진다. 둘째 줄부터 M개의 줄에 수행해야 하는 연산이 한 줄에 하나씩 주어진다.

www.acmicpc.net

 

 

 

 


 

 

  • 풀이

 

 

HashSet을 사용해서 푼 문제이다. HashSet으로 하는 이유는 입력한 데이터 중 특정 값의 데이터가 있었는지 판단하기 쉽고, 추가하고, 지우기 간편하기 때문이다. 이러한 자료구조는 ArrayList도 있지만 Hashset이 더 빠르기 때문에 사용했다.

 

HashSet과 ArrayList의 차이점은 ArrayList는 넣은 순서대로 저장되지만 HashSet은 순서대로 저장되지 않는다.

이러한 차이점 때문에 HashSet이 더 빠르다고 보면된다.

 

 

참고) 원래는 비트마스킹으로 해결하라고 낸 문제이다.

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int M;
	static HashSet<Integer> set;
	static StringBuilder sb;

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

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

		M = in.nextInt();
		set = new LinkedHashSet<>();
		sb = new StringBuilder();		
		
        for(int i = 0; i < M; i++){
            String[] s = in.nextLine().split(" ");
            String command = s[0];

            switch (command){
                case "add" :                	
                    set.add(Integer.parseInt(s[1]));
                    break;

                case "remove":
                    set.remove(Integer.parseInt(s[1]));
                    break;

                case "check" :
                    if(set.contains(Integer.parseInt(s[1]))) sb.append("1\n");
                    else sb.append("0\n");
                    break;
                    
                case "toggle" :
                    if(set.contains(Integer.parseInt(s[1]))) set.remove(Integer.parseInt(s[1]));
                    else set.add(Integer.parseInt(s[1]));
                    break;

                case "all" :
                    for(int num = 1; num<=20; num++){
                        set.add(num);
                    }
                    break;
                    
                case "empty" :
                    set.clear();
                    break;
            }

        }
	}
	
	//private static int SaveAnswer() {
	//}	
}

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

 

13335번: 트럭

입력 데이터는 표준입력을 사용한다. 입력은 두 줄로 이루어진다. 입력의 첫 번째 줄에는 세 개의 정수 n (1 ≤ n ≤ 1,000) , w (1 ≤ w ≤ 100) and L (10 ≤ L ≤ 1,000)이 주어지는데, n은 다리를 건너는 트

www.acmicpc.net

 

 

 

 


 

 

 

  • 풀이

 

 

Queue를 이용해서 다리의 무게를 더해가면서 time을 늘려주었다.

 

 

  • 코드

 

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

public class Main {
	static int N,W,L,answer;
	static Queue<Integer> truck;

	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();
		W = in.nextInt();
		L = in.nextInt();
		answer = 0;
		truck = new LinkedList<Integer>();
		
		for(int i = 0; i < N; i++) {
			truck.add(in.nextInt());
		}
		answer = SaveAnswer();
	}
	
	private static int SaveAnswer() {
		int count = 0; 
		int bridgeWeight=0;
		
		Queue<Integer> bridge = new LinkedList<Integer>();
		for(int i =0; i<W ; i++) {
			bridge.add(0);
		}
		
		while(!bridge.isEmpty()) {
			count++;
			bridgeWeight-=bridge.poll();
			if(!truck.isEmpty()) {				
				if(truck.peek()+bridgeWeight<=L) {
					bridgeWeight+=truck.peek();
					bridge.offer(truck.poll());
				}else {
					bridge.offer(0);
				}
			}
		}
		return count;
	}
	
}

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

 

18428번: 감시 피하기

NxN 크기의 복도가 있다. 복도는 1x1 크기의 칸으로 나누어지며, 특정한 위치에는 선생님, 학생, 혹은 장애물이 위치할 수 있다. 현재 몇 명의 학생들은 수업시간에 몰래 복도로 빠져나왔는데, 복

www.acmicpc.net

 

 

 


 

 

  • 풀이

 

모든 X를 O개로 번갈아가면서 모든 경우의 수를 바꿔주면서 백트래킹을 했다.

 

 

 

  • 참고

 

		/*
		for(int i = index; i < empty.size(); i++) {
	        array[empty.get(i)[0]][empty.get(i)[1]] = 'O'; 
	        SaveAnswer(count + 1, index + 1);
	        array[empty.get(i)[0]][empty.get(i)[1]] = 'X';
		}*/
		int r = index / N;
		int c = index % N;
		if(array[r][c] == 'X') {
			array[r][c] = 'O';
			SaveAnswer(count+1, index+1);
			array[r][c] = 'X';
		}

 

주석 처리된 부분으로하면 틀렸다고 떠서 바꾼 부분이다.

 

주석 처리된 부분이 왜 틀렸는지 아직 잘 모르겠음... 

empty는 ArrayList로 X의 index만 저장해놓은 데이터다.

 

  • 코드

 

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

public class Main {
	static int N;
	static char[][] array;
	static ArrayList<int []> teachers;
	static ArrayList<int []> empty;

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

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

		N = in.nextInt();
		array = new char[N][N];
		teachers = new ArrayList<>();
		empty = new ArrayList<>();
		
		for(int i = 0; i < N; i++) {
			String temp = in.nextLine();
			for(int j = 0; j < N; j++) {
				array[i][j] = temp.charAt(j*2);
				if(array[i][j] == 'T')
					teachers.add(new int[] {i,j});
				if(array[i][j] == 'X')
					empty.add(new int[] {i,j});
			}
		}
		
		SaveAnswer(0, 0);
	}
	
	private static void SaveAnswer(int count, int index) {
		// basecase
		if(count == 3) {			
			if(NotMeet()) {
				System.out.println("YES");
				System.exit(0);
			}			
			return;
		}
		if(index >=N*N) return;
        
		int r = index / N;
		int c = index % N;
		if(array[r][c] == 'X') {
			array[r][c] = 'O';
			SaveAnswer(count+1, index+1);
			array[r][c] = 'X';
		}
		SaveAnswer(count, index+1);
	}
	
	private static boolean NotMeet() {
		for(int t = 0; t < teachers.size(); t++) {
			int i = teachers.get(t)[0];
			int j = teachers.get(t)[1];
			
			// 왼
			for(int directon = j-1; directon >= 0; directon--) {
				if(array[i][directon] == 'S')
					return false;
				if(array[i][directon] == 'O')
					break;
			}
			
			// 오른
			for(int directon = j+1; directon < N; directon++) {
				if(array[i][directon] == 'S')
					return false;
				if(array[i][directon] == 'O')
					break;
			}
			
			// 위
			for(int directon = i-1; directon >= 0; directon--) {
				if(array[directon][j] == 'S')
					return false;
				if(array[directon][j] == 'O')
					break;
			}
			
			// 아래
			for(int directon = i+1; directon < N; directon++) {
				if(array[directon][j] == 'S')
					return false;
				if(array[directon][j] == 'O')
					break;
			}
		}
		
		return true;
	}
}

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

 

14569번: 시간표 짜기

연세대학교 수강신청 기간이 시작되었다. 많은 친구들은 비어 있는 시간에 어떤 과목을 추가로 신청할 수 있는지를 궁금해 한다. 이 친구들이 비어 있는 시간에 추가로 신청할 수 있는 과목의

www.acmicpc.net

 

 

 


 

 

 

  • 풀이

 

비트마스킹 공부를 위해 푼 문제.

문제를 읽고 코드를 봤는데 사실 아직 이해를 잘 못했다. (왜 써야 하는거지..?를 알아보자)

 

(참고) 비트마스크 공부한 사이트

 

비트마스크(BitMask) 는 무엇인가? :: 마이구미

이 글은 비트마스크(BitMask) 기법에 대해 다룬다. 특정 알고리즘이 아닌, bit 를 활용한 테크닉이라고 할 수 있다. bit 는 low level 이 아닌 경우에는 크게 비트를 다룰 일은 없어보이지만, 분명 이해

mygumi.tistory.com

 

 

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.Stack;

public class Main {
	static StringBuilder sb;

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

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

		int N = in.nextInt();
		sb = new StringBuilder();
		Long[] t = new Long[N];
		
		for (int i = 0; i < N; i++) {
			int p, q;
			t[i] = 0L;
			p = in.nextInt();
			for (int j = 0; j < p; j++) {
				q = in.nextInt(); 
				t[i] |= (1L << q);
				
			}
		}
		
		int M = in.nextInt();
		
		for (int i = 0; i < M; i++) {
			int p, q, count = 0;
			Long tmp = 0L;
			p = in.nextInt();
			for (int j = 0; j < p; j++) {
				q= in.nextInt(); 
				tmp |= (1L << q);
			}
			tmp = ~tmp;
			for (int j = 0; j < N; j++) {
				if (((tmp & t[j]) == 0L)) count++;
			}
			sb.append(count).append("\n");
		}
	}
}

class Node implements Comparable<Node> {
	long age;
	int index;

	public Node(long age, int index) {
		this.age= age;
		this.index = index;
	}

	@Override
	public int compareTo(Node o) {
		// TODO Auto-generated method stub
		return Long.compare(this.age, o.age);
	}
}

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

 

1303번: 전쟁 - 전투

첫째 줄에는 전쟁터의 가로 크기 N, 세로 크기 M(1 ≤ N, M ≤ 100)이 주어진다. 그 다음 두 번째 줄에서 M+1번째 줄에는 각각 (X, Y)에 있는 병사들의 옷색이 띄어쓰기 없이 주어진다. 모든 자리에는

www.acmicpc.net

 

 

 


 

 

  • 풀이

 

배열을 인덱스(i, j)부터 연결된 상, 하, 좌, 우로 탐색한다는 점에서 bfs방식으로 풀면 된다고 판단했다.

 

 

  • 코드

 

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

public class Main {
	static char[][] array;
	static boolean[][] check;
	static int N, M, friendly, enemy;
	static int[] x = { -1, 1, 0, 0 };
	static int[] y = { 0, 0, -1, 1 };

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

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

		M = in.nextInt();
		N = in.nextInt();
		array = new char[N][M];
		check = new boolean[N][M];
		friendly = 0;
		enemy = 0;
		
		for(int i = 0; i < N; i++) {
			String s = in.nextLine();
			for(int j = 0 ; j < M; j++) {
				array[i][j] = s.charAt(j);
			}
		}
		
		for(int i = 0; i < N; i++) {
			for(int j = 0 ; j < M; j++) {
				if(check[i][j])  continue;
				
				if(array[i][j] == 'W')
					friendly += bfs(i, j, 'W');
				else if(array[i][j] == 'B')
					enemy += bfs(i, j, 'B');
			}
		}
	}
	
	private static int bfs(int i, int j, char peerIdentification) {
		Queue<int[]> queue = new LinkedList<>();
		queue.offer(new int[] { i, j });
		check[i][j] = true;
		int count = 1;

		while (!queue.isEmpty()) {
			int location[] = queue.poll();

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

				if (r >= 0 && c >= 0 && r < N && c < M) {
					if (array[r][c] == peerIdentification && !check[r][c]) {
						queue.offer(new int[] { r, c });
						check[r][c] = true;
						count++;
					}
				}
			}
		}
		
		return count*count;
	}
	
	/*
	private static int SaveAnswer(int index, char c) {
		if(s.length() <= index)
			return 0;
		
		if(c == '(') {
			if(s.charAt(index) == ')')
				return 2;
			else if(s.charAt(index) == '(')
				return 2 * SaveAnswer(index + 1, '(');
			else if(s.charAt(index) == '[')
				return 2 * SaveAnswer(index + 1, '[');
			else 
				return 0;
		}
		else if(c == '[') {
			if(s.charAt(index) == ']')
				return 3;
			else if(s.charAt(index) == '(')
				return 3 * SaveAnswer(index + 1, '(');
			else if(s.charAt(index) == '[')
				return 3 * SaveAnswer(index + 1, '[');
			else
				return 0;
		} else {
			if(s.charAt(index) == '(')
				return SaveAnswer(index + 1, '(');
			else if(s.charAt(index) == '[')
				return SaveAnswer(index + 1, '[');
		}
		
		return 0;
	}*/
}

class Node implements Comparable<Node> {
	long age;
	int index;

	public Node(long age, int index) {
		this.age= age;
		this.index = index;
	}

	@Override
	public int compareTo(Node o) {
		// TODO Auto-generated method stub
		return Long.compare(this.age, o.age);
	}
}

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

 

2504번: 괄호의 값

4개의 기호 ‘(’, ‘)’, ‘[’, ‘]’를 이용해서 만들어지는 괄호열 중에서 올바른 괄호열이란 다음과 같이 정의된다. 한 쌍의 괄호로만 이루어진 ‘()’와 ‘[]’는 올바른 괄호열이다.  만일

www.acmicpc.net

 

 

 

 


 

 

  • 풀이

 

(이면 2, [이면 3으로 temp에 곱해주면서 닫힌괄호가 나올 시 temp를 더 해주고 닫힌 괄호의 값을 temp에서 다시 나눠주는 방식을 사용했다.

 

  • 코드

 

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.Stack;

public class Main {
	static String s;
	static int 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);

		s = in.nextLine();
		answer = 0;
		SaveAnswer();		
	}
	
	private static void SaveAnswer() {
		Stack<Integer> stack=new Stack<>();
		int temp=1;
		for (int i = 0; i < s.length(); i++) {
			if(s.charAt(i)=='(') {
				stack.add(2);
				temp*=2;
			}else if(s.charAt(i)=='[') {
				stack.add(3);
				temp*=3;
			}else {
				// 여는 괄호 X
				if(stack.size()==0) {
					answer=0;
					break;
				}
				
				// 여는 괄호 X && 닫는 괄호 X
				if(s.charAt(i)!=']' && s.charAt(i)!=')') {
					answer=0;
					break;
				}
				
				// 괄호 매칭 X
				if((s.charAt(i)==']' && stack.peek()==2) || (s.charAt(i)==')' && stack.peek()==3)) {
					answer=0;
					break;
				}

				if((s.charAt(i-1)=='(' && s.charAt(i) == ')') || (s.charAt(i-1)=='[' && s.charAt(i) == ']')) {
					answer+=temp;
				}
				temp/=stack.pop();
			}
			
		}
		
		if(stack.size()!=0) {
			answer=0;
		}
	}
}

class Node implements Comparable<Node> {
	long age;
	int index;

	public Node(long age, int index) {
		this.age= age;
		this.index = index;
	}

	@Override
	public int compareTo(Node o) {
		// TODO Auto-generated method stub
		return Long.compare(this.age, o.age);
	}
}

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