生成所有可能的覆盖选项

Question

假设我有 2 个列表：一个包含字符串，一个包含整数，它们的长度不同。我正在构建的应用程序将使用这些列表来生成车辆和覆盖区域的组合。字符串表示区域名称，整数表示车辆 ID。

我的目标是生成用于进一步调查的所有可能的独特组合的列表。一辆车可以服务多个区域，但一个区域不能由多辆车服务。每个区域都必须接受服务，每辆车都必须使用。

所以总结一下约束：

• 每个区域只使用一次
• 每辆车至少使用一次
• 不能遗漏任何区域。
• 不能遗漏任何车辆

这是一个例子：

public class record = {
    public string areaId string{get;set;}
    public int vehicleId int {get;set;}
}

List<string> areas = new List<string>{ "A","B","C","D"};
List<int> vehicles = new List<int>{ 1,2};

List<List<record>> uniqueCombinationLists = retrieveUniqueCombinations(areas,vehicles);

我只是不知道如何制作retrieveUniqueCombinations 函数。也许我只是看起来错了或想得太难了。我一直在思考大规模循环和其他蛮力方法。一个更好的方法的解释将不胜感激。

结果应该类似于这样，我认为这包含了此示例的所有可能性。

A1;B1;C1;D2
A1;B1;C2;D1
A1;B2;C1;D1
A2;B1;C1;D1
A2;B2;C2;D1
A2;B2;C1;D2
A2;B1;C2;D2
A1;B2;C2;D2
A2;B1;C1;D2
A1;B2;C2;D1
A2;B2;C1;D1
A1;B1;C2;D2
A2;B1;C2;D1
A1;B2;C1;D2

Answer 1

这是我总结的一些东西，可能有用也可能没用。大量借鉴dtb 在this answer 上的工作。

基本上都是我自己生成，然后把不符合要求的去掉。

List<string> areas = new List<string> { "A", "B", "C", "D" };
List<int> vehicles = new List<int> { 1, 2 };

var result = retrieveUniqueCombinations(areas, vehicles);
result.ToList().ForEach((recordList) => { 
    recordList.ToList().ForEach((record) => 
        Console.Write("{0}{1};", record.areaId, record.vehicleId)); 
    Console.WriteLine(); 
});

public IEnumerable<IEnumerable<record>> retrieveUniqueCombinations(IEnumerable<string> areas, IEnumerable<int> vehicles)
{
    var items = from a in areas
                from v in vehicles
                select new record { areaId = a, vehicleId = v };
    var result = items.GroupBy(i => i.areaId).CartesianProduct().ToList();
    result.RemoveAll((records) => 
        records.All(record => 
            record.vehicleId == records.First().vehicleId));
    return result;
}

public class record
{
    public string areaId { get; set; }
    public int vehicleId { get; set; }
}


static class Extensions
{
    public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(
      this IEnumerable<IEnumerable<T>> sequences)
    {
        IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
        return sequences.Aggregate(
          emptyProduct,
          (accumulator, sequence) =>
            from accseq in accumulator
            from item in sequence
            select accseq.Concat(new[] { item }));
    }
}

这会产生以下内容：

A1;B1;C1;D2;
A1;B1;C2;D1;
A1;B1;C2;D2;
A1;B2;C1;D1;
A1;B2;C1;D2;
A1;B2;C2;D1;
A1;B2;C2;D2;
A2;B1;C1;D1;
A2;B1;C1;D2;
A2;B1;C2;D1;
A2;B1;C2;D2;
A2;B2;C1;D1;
A2;B2;C1;D2;
A2;B2;C2;D1;

请注意，这些顺序与您的顺序不同，但我会将验证留给您。此外，可能还有更好的方法来做到这一点（例如，通过将逻辑放在CartesianProduct 函数中的RemoveAll 步骤中），但是嘿，你得到你所支付的;）。

Answer 2

因此，让我们使用一些辅助类将数字转换为不同基数的IEnumerable<int> 枚举。使用List<> 可能更有效，但由于我们正在尝试使用 LINQ：

public static IEnumerable<int> LeadingZeros(this IEnumerable<int> digits, int minLength) {
    var dc = digits.Count();
    if (dc < minLength) {
        for (int j1 = 0; j1 < minLength - dc; ++j1)
            yield return 0;
    }
    foreach (var j2 in digits)
        yield return j2;
}

public static IEnumerable<int> ToBase(this int num, int numBase) {
    IEnumerable<int> ToBaseRev(int n, int nb) {
        do {
            yield return n % nb;
            n /= nb;
        } while (n > 0);
    }

    foreach (var n in ToBaseRev(num, numBase).Reverse())
        yield return n;
}

现在我们可以创建一个枚举，列出所有可能的答案（以及一些额外的答案）。我将Lists 转换为Arrays 以​​提高索引效率。

var areas = new List<string> { "A", "B", "C", "D" };
var vehicles = new List<int> { 1, 2 };

var areasArray = areas.ToArray();
var vehiclesArray = vehicles.ToArray();
var numVehicles = vehiclesArray.Length;
var numAreas = areasArray.Length;
var NumberOfCombos = Convert.ToInt32(Math.Pow(numVehicles, numAreas));
var ansMap = Enumerable.Range(0, NumberOfCombos).Select(n => new { n, nd = n.ToBase(numVehicles).LeadingZeros(numAreas)});

鉴于可能的组合的枚举，我们可以转换为areas和vehicles，并排除不使用所有vehicles的组合。

var ans = ansMap.Select(nnd => nnd.nd).Select(m => m.Select((d, i) => new { a = areasArray[i], v = vehiclesArray[d] })).Where(avc => avc.Select(av => av.v).Distinct().Count() == numVehicles);