Question

这是我想问这个问题的最佳方式，详情如下。我花了一个小时才弄明白如何提问！

假设我有5种（或更多）类型的文本文件 - 它们是由科学仪器生成的，每种都有一定的结果。让我们称这些“类型”为A，B，C，D，E。文本文件的实际名称不会将其删除，因此用户无法通过名称轻松查看它们的内容。如果它更容易，我们可以考虑一个“字符串”列表。 {我不知道如何处理replcate类型，但我稍后会担心）

我希望为用户提供将文本文件合并到一个集合文件中的选项，但挑战在于，将某些类型组合起来是没有意义的（出于我觉得不值得进入的原因）

我构建了兼容性的示例矩阵

        A   B   C   D   E
   A    1   1   1   1   0
   B    1   1   1   0   0
   C    1   1   1   1   0
   D    1   0   1   1   1
   E    0   0   0   1   1

所以，这就是说我可以将A与B，C，D结合，但不能与E结合（依此类推）。

现在，如果用户从文件列表中选择类型为“A，B和C”的文件（显然没有输入），我想检查选择并说“是，ABC是合法合并”并执行合并。

如果用户选择A，B，C，D，我想说，不，你不能这样做，因为D与B不兼容 - 但是，你可以做A，B，C或A， C，D（因为D不应该是B所在的位置）。

还在我身边吗？

我在代码中创建了上面的矩阵，并且我得到了一个循环结构，我开始有点混乱，并且在我发现自己失去家庭和家庭之前，我可能会寻求帮助。关于我如何做出选择，我有一个相当大的评论部分。请记住，“A”可以是“Dog”，“B”可以是“Cat”等。

internal class CompatibilityCheck
{
    private List<string> FileTypes;

    public CompatibilityCheck()
    {
        //Strings are unique types for text files
        FileTypes = new List<string> {"A", "B", "C", "D", "E"};
        int[,] CompatibilityMatrix =
            {
                {1, 1, 1, 1, 0},
                {1, 1, 1, 0, 0},
                {1, 1, 1, 1, 0},
                {1, 0, 1, 1, 1},
                {0, 0, 0, 1, 1}
            };

        /* Scenario 1 */
        //List of file names from user = ALL LEGAL
        var userSelection = new List<string> {"A", "B", "C"};
        /* Go through each item in userSelection and make arrays of "legal" file combinations?
         * start with A and find the compatible matches, B and C.  Check that B and C are okay. 
        * Answer should look like this as A, B and C can be combined */

        /* Scenario 2 */
        // List of file names from user = NOT ALL LEGAL => D and B are incompatible
        var userSelection2 = new List<string> {"A", "B", "C", "D"};
        /* In my head, I go through each item in userSelction2
         * Take A and build "A,B,C,D" as it is compatible
         *  check B with C(yes) and D(no) - remove D.
         *      end [ A,B,C ]
         *          
         * Start with B and build B,A,C
         *  check A with C(yes) 
         *      end [ B,A,C ]
         *          
         * Start with C and build C,A,B
         *  check A with B(yes)
         *      end [C,A,B]
         *      
         * Start with D and build D,A,C
         *  check A with C(yes)
         *      end [D,A,C]
         *      
         * take the nth string and compare to n+1, n+2 ... n+(length-n)
         *  
         * the unique string sets woudld be  A , B , C and A , C , D  
         */
    }
}

我希望这很清楚。那么实现这样一项任务的最佳方法是什么？递归，LINQ“魔术”，矩阵数学？

[编辑：]我刚才有一个想法可能更容易实现，可能是显示文件列表，当用户选择它们时，我可以“停用”其他不兼容的选项。想象一下listBox或类似的选择“A”类型，如果上面的矩阵在播放，键入“E”文件将显示为灰色。我想知道这是否会减轻压力......？

Answer 1

您正在查看clique problem - 特别是最大集团问题。

你可以使用algorithms来解决这个问题，但是没有一个比指数时间更好。

您的编辑听起来更好一点 - 随着时间的推移限制选择会更容易。

Answer 2

我没有太多时间看这个或重构我的代码，所以这更像是一个大脑转储，但可能是一个好的开始和重构的东西！

public class StrongFileType
{
    private string _friendlyName = string.Empty;

    public StrongFileType(string friendlyName)
    {
        _friendlyName = friendlyName;
    }

    public IEnumerable<StrongFileType> CompatibleTypes { get; set; }

    public override string ToString()
    {
        return _friendlyName;
    }
}

private void SampleTest()
{
    // The possible types
    var typeA = new StrongFileType("A");
    var typeB = new StrongFileType("B");
    var typeC = new StrongFileType("C");
    var typeD = new StrongFileType("D");
    var typeE = new StrongFileType("E");

    // Setup possible compatible types
    typeA.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    typeB.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC };
    typeC.CompatibleTypes = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    typeD.CompatibleTypes = new List<StrongFileType> { typeA, typeC, typeD, typeE };
    typeE.CompatibleTypes = new List<StrongFileType> { typeD, typeE };

    // Now do a check...
    var userSubmittedFilesValid = new List<StrongFileType> { typeA, typeB, typeC };
    CheckCompatible(userSubmittedFilesValid);
    var userSubmittedFilesInvalid = new List<StrongFileType> { typeA, typeB, typeC, typeD };
    CheckCompatible(userSubmittedFilesInvalid);
}

private bool CheckCompatible(IEnumerable<StrongFileType> requestedFiles)
{
    // Useful for debugging
    var validList = new List<string>();
    var invalidList = new List<string>();

    foreach (StrongFileType fileType in requestedFiles)
    {
        string invalid = string.Empty;
        string validCombination = string.Empty;

        foreach (StrongFileType fileTypeToCheck in requestedFiles)
        {
            if (!fileType.CompatibleTypes.Contains(fileTypeToCheck))
            {
                // Show as not compatible and remove any previously valid combinations that match
                invalid += string.Format("{0} not compatible with {1}", fileType, fileTypeToCheck);
                validList.RemoveAll(x => x.Contains(fileType.ToString()) && x.Contains(fileTypeToCheck.ToString()));
            }
            else
            {
                validCombination += string.Format("{0}", fileTypeToCheck);
            }
        }

        // Add to respective lists
        if (!string.IsNullOrEmpty(validCombination) && !validList.Contains(validCombination))
        {
            validList.Add(validCombination);
        }
        if (!string.IsNullOrEmpty(invalid))
        {
            invalidList.Add(invalid);
        }
    }

    // Was valid?
    return invalidList.Count == 0;
}

这应该导致第一个显示ABC的VALID列表并且INVALID列表为空。第二个应该显示ABC和ACD为VALID，BD和DB显示为INVALID。

抱歉，我没有时间整理它！

如何根据特定条件从另一个列表中创建新的字符串列表？

2 个答案: