这个代码怎么会超时呀，当时报的Python语言，感觉这个复杂度已经很低了呀，还是超时了。

n=int(input())
l=[]
t=[]
c=[]
for i in range(1,n*8+1):
    a=input()
    t.append(a)
    if i%8==0:
        l.append(t)
        cnt=l.count(t)
        c.append(cnt)
        t=[]
for i in range(n):
    print(c[i])

'''
8
********
******pk
*****r*p
p*pQ****
********
**b*B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*pQ****
*b******
****B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*
******k*
******p*
*****r*p
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*
******k*
******p*
*****r*p
p*pQ****
*b******
****B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*pQ****
*b******
****B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*
********
******pk
******rp
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*
'''

国际象棋每一个局面可以用大小为 8 × 8 的字符数组来表示，其中每一位对应棋盘
上的一个格子。六种棋子王、后、车、象、马、兵分别用字母 k、q、r、b、n、p 表示，
其中大写字母对应白方、小写字母对应黑方。棋盘上无棋子处用字符 * 表示。两个字符
数组的每一位均相同则说明对应同一局面。
现已按上述方式整理好了每步棋后的局面，试统计每个局面分别是第几次出现。
从标准输入读入数据。
输入的第一行包含一个正整数 n，表示这盘棋总共有 n 步。
接下来 8 × n 行，依次输入第 1 到第 n 步棋后的局面。具体来说每行包含一个长度
为 8 的字符串，每 8 行字符串共 64 个字符对应一个局面。
输出到标准输出。
输出共 n 行，每行一个整数，表示该局面是第几次出现。

代码超时：使用了多个循环和列表操作，导致时间复杂度较高。

import sys

n = int(input())
l = []
t = []
c = []
for i in range(1, n * 8 + 1):
    try:
        a = sys.stdin.readline().strip()
    except:
        break
    t.append(a)
    if i % 8 == 0:
        l.append(t)
        cnt = l.count(t)
        c.append(cnt)
        t = []
for i in range(n):
    print(c[i])

每次count都是O(n)复杂度，不如将8行字符串合并成一行，然后用哈希表来计数

• 你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7661024
• 除此之外, 这篇博客: python中的抽象类中的 1.首先知道python中的抽象类其实就是一种代码规范，和前面两篇文章python中的单继承和python中的多继承说的都是一个道理归根到底都是为了代码规范，同样也是从Java中继承的思想，抽象类一般都是单继承，由于多个子类都需要继承同一个类，所以可以在抽象类中实现具体的方法，但是子类中还是要实现具体的方法，看下面的例子，抽象类中实现了文件打开和关闭操作，但是子类中还是定义了 读写功能，为了理解的简便还是可以直接理解成抽象类中不实现具体的方法，子类中必须实现具体的方法 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• import abc #利用abc模块实现抽象类
  
  class All_file(metaclass=abc.ABCMeta):
      all_type='file'
      @abc.abstractmethod #定义抽象方法，无需实现功能
      def read(self):
          '子类必须定义读功能'
          with open('filaname') as f:
              pass
  
      @abc.abstractmethod #定义抽象方法，无需实现功能
      def write(self):
          '子类必须定义写功能'
          pass
  
  class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
      def read(self):
          print('文本数据的读取方法')
      def write(self):
          print('文本数据的读取方法')
  
  class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
      def read(self):
          print('硬盘数据的读取方法')
  
      def write(self):
          print('硬盘数据的读取方法')
  
  class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
      def read(self):
          print('进程数据的读取方法')
  
      def write(self):
          print('进程数据的读取方法')
  
  wenbenwenjian=Txt()
  
  yingpanwenjian=Sata()
  
  jinchengwenjian=Process()
  
  #这样大家都是被归一化了,也就是一切皆文件的思想
  wenbenwenjian.read()
  yingpanwenjian.write()
  jinchengwenjian.read()
  
  print(wenbenwenjian.all_type)
  print(yingpanwenjian.all_type)
  print(jinchengwenjian.all_type)
  
  # 抽象类 ： 规范
  # 一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
  # 多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中
  
  
  # 抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化
  # java ：
  # java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
  # 但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题
  
  # python
  # python中没有接口类  ：
    #  python中自带多继承 所以我们直接用class来实现了接口类
  # python中支持抽象类  ： 一般情况下 单继承  不能实例化
    #  且可以实现python代码