soyoung210 / acmicpc_note Goto Github PK

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.EmptyStackException;
import java.util.Stack;

public class Main {
    static Stack<String> s = new Stack<>();

    public static void main(String[] args) {

    }

    /*
        현재 알고리즘 : 닫힌 괄호 쌍의 갯수만큼 수로 계산하여 마지막에 더하는 방식인듯.
        [()]() ==> stack <6,2>

        stack 상태
        stack <[(>
        stack <[2>
        stack <6>
        stack <6(>
        stack <6,2>

        하나의 스택만 사용하려고 해서 조금 어렵게 짠 듯한 느낌.

        *** 알고리즘 자체는 참신 ㅋㅋ ***

        결론 : 크게 바꿀거 없음. 잘 짬. 다만 로직이 어려움.
     */
    private static void originalMain() {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            char[] chArr = br.readLine().toCharArray();
            int chLeng = chArr.length;
            if (chLeng % 2 != 0) {
                System.out.println("0");
                return;
            }
            int i;

            int answer = 0;

            for (i = 0; i < chLeng; i++) {
                //stackOp call
                if (chArr[i] == ')') {
                    stackOp(2, ')');
                } else if (chArr[i] == ']') {
                    stackOp(3, ']');
                } else {
                    s.push(Character.toString(chArr[i]));
                }
            }

            while (!s.isEmpty()) {
                if (isInteger(s.peek())) {
                    answer += Integer.parseInt(s.pop());
                } else {
                    System.out.println("0");
                    return;
                }
            }
            System.out.println(answer);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }


    /*
        try - catch의 상태가??? --> 왜 쓴진 알거 같은데.. 하나로 합치는게

        강제종료가 상당히 많이 들어간다.
        stackOp의 동작을 호출하는 부분으 메인에서만 있다면 boolean 값으로 반환해도 좋을듯 싶음.

        exit(0)을 잘 안쓰는 이유 : 종료 시점을 알기 힘들어짐.

        ')' or ']'만 있는 케이스의 경우 문자열 길이만큼 실행됨. (try-catch에 걸리기 때문에 어떠한 동작도 실행되지는 않으나, 반복문이 살아있음.)

        반복문을 사용하면 코드는 간결해지지만, 현재 짠 방식으로 할 때 코드의 이해가 조금 더 쉽다는 장점이 있음.
     */
    public static void stackOp(int op, char bracket) {
        int sum = 0;
        String tmp;
        String tmp2;
        String second;

        try {
            tmp = s.pop();
            //System.out.println("tmp : "+tmp);
            if (isInteger(tmp)) {
                sum += Integer.parseInt(tmp);
                try {
                    second = s.peek();
                    if (isInteger(second)) {
                        tmp2 = s.peek();
                        while (isInteger(tmp2)) {
                            s.pop();
                            sum += Integer.parseInt(tmp2);
                            tmp2 = s.peek();
                        }
                        s.pop();
                        s.push(Integer.toString(sum * op));
                    } else {
                        if (bracket == ')') {
                            if (s.pop().charAt(0) == '(') {
                                s.push(Integer.toString(Integer.parseInt(tmp) * op));
                            } else {
                                System.out.println("0");
                                System.exit(0);
                            }
                        } else {
                            if (s.pop().charAt(0) == '[') {
                                s.push(Integer.toString(Integer.parseInt(tmp) * op));
                            } else {
                                System.out.println("0");
                                System.exit(0);
                            }
                        }

                    }

                } catch (Exception e) {
                    //System.out.println("0"); return;
                }
            } else {
                if (bracket == ')') {
                    if (tmp.charAt(0) == '(') {
                        s.push("2");
                    } else {
                        System.out.println("0");
                        System.exit(0);
                    }
                } else {
                    if (tmp.charAt(0) == '[') {
                        s.push("3");
                    } else {
                        System.out.println("0");
                        System.exit(0);
                    }
                }
                //s.push( (bracket=='(') ? '2' : '3' );
            }
        } catch (EmptyStackException ex) {
            //System.out.println("0"); return;
        }
    }


    /*
        기존 알고리즘 유지하며 바꾸고 싶은 부분 바꿔봄.
        정답임을 보장하진 않음. (안돌려봄)
     */

    private static char[] open = {'(', '['};
    private static char[] close = {')', ']'};

    private static void change() {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            char[] chArr = br.readLine().toCharArray();
            int chLeng = chArr.length;
            if (chLeng % 2 != 0) {
                System.out.println("0");
                return;
            }
            int i;

            int answer = 0;

            boolean isOk = true;
            for (i = 0; i < chLeng; i++) {
                //stackOp call
                char c = chArr[i];
                for (int j = 0; j < 2; j++) {
                    if (c == close[j]) {
                        isOk = stackOpChange(j + 2, close[j]);
                        break;
                    }
                    if (c == open[j]) {
                        s.push(String.valueOf(c));
                        break;
                    }
                }
                if (!isOk) {
                    System.out.println(0);
                    return;
                }
            }

            while (!s.isEmpty()) {
                if (isInteger(s.peek())) {
                    answer += Integer.parseInt(s.pop());
                } else {
                    System.out.println("0");
                    return;
                }
            }
            System.out.println(answer);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static boolean stackOpChange(int op, char bracket) {

        // 닫힘 괄호만 있을 때 체크
        if (s.isEmpty()) {
            return false;
        }

        int sum = 0;
        String tmp;
        String second;

        tmp = s.pop();

        boolean isCheck = true;
        if (isInteger(tmp)) {
            sum += Integer.parseInt(tmp);
            second = s.peek();
            if (isInteger(second)) {
                while (isInteger(second)) {
                    s.pop();
                    sum += Integer.parseInt(second);
                    second = s.peek();
                }
                s.pop();
                s.push(Integer.toString(sum * op));
            } else {
                isCheck = isPush(
                        bracket,
                        String.valueOf(Integer.parseInt(tmp) * op),
                        s.pop().charAt(0)
                );
            }
        } else {
            isCheck = isPush(bracket, "", tmp.charAt(0));
        }
        return isCheck;
    }

    private static boolean isPush(char bracket, String value, char openC) {
        for (int i = 0; i < 2; i++) {
            if (bracket == close[i]) {
                if (openC == open[i]) {
                    if (value.length() == 0) {
                        s.push(String.valueOf(i + 2));
                    } else {
                        s.push(value);
                    }
                    break;
                } else {
                    return false;
                }
            }
        }
        return true;
    }

    /*
        이 방법은 되게 참신하네 ㅋㅋㅋㅋㅋㅋ
        catch만 하나로 합침
     */
    public static boolean isInteger(String s) {
        try {
            Integer.parseInt(s);
        } catch (NumberFormatException | NullPointerException e) {
            return false;
        }
        // only got here if we didn't return false
        return true;
    }
}

//test = 2 
try(BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
	int test = Integer.parseInt(br.readLine());
	String[] answer = new String[test];
	int i;
			
	for(i=0;i<test;i++) {
		System.out.println("===test===");
		String[] nmw = br.readLine().split(" ");
				
		int n = Integer.parseInt(nmw[0]); //3
		int m = Integer.parseInt(nmw[1]); //3
		int w = Integer.parseInt(nmw[2]); //1
		int[] dist = new int[n+1];
		Arrays.fill(dist,INF);
		// 2 3 4

		for (i = 1; i <= m; i++) { 
			String[] set = br.readLine().split(" ");
			
			int s1 = Integer.parseInt(set[0]);
			int e1 = Integer.parseInt(set[1]);
			int t1 = Integer.parseInt(set[2]);

			g.add(new Edge(s1,e1,t1));
			g.add(new Edge(e1,s1,t1));
		} 
		for (i = 1; i <= w; i++) { 
			String[] set2 = br.readLine().split(" ");

			int s2 = Integer.parseInt(set2[0]);
			int e2 = Integer.parseInt(set2[1]);
			int t2 = Integer.parseInt(set2[2]);	
			g.add(new Edge(s2,e2,t2*(-1)));	
		}				
				
		boolean minus = BellmanFord(dist,g,n,(m+w),1);
		System.out.println( (minus) ? "YES" : "NO" );
		g.clear();
		}
		System.out.println("===out===");
}catch(IOException ex) {
		System.out.println("===error===");
		ex.printStackTrace();
}

//오름차순 정렬. 내림차순 하고싶으면 부등호만 바꾸자. 
	@Override
	public int compareTo(Element o){
		if(this.dist<o.dist) {
			return -1;
		}else if(this.dist > o.dist) {
			return 1;
		}else {
			return 0;
		}
    }

import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class B_9237 {
	public static void main (String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int count = Integer.parseInt(br.readLine());
		PriorityQueue<Integer> tree = new PriorityQueue<>(count, Collections.reverseOrder());
		StringTokenizer st = new StringTokenizer(br.readLine());

		int i;
		
		for(i=0;i<count;i++) {
			tree.add(Integer.parseInt(st.nextToken()));
		}
		int max = 0;
		System.out.println("max"+max);
		i = 1;
		for(Integer tmp : tree) {
			System.out.println("tmp"+tmp);
			max = (max < tmp) ? tmp : max;
		}
		System.out.println(max);
	}
}

int num = 11;
char ch = Character.forDigit(num,10);
//forDigit(숫자,진법) method.

for(List<Integer> an : result) {
      System.out.println("size : "+an.size());
       for(int k=0; k<4; k++) {
        	System.out.println(an.get(k));	
        }
       System.out.println("==============");
}