[Algorithm] 데일리 백준

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;

public class Main {

  public static void main(String[] args) throws Exception {

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

//    //1157
//    String word = br.readLine().toUpperCase();
////    String[] check = word.split("");
//
//    Map<String, Integer> letter = new HashMap<>();
//
//    int count = 0;
//
//    // 시간 초과
////    for (int i = 0 ; i < check.length ; i++) {
////      for(int j = 0 ; j < check.length ; j++) {
////        if(check[j].equals(check[i])){
////          count++;
////        }
////      }
//////      if(letter.containsKey(check[i])){
//////        count = 0;
//////      } else{
//////        letter.put(check[i], count);
//////        count = 0;
//////      }
////      // 간략화
////      if (!letter.containsKey(check[i])) {
////        letter.put(check[i], count);
////      }
////      count = 0;
////    }
//    for (int i = 0; i < word.length(); i++) {
//      String ch = String.valueOf(word.charAt(i));
//      letter.put(ch, letter.getOrDefault(ch, 0) + 1);
//    }
//    // 최대값을 찾기 위한 로직 추가
//    String maxKey = null;
//    int maxValue = Integer.MIN_VALUE;
//
//    for (Map.Entry<String, Integer> entry : letter.entrySet()) {
//      if (entry.getValue() > maxValue) {
//        maxKey = entry.getKey();
//        maxValue = entry.getValue();
//      } else if (entry.getValue() == maxValue) {
//        maxKey = "?"; // 같은 값이 여러 개일 경우
//      }
//    }
//    System.out.println(maxKey);

//    // 2941
//    String[] word = br.readLine().split("");
//    int count = 0;
//    for (int i = 0 ; i < word.length ; i++) {
//      // ArrayIndexOutOfBounds 예외 방지
//      if(i < word.length-1 && word[i].equals("c") && word[i+1].equals("=")) {
//        count++;
//        i++;
//      } else if(i < word.length-1 && word[i].equals("c") && word[i+1].equals("-")) {
//        count++;
//        i++;
//      } else if(i < word.length-2 && word[i].equals("d") && word[i+1].equals("z") && word[i+2].equals("=")) {
//        count++;
//        i += 2;
//      } else if(i < word.length-1 && word[i].equals("d") && word[i+1].equals("-")) {
//        count++;
//        i++;
//      } else if(i < word.length-1 && word[i].equals("l") && word[i+1].equals("j")) {
//        count++;
//        i++;
//      } else if(i < word.length-1 && word[i].equals("n") && word[i+1].equals("j")) {
//        count++;
//        i++;
//      } else if(i < word.length-1 && word[i].equals("s") && word[i+1].equals("=")) {
//        count++;
//        i++;
//      } else if(i < word.length-1 && word[i].equals("z") && word[i+1].equals("=")) {
//        count++;
//        i++;
//      } else {
//        count++;
//      }
//    }
//    System.out.println(count);

    //1316
    int testCase = Integer.parseInt(br.readLine());
    int count = testCase;
    for (int i = 0; i < testCase; i++) {
//      // 검증로직
////      // 1st try 배열로 비교해서 처리하려고 함
////      String[] word = br.readLine().split("");
////      if (word.length == 1) {
////        break;
////      } else {
////        for (int j = 0; j < word.length; j++) {
////          for (int k = j; k >= 0 ; k--) {
////            // 글자가 같고 연속되지 않았을 때 = 그룹단어 아님
////            if (word[j].equals(word[k]) && j - k > 1) {
////              count--;
////              break;
////            }
////            System.out.println(j);
////            System.out.println("word[j] : " + word[j]);
////            System.out.println(k);
////            System.out.println("word[k] : " + word[k]);
////            System.out.println("count : " + count);
////            System.out.println("-------------------");
////          }
////        }
////      }
//
////      // 2nd Queue를 써보려고 함
//////      for (int j = 0; j < testCase; j++) {
////      String[] word = br.readLine().split("");
////      Queue<String> queue = new LinkedList<>();
////
////      // 단어를 큐에 삽입
////      for (String c : word) {
////        queue.offer(c);
////      }
////      Map<String, Integer> stored = new HashMap();
////      String prev = " "; // 이전 문자를 기록 (초기에는 빈 문자)
////      int j = 0;
////
////      while (!queue.isEmpty()) {
////        String current = queue.poll();
////        if (current == prev && stored.containsKey(current)) { // 이전문자 = 현재문자 && 연속 => value update
////          stored.put(current, j);
////        } else if (current != prev && !stored.containsKey(current)) { // 이전문자 != 현재문자 && 새로운 문자 => 추가
////          stored.put(current, j);
////        } else if (current != prev && j - stored.get(current) == 1) {
////          System.out.println(prev);
////          System.out.println(current);
////          System.out.println(j);
////          count--;
////        }
////        prev = current; // 이전 문자 업데이트
////        j++;
////      }
////    }
//////    }
////    System.out.println(count);
//
      // 3rd
      String[] word = br.readLine().split("");
      Queue<String> queue = new LinkedList<>();

      for (String c : word) {
        queue.offer(c);
      }

      Map<String, Integer> stored = new HashMap();
      String prev = " ";
      int j = 0;
      while (!queue.isEmpty()) {
        String current = queue.poll();
        if (current.equals(prev)) {
          stored.put(current, j);
        } else {
          if (!stored.containsKey(current) || j - stored.get(current) == 1) {
            stored.put(current, j);
          } else if (stored.containsKey(current)) {
            count--;
            break;
          }
        }
        prev = current;
        j++;
      }
    }
    System.out.println(count);
  }
}

 

그룹단어 체크 문제가 좀 많이 헷갈렸다. 문제를 푸는거에 있어서 구상을 하고 이해를 하는 과정에서도 시간이 좀 걸렸던것 같다.