15948. 기념품 수집

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.function.Supplier;


public class Solution {
    public static void main(String[] args) throws Exception {
        new Solution();
    }

    private final Boolean USE_FILE_INPUT = false;

    private BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));

    private Solution() throws IOException {
        if (USE_FILE_INPUT) {
            try {
                bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("./input.txt")));
            } catch (FileNotFoundException e) { }
        }
        solve();
        close();
    }

    private void close() throws IOException {
        bufferedReader.close();
        bufferedWriter.close();
    }

    private void solve() throws IOException {
        int T = Integer.parseInt(bufferedReader.readLine());
        for (Integer testCaseNo = 1; testCaseNo <= T; testCaseNo++) {
            bufferedWriter.write("#"+testCaseNo+" "+solveTestcase()+"\n");
        }
    }

    private Integer solveTestcase() throws IOException {
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int R = Integer.parseInt(stringTokenizer.nextToken());
        int C = Integer.parseInt(stringTokenizer.nextToken());
        char[][] cities = new char[R][C];
        for (int r = 0; r < R; r++) {
            String line = bufferedReader.readLine();
            for (int c = 0; c < C; c++) {
                cities[r][c] = line.charAt(c);
            }
        }
        return solveTestcaseDFS(R, C, cities);
    }

    /**
     * 기념품(알파벳)을 하나의 노드로 보고, (1,1) 도시를 루트로 갖는 트리를 구성한다.
     * 루트에서 탐색을 시작하여 방문체크를 하였을 때, 중복되지 않은 노드로 이루어진 경로 중 가장 긴 경로의 크기를 찾는다.
     * @return 발견한 가장 긴 경로의 크기를 {@code Integer}로 반환한다.
     * @throws IOException
     */
    private Integer solveTestcaseDFS(int height, int width, char[][] cities) {
        Map<Character, Boolean> visited = new HashMap<>();
        return solveTestcaseDFSRecursive(height, width, 0, 0, cities, visited);
    }

    private Integer solveTestcaseDFSRecursive(int height, int width, int r, int c, char[][] cities, Map<Character, Boolean> visited) {
        if (!isValidRange(height, width, r, c) || isVisited(r, c, cities, visited)) {
            return 0;
        }
        return 1 + findMax(
            markVisitedThen(r, c, cities, visited, () -> solveTestcaseDFSRecursive(height, width, r+1, c, cities, visited)),
            markVisitedThen(r, c, cities, visited, () -> solveTestcaseDFSRecursive(height, width, r-1, c, cities, visited)),
            markVisitedThen(r, c, cities, visited, () -> solveTestcaseDFSRecursive(height, width, r, c+1, cities, visited)),
            markVisitedThen(r, c, cities, visited, () -> solveTestcaseDFSRecursive(height, width, r, c-1, cities, visited))
        );
    }

    private Boolean isValidRange(int height, int width, int r, int c) {
        return r >= 0 && r < height && c >= 0 && c < width;
    }

    private Boolean isVisited(int r, int c, char[][] cities, Map<Character, Boolean> visited) {
        return visited.getOrDefault(cities[r][c], false);
    }

    private <T> T markVisitedThen(int r, int c, char[][] cities, Map<Character, Boolean> visited, Supplier<T> callback) {
        visited.put(cities[r][c], true);
        T retval = callback.get();
        visited.put(cities[r][c], false);
        return retval;
    }

    private Integer findMax(Integer ...args) {
        return Arrays.asList(args).stream().reduce(Math::max).get();
    }
}