String 使用字典选择不重叠的子字符串的最大和

例如，我们有一些字符串

s = 'randomcaran'

我们有带子字符串和数值的字典：

d = {'ran': 2, 'ndo': 6, 'omca': 4, 'car': 3}   

我们想要选择返回最高和的组合，没有字母重叠，但是字典d中的子字符串可以在字符串s中以随机顺序多次找到。当然，字符串s可以是不同的

# result should be 9
# string s contains five substrings: 
#     ran   ndo   omca   car   ran            # ran is twice
#      2           4            2       == 8
#            6            3             == 9

还是这个组合

d = {'ran': 4, 'ndo': 6, 'omca': 4, 'car': 3}
# result should be 12
# string s contains five substrings: 
#     ran   ndo   omca   car   ran            # ran is twice
#      4           4            4       == 12
#            6            3             == 9

第一种情况的简单解决方案可能是：

result = s.count('ndo') * 6
result += s.count('car') * 3

我不知道如何解决这个问题

7.7奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈奈8.0万u u u-8282222U u u u u u u u u u u u u u u u u u u u u u u u 8222U u u u u u u u u u，u u u u u u u u u，u u u u u，u u u u，u u u，u u u u，u u u u，u u u u u u u u，u-8 8 8 8 8 8 8，u，u u，u u，p?u u u，p，p，p，p，p，p，p，x x x x，p，p，p，p，p 82828282828282828222222222277777777777γγγ，p，p，p，p，p，p，p，pγγγγγγγγγγγγγ，p，p，p，p，p，p，p，γγγ此外，我还将对其他国家的城市进行调查研究，并将其作为一个城市的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的城市间的；m,e,s,I,m,p,l,e,r,w,a,y,，̶a̶n̶y̶s̶u̶g̶g̶e̶s̶t̶i̶o̶n̶s̶

i̶m̶p̶o̶r̶t̶ ̶r̶e̶ ̶ ̶ ̶ ̶ ̶ ̶
r̶e̶s̶u̶l̶t̶ ̶=̶ ̶0̶ ̶ ̶ ̶ ̶ ̶
f̶o̶r̶ ̶k̶,̶ ̶v̶ ̶i̶n̶ ̶d̶.̶i̶t̶e̶m̶s̶(̶)̶:̶ ̶ ̶ ̶ ̶ ̶ ̶ ̶ ̶ ̶
    r̶e̶s̶u̶l̶t̶ ̶+̶=̶ ̶v̶ ̶*̶ ̶r̶e̶.̶f̶i̶n̶d̶a̶l̶l̶(̶r̶'̶{̶0̶}̶?̶'̶.̶f̶o̶r̶m̶a̶t̶(̶k̶)̶,̶ ̶s̶)̶.̶c̶o̶u̶n̶t̶(̶k̶)̶ ̶ ̶ ̶ ̶ ̶ ̶ ̶ ̶ ̶
    #̶ ̶r̶e̶s̶u̶l̶t̶ ̶+̶=̶ ̶v̶ ̶*̶ ̶s̶.̶c̶o̶u̶n̶t̶(̶k̶)̶ ̶ ̶ ̶ ̶ ̶
p̶r̶i̶n̶t̶(̶r̶e̶s̶u̶l̶t̶)̶ ̶ ̶ ̶#̶ ̶r̶e̶t̶u̶r̶n̶ ̶s̶u̶m̶ ̶o̶f̶ ̶a̶l̶l̶ ̶1̶7̶,̶ ̶b̶u̶t̶ ̶i̶t̶ ̶s̶h̶o̶u̶l̶d̶ ̶b̶e̶ ̶9̶

编辑：

---

也许动态规划是答案，但在这种情况下，我仍然不知道如何正确地开始使用这种方法。

这实际上是一个称为“加权区间调度”的已知问题的变体。基本上有两种方法：

递归蛮力，时间复杂度为O（n*2^n）

动态规划，时间复杂度为O（n*log（n））

您可以在此处阅读有关问题和解决方案的更多信息：

---

这两种解决方案甚至都有python实现

在我的脑海中，可能会计算每个字母的分数（唯一字母的值/个数），按此排序，然后以明显的方式选择元素。它可能不会给出最佳结果（必须证明这一点——我没有尝试过），但它可能工作得很好（如果它不能给出最佳结果，在某种意义上可能是一个近似算法）。@wokadakow效率有多重要？我可能会想出一个递归蛮力方法，这将是可行的，但可能有一个更聪明的方法。。。（顺便说一句，正则表达式不是解决这个问题的方法！）