Question

我有一个包含数字0和1的邻接矩阵。如果从一个节点到另一个节点没有边缘，则该字段将为0，否则该字段将标记为1。

然后，如果邻接矩阵中的字段为0，则节点之间没有边缘，否则存在权重为1的边。

现在，我已应用Floyd算法找出从任何节点到每个其他节点的最短路径。但我没有得到正确的解决方案。

这是我的Floyd算法实现。

def create(self, cr, uid, vals, context=None):
    if context is None:
        context = {}
    if vals['teacher_id']:
        teacher=self.pool.get("res.partner").browse(cr,uid,vals['teacher_id'],context)
        teacher.attendee=True
    if vals['etudiant_ids'][0][2]:
        for etudiant in self.pool.get("res.partner").browse(cr,uid,vals['etudiant_ids'][0][2],context):
            etudiant.attendee=True
    return super(attendee, self).create(cr, uid, vals, context=context)

我已将0＆0设置为if vals['etudiant_ids'][0][2]: TypeError: 'bool' object has no attribute '__getitem__'，以便为算法构建标准矩阵，但我没有得到正确的解决方案。

此外，这是我的矩阵的一个例子：

void Floyd_Warshal(int graph[Nodes][Nodes], int D[Nodes][Nodes])
{
    for (int i = 0; i < Nodes; i++)
    {
        for (int j = 0; j < Nodes; j++)
        {
            if (graph[i][j] == 0) { graph[i][j] = INT_MAX; }
            D[i][j] = graph[i][j];
        }
    }
    for (int k = 0; k < Nodes; k++) {
        for (int i = 0; i < Nodes; i++)
        {
            for (int j = 0; j < Nodes; j++)
            {
                if (D[i][j] > D[i][k] + D[k][j]) {
                    D[i][j] = D[i][k] + D[k][j];
                }
            }
        }
    }
}

将矩阵应用于算法后，矩阵中的任何0都将转换为INT_MAX。我期望得到2或者1的重量，但是我得到了意想不到的值，比如-2712323 ...

Answer 1

你得到非常大的负值的原因是整数溢出。

如果没有边缘，则设置D[i][j]=INT_MAX。但是接下来

            if (D[i][j] > D[i][k] + D[k][j]) {
                D[i][j] = D[i][k] + D[k][j];

如果从i到k以及从k到j没有边缘，则总和将溢出，结果将为负数。之后，您算法将认为从此i到此j的路径非常短（大负），这会使所有其他路径中毒。

我建议您使用INT_MAX/2代替INT_MAX。

使用Floyd算法找到最短路径

1 个答案: