Flattern Dictionary<string, HashSet<string>>

Question

我已经搞砸了这几天了，我无法理解它：

我有以下结构：

Dictionary<string, HashSet<string>>

包含以下数据：

P1     S1, S2
P2     S1, S2

其中 P 前缀值是字典键，S 前缀值是 HashSet 值。

我需要的是下面的输出列表，

P1, P2, S1, S2

如果我有以下起始值：

P1     S1, S2
P2     S1

输出列表应该是：

P1, P2, S1, P1, S2

如果多个字典项的HashSet中有相似的值，应该将它们组合在一起，这就是为什么P1，P2有S1，P1只有S2

这里有一个小TestApp，可以澄清更多：

static void Main(string[] args)
{
    var start = new Dictionary<string, HashSet<string>>();
    var output = new List<string>();

    //example1
    start.Add("P1", new HashSet<string> { "S1", "S2" });
    start.Add("P2", new HashSet<string> { "S1", "S2" });
    output = HocusPocus(start);
    PrintResult(output); // should be P1, P2, S1, S2

    //example 2
    start.Clear();
    start.Add("P1", new HashSet<string> { "S1", "S2" });
    start.Add("P2", new HashSet<string> { "S1" });
    output = HocusPocus(start);
    PrintResult(output); // should be P1, P2, S1, P1, S2

    //example 3
    start.Clear();
    start.Add("P1", new HashSet<string> { "S1", "S2", "S3" });
    start.Add("P2", new HashSet<string> { "S1" });
    start.Add("P3", new HashSet<string> { "S1", "S2" });
    output = HocusPocus(start);
    PrintResult(output); // should be P1, P2, P3, S1, P1, P3, S2, P1, S3

    Console.ReadKey();
}

public static List<string> HocusPocus(Dictionary<string, HashSet<string>> data)
{
    // magic happens here
}

public static void PrintResult(List<string> result)
{
    result.ForEach(x => Console.Write($"{x},"));
    Console.WriteLine();
}

Answer 1

您似乎希望为每个 S 找到与该 S 相关联的所有 P，并进一步将 S 值与同一组 P 值进行分组。如果您的数据集不是很大，即使不是以最有效的方式，您也可以很简单地做到这一点。

您的数据：

var start = new Dictionary<string, HashSet<string>> {
    { "P1", new HashSet<string> { "S1", "S2", "S3" } },
    { "P2", new HashSet<string> { "S1" } },
    { "P3", new HashSet<string> { "S1", "S2" } }
};

首先，下一次迭代需要所有 S 值：

var allSValues = start.SelectMany(kvp => kvp.Value).Distinct();

为了能够按 P 值序列进行分组，需要 IEqualityComparer<IEnumerable<string>>：

class SequenceEqualityComparer : IEqualityComparer<IEnumerable<string>>
{
    // Does not handle null values correctly.
    public bool Equals(IEnumerable<string> x, IEnumerable<string> y) => x.SequenceEqual(y);

    public int GetHashCode(IEnumerable<string> obj)
    {
        unchecked {
            return obj.Aggregate(17, (hash, @string) => hash * 23*@string.GetHashCode());
        }
    }
}

（比较应该将输入视为集合，而不是序列，但出于此目的，排序是稳定的，因此可以正常工作。）

找到每个 S 值的 P 值，然后将其分组到一个类似于字典的查找中，除了每个键（P 值序列）可以有多个值（S 值）：

var lookup = allSValues.Select(s => new
    {
        S = s,
        PValues = start
            .Where(kvp => kvp.Value.Contains(s))
            .Select(kvp => kvp.Key)
            .ToList()
    })
    .ToLookup(item => item.PValues, item => item.S, new SequenceEqualityComparer());

您可以打印查找：

foreach (var items in lookup)
{
    Console.Write(string.Join(" ", items.Key));
    Console.Write(" ");
    Console.WriteLine(string.Join(" ", items));
}

Answer 2

这是Martin's 的一个版本，它遍历主字典一次以构建倒排字典，并使用集合而不是序列（它也适用于您的原始方法签名）：

public static List<string> HocusPocus(Dictionary<string, HashSet<string>> data)
{
    var invert = new Dictionary<string, HashSet<string>>();

    foreach (var kvp in data)
    {
        foreach (var s in kvp.Value)
        {
            if (!invert.TryGetValue(s, out var pvalues))
            {
                pvalues = new HashSet<string>();
                invert[s] = pvalues;
            }

            pvalues.Add(kvp.Key);
        }
    }

    var lookup = invert
        .ToLookup(_ => _.Value, _ => _.Key, new SetComparer());

    var flat = new List<string>();

    foreach (var item in lookup)
    {
        flat.AddRange(item.Key);
        flat.AddRange(item);
    }

    return flat;
}


public class SetComparer : IEqualityComparer<ISet<string>>
{
    public bool Equals(ISet<string> x, ISet<string> y)
    {
        return x.SetEquals(y);
    }

    public int GetHashCode(ISet<string> obj)
    {
        unchecked
        {
            int hash = 19;
            foreach (var foo in obj)
            {
                hash = hash * 31 + foo.GetHashCode();
            }
            return hash;
        }
    }
}