lintcode

Posted 2021-03-18 connie313

1. stack push and pop

输入两个整数序列。其中一个序列表示栈的push顺序，判断另一个序列有没有可能是对应的pop顺序。为了简单起见，我们假设push序列的任意两个整数都是不相等的。

比如输入的push序列是1、2、3、4、5，那么4、5、3、2、1就有可能是一个pop系列。因为可以有如下的push和pop序列：push 1，push 2，push 3，push 4，pop，push 5，pop，pop，pop，pop，这样得到的pop序列就是4、5、3、2、1。但序列4、3、5、1、2就不可能是push序列1、2、3、4、5的pop序列

import math
def isLegalSeq(push, pop):
    # write your code here
    pushreal= []
    start =0
    while start<len(push) and len(pop)!=0:
        if pop[0] not in pushreal:
            tag =0
            while start<len(push) and push[start]!=pop[0]:
                tag = 1
                pushreal.append(push[start])
                start=start+1

            if push[start]==pop[0]:
                start=start+1
            pop.pop(0)
        else:
            if pushreal[-1]==pop[0]:
                pop.pop(0)
                pushreal.pop()
            else:
                return False
    start = 0
    if len(pop)!=0 and len(pop)==len(pushreal):
        while len(pushreal)!=0 and len(pop)!=0 and start<len(pop):
            if pushreal[start] != pop[-1*start-1]:
                return False
            start = start+1
        return True
    else:
        if len(pop)==0 and len(pushreal)==0:
            return True
        return False
2. rearch target
题目描述：我简单将题目用汉语描述一下。说初始位置在0，给定一个目标值target（target是一个整数），现在让你每次走一步，每次走的步长和已经走的步数相等（第一次走1，第二次走2，。。。），每次可以向左或者向右走（也就是加正数或者负数），问最少走多少次可以走到target.

def munss(target):
    m = math.floor((math.sqrt(1+8*target)-1)/2)
    targ = m/2+m*m/2
    return math.floor(2*(target - targ)+m)
outer = 0

3. rearch in a map

def rearch(map):
    start = [0,0]
    num = 0
    rearchfrom(start,map, num)
    print(outer)
def rearchfrom(start,map, num):
    if map[start[0]][start[1]] == 9:
        outer = outer + 1
        return
    if start[0]+1<len(map) and map[start[0]+1][start[1]]==0 and map[start[0]][start[1]+1]==0 and start[1]+1<len(map[0]):
        return
    else:
        if start[0]+1<len(map) and map[start[0]+1][start[1]]==1:
            start = [start[0]+1, start[1]]
            rearchfrom(start,map, num)
        if start[1]+1<len(map[0]) and map[start[0]][start[1]]==1:
            start = [start[0], start[1]+1]
            rearchfrom(start,map, num)
# print(munss(2))
print(rearch([
    [1,1,1],
    [1,1,1],
    [1,1,9]
]))
# print(isLegalSeq([1,2,4,3],[2,3,4,1]))