Huawei OD コンピューターベースのテストアルゴリズムの質問: Happy Xiaoxiaole

質問部分

トピック	ハッピーシャオシャオレ
困難	簡単
質問の説明	N 行 M 列の 2 次元行列の場合、行列内の各位置の数値は 0 または 1 の値になります。行列の例は次のとおりです。 1 1 0 0 a> 0 0 0 1 0 0 1 1 1 1 1 1< a i=5> 次に、行列を変換する必要があります。 内のすべての 1 は 0 に反転されます。ルールは次のとおりです。 1) 1 をクリックすると、1 は 0 に反転され、同時に、左上、左下、右上、右下の 8 方向の隣接する上下左右の 1 が (1 が存在する場合) 自動的に 0 に反転されます。 < a i=7> 2) さらに、ある位置の 1 が 0 に反転されると、隣接する 8 方向の 1 (1 がある場合) が自動的に 0 に反転されます。上記のルールに従って、例の行列は次のようになります。少なくとも 2 回クリックするだけで、すべての平均値が 0 になります。行列が与えられた場合、すべての数値が 0 になるまでに必要な最小クリック数は何回ですか?
説明を入力してください	最初の行は、行列の行数 N と列数 M をそれぞれ表す 2 つの整数を入力します。値の範囲は [1,100] です。次の N 行は行列の初期値を表します。各行には M 個の数値が含まれます、値の範囲は [ 0,1] です。
出力の説明	必要な最小クリック数を表す整数を出力します。
追加情報	なし
-------------------------------------------------- ----
例
例1
入力	3 3 1 0 1 0 1 0 1 0 1
出力	1
説明する	上の例では、四隅の 1 は中央の 1 に隣接する 8 方向すべてにあるため、必要なクリックは 1 回だけです。
例 2
入力	4 4 1 1 0 0 1 0 0 0 0 0 0 1 0 0 1 1
出力	2
説明する	上記の 4 * 4 マトリックスでは、2 回 (左上隅と右下隅) をクリックするだけで、すべての 1 が削除されます。

---

解釈と分析

题目解读：

1 をクリックすると、隣接する 8 方向の 1 が 0 になります。同時に、この 8 方向に 0 になる 1 があれば、隣接する 8 方向の 1 も 0 になります。

マインスイーパーゲームに少し似ています。

分析与思路：

この質問では、幅優先検索または深さ優先検索を使用して、すべてのクリック状況を横断できます。次に、すべてのクリックに基づいて最小クリック数を計算します。

の時間計算量は O()、空間計算量は O() です。

は、「Huawei OD コンピュータベースのテスト アルゴリズムの質問: ロボットの活動領域」に似ています。

---

コード

Javaコード

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

/**
 * 开心消消乐
 * 
 * @since 2023.10.13
 * @version 0.2
 * @author Frank
 *
 */
public class HappyCollapse {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			String line = sc.nextLine();
			String[] rc = line.split(" ");
			int row = Integer.parseInt(rc[0]);
			int column = Integer.parseInt(rc[1]);

			int[][] matrix = new int[row][column];
			for (int i = 0; i < row; i++) {
				line = sc.nextLine();
				String[] strColumnValue = line.split(" ");
				int[] number = new int[column];
				for (int j = 0; j < column; j++) {
					number[j] = Integer.parseInt(strColumnValue[j]);
				}
				matrix[i] = number;
			}

			processHappyCollapse(matrix, row, column);
		}

	}

	static class Node {
		int i;
		int j;

		public Node(int i, int j) {
			this.i = i;
			this.j = j;
		}

		@Override
		public int hashCode() {
			return (i + " " + j).hashCode();
		}

		@Override
		public boolean equals(Object obj) {
			if (!(obj instanceof Node))
				return false;
			Node node = (Node) obj;
			return node.i == i && node.j == j;
		}
	}

	private static void processHappyCollapse(int[][] matrix, int row, int column) {
		Set<Node> nodeSet = new HashSet<Node>();
		List<Node> nodeList = new ArrayList<Node>();
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < column; j++) {
				if (matrix[i][j] == 1) {
					Node node = new Node(i, j);
					nodeList.add(node);

					nodeSet.add(node);
				}
			}
		}

		int[] rowColumn = new int[2];
		rowColumn[0] = row;
		rowColumn[1] = column;

		int minCnt = Integer.MAX_VALUE;
		for (int i = 0; i < nodeList.size(); i++) {
			List<Node> copyOfList = new ArrayList<Node>();
			copyOfList.addAll(nodeList);

			Set<Node> copyOfSet = new HashSet<Node>();
			copyOfSet.addAll(nodeSet);

			Node node = nodeList.get(i);

			copyOfList.remove(i);
			copyOfSet.remove(node);

			int cnt = startClickNode(node, copyOfList, copyOfSet, rowColumn);
			if (cnt < minCnt) {
				minCnt = cnt;
			}
		}
		System.out.println(minCnt);

	}

	private static int startClickNode(Node node, List<Node> nodeList, Set<Node> nodeSet, int[] rowColumn) {
		int clickCnt = 1;
		clickCollapseNode(node, nodeList, nodeSet, rowColumn);

		if (nodeList.size() == 0) {
			return 1;
		}

		int minCnt = Integer.MAX_VALUE;
		for (int i = 0; i < nodeList.size(); i++) {
			List<Node> copyOfList = new ArrayList<Node>();
			copyOfList.addAll(nodeList);

			Set<Node> copyOfSet = new HashSet<Node>();
			copyOfSet.addAll(nodeSet);

			Node curNode = nodeList.get(i);

			copyOfList.remove(i);
			copyOfSet.remove(curNode);

			int cnt = startClickNode(curNode, copyOfList, nodeSet, rowColumn);
			if (cnt < minCnt) {
				minCnt = cnt;
			}

		}
		return clickCnt + minCnt;
	}

	private static void clickCollapseNode(Node node, List<Node> nodeList, Set<Node> nodeSet, int[] rowColumn) {
		int row = rowColumn[0];
		int column = rowColumn[1];

		if (node.i >= 1) {
			colapseNode(new Node(node.i - 1, node.j), nodeList, nodeSet, rowColumn);
		}
		if (node.i < row - 1) {
			colapseNode(new Node(node.i + 1, node.j), nodeList, nodeSet, rowColumn);
		}
		if (node.j >= 1) {
			colapseNode(new Node(node.i, node.j - 1), nodeList, nodeSet, rowColumn);
		}
		if (node.j < column - 1) {
			colapseNode(new Node(node.i, node.j + 1), nodeList, nodeSet, rowColumn);
		}
		if (node.i >= 1 && node.j >= 1) {
			colapseNode(new Node(node.i - 1, node.j - 1), nodeList, nodeSet, rowColumn);
		}
		if (node.i >= 1 && node.j < column - 1) {
			colapseNode(new Node(node.i - 1, node.j + 1), nodeList, nodeSet, rowColumn);
		}
		if (node.i < row - 1 && node.j >= 1) {
			colapseNode(new Node(node.i + 1, node.j - 1), nodeList, nodeSet, rowColumn);
		}
		if (node.i < row - 1 && node.j < column - 1) {
			colapseNode(new Node(node.i - 1, node.j + 1), nodeList, nodeSet, rowColumn);
		}
	}

	private static void colapseNode(Node node, List<Node> nodeList, Set<Node> nodeSet, int[] rowColumn) {
		if (nodeSet.contains(node)) {
			nodeList.remove(node);
			nodeSet.remove(node);
			clickCollapseNode(node, nodeList, nodeSet, rowColumn);
		}
	}

}

JavaScriptコード

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
void async function() {
    while (line = await readline()) {
        var rowColumn = line.split(" ");
        var row = parseInt(rowColumn[0]);
        var column = parseInt(rowColumn[1]);

        var matrix = new Array();
        for (var i = 0; i < row; i++) {
            line = await readline();
            var strNumbers = line.split(" ");
            var numbers = new Array(column);
            for (var j = 0; j < column; j++) {
                numbers[j] = parseInt(strNumbers[j]);
            }
            matrix[i] = numbers;
        }

        processHappyCollapse(matrix, row, column);
    }
}();

function processHappyCollapse(matrix, row, column) {
    var nodeSet = new Set();
    var nodeList = new Array();
    for (var i = 0; i < row; i++) {
        for (var j = 0; j < column; j++) {
            if (matrix[i][j] == 1) {
                var node = i + "," + j;
                nodeList.push(node);
                nodeSet.add(node);
            }
        }
    }

    var rowColumn = new Array();
    rowColumn[0] = row;
    rowColumn[1] = column;

    var minCnt = Number.MAX_VALUE;
    for (var i = 0; i < nodeList.length; i++) {
        var copyOfList = Array.from(nodeList);
        var copyOfSet = new Set(nodeSet);

        var node = nodeList[i];

        copyOfList.splice(i, 1);
        copyOfSet.delete(node);

        var cnt = startClickNode(node, copyOfList, copyOfSet, rowColumn);
        if (cnt < minCnt) {
            minCnt = cnt;
        }
    }
    console.log(minCnt);
}

function startClickNode(node, nodeList, nodeSet, rowColumn) {
    var clickCnt = 1;
    clickCollapseNode(node, nodeList, nodeSet, rowColumn);

    if (nodeList.length == 0) {
        return 1;
    }

    var minCnt = Number.MAX_VALUE;
    for (var i = 0; i < nodeList.length; i++) {
        var copyOfList = Array.from(nodeList);
        var copyOfSet = new Set(nodeSet);

        var curNode = nodeList[i];

        copyOfList.splice(i, 1);
        copyOfSet.delete(curNode);

        var cnt = startClickNode(curNode, copyOfList, nodeSet, rowColumn);
        if (cnt < minCnt) {
            minCnt = cnt;
        }
    }
    return clickCnt + minCnt;
}

function clickCollapseNode(node, nodeList, nodeSet, rowColumn) {
    var row = rowColumn[0];
    var column = rowColumn[1];

    var nodeStrValue = node.split(",");
    var nodeValue = new Array();
    nodeValue[0] = parseInt(nodeStrValue[0]);
    nodeValue[1] = parseInt(nodeStrValue[1]);

    for (var i = -1; i <= 1; i++) {
        if (nodeValue[0] + i < 0 || nodeValue[0] + i > row - 1) {
            continue;
        }
        for (var j = -1; j <= 1; j++) {
            if (i == 0 && j == 0) {
                continue;
            }
            if (nodeValue[1] + j < 0 || nodeValue[1] + j > column - 1) {
                continue;
            }
            colapseNode((nodeValue[0] + i) + "," + (nodeValue[1] + j), nodeList, nodeSet, rowColumn);
        }
    }

}

function colapseNode(node, nodeList, nodeSet, rowColumn) {
    if (nodeSet.has(node)) {
        var idx = nodeList.indexOf(node);
        nodeList.splice(idx, 1);
        nodeSet.delete(node);
        clickCollapseNode(node, nodeList, nodeSet, rowColumn);
    }
}

この問題の難易度は「易しい」とマークされていますが、実際のコーディング量は比較的多くなります。難易度は小さくなく、短時間でコードを書くのは簡単ではありません。

（以上）