Solution -「LOCAL」Minimal DFA

\(\mathscr{Description}\)

  Private link.

  令 \(\Sigma=\{\texttt a,\texttt b\}\)，对于所有形式语言 \(L\subseteq\Sigma^n\)，\(L\) 的最小 DFA 状态数的最大值，以及取到这一最大值时，\(|L|\) 的最小值和最大值。

  \(n\le10^3\)。

\(\mathscr{Solution}\)

  引理 对于任意串 \(x,y\in\Sigma^\star\)，定义 \(x\equiv_Ly\)，当且仅当 \(\forall z\in\Sigma^\star,xz\in L\equiv yz\in L\)。语言 \(L\) 的最小 DFA 状态数就是等价关系 \(\equiv_L\) 在 \(\Sigma^\star\) 上划分出的等价类数目。

  直接考虑 \(L\) 的最小 DFA 的形态，可以发现：

• 对于任意状态，从开始状态转移到它的路径长度唯一；
• 不存在两个状态的转移完全相同（输入同样字符，转移向同一个状态）。

  根据性质一，我们将 DFA 的 DAG 分层，那么总状态数就是每层的状态数之和。令 \(Q_i~(i=0,1,\dots,m)\) 为第 \(i\) 层的状态，则 \(Q_0=\{q_s\}\) 为开始状态，\(Q_m=\{q_t\}\) 为唯一接受状态，此时对于第 \(k\) 层，从 \(Q_{k-1}\) 对 \(Q_k\) 的限制来看，显然 \(|Q_k|\le2|Q_{k-1}|\)；从 \(Q_{k+1}\) 对 \(Q_k\) 的限制来看，为了满足性质二，\(Q_{k+1}\) 最多为 \(Q_k\) 内的某个点提供 \((|Q_{k+1}|+1)^2-1\) 种转移的选择（\(1\) 表示空状态，即分别枚举 \(\texttt a\) 和 \(\texttt b\) 转移向谁，不能同时为空）。根据这一构造，每个 \(|Q_k|\) 的上界显然可以同时取到，所以第一问就解决了。

  设 \(Q_p\) 为最后一层满足 \(Q_p=2|Q_{p-1}|\) 的状态，此后，\(Q_k\) 的大小都将由性质二的限制决定。前后都已经固定，\(|L|\) 只取决于 \(\delta_p:Q_p\times\Sigma\rightarrow Q_{p+1}\) 的长相。

  先来刻画 \(Q_{p+1}\) 内每个点对应的后缀串数量。令 \(G_k(x)~(k=p+1,\dots,m)\) 表示 \(Q_k\) 中，状态数量关于状态对应后缀串数量的 GF，那么 \(G_k(x)=(G_{k+1}(x)+1)^2-1\)，其实就是 \(G_k(x)=(x+1)^{2^{m-k}}-1\)。

  然后，讨论一下 \(|Q_p|\) 和 \(|Q_{p+1}|\) 的大小关系：

  若 \(|Q_p|<|Q_{p+1}|\)，注意到此时必然有 \(|Q_{p+1}|=2|Q_p|+1\)，\(\delta_p\) 的当务之急是让每个 \(q\in Q_{p+1}\) 都有前驱。因此先让 \(Q_p\) 内每个点随便在 \(Q_{p+1}\) 里连两个，剩下一个状态放弃一个转移最小化 \(|L|\)，增加一个到 \(Q_{p+1}\) 内后缀最多的状态的转移最大化 \(|L|\)。

  若 \(|Q_p|\ge|Q_{p+1}|\)，我们需要同时关注“每个状态都有前驱”以及“最小/最大化 \(L\)”的要求。先描述出“在 \(Q_{p+1}\) 里连两个后继”的贡献，令 \(F(x)\) 表示连接方案数关于连接到后继的后缀总数的 GF，那么 \(F(x)=(G_{p+1}(x)+1)^2-1=(x+1)^{2^{m-p+1}}-1\)。接着贪心考虑最小化与最大化 \(L\) 的构造方案：

• 最小化 \(|L|\)，先用 \(Q_p\) 内的 \(|Q_{p+1}|\) 个状态直接各自连一条转移边到 \(Q_{p+1}\) 内的状态，求到剩下能选的连接方案的 GF \(F_1(x)\)，在 \(F_1(x)\) 里按指标升序贪心选择。
• 最大化 \(|L|\)，先用 \(Q_p\) 内的 \(|Q_{p+1}|\) 个状态直接各自连一条转移边到 \(Q_{p+1}\) 内的状态，再连一条转移边到 \(Q_{p+1}\) 内后缀串最多的状态，其余和最小化类似。

  撇开高精度计算，复杂度是 \(\mathcal O(n)\) 的。

\(\mathcal{Code}\)

# Rainybunny #

import sys

if __name__ == "__main__":
    sys.stdin = open('dfa.in', 'r')
    sys.stdout = open('dfa.out', 'w')

    n = int(input())
    ans = [0 for _ in range(3)]

    m = 0
    while 1 << m + 1 <= n - m - 1: m += 1
    ## the last limited level's G.F. is f_m(x)=(x+1)^{2^m}-1.
    # sys.stderr.write(str(m) + '\n')

    ans[0] = (1 << n - m) - 1
    for i in range(0, m + 1):
        ans[0] += (1 << (1 << i)) - 1

    lef = 1 << n - m - 1; rig = (1 << (1 << m)) - 1
    if (lef < rig):
        sys.stderr.write('type 1\n')
        ans[1] = 1 << ((1 << m) + m - 1)
        ans[2] = ans[1] + (1 << m)
    else:
        sys.stderr.write('type 2\n')
        ## get f_m(x)(->bino[0]) and f_m^2(x)(->bino[1])
        bino = [[0 for _ in range((1 << m) + 1)],
          [0 for _ in range((1 << m + 1) + 1)]]
        bino[0][0] = bino[1][0] = 1
        for i in range(1, (1 << m) + 1):
            bino[0][i] = bino[0][i - 1] * ((1 << m) - i + 1) // i
        for i in range(1, (1 << m + 1) + 1):
            bino[1][i] = bino[1][i - 1] * ((1 << m + 1) - i + 1) // i

        ## get ans[1].
        for i in range(1, (1 << m) + 1):
            ans[1] += i * bino[0][i]
            bino[1][i] -= bino[0][i]
        rest = lef - rig; cur = 1
        while rest and rest > bino[1][cur]:
            ans[1] += bino[1][cur] * cur
            rest -= bino[1][cur]
            cur += 1
        ans[1] += cur * rest

        ## get ans[2].
        for i in range(1, (1 << m) + 1):
            ans[2] += bino[0][i] * (i + (1 << m))
            bino[1][i] += bino[0][i] # recover it
            bino[1][i + (1 << m)] -= bino[0][i]
        rest = lef - rig; cur = 1 << m + 1
        while rest and rest > bino[1][cur]:
            ans[2] += bino[1][cur] * cur
            rest -= bino[1][cur]
            cur -= 1
        ans[2] += cur * rest

    print("%d %d %d" % (ans[0], ans[1], ans[2]))

    sys.stdin.close()
    sys.stdout.close()