蓝桥杯 大写字符串 模拟

问题描述

　　小蓝有一个由大写字母 ABCDEF 组成的字符串 S ，长度为 n，字符串的下标依次为 0 到 n-1 。 　　小蓝按照如下方法生成一个无限长的字符串： 　　首先选定一个 0 到 n-1 之间的数，作为初始下标。 　　从初始下标开始，将下标对应的字符加入到字符串的结尾，将字符的序号（A到F依次对应 1 到 6 ）与下标相加作为新的下标值，如果下标大于等于 n，将其对 n 求余。重复此过程，即得到无限长的字符串。 　　例如，对于字符串 ACDF，当初始下标是 0 时，生成的字符串为：ACACACACAC... 　　再如，对于字符串 DCBA，当初始下标是 1 时，生成的字符串为：CDDDDDDDDD... 　　给定小蓝的字符串 S，请问当初始下标为多少时，生成的字符串最小。

输入格式

　　输入一行包含一个字符串。

输出格式

　　输出一行，包含一个整数，为所求的下标，如果有多个下标满足要求，输出最小的那个。

样例输入

DCBA

样例输出

3

样例输入

AAAA

样例输出

0

评测用例规模与约定

　　令 |S| 表示 S 的长度。 　　对于 30% 的评测用例，1 <= |S| <= 100。 　　对于 50% 的评测用例，1 <= |S| <= 1000。 　　对于 70% 的评测用例，1 <= |S| <= 10000。 　　对于 80% 的评测用例，1 <= |S| <= 100000。 　　对于所有评测用例，1 <= |S| <= 1000000。

=========================================================================

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] cs = sc.next().toCharArray();
        int n = cs.length;
        System.out.println(dfs(cs, n));
    }

    static class Node {
        StringBuilder sb;
        int pos;
        int index;
        public Node(StringBuilder sb, int pos) {
            this.sb = sb;
            this.pos = pos;
            this.index = pos;
        }
    }

    private static int dfs(char[] cs, int n) {
        List<Node> list = new ArrayList<>();
        // 初始化
        for (int i = 0; i < n; i++) {
            list.add(new Node(new StringBuilder(), i));
        }
        int m = 1000;
        while (m-- > 0) {
            // 更新各个节点的sb
            for (Node node : list) {
                node.sb.append(cs[node.pos]);
                node.pos = (node.pos + (cs[node.pos] - 'A' + 1)) % n;
            }
            list.sort((a, b) -> a.sb.toString().compareTo(b.sb.toString()));
            int index = 1;
            String min = list.get(0).sb.toString();
            // 找相同的
            while (index < list.size() && min.compareTo(list.get(index).sb.toString()) == 0) {
                index++;
            }
            // 去重
            while (index < list.size()) {
                list.remove(index);
            }
            if (list.size() == 1) return list.get(0).index;
        }
        list.sort((a,b)->a.index-b.index);
        return list.get(0).index;
    }
}