米哈游居然两个都a了，太难得了

import java.util.Scanner;

public class Main{
    private static int rows, cols;

    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String[] firstLine = scanner.nextLine().split(" ");
        rows = Integer.parseInt(firstLine[0]);
        cols = Integer.parseInt(firstLine[1]);
        char[][] canvas = new char[rows][cols];
        for(int i = 0; i < rows; i++){
            String line = scanner.nextLine();
            for(int j = 0; j < cols; j++){
                canvas[i][j] = line.charAt(j);
            }
        }

        {
            String[] lastLine = scanner.nextLine().split(" ");
            int r1 = Integer.parseInt(lastLine[0]);
            int c1 = Integer.parseInt(lastLine[1]);
            int r2 = Integer.parseInt(lastLine[2]);
            int c2 = Integer.parseInt(lastLine[3]);

            char temp = canvas[r1][c1];
            canvas[r1][c1] = canvas[r2][c2];
            canvas[r2][c2] = temp;
        }


        scanner.close();

        int count = 0;
        while (true) {
            boolean[][] mark = new boolean[rows][cols];
            markRow(canvas, mark);
            markCol(canvas, mark);

            boolean flag = false;
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < cols; j++) {
                    if (mark[i][j]) {
                        count += 1;
                        canvas[i][j] = '0';
                        flag = true;
                    }
                }
            }

            if(!flag || !fallDown(canvas))
                break;
        }
        System.out.println(count);

    }

    private static boolean fallDown(char[][] canvas){
        boolean flag = false;
        for(int j = 0; j < cols; j++){
            int zero = -1;
            int alpha = -1;
            for(int i = rows - 1; i >= 0; i--){
                if(zero == -1 && canvas[i][j] == '0')
                    zero = i;
                if(alpha == -1 && canvas[i][j] != '0')
                    alpha = i;
            }

            if(zero == -1 || alpha == -1 || zero <= alpha)
                continue;

            flag = true;
            int dis = zero - alpha;
            for(int i = alpha; i >= 0; i--){
                canvas[i + dis][j] = canvas[i][j];
                canvas[i][j] = '0';
            }
        }
        return flag;
    }


    private static void markRow(char[][] canvas, boolean[][] mark){
        for(int i = 0; i < rows; i++) {
            char last = '!';
            int count = 0;
            for(int j = 0; j < cols; j++){
                char curr = canvas[i][j];
                if(curr == '0'){
                    count = 0;
                    continue;
                }
                if(curr == last){
                    count += 1;
                } else{
                    if(count >= 3){
                        markRow(i, j - 1, count, mark);
                    }
                    last = curr;
                    count = 1;
                }
            }
            if(count >= 3)
                markRow(i, cols - 1, count, mark);
        }
    }

    private static void markCol(char[][] canvas, boolean[][] mark){
        for(int j = 0; j < cols; j++) {
            char last = '!';
            int count = 0;
            for(int i = 0; i < rows; i++){
                char curr = canvas[i][j];
                if(curr == '0'){
                    count = 0;
                    continue;
                }
                if(curr == last){
                    count += 1;
                } else{
                    if(count >= 3){
                        markCol(j, i - 1, count, mark);
                    }
                    last = curr;
                    count = 1;
                }
            }
            if(count >= 3)
                markCol(j, rows - 1, count, mark);
        }
    }

    private static void markRow(int row, int end, int count, boolean[][] mark){
        for(int j = end; j > end - count; j--){
            mark[row][j] = true;
        }
    }

    private static void markCol(int col, int end, int count, boolean[][] mark){
        for(int i = end; i > end - count; i--){
            mark[i][col] = true;
        }
    }
}

import javafx.util.Pair;

import java.util.HashMap;
import java.util.Scanner;

public class Main {
    private static HashMap<Character, Integer> hashMap = new HashMap<>();
    private static String dictionary = "";

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        scanner.close();

        initDictionary();

        String result = getString(text, 1);
//        System.out.println(result);
        System.out.println(getMostAlpha(result));
    }

    private static void initDictionary() {
        StringBuilder stringBuilder = new StringBuilder();

        int index = 0;
        for (char i = 'A'; i <= 'Z'; i++) {
            hashMap.put(i, index++);
            stringBuilder.append(i);
        }

        for (char i = 'a'; i <= 'z'; i++) {
            hashMap.put(i, index++);
            stringBuilder.append(i);
        }

        dictionary = stringBuilder.toString();
    }

    private static String getMostAlpha(String text){
        text = text.toLowerCase();

        int max = 0;
        char maxAlpha = '!';
        HashMap<Character, Integer> map = new HashMap<>();
        for(int i = 0; i < text.length(); i++){
            char ch = text.charAt(i);
            if(map.containsKey(ch))
                map.put(ch, map.get(ch) + 1);
            else
                map.put(ch, 1);
            if(map.get(ch) > max) {
                max = map.get(ch);
                maxAlpha = ch;
            }
        }

        return String.valueOf(maxAlpha) + max;
    }

    private static String getString(String text, int count) {
        StringBuilder result = new StringBuilder();
        StringBuilder last = new StringBuilder();
        int index = 0;
        while (index < text.length()) {
            char curr = text.charAt(index);
            if (curr >= '0' && curr <= '9') {
                int start = index++;
                while (index < text.length() && text.charAt(index) >= '0' && text.charAt(index) <= '9') {
                    index++;
                }
                int number = Integer.parseInt(text.substring(start, index)) - 1;
                for(int i = 0; i < number; i++){
                    result.append(last.toString());
                }
                last.delete(0, last.length());
            } else if (index < text.length() - 2 && text.charAt(index + 1) == '-') {
                int start = hashMap.get(curr);
                int end = hashMap.get(text.charAt(index + 2));
                result.append(dictionary.substring(start, end + 1));
                last.append(dictionary.substring(start, end + 1));
                index += 3;
            } else {
                result.append(curr);
                last.append(curr);
                index += 1;
            }
        }
        String s = "";
        for (int i = 0; i < count; i++) {
            s += result.toString();
        }
        return s;
    }
}