Question

我有一个字典，其中键是一个字符串，键的值是一组字符串，也包含键（字链）。我无法找到图表的最大深度，这将是字典中包含最多元素的集合，我也尝试打印出最大图表。

现在我的代码打印出来了：

{'DOG': [],
 'HIPPOPOTIMUS': [],
 'POT': ['SUPERPOT', 'HIPPOPOTIMUS'],
 'SUPERPOT': []}
1

其中1是我的最大字典深度。我期待深度为2，但“POT”图表似乎只有1层

如何从字典中的键组中找到最大值集？

import pprint

def dict_depth(d, depth=0):
    if not isinstance(d, dict) or not d:
        return depth
    print max(dict_depth(v, depth+1) for k, v in d.iteritems())


def main():
    for keyCheck in wordDict:
        for keyCompare in wordDict:
            if keyCheck in keyCompare:
                if keyCheck != keyCompare:
                    wordDict[keyCheck].append(keyCompare)

if __name__ == "__main__":
    #load the words into a dictionary
    wordDict = dict((x.strip(), []) for x in open("testwordlist.txt"))
    main()
    pprint.pprint (wordDict)
    dict_depth(wordDict)

testwordlist.txt：

POT
SUPERPOT
HIPPOPOTIMUS
DOG

Answer 1

抱歉，我的示例不会出现在python中，因为我的python已经生锈但你应该明白这个想法。

让我们说这是一棵二叉树：
（用c ++编写）

int depth(TreeNode* root){
  if(!root) return 0;
  return 1+max(depth(root->left), depth(root->right));
}

简单。现在让我们将它扩展得更多，然后只是左右两个（golang代码）

func depthfunc(Dic dic) (int){
   if dic == nil {
     return 0
   }
   level := make([]int,0)
   for key, anotherDic := range dic{
      depth := 1
      if ok := anotherDic.(Dic); ok { // check if it does down further
        depth = 1 + depthfunc(anotherDic)
      }
        level = append(level, depth)          
   }

   //find max
   max := 0
   for _, value := range level{
     if value > max {
       max = value
     }
   }
   return max
}

这个想法是你只需按下每个字典，直到没有更多的字典向你追溯的每个级别添加1。

Answer 2

字典的“深度”自然是1加上其条目的最大深度。您已将非字典的深度定义为零。由于您的顶级词典不包含任何自己的词典，因此词典的深度显然是1.您的函数会正确报告该值。

但是，您的函数不会写入您期望提供的数据格式。我们可以轻松地提出输入，其中子串链的深度不仅仅是一个。例如：

DOG
DOGMA
DOGMATIC
DOGHOUSE
POT

当前脚本的输出：

{'DOG': ['DOGMATIC', 'DOGMA', 'DOGHOUSE'],
 'DOGHOUSE': [],
 'DOGMA': ['DOGMATIC'],
 'DOGMATIC': [],
 'POT': []}
1

我认为你想获得2个输入，因为最长的子串链是DOG→DOGMA→DOGMATIC，它包含两个跃点。

要在构建字典时获取字典的深度，您需要计算每个单词的链长。这是1加上每个子串的最大链长，这给了我们以下两个函数：

def word_chain_length(d, w):
    if len(d[w]) == 0:
        return 0
    return 1 + max(word_chain_length(d, ww) for ww in d[w])

def dict_depth(d):
    print(max(word_chain_length(d, w) for w in d))

此处给出的word_chain_length函数效率不高。如果字符串是许多单词的子字符串，它可能会多次计算同一链的长度。 动态编程是一种减轻这种情况的简单方法，我将把它留作练习。

查找字典中集合的最大深度

2 个答案: