offer常考算法

01背包

题目描述：

风机离升压站的距离d，如 30 20 35 40

风机发电量e， 如 20 18 25 30

输电总距离的限制m，如50

求输送电量的最大值（38）

d = [int(i) for i in input().split()]
e = [int(i) for i in input().split()]
m = int(input())
dp = [0] * (m + 5)
for i in range(len(d)):
    for j in range(m, d[i] - 1, -1):
        dp[j] = max(dp[j], dp[j - d[i]] + e[i])
print(dp[m])

归并排序

基本思想：基本思想:归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。

def merge_sort(nums):
    if len(nums) <= 1:
        return 0
    # 确定分界点
    mid = len(nums) // 2
    # 一分为二，左右递归排序
    L = nums[:mid]
    R = nums[mid:]
    merge_sort(L), merge_sort(R)
    # 双路归并，合二为一
    i = j = k = 0
    while i < len(L) and j < len(R):
        if L[i] <= R[j]:
            nums[k] = L[i]
            k += 1
            i += 1
        else:
            nums[k] = R[j]
            k += 1
            j += 1
    while i < len(L):  # 左边没循环完，加在后边
        nums[k] = L[i]
        k += 1
        i += 1
    while j < len(R):  # 右边没循环完，加在后边
        nums[k] = R[j]
        k += 1
        j += 1


if __name__ == "__main__":
    nums = list(map(int, input().split()))
    merge_sort(nums)
    print(','.join(map(str, nums)))

快速排序

基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一轮扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分，直到各区间只有一个数。

def quick_sort(li, start, end):
    # 分治 一分为二
    # start=end ,证明要处理的数据只有一个
    # start>end ,证明右边没有数据
    if start >= end:
        return
    # 定义两个游标，分别指向0和末尾位置
    left = start
    right = end
    # 把0位置的数据，认为是中间值
    mid = li[left]
    while left < right:
        # 让右边游标往左移动，目的是找到小于mid的值，放到left游标位置
        while left < right and li[right] >= mid:
            right -= 1
        li[left] = li[right]
        # 让左边游标往右移动，目的是找到大于mid的值，放到right游标位置
        while left < right and li[left] < mid:
            left += 1
        li[right] = li[left]
    # while结束后，把mid放到中间位置，left=right
    li[left] = mid
    # 递归处理左边的数据
    quick_sort(li, start, left-1)
    # 递归处理右边的数据
    quick_sort(li, left+1, end)


if __name__ == '__main__':
    lst = [int(i) for i in input().split()]
    quick_sort(lst, 0, len(lst) - 1)  # 改变了原数组
    print(lst)

冒泡排序

基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。

def bub_sort(lst):
    for i in range(len(lst) - 1):
        for j in range(len(lst) - 1 - i):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
    return lst


if __name__ == '__main__':
    lst = [int(i) for i in input().split()]
    print(bub_sort(lst))

直接插入排序

基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。（是一种最简单的排序方法，其基本操作是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。）

def insert_sort(lst):
    for i in range(1, len(lst)):
        j = i - 1
        temp = lst[i]
        while j >= 0 and lst[j] > temp:
            lst[j + 1] = lst[j]
            j -= 1
        lst[j + 1] = temp
    return lst


if __name__ == '__main__':
    lst = [int(i) for i in input().split()]
    print(insert_sort(lst))

直接选择排序

思想：每趟从待排序的记录序列中选择关键字最小的记录放置到已排序表的最前位置，直到全部排完。

def select_sort(lst):
    for i in range(len(lst) - 1):
        for j in range(i + 1, len(lst)):
            if lst[j] < lst[i]:
                lst[i], lst[j] = lst[j], lst[i]
    return lst


if __name__ == '__main__':
    lst = [int(i) for i in input().split()]
    print(select_sort(lst))

最长公共子串

def lc_string(string1, string2):
    len1 = len(string1)
    len2 = len(string2)
    res = [[0 for i in range(len1+1)] for j in range(len2+1)]
    result = 0
    for i in range(1, len2 + 1):
        for j in range(1, len1 + 1):
            if string2[i - 1] == string1[j - 1]:
                res[i][j] = res[i - 1][j - 1] + 1
                result = max(result, res[i][j])
    return result


print(lc_string("helloworld", "loop"))

最长公共子序列

动态规划的子问题res[i][j]为截止到字符串A的第i个字符和截止到字符串B的第j个字符的最长公共子序列。

def lcs(string1, string2):
    len1 = len(string1)
    len2 = len(string2)
    res = [[0 for i in range(len1 + 1)] for j in range(len2 + 1)]
    for i in range(1, len2 + 1):
        for j in range(1, len1 + 1):
            if string2[i - 1] == string1[j - 1]:
                res[i][j] = res[i - 1][j - 1] + 1
            else:
                res[i][j] = max(res[i - 1][j], res[i][j - 1])
    return res, res[-1][-1]


print(lcs("helloworld", "loop"))
"""
输出结果为：
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2],
 [0, 0, 0, 1, 1, 2, 2, 3, 3, 3, 3],
 [0, 0, 0, 1, 1, 2, 2, 3, 3, 3, 3]], 3
"""

最长上升子序列

# max_len[k]代表从a1到ak（1<=k<=n）的最长上升序列,所以只需求max(max_len)
n = eval(input())
num = list(map(int, input().split()))
max_len = [1 for i in range(n)]
for i in range(n):
    for j in range(i + 1, n):
        if num[j] > num[i]:
            max_len[j] = max(max_len[j], max_len[i] + 1)
print(max(max_len))

最长不重复子串

从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

import java.util.HashSet;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String s = input.next().trim();
        int l = 0, r = 0, n = s.length();
        int ans = 0;
        HashSet<Character> hs = new HashSet<>();
        while (l < n && r < n) {
            if (!hs.contains(s.charAt(r))) {
                hs.add(s.charAt(r));
                r += 1;
                ans = Math.max(r - l, ans);
            }
            else {
                hs.remove(s.charAt(l));
                l += 1;
            }
        }
        System.out.println(ans);
    }
}

判断平衡二叉树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def is_balanced(self, root):
        def recur(root):
            # 树为空，也是平衡二叉树
            if not root:
                return 0
            # 查看左子树
            left = recur(root.left)
            # 左子树非平衡，直接返回非平衡的结论
            if left == -1:
                return -1
            # 查看右子树
            right = recur(root.right)
            # 右子树非平衡，直接返回非平衡的结论
            if right == -1:
                return -1
            # 如果左右子树均是平衡的，那么返回它们深度的最大值并加1
            # 表示对应结点的深度
            # 如果左右子树的深度相差大于1， 那么当前结点是非平衡的
            # 总体来看，整棵树也是非平衡的
            return max(left, right) + 1 if abs(left-right) <= 1 else -1
        return recur(root) != -1

堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树（一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。）的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。

• 上浮：插入操作，当一个节点比父节点大，那么需要交换这个两个节点。交换后还可能比它新的父节点大，因此需要不断地进行比较和交换操作。
• 下沉：删除操作，当一个节点比子节点来得小，也需要不断地向下进行比较和交换操作，一个节点如果有两个子节点，应当与两个子节点中最大那个节点进行交换。

def heap_sort(elems):
    def siftdown(elems, e, begin, end): #向下筛选
        i, j = begin, begin*2+1 #j为i的左子结点
        while j < end:
            if j+1 < end and elems[j] > elems[j+1]: #如果左子结点大于右子结点
                j += 1                              #则将j指向右子结点
            if e < elems[j]: #j已经指向两个子结点中较小的位置，
                break        #如果插入元素e小于j位置的值，则为3者中最小的
            elems[i] = elems[j] #能执行到这一步的话，说明j位置元素是三者中最小的，则将其上移到父结点位置
            i, j = j, j*2+1 #更新i为被上移为父结点的原来的j的位置，更新j为更新后i位置的左子结点
        elems[i] = e #如果e已经是某个子树3者中最小的元素，则将其赋给这个子树的父结点
                     #或者位置i已经更新到叶结点位置，则将e赋给这个叶结点。
        
    end = len(elems)
    for i in range(end//2-1, -1, -1): #构造堆序。
        siftdown(elems, elems[i], i, end)
    for i in range ((end-1), 0,-1): #进行堆排序.i最后一个值为1，不需要到0
        print(elems)
        e = elems[i] #将末尾元素赋给e
        elems[i] = elems[0] #交换堆顶与最后一个元素
        siftdown(elems, e, 0, i)
        
    return(elems)
 
if __name__=="__main__":
    print(heap_sort([5,6,8,1,2,4,9]))

链表的反转

记–简单的将单链表的数据顺序进行反转。如将原来的顺序1 2 3 4 5 6 7 反转为：7 6 5 4 3 2 1

• 头插法：断开链表头，然后以头插法的方式将原链表的数据添加链表。
• 尾插法：找到最后一个元素，然后从第一个元素逐个插入到尾部。

最大子数组和

for(int i = 1; i < array.length; i++){
    if(currentsum > 0){
        currentsum += array[i];
    }
    else{
        currentsum = array[i];
    }
    if(currentsum > greatsetsum){
        greatsetsum  = currentsum;
    }
    System.out.println("第"+(i+1)+"步：累加子数组和："+currentsum+"，最大子数组和："+greatsetsum);
}

快速幂

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

快速幂算法的核心思想就是每一步都把指数分成两半，而相应的底数做平方运算。这样不仅能把非常大的指数给不断变小，所需要执行的循环次数也变小，而最后表示的结果却一直不会变。

public double Power(double base, int exponent) {
    int n = Math.abs(exponent);
    if (n == 0) return 1;
    double res = 1;
    while (n != 0) {
        if ((n & 1) == 1) res *= base;
        n >>= 1;
        base *= base;
    }
    if (exponent < 0) res = 1 / res;
    return res;
}