【思特奇杯·云上蓝桥 -算法 集训营】第3周

1. 斐波那契数列

def fib(self, n: int) -> int:
        if  n==0:
            return 0
        if n==1:
            return 1
        a=0
        b=1
        for i in range(2,n+1):
            a,b=b,a+b
        return b

2.第 N 个泰波那契数

def tribonacci(self, n: int) -> int:
        if n==0:
            return 0
        if n==1:
            return  1
        if n==2:
            return 1
        a=0
        b=1
        c=1
        for i in range(3,n+1):
            a,b,c=b,c,a+b+c
        return c

3.爬楼梯

def climbStairs(self, n: int) -> int:
        if n == 1:
            return 1
        if n == 2:
            return 2
        a,b = 1,2
        for i in range(3,n+1):
            a,b=b,a+b
        return b

4.使用最小花费爬楼梯

def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        if n == 2:
            return min(cost)
        dp = []#dp[i]=min(dp[i-1],dp[i-2])+cost[i]
        dp.append(cost[0]) 
        dp.append(cost[1])
        for i in range(2,n):
            if i == n-1:
                dp.append(min(dp[i-1],dp[i-2]+cost[i]))
            else:
                dp.append(min(dp[i-1],dp[i-2])+cost[i])
        return dp[-1]

5.买卖股票的最佳时机

def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n < 2:
            return 0
        Min = prices[0]
        Max = prices[1]
        ans = 0
        for i in range(n):
            if prices[i] >= Max:
                Max = prices[i]
                ans = max(ans,Max - Min)
            if prices[i] < Min:
                Min = prices[i]
                Max = prices[i]
        return ans

6.最⻓长公共⼦子序列

def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        n,m = len(text1),len(text2)
        dp = [[0]*(m+1) for _ in range(n+1)]
        for i in range(1,n+1):
            for j in range(1,m+1):
                if text1[i-1] == text2[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = max(dp[i-1][j],dp[i][j-1])
        return dp[-1][-1]

7.杨辉三角形

#杨辉三角
def solution(n):
    a = [1]
    row = i = 1
    while True:
        row += 1
        while i < row*(row+1)//2:
            if a[-1] == n:
                return len(a)
            if i == row*(row+1)//2 - 1 or i == row*(row+1)//2 - row:
                a.append(1)
            else:
                a.append(a[i-row]+a[i-row+1])
            i += 1
            
if __name__ == '__main__':
    n = 6
    ans = solution(n)
    print(ans)

8.节点选择

#节点选择
def check(a,k):
    for i in range(len(grah[k])):
        if grah[k][i] == 1 and a[i] == 1:
            return False
    return True
def dfs(start,end):
    global ans
    if start == end:
        tmp = 0
        for i in range(end):
            if a[i] == 1:
                tmp += weight[i]
        ans = max(ans,tmp)
        return
    for i in range(start,end):
        if check(a,i):
            a[i] = 1
            dfs(start+1,end)
            a[i] = 0
            
if __name__ == '__main__':
    n = int(input())
    a = [0]*n
    weight = list(map(int,input().split()))
    grah = [[0]*n for _  in range(n)]
    count = 0
    while count < n-1:
        i,j = map(int,input().split())
        grah[i-1][j-1] =  1
        grah[j-1][i-1] =  1
        count += 1
    ans = 0
    dfs(0,n)
    print(ans)

9.耐摔指数

#耐摔指数
def solution(n):
    i = sum1 = sum2 = 0
    while sum2 < n:
        i += 1
        sum2 += (sum1+1)
        sum1 += i
    return i
if __name__ == '__main__':
    n = int(input())
    ans = solution(n)
    print(ans)

10.K好数

while True:
    try:
         n = list(map(int, input().split()))
         k, l = n[0], n[1]
         mod = 1000000007
         result = 0
         dp = [[0 for i in range(l+1)] for j in range(k)]
         #if l == 0 or l == 1:
             #print(0)
         #else:
         for w in range(k):
             dp[w][1] = 1
         for y in range(2, l + 1):
             for x in range(k):
                 for z in range(k):
                     if z != x+1 and z != x-1:
                         dp[x][y] = (dp[x][y]%mod + dp[z][y-1]%mod)%mod
         for i in range(1,k):
             result = result%mod + dp[i][l]%mod
         print(result % mod)
    except:
        break