Question

我目前正处于优化问题的中间。我正在使用动态编程，在完成计算后，我留下了N x N矩阵，表示：如果你选择mat[i][j]，那么该值是从i到{j的费用{1}} ==邻接矩阵。

我还可以访问两个变量K和C，它们可以分别解释为路径长度和路径成本。

那么是否有算法可以找到长度为K且成本为C的所有路径？

修改

这是邻接矩阵的样本。路径是0 - > 8，成本为48，长度为3。

因此，例如，一个有效路径将是：0-> 3（15），3-> 6（15 + 13），6-> 8（15 + 13 + 20 = 48）。另一种可能是：0-> 4（20），4-> 6（20 + 8），6-> 8（20 + 8 + 20 = 48）。

无效路径可能包括：0-> 1（8），1-> 2（8 + 4），2-> 3（8 + 4 + 3），3-> 4（8） + 4 + 3 +5），...，但长度大于3，因此无效，同样的事情0-＆gt; 8的成本为48，但长度为1。

    1   2   3   4   5   6   7   8
---------------------------------
0:  8  12  15  20  26  28  37  48
1:----  4   7  12  18  20  29  40
2:--------  3   8  14  16  25  36
3:------------  5  11  13  22  33
4:----------------  6   8  17  28
5:--------------------  2  11  22
6:------------------------  9  20
7:---------------------------- 11

实际上，现在看着它，我看到我必须重新解释我的问题。在用户输入期间确定顶点的数量，长度和成本也是如此。你总是从第一个顶点到最后一个顶点。无论你采取什么样的路径（现在忽略长度），从第一个顶点到最后一个顶点总是有成本C，只有变化的是长度。

所以新的（更好的）问题是，如何找到从第一个顶点到最后一个的所有路径，长度为K？

Answer 1

OP说：你总是从第一个顶点到最后一个顶点。所以：

for any i->j, the index j must be greater than i.

并且作为示例（并且根据OP的解释），边缘的成本是线性添加。这意味着：

mat[i][k] + mat[k][j] = mat[i][j]

所以：

C(i->j) == C当且仅当mat[i][j] == C.

假设存在mat[i][j] == C和j-i<=K，问题可以简化为从K-1到i+1选择j-1个节点，并列出所有组合。您可以通过Algorithm to return all combinations of k elements from n完成此操作。

在这里，我编写了一个代码来解决你在python中测试的例子：

N = 9
mat = [None] * (N-1)
mat [0] =[None,    8,   12,   15,   20,   26,   28,   37,   48]
mat [1] =[None, None,    4,    7,   12,   18,   20,   29,   40]
mat [2] =[None, None, None,    3,    8,   14,   16,   25,   36]
mat [3] =[None, None, None, None,    5,   11,   13,   22,   33]
mat [4] =[None, None, None, None, None,    6,    8,   17,   28]
mat [5] =[None, None, None, None, None, None,    2,   11,   22]
mat [6] =[None, None, None, None, None, None, None,    9,   20]
mat [7] =[None, None, None, None, None, None, None, None,   11]

def xcombination(seq,length):
    if not length:
        yield []
    else
        for i in xrange(len(seq)):
            for result in xcombination(seq[i+1:],length-1):
                yield [seq[i]]+result

def find_path(C, K):
    i_j = []
    paths = []
    for i in range(N):
        for j in range(i+1, N):
            if mat[i][j] == C:
                i_j.append([i, j])
    for p in i_j:
        if p[1]-p[0] >= K:
            paths += [[p[0]]+i+[p[1]] for i in xcombination(range(p[0]+1, p[1]), K-1)]
    return paths


paths = find_path(48, 3)
for path in paths:
    for step in range(len(path)-1):
        print str(path[step])+"->"+str(path[step+1])+"("+str(mat[path[step]][path[step+1]])+") ", 
    print

您的示例的输出答案：

0->1(8)      1->2(4)      2->8(36)
0->1(8)      1->3(7)      3->8(33)
0->1(8)      1->4(12)      4->8(28)
0->1(8)      1->5(18)      5->8(22)
0->1(8)      1->6(20)      6->8(20)
0->1(8)      1->7(29)      7->8(11)
0->2(12)      2->3(3)      3->8(33)
0->2(12)      2->4(8)      4->8(28)
0->2(12)      2->5(14)      5->8(22)
0->2(12)      2->6(16)      6->8(20)
0->2(12)      2->7(25)      7->8(11)
0->3(15)      3->4(5)      4->8(28)
0->3(15)      3->5(11)      5->8(22)
0->3(15)      3->6(13)      6->8(20)
0->3(15)      3->7(22)      7->8(11)
0->4(20)      4->5(6)      5->8(22)
0->4(20)      4->6(8)      6->8(20)
0->4(20)      4->7(17)      7->8(11)
0->5(26)      5->6(2)      6->8(20)
0->5(26)      5->7(11)      7->8(11)
0->6(28)      6->7(9)      7->8(11)

Answer 2

我认为它与最长的路径问题无关，但我相信计算长度为K的所有路径成本至少可以在伪多项式时间内完成。我还没有实际的实现，只是下面显示的想法，它看起来像是在O（N ^ 3 * K * P）附近，其中P是长度的路径数＆lt; = K（这只是一个第一眼看上限，不确定是否可以确定更严格的限制。）

我想到的一个与此有关的问题如下：

＆＃34; 给定图的邻接矩阵A（A [i，j] == 1 iff。边缘i-> j存在），计算每个路径之间的长度K的路径数节点对。＆＃34;

在这种情况下，答案是将矩阵A提高到Kth幂，这个公式可以从以下关系推导出来：

num_paths[i->j, K] = sum (num_paths[i->x, K-1] * A[x,j]) for all x=1..N

当然，num_paths [i-＆gt; j，1] = A [i，j]，上述公式实际上与朴素矩阵乘法算法相同。

现在，既然您有一个算法来计算所有节点对之间给定长度的路径数，那么切换到计算所有成本就需要更换＆＃39; sum ＆＃39;上面的＆＃39; 联盟＆＃39;而不是＆＃34; num_paths [i-＆gt; x，K-1] * A [x，j]＆＃34;，按照＆＃39;添加成本[x，j]的方式做一些事情。长度K-1的路径在i-> x＆＃34;。

之间

如果您需要进一步澄清，请与我们联系。

Answer 3

您可以尝试编写自己的算法，而无需使用其他软件包。所以首先找到所有节点连接到你的起始节点，比如1.你可能有[1,2]，[1,4]，[1,7]，然后找到所有节点连接到2,4和7然后你可能有[1,2,3]，[1,4,5]，[1,7,6]，重复这个过程直到Kth迭代。选择以目标节点结束的所有路径。如果你不想循环，这意味着每个节点都可以访问oncc。您可以使用True（已访问过）或False（尚未访问过）向每个节点添加一个符号注意：这是最直接的方式，也是一种“虚拟”方式。如果N不是太大而且1 <1。 K＆lt; ＆LT; N，它运作良好，否则可能会耗费大量时间和记忆。

我不同意 Cata ，获取路径数并获取所有路径是不同的事情。

Answer 4

如果所有Verticle都相邻，您只需获取二项式系数作为答案：有

（N-1）！/（（K-1）！（N-K）！）

路径。它可以很容易地显示：长度为k的路径为（0 v1 v2 .. v（k-1）n）。所以我们必须从1,2，...，n-1中选择（k-1）分辨值。因此，我们需要计算（k-1）组合的数量。

如果不是，我们可以使用dp创意来计算路径数量。令f（i，j）为从长度为j的s到i的路径量。然后f（i，j）= sum f（w，j-1）* F [w，i]，其中F [w，i] = 1，如果是从w到i的路径，则否则为0。这可以通过以下方式完成：crate a matrix F [i，j]（应该是（n + 1）*（n + 1））并计算F ^ k（通过平方取幂可以在这里使用，导致a O（n ^ 3 * log k）溶液）。答案应该是F ^ k（0，n）但是这个想法只有在图形没有周期时才有效。

如果有周期，我能想到的最好的想法（可能有更好的想法）就是这个。设f（i，m）是从s（起始垂直）到i的路径的数量，仅从m访问垂直（m是一组）。设g（i，m）是从i到t（最后一个）的路径量，从m访问obly verticle。我们计算长度为k / 2的所有路径的f（i，m），以及长度为k-k / 2的g（i，m）。然后我们必须遍历从s到t的路径的中间垂直v并找到只有v共同的m1（来自f）和m2（来自g）的集合，并计算f（v，m1）的总和* g（v，m2）。因此，我们可以通过迭代所有m1来搜索正确的（m1，m2）对。

如果我们必须输出路径，而不是计算金额，那么：

如果所有的Verticle都是相邻的，我们可以生成（1,2，...，n-1）的所有（k-1）组合，这是一种经典的组合算法。

2如果没有，我只能想到dfs，它可以变成指数（因为路径的数量可以是指数）。

在图表中找到所有精确长度和成本的路径

4 个答案: