常用算法模板与知识点_常用算法思想模版-优快云博客

1.循环

def recursion(level,p1,p2...):
    #终止条件
    if level>Max_Level:
        return
    
    #处理当前层的问题
    process(level,p1,p2,...)

    #进入下一层
    recursion(level+1,p1,p2,...)

    #恢复当前层状态(if needed)
    recover(level,p1,p2,...)

2.DFS

def DFS(node,visited,p1,p2,...)
    #终止条件
    if node is end_node:
        return

    #处理当前node
    process(node,p1,p2,...)
    visited.add(node)

    #进入子节点
    for node_child in node.children():
        if node_child not in visited:
            DFS(node_child,visited,p1,p2,...)
    
    #恢复当前节点状态（if needed）
    recover(node,p1,p2,...)

3.BFS

def BFS(node,p1,p2,...)
    from collection import deque
    quene=deque([])
    visited=[]

    quene.append(node)
    
    while quene:
        cur_node=quene.popleft()
        
        if cur_node not in visited:
            process(node,p1,p2)
            visited.append(cur_node) #一般用于图

        for child in node.children():
            quene.append(child)

        #恢复当前节点数据（if needed）
        recover(node,p1,p2,...)

1. 判断质数

    def isPrime(self,num):
        if num<=3:
            return num>1

        # 不在6的倍数两侧的一定不是质数，必要非充分条件，如25就不是质数
        if num % 6 != 1 and num % 6 != 5:
            return False
        
        # 加上这段，就是充分条件了
        sqt=int(math.sqrt(num))
        for i in range(5,sqt+1,6):
            if num % i == 0  or num % (i + 2) == 0:
                return False
        return True

1. 三角形面积

    def area(self,pa,pb,pc):
        ab = sqrt((pa[0]-pb[0])**2 + (pa[1]-pb[1])**2)  # 直线ab长度
        ac = sqrt((pa[0]-pc[0])**2 + (pa[1]-pc[1])**2)  # 直线ac长度
        bc = sqrt((pb[0]-pc[0])**2 + (pb[1]-pc[1])**2)  # 直线bc长度
        
        # 海伦公式
        q = (ab + ac + bc) / 2 
        s = round(sqrt(q * (q - ab) * (q - ac) * (q - bc)), 3)  # 保留3位小数
        print(pa,pb,pc,s)
        return s

   def area2(self,p, q, r):
       # 行列式
       return .5 * abs(p[0]*q[1]+q[0]*r[1]+r[0]*p[1]-p[1]*q[0]-q[1]*r[0]-r[1]*p[0])

1. 判断两线段相交：

 def intersect(p_left, p_right, q_left, q_right):
            return min(p_right, q_right) > max(p_left, q_left) # 最小右端大于最大左端

1. 最大公约数：

# 辗转相除法也可以用来求两个数的最大公约数。
#更相减损术和辗转相除法的主要区别在于前者所使用的运算是“减”，后者是“除”。从算法思想上看，两者并没有本质上的区别，但是在计算过程中，如果遇到一个数很大，另一个数比较小的情况，可能要进行很多次减法才能达到一次除法的效果，从而使得算法的时间复杂度退化为O(N)，其中N是原先的两个数中较大的一个。相比之下，辗转相除法的时间复杂度稳定于O(logN)

    def gcd(self,a,b):
        r=a%b
        if r!=0:
            return self.gcd(b,r)
        else:
            return n