Question

我有一个词典，每个键列出其依赖项：

parent[2] = 1 (2 depends on 1)
parent[3] = 1 (3 depends on 1)
parent[4] = {2,3} (4 depends on 2, or 4 depends on 3)

我想从这本词典中建立列表：

[4,2,1]
[4,3,1]

我怀疑我应该使用递归算法。任何提示？

编辑：这就是我目前的情况：

我如何调用递归函数：

var result = new List<List<Node<TData, TId>>>();
GetResult(parent, target, result);
return result;

递归函数本身：

private static List<Node<TData, TId>> GetResult<TData, TId>(Dictionary<Node<TData, TId>, List<Node<TData, TId>>> parent, Node<TData, TId> index,
    List<List<Node<TData, TId>>> finalList)
    where TData : IIdentifiable<TId>
    where TId : IComparable
{
    var newResult = new List<Node<TData, TId>> { index };

    if (parent.ContainsKey(index))
    {
        if (parent[index].Count == 1)
        {
            return new List<Node<TData, TId>> { index, parent[index].First()};
        }

        foreach (var child in parent[index])
        {
            var temp = newResult.Union(GetResult(parent, child, finalList)).ToList();
            finalList.Add(temp);
        }
    }

    return newResult;
}

Answer 1

您可以尝试根据需要调整以下代码：

public static List<List<int>> FindParents(Dictionary<int, List<int>> parents, int index)
{
    List<int> prefix = new List<int>();
    List<List<int>> results = new List<List<int>>();
    FindParentsInternal(parents, index, prefix, results);
    return results;
}

private static void FindParentsInternal(Dictionary<int, List<int>> parents, int index,
    List<int> prefix, List<List<int>> results)
{
    var newPrefix = new List<int>(prefix) { index };
    if (!parents.ContainsKey(index))
    {
        results.Add(newPrefix);
        return;
    }
    parents[index].ForEach(i => FindParentsInternal(parents, i, newPrefix, results));
}

用法：

Dictionary<int, List<int>> parents = new Dictionary<int, List<int>>
    {
        { 2, new List<int> { 1 } },
        { 3, new List<int> { 1 } },
        { 4, new List<int> { 2, 3 } }
    };

var t = FindParents(parents, 4);

Answer 2

您可以通过保留结果字典来获益 - 这样您就不需要重新计算它们了。

Dictionary<Int, Set<Int>> results;

Set<Int> getResult(int index) {
  Set<Int> dictResult = results.get(index);
  if(dictResult != null) {
    // result has already been computed
    return dictResult;
  } else {
    // compute result, store in dictResult
    Set<Int> newResult = // compute dependency set
    dictResult.put(index, newResult);
    return newResult;
  }
}

对于// compute dependency list部分，您可以执行以下操作：

Set<Int> newResult = new Set(index);
if(dict.containsKey(index)) {
  List<Int> dependencies = dict.get(index);
  foreach(int subIndex in dependencies) {
    newResult = newResult.union(getResult(subIndex));
  }
}

您的基本情况是索引不在dict时（即dict.containsKey返回false），例如1表示您提供的数据。

从字典中构建列表

2 个答案: