9.2   グラフの基本操作¶

class GraphAdjMat:
    """隣接行列に基づく無向グラフクラス"""

    def __init__(self, vertices: list[int], edges: list[list[int]]):
        """コンストラクタ"""
        # 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
        self.vertices: list[int] = []
        # 隣接行列。行・列のインデックスは「頂点インデックス」に対応
        self.adj_mat: list[list[int]] = []
        # 頂点を追加
        for val in vertices:
            self.add_vertex(val)
        # 辺を追加
        # 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for e in edges:
            self.add_edge(e[0], e[1])

    def size(self) -> int:
        """頂点数を取得"""
        return len(self.vertices)

    def add_vertex(self, val: int):
        """頂点を追加"""
        n = self.size()
        # 頂点リストに新しい頂点の値を追加
        self.vertices.append(val)
        # 隣接行列に 1 行追加
        new_row = [0] * n
        self.adj_mat.append(new_row)
        # 隣接行列に 1 列追加
        for row in self.adj_mat:
            row.append(0)

    def remove_vertex(self, index: int):
        """頂点を削除"""
        if index >= self.size():
            raise IndexError()
        # 頂点リストから index の頂点を削除する
        self.vertices.pop(index)
        # 隣接行列で index 行を削除する
        self.adj_mat.pop(index)
        # 隣接行列で index 列を削除する
        for row in self.adj_mat:
            row.pop(index)

    def add_edge(self, i: int, j: int):
        """辺を追加"""
        # パラメータ i, j は vertices の要素インデックスに対応する
        # 範囲外と同値の場合の処理
        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
            raise IndexError()
        # 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
        self.adj_mat[i][j] = 1
        self.adj_mat[j][i] = 1

    def remove_edge(self, i: int, j: int):
        """辺を削除"""
        # パラメータ i, j は vertices の要素インデックスに対応する
        # 範囲外と同値の場合の処理
        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
            raise IndexError()
        self.adj_mat[i][j] = 0
        self.adj_mat[j][i] = 0

    def print(self):
        """隣接行列を出力"""
        print("頂点リスト =", self.vertices)
        print("隣接行列 =")
        print_matrix(self.adj_mat)

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
    vector<int> vertices;       // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    vector<vector<int>> adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

  public:
    /* コンストラクタ */
    GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {
        // 頂点を追加
        for (int val : vertices) {
            addVertex(val);
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for (const vector<int> &edge : edges) {
            addEdge(edge[0], edge[1]);
        }
    }

    /* 頂点数を取得 */
    int size() const {
        return vertices.size();
    }

    /* 頂点を追加 */
    void addVertex(int val) {
        int n = size();
        // 頂点リストに新しい頂点の値を追加
        vertices.push_back(val);
        // 隣接行列に 1 行追加
        adjMat.emplace_back(vector<int>(n, 0));
        // 隣接行列に 1 列追加
        for (vector<int> &row : adjMat) {
            row.push_back(0);
        }
    }

    /* 頂点を削除 */
    void removeVertex(int index) {
        if (index >= size()) {
            throw out_of_range("頂点が存在しません");
        }
        // 頂点リストから index の頂点を削除する
        vertices.erase(vertices.begin() + index);
        // 隣接行列で index 行を削除する
        adjMat.erase(adjMat.begin() + index);
        // 隣接行列で index 列を削除する
        for (vector<int> &row : adjMat) {
            row.erase(row.begin() + index);
        }
    }

    /* 辺を追加 */
    // 引数 i, j は vertices の要素インデックスに対応する
    void addEdge(int i, int j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
            throw out_of_range("頂点が存在しません");
        }
        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
        adjMat[i][j] = 1;
        adjMat[j][i] = 1;
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    void removeEdge(int i, int j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
            throw out_of_range("頂点が存在しません");
        }
        adjMat[i][j] = 0;
        adjMat[j][i] = 0;
    }

    /* 隣接行列を出力 */
    void print() {
        cout << "頂点リスト = ";
        printVector(vertices);
        cout << "隣接行列 =" << endl;
        printVectorMatrix(adjMat);
    }
};

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
    List<Integer> vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    List<List<Integer>> adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

    /* コンストラクタ */
    public GraphAdjMat(int[] vertices, int[][] edges) {
        this.vertices = new ArrayList<>();
        this.adjMat = new ArrayList<>();
        // 頂点を追加
        for (int val : vertices) {
            addVertex(val);
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for (int[] e : edges) {
            addEdge(e[0], e[1]);
        }
    }

    /* 頂点数を取得 */
    public int size() {
        return vertices.size();
    }

    /* 頂点を追加 */
    public void addVertex(int val) {
        int n = size();
        // 頂点リストに新しい頂点の値を追加
        vertices.add(val);
        // 隣接行列に 1 行追加
        List<Integer> newRow = new ArrayList<>(n);
        for (int j = 0; j < n; j++) {
            newRow.add(0);
        }
        adjMat.add(newRow);
        // 隣接行列に 1 列追加
        for (List<Integer> row : adjMat) {
            row.add(0);
        }
    }

    /* 頂点を削除 */
    public void removeVertex(int index) {
        if (index >= size())
            throw new IndexOutOfBoundsException();
        // 頂点リストから index の頂点を削除する
        vertices.remove(index);
        // 隣接行列で index 行を削除する
        adjMat.remove(index);
        // 隣接行列で index 列を削除する
        for (List<Integer> row : adjMat) {
            row.remove(index);
        }
    }

    /* 辺を追加 */
    // 引数 i, j は vertices の要素インデックスに対応する
    public void addEdge(int i, int j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw new IndexOutOfBoundsException();
        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
        adjMat.get(i).set(j, 1);
        adjMat.get(j).set(i, 1);
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    public void removeEdge(int i, int j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw new IndexOutOfBoundsException();
        adjMat.get(i).set(j, 0);
        adjMat.get(j).set(i, 0);
    }

    /* 隣接行列を出力 */
    public void print() {
        System.out.print("頂点リスト = ");
        System.out.println(vertices);
        System.out.println("隣接行列 =");
        PrintUtil.printMatrix(adjMat);
    }
}

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
    List<int> vertices;     // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    List<List<int>> adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

    /* コンストラクタ */
    public GraphAdjMat(int[] vertices, int[][] edges) {
        this.vertices = [];
        this.adjMat = [];
        // 頂点を追加
        foreach (int val in vertices) {
            AddVertex(val);
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        foreach (int[] e in edges) {
            AddEdge(e[0], e[1]);
        }
    }

    /* 頂点数を取得 */
    int Size() {
        return vertices.Count;
    }

    /* 頂点を追加 */
    public void AddVertex(int val) {
        int n = Size();
        // 頂点リストに新しい頂点の値を追加
        vertices.Add(val);
        // 隣接行列に 1 行追加
        List<int> newRow = new(n);
        for (int j = 0; j < n; j++) {
            newRow.Add(0);
        }
        adjMat.Add(newRow);
        // 隣接行列に 1 列追加
        foreach (List<int> row in adjMat) {
            row.Add(0);
        }
    }

    /* 頂点を削除 */
    public void RemoveVertex(int index) {
        if (index >= Size())
            throw new IndexOutOfRangeException();
        // 頂点リストから index の頂点を削除する
        vertices.RemoveAt(index);
        // 隣接行列で index 行を削除する
        adjMat.RemoveAt(index);
        // 隣接行列で index 列を削除する
        foreach (List<int> row in adjMat) {
            row.RemoveAt(index);
        }
    }

    /* 辺を追加 */
    // 引数 i, j は vertices の要素インデックスに対応する
    public void AddEdge(int i, int j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
            throw new IndexOutOfRangeException();
        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
        adjMat[i][j] = 1;
        adjMat[j][i] = 1;
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    public void RemoveEdge(int i, int j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
            throw new IndexOutOfRangeException();
        adjMat[i][j] = 0;
        adjMat[j][i] = 0;
    }

    /* 隣接行列を出力 */
    public void Print() {
        Console.Write("頂点リスト = ");
        PrintUtil.PrintList(vertices);
        Console.WriteLine("隣接行列 =");
        PrintUtil.PrintMatrix(adjMat);
    }
}

/* 隣接行列に基づく無向グラフクラス */
type graphAdjMat struct {
    // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    vertices []int
    // 隣接行列。行・列のインデックスは「頂点インデックス」に対応
    adjMat [][]int
}

/* コンストラクタ */
func newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {
    // 頂点を追加
    n := len(vertices)
    adjMat := make([][]int, n)
    for i := range adjMat {
        adjMat[i] = make([]int, n)
    }
    // グラフを初期化する
    g := &graphAdjMat{
        vertices: vertices,
        adjMat:   adjMat,
    }
    // 辺を追加
    // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
    for i := range edges {
        g.addEdge(edges[i][0], edges[i][1])
    }
    return g
}

/* 頂点数を取得 */
func (g *graphAdjMat) size() int {
    return len(g.vertices)
}

/* 頂点を追加 */
func (g *graphAdjMat) addVertex(val int) {
    n := g.size()
    // 頂点リストに新しい頂点の値を追加
    g.vertices = append(g.vertices, val)
    // 隣接行列に 1 行追加
    newRow := make([]int, n)
    g.adjMat = append(g.adjMat, newRow)
    // 隣接行列に 1 列追加
    for i := range g.adjMat {
        g.adjMat[i] = append(g.adjMat[i], 0)
    }
}

/* 頂点を削除 */
func (g *graphAdjMat) removeVertex(index int) {
    if index >= g.size() {
        return
    }
    // 頂点リストから index の頂点を削除する
    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)
    // 隣接行列で index 行を削除する
    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)
    // 隣接行列で index 列を削除する
    for i := range g.adjMat {
        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)
    }
}

/* 辺を追加 */
// 引数 i, j は vertices の要素インデックスに対応する
func (g *graphAdjMat) addEdge(i, j int) {
    // インデックスの範囲外と等値の処理
    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
        fmt.Errorf("%s", "Index Out Of Bounds Exception")
    }
    // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
    g.adjMat[i][j] = 1
    g.adjMat[j][i] = 1
}

/* 辺を削除 */
// 引数 i, j は vertices の要素インデックスに対応する
func (g *graphAdjMat) removeEdge(i, j int) {
    // インデックスの範囲外と等値の処理
    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
        fmt.Errorf("%s", "Index Out Of Bounds Exception")
    }
    g.adjMat[i][j] = 0
    g.adjMat[j][i] = 0
}

/* 隣接行列を出力 */
func (g *graphAdjMat) print() {
    fmt.Printf("\t頂点リスト = %v\n", g.vertices)
    fmt.Printf("\t隣接行列 = \n")
    for i := range g.adjMat {
        fmt.Printf("\t\t\t%v\n", g.adjMat[i])
    }
}

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
    private var vertices: [Int] // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    private var adjMat: [[Int]] // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

    /* コンストラクタ */
    init(vertices: [Int], edges: [[Int]]) {
        self.vertices = []
        adjMat = []
        // 頂点を追加
        for val in vertices {
            addVertex(val: val)
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for e in edges {
            addEdge(i: e[0], j: e[1])
        }
    }

    /* 頂点数を取得 */
    func size() -> Int {
        vertices.count
    }

    /* 頂点を追加 */
    func addVertex(val: Int) {
        let n = size()
        // 頂点リストに新しい頂点の値を追加
        vertices.append(val)
        // 隣接行列に 1 行追加
        let newRow = Array(repeating: 0, count: n)
        adjMat.append(newRow)
        // 隣接行列に 1 列追加
        for i in adjMat.indices {
            adjMat[i].append(0)
        }
    }

    /* 頂点を削除 */
    func removeVertex(index: Int) {
        if index >= size() {
            fatalError("範囲外")
        }
        // 頂点リストから index の頂点を削除する
        vertices.remove(at: index)
        // 隣接行列で index 行を削除する
        adjMat.remove(at: index)
        // 隣接行列で index 列を削除する
        for i in adjMat.indices {
            adjMat[i].remove(at: index)
        }
    }

    /* 辺を追加 */
    // 引数 i, j は vertices の要素インデックスに対応する
    func addEdge(i: Int, j: Int) {
        // インデックスの範囲外と等値の処理
        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
            fatalError("範囲外")
        }
        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
        adjMat[i][j] = 1
        adjMat[j][i] = 1
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    func removeEdge(i: Int, j: Int) {
        // インデックスの範囲外と等値の処理
        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
            fatalError("範囲外")
        }
        adjMat[i][j] = 0
        adjMat[j][i] = 0
    }

    /* 隣接行列を出力 */
    func print() {
        Swift.print("頂点リスト = ", terminator: "")
        Swift.print(vertices)
        Swift.print("隣接行列 =")
        PrintUtil.printMatrix(matrix: adjMat)
    }
}

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
    vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

    /* コンストラクタ */
    constructor(vertices, edges) {
        this.vertices = [];
        this.adjMat = [];
        // 頂点を追加
        for (const val of vertices) {
            this.addVertex(val);
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for (const e of edges) {
            this.addEdge(e[0], e[1]);
        }
    }

    /* 頂点数を取得 */
    size() {
        return this.vertices.length;
    }

    /* 頂点を追加 */
    addVertex(val) {
        const n = this.size();
        // 頂点リストに新しい頂点の値を追加
        this.vertices.push(val);
        // 隣接行列に 1 行追加
        const newRow = [];
        for (let j = 0; j < n; j++) {
            newRow.push(0);
        }
        this.adjMat.push(newRow);
        // 隣接行列に 1 列追加
        for (const row of this.adjMat) {
            row.push(0);
        }
    }

    /* 頂点を削除 */
    removeVertex(index) {
        if (index >= this.size()) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // 頂点リストから index の頂点を削除する
        this.vertices.splice(index, 1);

        // 隣接行列で index 行を削除する
        this.adjMat.splice(index, 1);
        // 隣接行列で index 列を削除する
        for (const row of this.adjMat) {
            row.splice(index, 1);
        }
    }

    /* 辺を追加 */
    // 引数 i, j は vertices の要素インデックスに対応する
    addEdge(i, j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // 無向グラフでは、隣接行列は主対角線に関して対称であり、(i, j) === (j, i) を満たす
        this.adjMat[i][j] = 1;
        this.adjMat[j][i] = 1;
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    removeEdge(i, j) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        this.adjMat[i][j] = 0;
        this.adjMat[j][i] = 0;
    }

    /* 隣接行列を出力 */
    print() {
        console.log('頂点リスト = ', this.vertices);
        console.log('隣接行列 =', this.adjMat);
    }
}

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
    vertices: number[]; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    adjMat: number[][]; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

    /* コンストラクタ */
    constructor(vertices: number[], edges: number[][]) {
        this.vertices = [];
        this.adjMat = [];
        // 頂点を追加
        for (const val of vertices) {
            this.addVertex(val);
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for (const e of edges) {
            this.addEdge(e[0], e[1]);
        }
    }

    /* 頂点数を取得 */
    size(): number {
        return this.vertices.length;
    }

    /* 頂点を追加 */
    addVertex(val: number): void {
        const n: number = this.size();
        // 頂点リストに新しい頂点の値を追加
        this.vertices.push(val);
        // 隣接行列に 1 行追加
        const newRow: number[] = [];
        for (let j: number = 0; j < n; j++) {
            newRow.push(0);
        }
        this.adjMat.push(newRow);
        // 隣接行列に 1 列追加
        for (const row of this.adjMat) {
            row.push(0);
        }
    }

    /* 頂点を削除 */
    removeVertex(index: number): void {
        if (index >= this.size()) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // 頂点リストから index の頂点を削除する
        this.vertices.splice(index, 1);

        // 隣接行列で index 行を削除する
        this.adjMat.splice(index, 1);
        // 隣接行列で index 列を削除する
        for (const row of this.adjMat) {
            row.splice(index, 1);
        }
    }

    /* 辺を追加 */
    // 引数 i, j は vertices の要素インデックスに対応する
    addEdge(i: number, j: number): void {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        // 無向グラフでは、隣接行列は主対角線に関して対称であり、(i, j) === (j, i) を満たす
        this.adjMat[i][j] = 1;
        this.adjMat[j][i] = 1;
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    removeEdge(i: number, j: number): void {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError('Index Out Of Bounds Exception');
        }
        this.adjMat[i][j] = 0;
        this.adjMat[j][i] = 0;
    }

    /* 隣接行列を出力 */
    print(): void {
        console.log('頂点リスト = ', this.vertices);
        console.log('隣接行列 =', this.adjMat);
    }
}

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat {
  List<int> vertices = []; // 頂点要素。要素は「頂点値」を表し、インデックスは「頂点インデックス」を表す
  List<List<int>> adjMat = []; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

  /* コンストラクタ */
  GraphAdjMat(List<int> vertices, List<List<int>> edges) {
    this.vertices = [];
    this.adjMat = [];
    // 頂点を追加
    for (int val in vertices) {
      addVertex(val);
    }
    // 辺を追加
    // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
    for (List<int> e in edges) {
      addEdge(e[0], e[1]);
    }
  }

  /* 頂点数を取得 */
  int size() {
    return vertices.length;
  }

  /* 頂点を追加 */
  void addVertex(int val) {
    int n = size();
    // 頂点リストに新しい頂点の値を追加
    vertices.add(val);
    // 隣接行列に 1 行追加
    List<int> newRow = List.filled(n, 0, growable: true);
    adjMat.add(newRow);
    // 隣接行列に 1 列追加
    for (List<int> row in adjMat) {
      row.add(0);
    }
  }

  /* 頂点を削除 */
  void removeVertex(int index) {
    if (index >= size()) {
      throw IndexError;
    }
    // 頂点リストから index の頂点を削除する
    vertices.removeAt(index);
    // 隣接行列で index 行を削除する
    adjMat.removeAt(index);
    // 隣接行列で index 列を削除する
    for (List<int> row in adjMat) {
      row.removeAt(index);
    }
  }

  /* 辺を追加 */
  // 引数 i, j は vertices の要素インデックスに対応する
  void addEdge(int i, int j) {
    // インデックスの範囲外と等値の処理
    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
      throw IndexError;
    }
    // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
    adjMat[i][j] = 1;
    adjMat[j][i] = 1;
  }

  /* 辺を削除 */
  // 引数 i, j は vertices の要素インデックスに対応する
  void removeEdge(int i, int j) {
    // インデックスの範囲外と等値の処理
    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
      throw IndexError;
    }
    adjMat[i][j] = 0;
    adjMat[j][i] = 0;
  }

  /* 隣接行列を出力 */
  void printAdjMat() {
    print("頂点リスト = $vertices");
    print("隣接行列 = ");
    printMatrix(adjMat);
  }
}

/* 隣接行列に基づく無向グラフ型 */
pub struct GraphAdjMat {
    // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    pub vertices: Vec<i32>,
    // 隣接行列。行・列のインデックスは「頂点インデックス」に対応
    pub adj_mat: Vec<Vec<i32>>,
}

impl GraphAdjMat {
    /* コンストラクタ */
    pub fn new(vertices: Vec<i32>, edges: Vec<[usize; 2]>) -> Self {
        let mut graph = GraphAdjMat {
            vertices: vec![],
            adj_mat: vec![],
        };
        // 頂点を追加
        for val in vertices {
            graph.add_vertex(val);
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for edge in edges {
            graph.add_edge(edge[0], edge[1])
        }

        graph
    }

    /* 頂点数を取得 */
    pub fn size(&self) -> usize {
        self.vertices.len()
    }

    /* 頂点を追加 */
    pub fn add_vertex(&mut self, val: i32) {
        let n = self.size();
        // 頂点リストに新しい頂点の値を追加
        self.vertices.push(val);
        // 隣接行列に 1 行追加
        self.adj_mat.push(vec![0; n]);
        // 隣接行列に 1 列追加
        for row in self.adj_mat.iter_mut() {
            row.push(0);
        }
    }

    /* 頂点を削除 */
    pub fn remove_vertex(&mut self, index: usize) {
        if index >= self.size() {
            panic!("index error")
        }
        // 頂点リストから index の頂点を削除する
        self.vertices.remove(index);
        // 隣接行列で index 行を削除する
        self.adj_mat.remove(index);
        // 隣接行列で index 列を削除する
        for row in self.adj_mat.iter_mut() {
            row.remove(index);
        }
    }

    /* 辺を追加 */
    pub fn add_edge(&mut self, i: usize, j: usize) {
        // パラメータ i, j は vertices の要素インデックスに対応する
        // 範囲外と同値の場合の処理
        if i >= self.size() || j >= self.size() || i == j {
            panic!("index error")
        }
        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
        self.adj_mat[i][j] = 1;
        self.adj_mat[j][i] = 1;
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    pub fn remove_edge(&mut self, i: usize, j: usize) {
        // パラメータ i, j は vertices の要素インデックスに対応する
        // 範囲外と同値の場合の処理
        if i >= self.size() || j >= self.size() || i == j {
            panic!("index error")
        }
        self.adj_mat[i][j] = 0;
        self.adj_mat[j][i] = 0;
    }

    /* 隣接行列を出力 */
    pub fn print(&self) {
        println!("頂点リスト = {:?}", self.vertices);
        println!("隣接行列 =");
        println!("[");
        for row in &self.adj_mat {
            println!("  {:?},", row);
        }
        println!("]")
    }
}

/* 隣接行列に基づく無向グラフ構造体 */
typedef struct {
    int vertices[MAX_SIZE];
    int adjMat[MAX_SIZE][MAX_SIZE];
    int size;
} GraphAdjMat;

/* コンストラクタ */
GraphAdjMat *newGraphAdjMat() {
    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));
    graph->size = 0;
    for (int i = 0; i < MAX_SIZE; i++) {
        for (int j = 0; j < MAX_SIZE; j++) {
            graph->adjMat[i][j] = 0;
        }
    }
    return graph;
}

/* デストラクタ */
void delGraphAdjMat(GraphAdjMat *graph) {
    free(graph);
}

/* 頂点を追加 */
void addVertex(GraphAdjMat *graph, int val) {
    if (graph->size == MAX_SIZE) {
        fprintf(stderr, "グラフの頂点数が最大値に達しました\n");
        return;
    }
    // n 番目の頂点を追加し、n 行目と n 列目を 0 にする
    int n = graph->size;
    graph->vertices[n] = val;
    for (int i = 0; i <= n; i++) {
        graph->adjMat[n][i] = graph->adjMat[i][n] = 0;
    }
    graph->size++;
}

/* 頂点を削除 */
void removeVertex(GraphAdjMat *graph, int index) {
    if (index < 0 || index >= graph->size) {
        fprintf(stderr, "頂点インデックスが範囲外です\n");
        return;
    }
    // 頂点リストから index の頂点を削除する
    for (int i = index; i < graph->size - 1; i++) {
        graph->vertices[i] = graph->vertices[i + 1];
    }
    // 隣接行列で index 行を削除する
    for (int i = index; i < graph->size - 1; i++) {
        for (int j = 0; j < graph->size; j++) {
            graph->adjMat[i][j] = graph->adjMat[i + 1][j];
        }
    }
    // 隣接行列で index 列を削除する
    for (int i = 0; i < graph->size; i++) {
        for (int j = index; j < graph->size - 1; j++) {
            graph->adjMat[i][j] = graph->adjMat[i][j + 1];
        }
    }
    graph->size--;
}

/* 辺を追加 */
// 引数 i, j は vertices の要素インデックスに対応する
void addEdge(GraphAdjMat *graph, int i, int j) {
    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
        fprintf(stderr, "辺インデックスが範囲外であるか、同一です\n");
        return;
    }
    graph->adjMat[i][j] = 1;
    graph->adjMat[j][i] = 1;
}

/* 辺を削除 */
// 引数 i, j は vertices の要素インデックスに対応する
void removeEdge(GraphAdjMat *graph, int i, int j) {
    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
        fprintf(stderr, "辺インデックスが範囲外であるか、同一です\n");
        return;
    }
    graph->adjMat[i][j] = 0;
    graph->adjMat[j][i] = 0;
}

/* 隣接行列を出力 */
void printGraphAdjMat(GraphAdjMat *graph) {
    printf("頂点リスト = ");
    printArray(graph->vertices, graph->size);
    printf("隣接行列 =\n");
    for (int i = 0; i < graph->size; i++) {
        printArray(graph->adjMat[i], graph->size);
    }
}

/* 隣接行列に基づく無向グラフクラス */
class GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {
    val vertices = mutableListOf<Int>() // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
    val adjMat = mutableListOf<MutableList<Int>>() // 隣接行列。行・列のインデックスは「頂点インデックス」に対応

    /* コンストラクタ */
    init {
        // 頂点を追加
        for (vertex in vertices) {
            addVertex(vertex)
        }
        // 辺を追加
        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
        for (edge in edges) {
            addEdge(edge[0], edge[1])
        }
    }

    /* 頂点数を取得 */
    fun size(): Int {
        return vertices.size
    }

    /* 頂点を追加 */
    fun addVertex(_val: Int) {
        val n = size()
        // 頂点リストに新しい頂点の値を追加
        vertices.add(_val)
        // 隣接行列に 1 行追加
        val newRow = mutableListOf<Int>()
        for (j in 0..<n) {
            newRow.add(0)
        }
        adjMat.add(newRow)
        // 隣接行列に 1 列追加
        for (row in adjMat) {
            row.add(0)
        }
    }

    /* 頂点を削除 */
    fun removeVertex(index: Int) {
        if (index >= size())
            throw IndexOutOfBoundsException()
        // 頂点リストから index の頂点を削除する
        vertices.removeAt(index)
        // 隣接行列で index 行を削除する
        adjMat.removeAt(index)
        // 隣接行列で index 列を削除する
        for (row in adjMat) {
            row.removeAt(index)
        }
    }

    /* 辺を追加 */
    // 引数 i, j は vertices の要素インデックスに対応する
    fun addEdge(i: Int, j: Int) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw IndexOutOfBoundsException()
        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
        adjMat[i][j] = 1
        adjMat[j][i] = 1
    }

    /* 辺を削除 */
    // 引数 i, j は vertices の要素インデックスに対応する
    fun removeEdge(i: Int, j: Int) {
        // インデックスの範囲外と等値の処理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw IndexOutOfBoundsException()
        adjMat[i][j] = 0
        adjMat[j][i] = 0
    }

    /* 隣接行列を出力 */
    fun print() {
        print("頂点リスト = ")
        println(vertices)
        println("隣接行列 =")
        printMatrix(adjMat)
    }
}