可被 K 整除的数字字符串中的最长子序列

问题描述

给定一个由数字组成的字符串，求该字符串中最长的可被 K 整除的数字子序列的长度。

例如，对于字符串 1234567890 和 K 值为 6，最长的可被 6 整除的数字子序列为 24690，长度为 5。

解决方案

贪心算法

第一种解决方案是使用贪心算法。我们可以以每个数字为起点，向后遍历字符串，依次将当前数字添加到子序列中，直到子序列的元素之和能够被 K 整除 或者 遍历到字符串的末尾为止。如果存在多个满足条件的子序列，我们选择长度最长的那个子序列。

def longest_divisible_subsequence(s: str, k: int) -> int:
    longest = 0
    
    for i in range(len(s)):
        subseq = []
        for j in range(i, len(s)):
            subseq.append(int(s[j]))
            if sum(subseq) % k == 0:
                longest = max(longest, len(subseq))
    
    return longest

该算法的时间复杂度为 $O(n^2)$，其中 $n$ 是字符串的长度，因为我们在遍历每个数字时，都需要向后遍历整个字符串。

动态规划

第二种解决方案是使用动态规划。我们定义 $dp[i][j]$ 表示从字符串的第 $i$ 个位置开始的、元素之和为 $j$ 的、可被 K 整除的最长子序列的长度。那么，我们需要求的就是 $dp[0][0]$。

对于一个位置 $i$，我们有两种选择：要么将数字 $s[i]$ 加入子序列，要么不加入。如果选择将数字 $s[i]$ 加入子序列，那么子序列的元素之和就变成了 $(j + s[i]) \bmod K$。如果不加入数字 $s[i]$，那么子序列的元素之和就是 $j$。因此，

$dp[i][j] = \max(dp[i+1][(j + s[i]) \bmod K] + 1, dp[i+1][j])$

这个转移方程的含义是：如果将 $s[i]$ 加入子序列，那么最终子序列的长度就是 $dp[i+1][(j + s[i]) \bmod K] + 1$，而如果不加入 $s[i]$，那么最终子序列的长度就是 $dp[i+1][j]$。

根据上面的转移方程，我们可以按照 $i$ 从大到小的顺序，依次填充 $dp$ 数组。最终的答案就是 $dp[0][0]$。

def longest_divisible_subsequence(s: str, k: int) -> int:
    n = len(s)
    dp = [[0] * k for _ in range(n+1)]
    dp[n][0] = 0
    
    for i in range(n-1, -1, -1):
        for j in range(k):
            dp[i][j] = max(dp[i+1][(j + int(s[i])) % k] + 1, dp[i+1][j])
    
    return dp[0][0]

该算法的时间复杂度为 $O(nk)$，其中 $n$ 是字符串的长度，$k$ 是 K 的取值范围。这个算法的空间复杂度也为 $O(nk)$，因为我们需要一个二维数组来存储所有的状态。