Java

Stack

백준 9012

package 스택;

import java.util.Scanner;
import java.util.Stack;

public class BOJ9012 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Stack<String>stack;
        String []tokens;
        String top;
        StringBuilder sb = new StringBuilder();
        int t = scanner.nextInt();

        for(int i = 0; i < t; i++) {
            stack = new Stack<String>();
            tokens = scanner.next().split("");
            for(int j = 0; j < tokens.length; j++){
                if(stack.isEmpty()){    // 스택이 비어 있을때
                    if(tokens[j].equals(")")){  // 바로 실패일 경우
                        stack.add(tokens[j]);
                        break;
                    }else{  // 정상적으로 "(" 이 토큰이 들어온 경우
                        stack.add(tokens[j]);
                        continue;
                    }
                }else{
                    top = stack.peek(); //스택의 최상위 데이터
                    if(top.equals("(") && tokens[j].equals(")")){   // 괄호 토큰이 완성된 경우
                        stack.pop();
                        continue;
                    }else{      // 완성되지 않은 경우
                        stack.add(tokens[j]);
                        continue;
                    }

                }
            }
            if(!stack.isEmpty()){   // 만약에 스택이 남아 있다면
                sb.append("NO").append("\n");
            }else{
                sb.append("YES").append("\n");
            }
        }
        System.out.println(sb);
    }
}

백준 10828

package 스택;

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

public class BOJ10828 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());    //  테스트 케이스의 수
        StringBuilder sb = new StringBuilder();
        Stack<Integer> stack = new Stack<Integer>();
        String commend;
        int num;
        for(int i =0; i<t; i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            commend = st.nextToken();
            if(commend.equals("push")){
                num = Integer.parseInt(st.nextToken());
                stack.add(num);
            } else if (commend.equals("pop")) {
                if(stack.isEmpty()){
                    sb.append(-1).append("\n");
                    continue;
                }
                sb.append(stack.pop()).append("\n");
            } else if(commend.equals("size")){
                sb.append(stack.size()).append("\n");
            } else if (commend.equals("empty")){
                if(stack.isEmpty()){
                    sb.append(1).append("\n");
                    continue;
                }else{
                    sb.append(0).append("\n");
                    continue;
                }
            } else if (commend.equals("top")){
                if(stack.isEmpty()){
                    sb.append(-1).append("\n");
                    continue;
                }
                sb.append(stack.peek()).append("\n");
            }
        }
        System.out.println(sb);
    }
}

백준 10773

package 스택;

import java.util.Scanner;
import java.util.Stack;

public class BOJ10773 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int answer = 0;
        int k = scanner.nextInt();
        int num;
        int removeNum;
        Stack<Integer>stack = new Stack<Integer>();
        for(int i = 0; i < k; i++){
            num = scanner.nextInt();
            if(num != 0){
                stack.add(num);
                answer += (num);
            }else{
                removeNum = stack.pop();
                answer -= (removeNum);
            }
        }
        System.out.println(answer);

    }
}

백준 1874

package 스택;

import java.util.Scanner;
import java.util.Stack;

public class BOJ1874 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder sb = new StringBuilder(); // 정답을 담을 StringBuilder
        int k = scanner.nextInt(); // 스택에 담을 공간
        Stack<Integer> stackInt = new Stack<Integer>();
        int target;
        boolean check;
        int n = 1;
        for(int i = 0; i < k;i++){
            target = scanner.nextInt();
            check = true;
            while (true){
                if(!stackInt.isEmpty()){    // 스택이 비어있지 않은 상태
                    if(stackInt.peek() == target){
                        stackInt.pop();
                        sb.append("-").append("\n");
                        break;
                    } else if (stackInt.peek() > target) {
                        sb = new StringBuilder("NO");
                        check =false;
                        break;
                    }else{
                        sb.append("+").append("\n");
                        stackInt.add(n);
                        n++;
                        continue;
                    }
                }else{  // 비어있는 상태
                    if(n <= target){
                        sb.append("+").append("\n");
                        stackInt.add(n);
                        n++;
                        continue;
                    }
                }
            }
            if(!check){
                break;
            }
        }
        System.out.println(sb);
    }
}

백준 28278

package 스택;

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

public class BOJ28278 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Stack<Integer> stack = new Stack<Integer>();
        int commands = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        StringTokenizer st;
        int command;
        for(int i =0; i<commands; i++){
            st = new StringTokenizer(br.readLine());
            command = Integer.parseInt(st.nextToken());
            
            if(command == 1){
                int num = Integer.parseInt(st.nextToken());
                stack.add(num);
            } else if (command ==2) {
                if(stack.isEmpty()){
                    sb.append(-1).append("\n");
                    continue;
                }
                sb.append(stack.pop()).append("\n");
            } else if (command == 3) {
                sb.append(stack.size()).append("\n");
            } else if (command == 4) {
                if (stack.isEmpty()){
                    sb.append(1).append("\n");
                }else{
                    sb.append(0).append("\n");
                }
            }else if (command == 5){
                if (stack.isEmpty()){
                    sb.append(-1).append("\n");
                    continue;
                }
                sb.append(stack.peek()).append("\n");
            }
        }

        System.out.println(sb);
    }
}

백준 4949

package 스택;

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

public class BOJ4949 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        Stack<String> stack = new Stack<String>();
        String strs;
        String[] strStack;
        while(true){
            strs = br.readLine();
            if(strs.equals(".")){
                break;
            }
            strStack = strs.split("");
            stack.clear();
            for(int i = 0; i<strStack.length; i++){
                if(stack.isEmpty()){
                    if(strStack[i].equals("(")){
                        stack.add(strStack[i]);
                    } else if (strStack[i].equals(")")) {
                        sb.append("no").append("\n");
                        break;
                    } else if (strStack[i].equals("[")) {
                        stack.add(strStack[i]);
                    } else if (strStack[i].equals("]")) {
                        sb.append("no").append("\n");
                        break;
                    } else if (strStack[i].equals(".")) {
                        sb.append("yes").append("\n");
                        break;
                    }
                }else{
                    String top = stack.peek();
                    if(top.equals("(") && strStack[i].equals(")")){
                        stack.pop();
                    } else if (top.equals("[") && strStack[i].equals("]")) {
                        stack.pop();
                    } else if (top.equals("(") && strStack[i].equals("]")) {
                        sb.append("no").append("\n");
                        break;
                    } else if (top.equals("[") && strStack[i].equals(")")) {
                        sb.append("no").append("\n");
                        break;
                    } else if (top.equals("(") && strStack[i].equals("[")) {
                        stack.add(strStack[i]);
                    } else if (top.equals("[") && strStack[i].equals("(")) {
                        stack.add(strStack[i]);
                    } else if (top.equals("(") && strStack[i].equals("(")) {
                        stack.add(strStack[i]);
                    } else if (top.equals("[") && strStack[i].equals("[")) {
                        stack.add(strStack[i]);
                    } else if (strStack[i].equals(".")) {
                        sb.append("no").append("\n");
                        break;
                    }
                }
            }
        }
        System.out.println(sb);
    }
}

백준 12789

package 스택;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

public class BOJ12789 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Stack<Integer> stack = new Stack<Integer>();
        Queue<Integer> queue = new LinkedList<Integer>();
        Stack<Integer> finishStack = new Stack<Integer>();
        int queueInt , stackInt;
        for(int i = 0; i < n; i++){
            queue.add(scanner.nextInt());
        }
        int next = 1;
        while(true){
            if(queue.isEmpty()){                // 큐가 비어 있을떄
                if(!stack.isEmpty()){           // 스택이 비어 있지 않을떄
                    stackInt = stack.pop();
                    if(stackInt == next){
                        finishStack.add(stackInt);
                        next++;
                        continue;
                    }else{
                        break;
                    }
                }else{
                    break;
                }
            }else{  // 큐가 비어있지 않을떄
                queueInt = queue.peek();
                if(queueInt == next){   // 큐 == next
                    finishStack.add(queueInt);
                    queue.remove();
                    next++;
                    continue;
                }else{      // 큐 != next
                    if(stack.isEmpty()){        // 큐의 값이 맞지 않고 스택이 비어 있으면 큐 값을 스택에 넣는다.
                        stack.add(queueInt);
                        continue;
                    }else{                      // 큐의 값이 맞지 않는데 스택에 값이 존재 할때
                        stackInt = stack.pop(); // 스택의 값을 추출
                        if(stackInt == next){      // 스택의 값이랑 == next
                            finishStack.add(stackInt);
                            next++;
                            continue;
                        }else{
                            stack.add(stackInt);
                            stack.add(queueInt);
                            queue.remove();
                            continue;
                        }
                    }
                }
            }
        }
        if(finishStack.size() == n){
            System.out.println("Nice");
        }else{
            System.out.println("Sad");
        }
    }
}