查找圖形的所有可能修改

Question

我現在使用列表來表示圖形，這與上一個問題類似。 我發現 dict 方法會非常長且復雜，所以決定使用列表方法 go。 但我仍然面臨一些障礙。

例如，圖表：

現在表示為：

nodes = ["1", "2", "3", "4", "5"]
edges = [
  [0, 2, 1, 2, 0],
  [1, 0, 1, 0, 0],
  [0, 2, 0, 0, 0],
  [1, 0, 1, 0, 2],
  [1, 2, 0, 0, 0],
]

在這里，邊權重只能是 1 或 2，0 表示從一個節點到另一個節點沒有邊。 邊是有向的，因此矩陣中的每個列表都表示朝向節點的邊。

與上一個問題類似，我想要圖形上所有可能的雙邊修改。 因此，例如，如果我們從節點“4”到“5”添加一條權重為 1 的邊，並刪除從節點“1”到“4”的權重為 1 的邊，則新圖將如下所示：

edges = [
  [0, 2, 1, 2, 0],
  [1, 0, 1, 0, 0],
  [0, 2, 0, 0, 0],
  [0, 0, 1, 0, 2],
  [1, 2, 0, 1, 0],
]

這是可能的修改之一。

我想構建一個生成器，可以按順序創建所有此類修改並將其傳遞給我，以便我可以使用它們進行測試。

到目前為止我的代碼是這樣的：

def all_modification_generation(graph: list[list], iter_count: int = 0):
    possible_weights = {-1, 0, 1}
    node_len = len(graph)
    for i in range(node_len**2):
          ix_x = i // node_len
          ix_y = i % node_len
          if i == ix_y:
              continue
          for possible_pertubs in possible_weights - {graph[ix_x][ix_y]}:
              graph[ix_x][ix_y] = possible_pertubs
              if iter_count == 0:
                  all_modification_generation(graph=graph, iter_count=iter_count + 1)
              else:
                  yield all_modification_generation(graph=graph)

我的邏輯是，一旦我做了一個改變，我就可以遍歷矩陣中它之后的所有其他元素。 所以這個問題可以遞歸解決。 一旦探索了一個節點，我們就不需要在下一個循環中考慮它，因為它只會給我們一個我們已經找到的重復結果。 因為我需要檢查 2 次修改，所以我在第一次迭代后增加iter_count ，然后在下一次產生。 我正在跳過ix_x == ix_y案例，因為自循環邊在這種情況下沒有任何意義，因此不需要記錄更改。

但即便如此，這 output 也沒有任何結果。 我究竟做錯了什么？ 任何幫助表示贊賞，謝謝！

編輯：我想我已經找到了一種無需重復生成修改矩陣即可進行雙重修改的方法。 現在唯一的問題是有相當多的代碼重復和 4 級嵌套 for 循環。

我不確定如何遞歸調用生成器，但我覺得應該這樣做！ 感謝J_H為我指明了正確的方向。

工作代碼是：

def all_modification_generation(graph: list[list]):
    possible_weights = {-1, 0, 1}
    node_len = len(graph)
    for i in range(node_len**2):
        ix_x1 = i // node_len
        ix_y1 = i % node_len
        if ix_x1 == ix_y1:
            continue
        for possible_pertubs in possible_weights - {graph[ix_x1][ix_y1]}:
            cc1_graph = deepcopy(graph)
            cc1_graph[ix_x1][ix_y1] = possible_pertubs
            for j in range(i + 1, node_len**2):
                ix_x2 = j // node_len
                ix_y2 = j % node_len
                if ix_x2 == ix_y2:
                    continue
                for possible_perturbs2 in possible_weights - {cc1_graph[ix_x2][ix_y2]}:
                    cc2_graph = deepcopy(cc1_graph)
                    cc2_graph[ix_x2][ix_y2] = possible_perturbs2
                    yield cc2_graph

Answer 1

二次循環是一種有趣的技術。 我們確實從// node_len得到了很多重復的除法結果，但這很好。

---

對於這個問題，我有一個“基礎+編輯”數據結構。

將數組轉換為列表列表很簡單。

在開銷之后，一個 5 節點圖消耗 25 個字節——非常緊湊。 Numpy 為稀疏圖的幾個 styles 提供了很好的支持，如果你感興趣的話。

from typing import Generator, Optional
import numpy as np


class GraphEdit:
    """A digraph with many base edge weights plus a handful of edited weights."""

    def __init__(self, edge: np.ndarray, edit: Optional[dict] = None):
        a, b = edge.shape
        assert a == b, f"Expected square matrix, got {a}x{b}"
        self.edge = edge  # We treat these as immutable weights.
        self.edit = edit or {}

    @property
    def num_nodes(self):
        return len(self.edge)

    def __getitem__(self, item):
        return self.edit.get(item, self.edge[item])

    def __setitem__(self, item, value):
        self.edit[item] = value


def as_array(g: GraphEdit) -> np.ndarray:
    return np.array([[g[i, j] for j in range(g.num_nodes)] for i in range(g.num_nodes)])


def all_single_mods(g: GraphEdit) -> Generator[GraphEdit, None, None]:
    """Generates all possible single-edge modifications to the graph."""
    orig_edit = g.edit.copy()
    for i in range(g.num_nodes):
        for j in range(g.num_nodes):
            if i == j:  # not an edge -- we don't support self-loops
                continue
            valid_weights = {0, 1, 2} - {g[i, j]}
            for w in sorted(valid_weights):
                yield GraphEdit(g.edge, {**orig_edit, (i, j): w})


def all_mods(g: GraphEdit, depth: int) -> Generator[GraphEdit, None, None]:
    assert depth >= 1
    if depth == 1:
        yield from all_single_mods(g)
    else:
        for gm in all_single_mods(g):
            yield from all_mods(gm, depth - 1)


def all_double_mods(g: GraphEdit) -> Generator[GraphEdit, None, None]:
    """Generates all possible double-edge modifications to the graph."""
    yield from all_mods(g, 2)

這是相關的測試套件。

import unittest
from numpy.testing import assert_array_equal
import numpy as np
from .graph_edit import GraphEdit, all_double_mods, all_single_mods, as_array


class GraphEditTest(unittest.TestCase):
    def setUp(self):
        self.g = GraphEdit(
            np.array(
                [
                    [0, 2, 1, 2, 0],
                    [1, 0, 1, 0, 0],
                    [0, 2, 0, 0, 0],
                    [1, 0, 1, 0, 2],
                    [1, 2, 0, 0, 0],
                ],
                dtype=np.uint8,
            )
        )

    def test_graph_edit(self):
        g = self.g
        self.assertEqual(5, self.g.num_nodes)
        self.assertEqual(2, g[0, 1])
        g[0, 1] = 3
        self.assertEqual(3, g[0, 1])
        del g.edit[(0, 1)]
        self.assertEqual(2, g[0, 1])

    def test_non_square(self):
        with self.assertRaises(AssertionError):
            GraphEdit(np.array([[0, 0], [1, 1], [2, 2]]))

    def test_all_single_mods(self):
        g = GraphEdit(np.array([[0, 0], [1, 0]]))

        self.assertEqual(4, len(list(all_single_mods(g))))

        expected = [
            np.array([[0, 1], [1, 0]]),
            np.array([[0, 2], [1, 0]]),
            np.array([[0, 0], [0, 0]]),
            np.array([[0, 0], [2, 0]]),
        ]

        for ex, actual in zip(
            expected,
            map(as_array, all_single_mods(g)),
        ):
            assert_array_equal(ex, actual)

            # Now verify that original graph is untouched.
            assert_array_equal(
                np.array([[0, 0], [1, 0]]),
                as_array(g),
            )

    def test_all_double_mods(self):
        g = GraphEdit(np.array([[0, 0], [1, 0]]))

        self.assertEqual(16, len(list(all_double_mods(g))))

        expected = [
            np.array([[0, 0], [1, 0]]),
            np.array([[0, 2], [1, 0]]),
            np.array([[0, 1], [0, 0]]),
            np.array([[0, 1], [2, 0]]),
            np.array([[0, 0], [1, 0]]),  # note the duplicate
            np.array([[0, 1], [1, 0]]),
            np.array([[0, 2], [0, 0]]),  # and it continues on in this vein
        ]

        for ex, actual in zip(
            expected,
            map(as_array, all_double_mods(g)),
        ):
            assert_array_equal(ex, actual)

    def test_many_mods(self):
        self.assertEqual(40, len(list(all_single_mods(self.g))))
        self.assertEqual(1_600, len(list(all_double_mods(self.g))))
        self.assertEqual(1_600, len(list(all_mods(self.g, 2))))
        self.assertEqual(64_000, len(list(all_mods(self.g, 3))))
        self.assertEqual(2_560_000, len(list(all_mods(self.g, 4))))

人們可能會質疑它會產生重復項這一事實，因為內部循環和外部循環彼此之間一無所知。 感覺這個算法想要使用itertools.combinations方法，按字典順序生成所有修改。