Question

所以我试图检查是否在所有可能的排列之一上我会得到一个矩阵是对角占优势的形式但是当我试图检查它时我得到一个错误

import numpy
from itertools import product
A = numpy.array([[10., -1., 2., 0.],
    [2., -1., 10., -1.],
    [-1., 11., -1., 3.],
    [0.0, 3., -1., 8.]])

def dominance(A):
    dominance=True
    n=4
    sumC=numpy.sum(numpy.absolute(A),axis=0)
    sumR=numpy.sum(numpy.absolute(A),axis=1)
    resC = [0 for i in range(n)]
    resR= [0 for i in range(n)]
    for i in range(n):
        resC[i]=sumC[i]-A[i,i]
        resR[i]=sumR[i]-A[i,i]
        if A[i,i]<resC[i] or A[i,i]<resR[i]:
            dominance=False
            break

    return dominance

def permutate(iterable, r=None):
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    for indices in product(range(n), repeat=r):
        if len(set(indices)) == r:
            yield tuple(pool[i] for i in indices)


if dominance(A):
    print "Es dominante"
else:
    for i in permutate(A):
        if dominance(list(i)):
            print "this way is dominant"
            print i
            break

这是错误

Traceback (most recent call last):
    File "Prueba.py", line 37, in <module>
        if dominance(list(i)):
    File "Prueba.py", line 16, in dominance
        resC[i]=sumC[i]-A[i,i]
TypeError: list indices must be integers, not tuple

Answer 1

您将A定义为列表列表。将其传递给dominance时会出现此错误：

In [87]: dominance(A)
---------------------------------------------------------------------------
...
      8         for i in range(n):
----> 9                 resC[i]=sumC[i]-A[i,i]
     10                 resR[i]=sumR[i]-A[i,i]
     11                 if A[i,i]<resC[i] or A[i,i]<resR[i]:

TypeError: list indices must be integers, not tuple

但是如果你首先使A成为一个数组，它运行良好：

In [94]: dominance(np.array(A))
Out[94]: False

我不会深入研究为什么dominance有问题，但看起来dominance是用numpy数组编写的，而不是列表列表。 sumC=numpy.sum(numpy.absolute(A),axis=0)将A视为数组（它与列表A一起使用，因为内部absolute将其转换为数组）。

对dominance的第二次调用也必须得到一个数组：

dominance(np.array(i))

Answer 2

你的效率非常低！

如果您正在寻求严格的对角优势：

矩阵的每一行只能有0或1个严格支配值
矩阵的每一列只能有0或1个严格支配值
如果任何行或列具有0个严格显性值，则矩阵没有严格对角占优势的排列
如果每一行和每一列都有一个严格的主导值，则恰好有1个严格对角占优势的置换矩阵：对于原始矩阵的每一行，主要项目的列索引指定了该矩阵的索引。排列结果矩阵中的行

这导致O（n ^ 2）算法而不是O（n ^ 2 * n！） - 对于10 * 10矩阵，它应该比300万倍快。

如果您正在寻求非严格的对角优势：

矩阵的每一行只能有0,1或2个显性值
矩阵的每一列只能有0,1或2个显性值
如果任何行或列具有0个显性值，则矩阵没有对角占优势的排列
（减少:)如果一行有1个显性值，并且该值的列包含2个显性值，则该列中的另一个显性值可以忽略不计（反之亦然）
< / LI>
如果每一行和每一列都有1个显性值，则恰好有1个对角占优势的置换矩阵：对于原始矩阵的每一行，主要项的列索引指定行中的索引。置换结果矩阵
具有2个主导值的行组可以组合形成电路，其中每个电路具有0,1或2个对角占优势的解（并且选择一行的主导值强制选择所有其他行中的电路）。分支和修剪方法可以非常快速地找到所有有效的解决方案。

对于具有2个主导值的t行的矩阵，这导致O（n ^ 2 * 2 ^ t）算法而不是O（n ^ 2 * n！） - 对于10 * 10矩阵，它应该快于3到3百万倍（取决于具有2个主导值的行数）。

如何在python中将元组转换为Integer

2 个答案: