python bisect, re以及heapq

Python bisect

      Python内置库的bisect是一个小但是某种时候很有用的库，其功能就是有序插入和返回应该插入的index。其原理自然就是二分查找，时间复杂度O（lgn）。
    这个库主要有4个函数，即bisect_left,bisect,insort_left和insort。默认是升序序列。
1.  bisect. bisect_left ( a ,   x ,   lo=0 ,   hi=len(a) )

Locate the insertion point for x in a to maintain sorted order. The parameters lo and hi may be used to specify a subset of the list which should be considered; by default the entire list is used. Ifx is already present in a, the insertion point will be before (to the left of) any existing entries. The return value is suitable for use as the first parameter to list.insert() assuming that a is already sorted.

    The returned insertion point   i   partitions the array   a   into two halves so     that   all(val  <  x  for  val  in  a[lo:i])   for the left side     and   all(val  >=  x  for  val  in  a[i:hi])   for the right side.  
即返回最左边可以保持有序的插入的位置，a是插入元素，x是序列，还可以指定范围。

>>> num = [3,4,4,4,5,7,9]

>>> bisect.bisect_left(num, 4)

1

>>> bisect.bisect_left(num, 4, 4)

4

>>> bisect.bisect_left(num, 4, 2, 3)

2

2.  bisect. bisect_right ( a ,   x ,   lo=0 ,   hi=len(a) ) &  bisect. bisect ( a ,  x ,  lo=0 ,  hi=len(a) )

Similar to bisect_left(), but returns an insertion point which comes after (to the right of) any existing entries of x in a.

    The returned insertion point   i   partitions the array   a   into two halves so     that   all(val  <=  x  for  val  in  a[lo:i])   for the left side     and   all(val  >  x  for  val  in  a[i:hi])   for the right side.
这两个是一个意思，和 bisect_left相似，唯一不同就是找的是最右边的插入位置：

>>> bisect.bisect(num, 4)

4

3.  bisect. insort_left ( a ,  x ,  lo=0 ,  hi=len(a) )

Insert  x in  a in sorted order. This is equivalent to  a.insert(bisect.bisect_left(a,  x,  lo,  hi),  x) assuming that  a is already sorted. Keep in mind that the O(log n) search is dominated by the slow O(n) insertion step.

前面两个只是返回插入位置，并没有实际插入，这个及后面那个就是真的插入了。由于插入时间复杂度为O（n），会影响到整体的时间复杂度。 

4. bisect. insort_right ( a,  x,  lo=0,  hi=len(a) )

bisect. insort ( a,  x,  lo=0,  hi=len(a) )

Similar to  insort_left(), but inserting  x in  a after any existing entries of  x.

应用例题：给一个整数的序列，和一个正整数k，返回这个序列里面有没有长度为k的递增子序列。
【解】这道题其实和求最大递增子序列的思路类似，不过限定了长度k。可以用bisect，其实这个就是二分查找的实现版，不用自己再写一个。具体做法就是维持一个长度为k-1的序列，每次找到插入位置，但是不是插入而是替代，这样假如某个值要插入在最后，就说明有长度为k的递增子序列。

# Time:  O(n *logk)
# Space: O(k)
# Generalization of k-uplet.
class Solution_Generalization(object):
    def increasingKUplet(nums, k):
         inc = [float('inf')] * (k - 1)
        for num in nums:
              i = bisect.bisect_left(inc, num)
            if i >= k - 1:
                return True
            inc[i] = num
          return k == 0

Python re

     re库是Python里面负责正则表达（regular expression）的一个库。
    维基百科对正则表达的定义：
 In  theoretical computer science  and  formal language theory , a  regular expression  (sometimes called a  rational expression )  is a sequence of  characters  that define a search pattern, mainly for use in pattern matching  with  strings , or  string matching , i.e. "find and replace"-like operations.
 简而言之，正则表达式是一个字符串的搜索模式，本身也是一个字符串，而且语法和含义具有跨语言通用性，即大部分规定在很多语言里面都是相通的。 
 某种程度上可以把正则表达式理解成为一种语言，而组成这个语言最重要的就是元字符（ Metacharacter ）了。下面是从re文档copy的元字符列表：

The special characters are:

        "."      Matches any character except a newline.

        "^"      Matches the start of the string.

        "$"      Matches the end of the string or just before the newline at

                 the end of the string.

        "*"      Matches 0 or more (greedy) repetitions of the preceding RE.

                 Greedy means that it will match as many repetitions as possible.

        "+"      Matches 1 or more (greedy) repetitions of the preceding RE.

        "?"      Matches 0 or 1 (greedy) of the preceding RE.

        *?,+?,?? Non-greedy versions of the previous three special characters.

        {m,n}    Matches from m to n repetitions of the preceding RE.

        {m,n}?   Non-greedy version of the above.

        "\\"     Either escapes special characters or signals a special sequence.

        []       Indicates a set of characters.

                 A "^" as the first character indicates a complementing set.

        "|"      A|B, creates an RE that will match either A or B.

        (...)    Matches the RE inside the parentheses.

                 The contents can be retrieved or matched later in the string.

        (?aiLmsux) Set the A, I, L, M, S, U, or X flag for the RE (see below).

        (?:...)  Non-grouping version of regular parentheses.

        (?P<name>...) The substring matched by the group is accessible by name.

        (?P=name)     Matches the text matched earlier by the group named name.

        (?#...)  A comment; ignored.

        (?=...)  Matches if ... matches next, but doesn't consume the string.

        (?!...)  Matches if ... doesn't match next.

        (?<=...) Matches if preceded by ... (must be fixed length).

        (?<!...) Matches if not preceded by ... (must be fixed length).

        (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,

                           the (optional) no pattern otherwise.

    

    The special sequences consist of "\\" and a character from the list

    below.  If the ordinary character is not on the list, then the

    resulting RE will match the second character.

        \number  Matches the contents of the group of the same number.

        \A       Matches only at the start of the string.

        \Z       Matches only at the end of the string.

        \b       Matches the empty string, but only at the start or end of a word.

        \B       Matches the empty string, but not at the start or end of a word.

        \d       Matches any decimal digit; equivalent to the set [0-9] in

                 bytes patterns or string patterns with the ASCII flag.

                 In string patterns without the ASCII flag, it will match the whole

                 range of Unicode digits.

        \D       Matches any non-digit character; equivalent to [^\d].

        \s       Matches any whitespace character; equivalent to [ \t\n\r\f\v] in

                 bytes patterns or string patterns with the ASCII flag.

                 In string patterns without the ASCII flag, it will match the whole

                 range of Unicode whitespace characters.

        \S       Matches any non-whitespace character; equivalent to [^\s].

        \w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]

                 in bytes patterns or string patterns with the ASCII flag.

                 In string patterns without the ASCII flag, it will match the

                 range of Unicode alphanumeric characters (letters plus digits

                 plus underscore).

                 With LOCALE, it will match the set [0-9_] plus characters defined

                 as letters for the current locale.

        \W       Matches the complement of \w.

        \\       Matches a literal backslash.

 正则表达的强大之处在于处理字符串的灵活性和简约性，一行可以顶的上N行常规匹配代码。
 举例：匹配email：\ w+([-+.]\w+)*@\w+([-.]\w+)*.\w+([-.]\w+)*
    \w匹配单词字符，  ([-+.]\w+)*表示可能含有以-或+或.开头后面跟若干字符，整个部分可能出现零至若干次。后面的类似。
    Python re库提供了几个函数，用来实现正则表达式的各种功能，包括查找、匹配、分割等等。文档同样提供了函数列表：

        match     Match a regular expression pattern to the beginning of a string.

        fullmatch Match a regular expression pattern to all of a string.

        search    Search a string for the presence of a pattern.

        sub       Substitute occurrences of a pattern found in a string.

        subn      Same as sub, but also return the number of substitutions made.

        split     Split a string by the occurrences of a pattern.

        findall   Find all occurrences of a pattern in a string.

        finditer  Return an iterator yielding a match object for each match.

        compile   Compile a pattern into a RegexObject.

        purge     Clear the regular expression cache.

        escape    Backslash all non-alphanumerics in a string.

     常用的主要有match,search,sub,split,findall。在介绍这些函数之前，先看看re库提供了哪些flags，即特殊匹配模式，比如可以指定忽略大小写，多行匹配，点符号能不能匹配新行等等：

Some of the functions in this module takes flags as optional parameters:

        A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D

                       match the corresponding ASCII character categories

                       (rather than the whole Unicode categories, which is the

                       default).

                       For bytes patterns, this flag is the only available

                       behaviour and needn't be specified.

        I  IGNORECASE  Perform case-insensitive matching.

        L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.

        M  MULTILINE   "^" matches the beginning of lines (after a newline)

                       as well as the string.

                       "$" matches the end of lines (before a newline) as well

                       as the end of the string.

        S  DOTALL      "." matches any character at all, including the newline.

        X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.

        U  UNICODE     For compatibility only. Ignored for string patterns (it

                       is the default), and forbidden for bytes patterns.
 

     然后看几个函数：

match(pattern, string, flags=0)

        Try to apply the pattern at the start of the string, returning

        a match object, or None if no match was found.
     最基本的匹配的函数，接受三个参数，功能是从字符串开头开始匹配。也就是说，想要的pattern必须从字符串开头就符合，否则就算中间出现了，也不会认为是match。例如：
>>> text = "JGood is a handsome boy, he is cool, clever, and so on..."

>>> m = re.match(r"(\w+)\s", text)

>>> m

<_sre.SRE_Match object; span=(0, 6), match='JGood '>

>>> m.groups()

('JGood',)

>>> m.span()

(0, 6)    

>>> m = re.match(r"\s(\w+)", text)

>>> m       # m is none
 其中，pattern前面的r是raw的意思，用来避免转义，比如要匹配的是\n，假如没有r，输入的时候自动就当做换行处理了。当然这个例子加不加无所谓。
 返回的是一个matchObject，可以用groups()函数将match结果以tuple形式返回。同样还可以用span()函数得到match结果在原字符串的index范围。
 假如想要设置flags，在后面加上re.+匹配模式，例如      

>>> m = re.match("jgood\s", text, re.I)

>>> m

<_sre.SRE_Match object; span=(0, 6), match='JGood '>

    

search(pattern, string, flags=0)

        Scan through string looking for a match to the pattern, returning

        a match object, or None if no match was found.
    相当于整体版的match：

>>> m = re.search(r"\s(\w+)", text)

>>> m

<_sre.SRE_Match object; span=(5, 8), match=' is'>
     值得注意的是，search找到一个就返回了，如果想找到全部，用后面的findall。 

split(pattern, string, maxsplit=0, flags=0)

        Split the source string by the occurrences of the pattern,

        returning a list containing the resulting substrings.  If

        capturing parentheses are used in pattern, then the text of all

        groups in the pattern are also returned as part of the resulting

        list.  If maxsplit is nonzero, at most maxsplit splits occur,

        and the remainder of the string is returned as the final element

        of the list.
    分割函数，只不过是用正则表达式来分割。返回一个包含分割结果的list。

>>> m = re.split(r"\s", text)

>>> m

['JGood', 'is', 'a', 'handsome', 'boy,', 'he', 'is', 'cool,', 'clever,', 'and', 'so', 'on...']

 

sub(pattern, repl, string, count=0, flags=0)

        Return the string obtained by replacing the leftmost

        non-overlapping occurrences of the pattern in string by the

        replacement repl.  repl can be either a string or a callable;

        if a string, backslash escapes in it are processed.  If it is

        a callable, it's passed the match object and must return

        a replacement string to be used.  
    替代函数。将符合pattern的表达式用提供的字符串替换，还可以指定替换几个。

>>> m = re.sub(r"\s", "+", text, 3)

>>> m

'JGood+is+a+handsome boy, he is cool, clever, and so on...'

findall(pattern, string, flags=0)

        Return a list of all non-overlapping matches in the string.

        

        If one or more capturing groups are present in the pattern, return

        a list of groups; this will be a list of tuples if the pattern

        has more than one group.

        

        Empty matches are included in the result.  
    匹配全部能够匹配的，不像search找到一个就返回，而是搜索完毕整个字符串。
  >>> m = re.findall(r"(\w+)\s", text)

>>> m

['JGood', 'is', 'a', 'handsome', 'he', 'is', 'and', 'so']

     总结：re库的作用，一般是在解决问题的时候对字符串进行处理，以方便后续运算。也有一些字符串处理题，re库可以直接解决，不过更多时候是充当一个中间工具。

例题：（翻转游戏）甲乙两个人玩一个翻转字符串的游戏，给出一个只有"+""-"符号的字符串，每个人每次可以把连续的“++”翻转成“--”，假如无法做到，则此人判负，游戏结束。由甲先开始。现在给出字符串s，返回甲是否有必胜的策略。
【解】这个题解法其实有不少，贴一个和re相关的。
首先要明白一个事情，那就是对于一个字符串，只有两种情况：甲必胜或者乙必胜。
证明（思路是：假设单个连续+序列必胜或必负的前提下，其组合必胜或必负；然后对于单个连续+序列，可以从简单情况开始推，前几个是一眼能看出来必胜和必负的。因此对于某个长度为i的，必定可以通过翻转++成为之前的两个连续+序列的组合，而之前的已经证明了，所以这一个也将会必胜或必负）：
对于被-隔开的几个+序列pi，如果说1代表必胜，0代表必败的话，总体结果p=p0^p1...^pn-1. 
关于这个结论，只考虑两个连续的+序列a和b，无非三种情况：
（0，0），那么无论甲从哪一个开始，乙只要也在同一个序列里翻转即可，到一个序列完结，甲无法再翻转，因此在另一个序列甲还是先手必败。
（0，1），甲从必胜的开始，那么乙将被逼迫先手开必败，因此甲必胜。
（1，1），甲开始一个序列，但是乙总能先手开第二个必胜序列，因此最终乙必胜。
因此，总的结果就是两个分结果异或，推广到更多也是一样。
所以，对于单个连续的+序列，甲的选择就是相当于把一个裂开成为两个，这两个都比这个字符串小，因此之前就确定是必胜或者必负的。通过上面的证明可以知道，假如有某一个方法可以让裂开的两个子序列的组合是必败的，那么甲相反就是必胜的。否则甲必败。因此，对于单个连续+序列，也是必胜或必败，没有中间结果。
# Time:  O(n + c^2)
# Space: O(c)

import re

class SolutionM :
     def canWin ( self ,  s):
        lens =  list ( map ( len ,  re.split( '-+' ,  s)))
        g = [ 0 ]*( max (lens)+ 1 )
         for  i  in  range ( 1 ,  len (g)):
            subset = {x^y  for  x ,  y  in  zip (g[:i// 2 ] ,  reversed (g[i- 1 -i// 2 :i- 1 ]))}
             if  subset:
                g[i] =  1  -  min (subset)
             else :
                g[i] =  0
         ret =  0
         for  j  in  lens:
            ret ^= g[j]
         return  ret ==  1
     这里的re.split('-+', s)，里面的+可不是字符+，而是正则表达的元字符+，相当于说在有一个或者多个-的地方断开，即把连续+序列拿出来，类似于于re.findall('\+\++',s)【其实不完全等价，因为findall这个表达式只找两个及以上+符号的。不过实际上，一个单独的+可以忽略，和不存在没区别（和0异或不变），所以最后对结果没有影响。】。假如要想表达元字符的字符，需要加斜杠来escape。
    解法有点DP的味道，通过之前的结果来推下一个，g[i]表示长度为i的连续+序列的胜负，通过拆分判断其两个子序列的异或结果来判断这个字符串的胜负关系，然后利用上面证明的理论得到最终结果。
 

Python heapq

      collections库里面都是一些容器，而heapq不是一种容器，而是一个能对堆进行操作的类。heapq形成的是最小堆，假如需要最大堆，就得进行一些取反处理。
    所谓最小堆，可以看做排好序的完全二叉树，任意根节点总是不大于子节点。最小堆和BST有相似的地方，但也有不同，最小堆左右就没有大小之分。
    总而言之，最小堆的应用场合就是在取出最小元素的时候，优势就是效率高，插入、取出效率O(lgn)。因为假如每取出一个元素或者放入一个元素之后排序，复杂度是O（nlgn）。用deque也许能解决取出的问题，但是插入还是麻烦（当然可以用二分查找插入，效率也能到O（lgn））。 
    前面提到过，heapq并不是容器，而可以看成一个帮助类，用里面包含的方法进行操作。
★创建最小堆
    使用heapq.heapify(list)函数对一个list进行转换，复杂度O（n）。

>>> import heapq

>>> h = [3 , 2, 1]

>>> heapq.heapify(h)

>>> h

[1, 2, 3]

>>> type(h)

<class 'list'>

    可见，heapq形成的最小堆还是一个list，这也很方便操作。同时，直接访问list[0]也就是最小值了。
    这一个功能有点像排序，线性复杂度足够满意。 
★添加元素
    使用heapq.heappush(heap, item)函数添加元素，并维持最小堆：
>>> heapq.heappush(h, 0)

>>> h

[0, 1, 3, 2]
    可见最小堆确实是树状结构。
★弹出元素
    使用 heapq.heappop(heap)从堆顶弹出元素，弹出的自然是最小值。

>>> heapq.heappop(h)

0

>>> h

[1, 2, 3]
★添加后弹出最小
    相当于push之后pop，但是这个函数效率要更高：heapq.heappushpop(heap, item):

>>> heapq.heappushpop(h, 0)

0
★弹出后添加
    相当于pop之后push，效率更高。假如heap的size为0，会报错，因为没东西pop：heapq.heapreplace(heap, item):

>>> heapq.heapreplace(h, 0)

1

>>> h

[0, 2, 3]
★找出n个最小/大的
    使用heapq.nsmallest(n, iterable[,key])。这个功能不止对堆，对iterable都可以使用。还可以带一个key设置排序条件。 

>>> h = [1,2,3,4,5]

>>> heapq.nsmallest(3, h)

[1, 2, 3]        

>>> h = ['cool', 'new', 'hi']

>>> heapq.nsmallest(1, h, key = lambda x: len(x))

['hi']  
    对应的nlargest，一样的用法。

    总而言之，heapq是Python里面进行堆操作的一个很不错的选择，唯一不好的地方就是只能形成最小堆，要是需要的是最大堆，还得麻烦转换一下正负关系。