Question

我有一个X×Y矩阵，从中我需要生成所有可能的方法从一侧（第一列）到另一侧（最后一列），但是路上只有N个点可以是与任何其他生成的组合相同。

我知道我可以生成所有组合并将它们与其他所有组合进行比较以过滤掉我想要的组合，但是对于像16乘16这样的更大的矩阵，这些组合可以通过多种方式生成它们并且还可以将每个组合进行比较。其余部分。

有没有办法在相似的情况下生成最大N的组合，而不必全部生成？

示例：N = 1

["a", "a", "a"]
["b", "b", "b"]
["c", "c", "c"]

应该生成这样的东西： AAA ABB ACC BBA CCA 驾驶室

我已经在这几天了，并且没有找到任何好的解决方案，所以任何帮助都会非常感谢，如果可能的话，在C＃中。

Answer 1

答案= y ^（x - n）

在第一个实例中忽略您的问题，并概括，您有一个3x3网格。所以：

x = 3;
y = 3;
n = 1;

因此，您有y ^ x个组合，即3 ^ 3 = 27

如果你想确保在整个过程中没有一定数量的匹配，你可以简单地减少该数量的列数，以减少排列量。

在您的示例中，N是1，因此将x减1以得到x为2.

现在3 ^ 2 = 6，这是你给出的答案。

如果你要扩大规模，我相信这是准确的，但我已经度过了漫长的一周，所以如果我错过了什么，请随时告诉我。

修改重新阅读你的问题后，我并不完全确定我理解正确，我很感兴趣，所以请让我知道......

Answer 2

我不确定如何立即降低空间复杂度，但是，您可以使用动态编程来避免检查重复项，从而减少时间复杂度。通过一些额外的努力，通常也可以在动态编程问题中减少空间复杂性。

在某种意义上存在最佳子结构，即路径只是独立但重叠的前缀的总和（a + a = aa，aa + a = aaa）。考虑到这一点，我们可以通过以下方式解决3x3的问题。

纸和铅笔方法：

确定第一选择的解决方案已经完成 - a，b，c。我们需要确定第二种选择的解决方案，第三种等等。

通过连接行+ col确定两个前缀 - 两列可用的选项。

    a   b   c
a   aa  ab  ac
b   ba  bb  bc
c   ca  cb  cc

获取我们刚刚创建的前缀并将它们应用到我们最初的1x1解决方案 - row + col

    a   b   c
aa  aaa aab aac
ba  baa bab bac
ca  caa cab cac
ab  aba abb abc
bb  bba bbb bbc
cb  cba cbb cbc
ac  aca acb acc
bc  bca bcb bcc
cc  cca ccb ccc

n * n解决方案只是这种方法重复n-1次。

我在C＃中也写了这个

class Program
{
    static void Main(string[] args)
    {
        int sizeOf = 3; //size of problem - ex 3x3
        var vals = "abcdefghijklmnop".ToCharArray(); //up to 16 (abc in ex)

        //Create initial problem
        String[] x = new String[sizeOf]; 
        String[] y = new String[sizeOf];

        for (int i = 0; i < x.Length; i++)
        {
            x[i] = vals[i].ToString();
            y[i] = vals[i].ToString();
        }

        //hold our solutions
        String[][] result = null;
        String[] temp = x;

        for (int i = 1; i < y.Length; i++)
        {
            result = getCombos(temp, y);

            temp = (from k in result
                    from l in k
                    select l).ToArray();
        }

        //Flatten out solution
        var finalResult = (from k in result
                           from l in k
                           select l).ToList();

        printArray(finalResult);
        Console.WriteLine("Total Count: {0}", finalResult.Count());

    }

    static void printArray(List<String> a)
    {
        foreach (var x in a)
        {
            Console.Write("{0} ", x);
        }
        Console.WriteLine();
    }

    static String[][] getCombos(String[] x, String[] y)
    {
        //Initialize array to hold solution
        String[][] prefixes = new String[x.Length][];
        for (int j = 0; j < x.Length; j++)
        {
            prefixes[j] = new String[y.Length];
        }

        //concat to form solution
        for (var i = 0; i < x.Length; i++)
        {
            for (var j = 0; j < y.Length; j++)
            {
                prefixes[i][j] = x[i] + y[j];
            }
        }
        return prefixes;
    }
}

在空间复杂度变得太大之前，我将其运行到9x9。这是一个非常有趣的问题。

生成通过矩阵的所有路径，其中任何其他路径的最大N相似度

2 个答案: