牛客算法入门02

AB24 二分查找-I
请实现无重复数字的升序数组的二分查找
给定一个 元素升序的、无重复数字的整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标（下标从 0 开始），否则返回 -1

class Solution:
    def search(self , nums: List[int], target: int) -> int:
        # write code here
        left = 0
        right = len(nums) - 1
        while left <= right:
            mid = int((left + right)/2)
            if nums[mid] == target:
                return mid
            elif nums[mid] > target:
                right = mid - 1
            else:
                left = mid + 1
        return -1

AB28 快速幂
请你计算
𝑎^𝑏 𝑚𝑜𝑑 𝑝的值。

def fast_power(base, power, p):
    res = 1
    while power > 0:
        if power % 2 == 1:
            res = res * base % p
        power = power // 2
        base = base * base % p
    return res % p

a = int(input())
for _ in range(a):
    i = input()
    a = int(i.split()[0])
    b = int(i.split()[1])
    p = int(i.split()[2])
    res = fast_power(a, b, p)
    print(res)

循环的话，超时。
快速幂：（对指数奇偶性进行判断）当指数大于零的时候，对2取余数，余数为1的时候，此时计算的结果res乘一次底数，并将结果对p取余。
指数对2取整（变为原来的一半），底数取平方并对p取余数。
当指数<=0，跳出循环。

AB29 快速乘
请你计算 𝑎∗𝑏 𝑚𝑜𝑑 𝑝的值。要求只能使用加法和取模运算。

def fast_add(a, b, p):
    res = 0
    while b > 0:
        if b % 2 == 1:
            res = (res + a) % p
        b = b // 2
        a = (a + a) % p
    return res % p

a = int(input())
for _ in range(a):
    i = input()
    a = int(i.split()[0])
    b = int(i.split()[1])
    p = int(i.split()[2])
    res = fast_add(a, b, p)
    print(res)

AB30 排序
给定一个长度为 n 的数组，请你编写一个函数，返回该数组按升序排序后的结果。

class Solution:
    def MySort(self , arr: List[int]) -> List[int]:
        # write code here
        for i in range(len(arr)):
            for j in range(i+1, len(arr)):
                if arr[j] < arr[i]:
                    arr[j], arr[i] = arr[i], arr[j]
        return arr

动态规划
BM1 斐波那契数列

class Solution:
    def Fibonacci(self , n: int) -> int:
        # write code here
        if n <= 1:
            return n
        a = 0
        b = 1
        res = 0
        for i in range(2, n+1):
            res = (a + b)
            a = b
            b = res
        return res

BM2 跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

class Solution:
    def jumpFloor(self , number: int) -> int:
        # write code here
        if number <= 1:
            return 1
        res = 0
        a = 1
        b = 1
        for i in range(2, number + 1):
            res = (a + b)
            a = b
            b = res
        return res

分析：一只青蛙一次可以跳1阶或2阶，直到跳到第𝑛阶，也可以看成这只青蛙从𝑛阶往下跳，到0阶，按照原路返回的话，两种方法事实上可以的跳法是一样的——即怎么来的，怎么回去！ 当青蛙在第n阶往下跳，它可以选择跳1阶到𝑛−1，也可以选择跳2阶到𝑛−2，即它后续的跳法变成𝑓(𝑛−1)+𝑓(𝑛−2)，这就变成了斐波那契数列。因此可以按照斐波那契数列的做法来做：即输入n，输出第n个斐波那契数列的值，初始化0阶有1种，1阶有1种。

BM3 最小花费爬楼梯
给定一个整数数组 𝑐𝑜𝑠𝑡，其中 𝑐𝑜𝑠𝑡[𝑖] 是从楼梯第𝑖个台阶向上爬需要支付的费用，下标从0开始。一旦你支付此费用，即可选择向上爬一个或者两个台阶。
你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。

class Solution:
    def minCostClimbingStairs(self , cost: List[int]) -> int:
        # write code here
        dp = [0 for i in range(len(cost) + 1)]
        for i in range(2, len(cost) + 1):
            dp[i] = min(cost[i-1]+dp[i-1], cost[i-2]+dp[i-2])
        return dp[len(cost)]

分析：使用一个数组记录每次爬楼梯的最小花费，𝑑𝑝[𝑖]=𝑚𝑖𝑛(𝑑𝑝[𝑖−1]+𝑐𝑜𝑠𝑡[𝑖−1],𝑑𝑝[𝑖−2]+𝑐𝑜𝑠𝑡[𝑖−2])。