'WHY' than 'HOW'

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class BOJ2206 {

    static int n,m;
    static char map[][];

    static int mx[] = {0, -1, 0, 1};
    static int my[] = {-1, 0, 1, 0};

    static int BFS(){

        Queue<Info> queue = new LinkedList<>();
        boolean visit[][][] = new boolean[2][n+1][m+1];

        visit[0][1][1] = true;
        visit[1][1][1] = true;

        queue.add(new Info(1, 1, 1, 1));

        while (!queue.isEmpty()) {
            Info now = queue.poll();

            if (now.x == n && now.y == m) {
                return now.cost;
            }

            for (int i = 0; i < 4; i++) {
                int xx = now.x + mx[i];
                int yy = now.y + my[i];

                if (xx > 0 && xx <= n && yy > 0 && yy <= m) {

                    // 이미 방문한 경우
                    if(visit[now.cnt][xx][yy]) continue;

                    // 아직 방문하지 않았고 벽인 경우
                    if (map[xx][yy] == '1' && now.cnt == 1) {
                        visit[0][xx][yy] = true;
                        queue.add(new Info(xx, yy, 0, now.cost + 1));
                    }

                    // 벽이 아닌 경우는 cnt값을 유지하며 큐에 추가한다.
                    if (map[xx][yy] == '0') {
                        visit[now.cnt][xx][yy] = true;
                        queue.add(new Info(xx, yy, now.cnt, now.cost + 1));
                    }

                }
            }
        }

        return -1;
    }




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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] s = br.readLine().split(" ");

        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);

        map = new char[n + 1][m + 1];

        for (int i = 1; i <= n; i++) {

            char[] input = br.readLine().toCharArray();

            for (int j = 1; j <= m; j++) {
                map[i][j] = input[j - 1];
            }

        }

        int result = BFS();

        System.out.println(result);
  }

    static class Info{

        int x, y, cost;

        // 벽 부순 횟수
        int cnt;

        public Info(int x, int y, int cnt, int cost) {
            this.x = x;
            this.y = y;
            this.cnt = cnt;
            this.cost = cost;
        }
    }

}

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

/**
 * 도로 포장
 */
public class BOJ1162 {

    static int n, m, k;
    static List<Info> map[];

    static long INF = Long.MAX_VALUE;

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] input = br.readLine().split(" ");

        n = Integer.parseInt(input[0]);
        m = Integer.parseInt(input[1]);
        k = Integer.parseInt(input[2]);

        map = new ArrayList[n+1];

        for (int i = 1; i <= n; i++) {
            map[i] = new ArrayList<>();
        }

        for (int i = 0; i < m; i++) {
            int from, to , cost;
            String[] s = br.readLine().split(" ");

            from = Integer.parseInt(s[0]);
            to = Integer.parseInt(s[1]);
            cost = Integer.parseInt(s[2]);

            // 양방향 그래프 입력
            map[from].add(new Info(to, cost,0));
            map[to].add(new Info(from, cost, 0));
        }

        long result = dijkstra(1, n);

        System.out.println(result);
    }

    static long dijkstra(int start, int destination){

        PriorityQueue<Info> pq = new PriorityQueue<>(Comparator.comparingLong(i -> i.cost));

        // dist[i][j] i번째 도시를 방문 , 포장한 도로의 수 j
        long dist[][] = new long[n+1][k+1];

        for (int i = 1; i <= n; i++) {
            Arrays.fill(dist[i], INF);
        }

        dist[start][0] = 0;
        pq.add(new Info(start, 0, 0));


        while (!pq.isEmpty()) {
            Info now = pq.poll();

            if (dist[now.node][now.cnt] < now.cost) {
                continue;
            }

            for (Info next : map[now.node]) {

                // 포장 안 하는 경우 cnt 값을 그대로 유지하며 값이 더 작은 경우에만 탐색
                if (dist[next.node][now.cnt] > (now.cost + next.cost) ) {

                    dist[next.node][now.cnt] = next.cost + now.cost;
                    pq.add(new Info(next.node, now.cost + next.cost, now.cnt));

                }

                // 도로 포장을 하는 경우
                if ( (now.cnt < k) && (now.cost < dist[next.node][now.cnt + 1]) ) {

                    dist[next.node][now.cnt + 1] = now.cost;
                    pq.add(new Info(next.node, now.cost, now.cnt+1));

                    }
                }
            }

        long result = INF;

        for (Long v : dist[n]) {

            result = Math.min(v, result);
        }

        return result;
        }


    static class Info{

        int node;
        long cost;
        int cnt;

        public Info(int node, long cost, int cnt) {
            this.node = node;
            this.cost = cost;
            this.cnt = cnt;
        }
    }
}

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

/**
 * RGB거리 2
 */

public class BOJ17404 {


    static int dp_r[][], dp_g[][], dp_b[][];
    static int n;

    static final int INF = 10000000;

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

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(bufferedReader.readLine());

        // 2차원 배열의 각각 행은 1번 집을 어떤 색으로 칠했는지를 나타낸다.
        // 즉, 0행은 R, 1행은 G, 2행은 B로 1번 집을 색칠했다는 것이다.
        dp_r = new int[3][n+1];
        dp_g = new int[3][n+1];
        dp_b = new int[3][n+1];

        // 칠하는 비용으로 0행은 R, 1행은 G, 2행은 B로 칠하는 비용을 저장
        int[][] dt = new int[3][n+1];

        for (int i = 1; i <= n; i++) {
            String[] s = bufferedReader.readLine().split(" ");

            dt[0][i] = Integer.parseInt(s[0]); // R로 칠하는 비용
            dt[1][i] = Integer.parseInt(s[1]); // G로 칠하는 비용
            dt[2][i] = Integer.parseInt(s[2]); // B로 칠하는 비용
        }

        
        // dp 초깃값 갱신
        // 0행: 1번째 집을 R로 색칠하는 경우이므로 다른 색으로 칠하는 비용은 INF로 처리
        dp_r[0][1] = dt[0][1];
        dp_g[0][1] = INF;
        dp_b[0][1] = INF;

        // G로 출발하는 경우
        dp_r[1][1] = INF;
        dp_g[1][1] = dt[1][1];
        dp_b[1][1] = INF;

        // B로 출발하는 경우
        dp_r[2][1] = INF;
        dp_g[2][1] = INF;
        dp_b[2][1] = dt[2][1];


        int result = INF;


        for (int i = 0; i < 3; i++) {

            // 기본 점화식을 사용하여 n-1번 집까지의 최소 색칠 비용을 구함
            for (int j = 2; j <= n - 1; j++) {

                dp_r[i][j] = Math.min(dp_g[i][j - 1], dp_b[i][j - 1]) + dt[0][j];
                dp_g[i][j] = Math.min(dp_r[i][j - 1], dp_b[i][j - 1]) + dt[1][j];
                dp_b[i][j] = Math.min(dp_g[i][j - 1], dp_r[i][j - 1]) + dt[2][j];

            }

            // 마지막 n번째 집을 색칠할 때는 1번 집의 색(2차원 배열의 행)을 고려해 같은 색인 경우 INF로 처리함
            dp_r[i][n] = Math.min(dp_g[i][n - 1], dp_b[i][n - 1]) + ((i == 0) ? INF : dt[0][n]);
            dp_g[i][n] = Math.min(dp_r[i][n - 1], dp_b[i][n - 1]) + ((i == 1) ? INF : dt[1][n]);
            dp_b[i][n] = Math.min(dp_g[i][n - 1], dp_r[i][n - 1]) + ((i == 2) ? INF : dt[2][n]);

            // 최솟값 구하기
            result = Math.min(result, Math.min(dp_r[i][n], Math.min(dp_g[i][n], dp_b[i][n])));
        }

        // 결과 출력
        System.out.println(result);
    }


}

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

/**
 * A와 B 2
 */
public class BOJ12919 {

    static String S, T;
    static StringBuilder sb;
    
    static int length;

    static boolean equal = false;
    static void back(String now){

        // 탐색 종료 조건
        if (equal || now.length() <= length) {

            if (now.hashCode() == S.hashCode())
                equal = true;
            return;
        }
        
        // 1 ) 첫 문자가 'A'인 경우
        if (now.charAt(0) == 'A')
        {
            // 'A'로 시작하고 'B'로 끝나는 문자열은 만들 수 없으므로 탐색 종료
            if (now.charAt(now.length() - 1) == 'B')
                return;
            // 가장 뒤에 추가된 'A'를 제외
            back( now.substring(0, now.length()-1) );
        }
        else // if(now.charAt(0) =='B') 2) 첫 문자가 'B'인 경우
        {
            // 가장 마지막 문자가 'B'인 경우 앞에서 B를 제거하고 뒤집는다.
            if (now.charAt(now.length() - 1) == 'B') {
                sb = new StringBuilder( now.substring(1, now.length()) );
                back( sb.reverse().toString() );
            }
            else // if (now.length() -1 == 'A')
            {
                sb = new StringBuilder( now.substring(1, now.length()) );

                // 'B'가 마지막에 추가되어 뒤집어졌거나 'A'가 마지막에 추가된 경우
                back( sb.reverse().toString() );
                back( now.substring(0, now.length() - 1) );
            }
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        S = bufferedReader.readLine();
        T = bufferedReader.readLine();
        length = S.length();

        back(T);

        if (equal)
            System.out.println(1);
        else
            System.out.println(0);
    }

}