《python算法笔记》(二)基础知识

1.计算机的核心概念

• 
  
• 图灵论文《论数字计算在决断难题中的应用》是现代计算机科学的基石。他提出的图灵机概念成为了计算机理论的核心概念。
• 图灵机（Turing machine）：A Turing machine is a simple
  (abstract) device that can read from, write to, and move along an infinitely long strip of paper

• 实际中的机器有所不同，但都叫做有限状态机（finite state machine）.
  有限状态机（finite state machine）:it has a finite set of states (some
  of which indicate that it has finished), and every symbol it reads potentially triggers reading and/or
  writing and switching to a different state. You can think of this machinery as a set of rules.
  这些看似简单的机器完全的概述了计算机的本质。

• 算法（Algorithm）：An algorithm is a procedure, consisting of a finite set of steps (possibly including loops and
  conditionals) that solves a given problem in finite time.

• 图灵机就是一种模型，准确的描述算法解决问题的过程
  现代计算机用存储器块取代了纸带，就是我们所熟知的内存（Random-Access machine)
• 图灵机是一种抽象的简化的标准单处理计算机，并有以下特点：
  1.顺序执行
  2.标准的基础操作（例如算数，比较和内存存取）花费常量时间。
  3.计算机字节（常量时间能够处理的值得大小）并不是无限制的。
  

决断难题（Entscheidungsproblem）：David Hilbert提出的问题，是否存在一个算法来判断数学陈述的正确性

2.渐进符号

• 
  
• O：上界
• Ω：下界
• Θ：上下综合

• 渐进时间复杂度的常见例子

复杂度	名称	例子
$Θ(1)$	常量时	哈希表的查找修改
$Θ(lgn)$	对数	二插树搜索
$Θ(n)$	线性	便利列表
$Θ(nlgn)$	对数线性	最佳排序算法
$Θ(n^2)$	二次方	n个对象相互比较
$Θ(n^3)$	三次方	floyd-warshall最短路径算法
$Θ(n^k)$	多项式	k层嵌套循环
$Θ(k^n)$	指数	处理n个元素的每个子集（k=2）
$Θ(n!)$	结成	处理n个值的每个顺序

• 三种重要的情况
  1.最佳情况：
  2.最坏情况
  3.平均情况

• 算法的经验评估
  算法设计的目的是获得低的渐进运行时间（设计高效的算法），算法工程的目的是减少那个渐进复杂度下的隐藏的常量。
  1.先用直接发解决问题，在考虑优化算法。
  2.使用timeit来计算时间
  3.用分析工具来发现瓶颈
  4.画下你的结果
  5.在你以运行时间比较为基础做出结论时要当心随机误差。
  

  for else 结构富国循环没有过早的被break终止，则执行else的子句

• 3.实现图和树

  3.1图的实现（临接表/临接矩阵）

  2-1 A Straightforward Adjacency Set Representation

  a, b, c, d, e, f, g, h = range(8)
  N = [
      {b, c, d, e, f},    # a
      {c, e},             # b
      {d},                # c
      {e},                # d
      {f},                # e
      {c, g, h},          # f
      {f, h},             # g
      {f, g}              # h
  ]

  2-2 Adjacency Lists

  a, b, c, d, e, f, g, h = range(8)
  N = [
      [b, c, d, e, f],    # a
      [c, e],             # b
      [d],                # c
      [e],                # d
      [f],                # e
      [c, g, h],          # f
      [f, h],             # g
      [f, g]              # h
  ]

  2-3 Adjacency dicts with Edge Weights

  a, b, c, d, e, f, g, h = range(8)
  N = [
      {b:2, c:1, d:3, e:9, f:4},    # a
      {c:4, e:3},                   # b
      {d:8},                        # c
      {e:7},                        # d
      {f:5},                        # e
      {c:2, g:2, h:2},              # f
      {f:1, h:6},                   # g
      {f:9, g:8}                    # h
  ]

  2-4 Dict with Adjacency Sets

  N = {
      'a':set('bcdef'),
      'b':set('ce'),
      'c':set('d'),
      'd':set('e'),
      'e':set('f'),
      'f':set('cgh'),
      'g':set('fh'),
      'h':set('fg'),
  }

  2-5 An Adjacency Matrix, Implemented with Nested Lists

  a, b, c, d, e, f, g, h = range(8)
  #     a b c d e f g h
  N = [[0,1,1,1,1,1,0,0],    # a
       [0,0,1,0,1,0,0,0],    # b
       [0,0,0,1,0,0,0,0],    # c
       [0,0,0,0,1,0,0,0],    # d
       [0,0,0,0,0,1,0,0],    # e
       [0,0,1,0,0,0,1,1],    # f
       [0,0,0,0,0,1,0,1],    # g
       [0,0,0,0,0,1,1,0]]    # h

  2-6 A Weight Matrix with Infinite Weight for Missing Edges

  a, b, c, d, e, f, g, h = range(8)
  _ = float('inf')
  #     a b c d e f g h
  W = [[0,2,1,3,9,4,_,_],    # a
       [_,0,4,_,3,_,_,_],    # b
       [_,_,0,8,_,_,_,_],    # c
       [_,_,_,0,7,_,_,_],    # d
       [_,_,_,_,0,5,_,_],    # e
       [_,_,2,_,_,0,2,2],    # f
       [_,_,_,_,_,1,0,6],    # g
       [_,_,_,_,_,9,8,0]]    # h

  3.2树的实现

  2-7 A Binary Class

  class Tree:
      def __init__(self, left, right):
          self.left = left
          self.right = right
  
  >>> t = Tree(Tree("a", "b"), Tree("c", "d"))
  >>> t.right.left
  'c'

  2-8 A Multiway Tree Class

  class Tree:
      def __init__(self, kids, next=None):
          self.kids = self.val = kids
          self.next = next
  
  >>> t = Tree(Tree("a", Tree("b", Tree("c", Tree("d")))))
  >>> t.kids.next.next.val
  'c'

  Bunch Pattern(一个灵活的类，允许你在构造器中制定任一属性)

  class Bunch(dict):
      def __init__(self, *args, **kwds):
          super(Bunch, self).__init__(*args, **kwds)
          self.__dict__ = self
  
   >>> T = Bunch
   >>> t = T(left=T(left="a", right="b"), right=T(left="c"))
   >>> t.left
   {'right': 'b', 'left': 'a'}
   >>> t.left.right
   'b'
   >>> t['left']['right']
   'b'
   >>> "left" in t.right
   True
   >>> "right" in t.right
   False

  3.3图和树还有其他表示方法，具体的实现要结合具体的问题

  哈希：为任意一个对象计算出一个整数

  4.小心黑盒子（底层实现）

  如果不知道底层实现可能会增加算法的时间复杂度。
  例如：

  1.check in list and set

  >>> from random import randrange
  >>> L = [randrange(10000) for i in range(1000)]
  >>> 42 in L
  False
  >>> S = set(L)
  >>> 42 in S
  False

  由于list其实是array，所以对list进行check的时间复杂度是线性的，set是经过哈希的，所以对lset进行check的时间复杂度是常量时间。
  

  2.构造字符串

  >>> s = ""
  >>> for chunk in input():
  ...
  s += chunk

  它起作用，因为在python中做了一些聪明的优化，但是如果到达一定的大小，优化就会崩塌，时间复杂度就会上升到二次方。每一次+=操作都会创建一个新的字符串。一个更好的方法是：

  >>> chunks = []
  >>> for chunk in input():
  ...
  chunks.append(chunk)
  ...
  >>> s = ''.join(chunks)

  更进一步的简化

  >>> s = ''.join(input())

  3.Floats的麻烦
  float的精度不高，在要求高精度的情况下请用decimal