【Kickstart】2018 Round F - Palindromic Sequence

解法

这个题我看解答都想了好久= =

对于小数据集，当N<=100时，可以通过计算出以S为前缀的字符串有多少个来慢慢遍历，记作$P_N(S)$
为了方便大数据集的分析，我们把空串也算上，空串是K=0对应的串

处理过程伪代码如下：

def solve(l,N,K):
  prefix = ""
  while True:
    if K < P(prefix+"$"):   # 是否可以直接成回文串，如果可以P是1，不可以P是0
      return len(prefix)
    K -= P(prefix+"$")
    for i in range(l):
      c = 'a'+i
      if K<P(prefix+c):
        prefix += c
        break
      else:
        prefix -= P(prefix+c)
    else: # 如果所有可用字符都遍历完了也不确定下一个字符是啥，那就说明K太大了
      return 0

$P_N(S)$的求法如下:
$P_N(S)={\sum }_{l=len(S)}^{N}P(S,L)$，其中，$P(S,L)$表示以S开头的，长度为L的回文串

P(S,L)的求法如下：

• 如果S的长度超过L的一半，那么要检查超过部分是否是回文，如果是，P(S,L)=1，否则为0
• 如果S的长度不足L的一半，$len(S)<\lfloor \frac{L+1}{2}\rfloor$，不足一半的那部分可以随便变换，所以可能性有$l^{\lfloor \frac{L+1}{2}\rfloor -len(S)}$种

现在如果N可能很大，我们不能一个一个字符推测了，而是应该根据K的大小来直接得到一个前缀：

• 如果K<=N，首先我们知道，这个回文串序列的前N个一定是长度分别为1,2,...,N的全是a的串，所以此时第K个串对应的长度一定是K

• 如果K>N：
  首先，以t个a为前缀的回文串，我们记作$A_t$，并且有$$P_N(A_t)=\sum _{L=t}^{2t-1}P(A_t,L)+\sum _{L=2t}^{N}P(A_t,L)$$，前一部分很明显满足条件的只能是全a的串，所以等于t，并且它们刚好是以$A_t$开头的前t个回文串；而后一部分全部都是长度为L的以$A_t$开头和结尾的回文串，它等价于长度为L-2t的任意回文串，因此最后我们有：$$\begin{gathered} P_N(A_t)=t+\sum _{L=2t}^{N}P("",L-2t) \\ =t+\sum _{L=0}^{N-2t}P("",L)=t+P_{N-2t}("") \end{gathered}$$

  而$P_{N-2t}("")$恰好对应于一个更小规模（$N^{\prime }=N-2t$）的问题，也就是说，如果我们能确定K对应的回文串开头有多少个a，那么问题的规模就能减小

  现在，按照我们的遍历逻辑：
  1. 前缀为"a"时，如果K==1，那么对应的串是"a"（当然这在K>N时不会发生）
  如果K>=2且K-2<P("aa")，那么K对应的串将以"aa"开头，而由于P("aa")很大，这是很有可能的
  而如果K>=2且$K-2<P_{N-2}("")$，那么K对应的回文串就落在了P("a")的第二部分，它将是以"a"开头，"a"结尾的串，并且是长为N-2的字典序回文串里的第K-2个。
  2. 接下来，可能由于K>=3并且K-3<P("aaa")，所以对应的串将以"aaa"开头，由于K>=4且$K-4<P_{N-4}("")$，它将是以"aa"开头，"aa"结尾的串，并且是长为N-4的字典序回文串里的第K-4个。

  以此类推，我们有：

  假如K>=t（这条由于K>N一定成立）且$K-t<P(A_t)$，那么对应的串将由$A_t$开头
  假如K>=2t且$K-2t<P_{N-2t}("")$，那么对应的串将由$A_t$开头，$A_t$结尾，并且是长为N-2t的字典序回文串里的第K-2t个。

  现在我们想确定一个尽量大的t，使得K对应的串以$A_t$开头，$A_t$结尾，并且是是长为N-2t的字典序回文串里的第K-2t个.

  根据$P_{N-2t}("")$的定义我们知道$P_{N-2t}("")\ge P("",N-2t)=l^{\lfloor \frac{N+1}{2}\rfloor -t}$，当且仅当2t==N取等号
  而$K-2t\le K$，当且仅当t==0时取等号
  由于N>0，所以它们不会同时取等号，这意味着如果我们让$$K\le l^{\lfloor \frac{N+1}{2}\rfloor -t}$$，就能让$K-2t<P_{N-2t}("")$。
  解得$$t=\lfloor \lfloor \frac{N+1}{2}\rfloor -{\log }_{l}K\rfloor$$
  如果t<0，说明K太大了，应该返回0。
  然后问题就从solve(l,n,k)变成2t+solve(l,n-2t,k-2t)啦，由于$k\in (2^{32},2^{64})$，所以${\log }_{l}K$不会超过64，而n-2t接近$2{\log }_{l}K$，所以问题规模不会比小数据集大很多。

# -*- coding:utf-8 -*-

import math
INF = 10**5
BASE = ord('a')
END = '$'

def isPalindrome(s,l,r):
    while l<r:
        if s[l]!=s[r]:
            return False
        l += 1
        r -= 1
    return True

def solve(l,n,k):
    def P(s,l,n):
        d = len(s)
        if s[-1]=='$':
            return 1 if isPalindrome(s,0,d-2) else 0
        res = 0
        for L in range(d,n+1):
            diff = (L+1)//2-d
            if diff>=0 or isPalindrome(s,L-d,d-1):
                res += l**max(0,diff)
        return res

    if k<=n:
        return k
    if l==1:
        return 0
    t = int((n+1)//2-math.log(k,l))
    if t<0:
        return 0
    n -= (t<<1)
    k -= (t<<1)
    prefix = ""
    while True:
        res = P(prefix+'$',l,n)
        if res<=k:
            k -= res
        else:
            return len(prefix)+(t<<1)
        for i in range(l):
            c = chr(BASE + i)
            res = P(prefix+c,l,n)
            if res<=k:
                k -= res
            else:
                prefix += c
                break
        else:
            return 0

if __name__ == "__main__" :
    t = int(input())
    for round in range(1,t+1):
        l,n,k = map(int,input().split())
        print("Case #%d: %d"%(round,solve(l,n,k)))