Inhalt
was ist ein zusammenhängender block
Vorwort
Das Problem verbundener Blöcke gehört zur Tiefendurchquerung von dfs von Graphen.Dieser Artikel führt dfs ein, um das Problem verbundener Blöcke durch einen einfachen Fall zu lösen, in dem die Anzahl verbundener Blöcke ermittelt wird.
Beispiellink
http://oj.hzjingma.com/p/29?view=classic
Das gegebene Beispiel ist eine Karte vom Typ char, ' . ' bedeutet kein Zugriff und ' W ' bedeutet verbindbar, und die spezifische Situation sollte gemäß dem Titel geändert werden.
was ist ein zusammenhängender block
Wie in der Abbildung gezeigt, ist die gesamte Tabelle ein zweidimensionales 5*5-Array, das verwendet wird, um die gesamte Karte darzustellen. Die weiße Füllung ist der Index des zweidimensionalen Arrays. Das äußerste Hellgrün stellt die Grenze des dar map (weshalb die Grenze unten erstellt wird), und die dunklere Farbe ist ein zweidimensionales Array zum Speichern von Daten, dh der Index (1~4)*(1~4). Der Block mit der dunkelsten Farbe ist der verbundene Block, und in der Abbildung sind drei verbundene Blöcke (oben, unten, links und rechts verbunden, unabhängig von der schrägen Paarverbindung) angegeben.
konkrete Vorstellungen
Zusätzlich zur Anzahl der Zeilen und Spalten und der Entwicklung einer zweidimensionalen Array-Karte wird ein zweidimensionales besuchtes Array benötigt, das die gleiche Größe wie die Karte hat, um anzuzeigen, ob der aktuelle Knoten besucht wurde. Die spezifische Idee ähnelt der dfs des Graphen.Wenn ein Knoten auf 1 traversiert wird, bedeutet dies, dass der Knoten verbunden werden kann (kann je nach Titel unterschiedlich sein) und eine tiefe Traversierung durchgeführt wird, ohne besucht zu werden.
Einzelheiten finden Sie im Code.
Code
import java.util.Scanner;
/**
* 注意本例题中
* char[][]map地图 值为' . ' 代表不通，' W '代表可以连通
* int[][] visitied访问标记，初始值0未访问，1已访问
* @author lenovo
*
*/
public class Main {
static int n,m,ans;
static char[][] map;
static int[][] vistied;
static int[][] step= {
{1,0},{0,1},{-1,0},{0,-1}};
/*
* 上下左右移动遍历搜索
* 1 ,0 表示 x + 1 ，y + 0 向右移动，其他同理
* 如果为八向连通 则加上, { 1, 1 }, { 1, -1 }, { -1, 1 }, { -1, -1 } 代表斜向移动
*/
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
m=sc.nextInt();
map=new char[n+2][m+2];
vistied=new int[n+2][m+2];
//初始化地图，创建边界
for (int i = 0; i <= n+1; i++) {
map[i][0] = '.';
map[i][m+1] = '.';
}
for (int i = 0; i <= m+1; i++) {
map[0][i] = '.';
map[n+1][i] = '.';
}
//录入数据图（1~n）*（1~m）
for (int i = 1; i <= n; i++) {
String s=sc.next();
int k=0;
for (int j = 1; j <= m; j++) {
map[i][j]=s.charAt(k++);
}
}
//从1-n 1-m一次遍历整张数据图
for (int x = 1; x <=n; x++) {
for (int y =1; y <=m; y++) {
//如果当前节点为'W'可以连通 并且为被访问则说明存在一个连通块
if(vistied[x][y] ==0 && map[x][y] == 'W') {
ans++;//连接块数量+1
vistied[x][y] = 1;//当前节点标记为已经访问，以免重复判断
dfs(x,y);//进行深度优先遍历，将与其连通的所有节点都标记为已经访问。
//遍历完后从(1,1)到下一个节点(1,2)继续遍历，一次类推，直到所有节点全遍历完。
}
}
}
System.out.println(ans);
}
private static void dfs(int x, int y) {
/**
* step.length - 1 = 3
* 0 1 2 3 四步代表上下左右均走一遍
*/
for (int i = 0; i <=(step.length - 1); i++) {
int newx=x+step[i][0]; //x移动
int newy=y+step[i][1];//y移动
//如果移动后的节点 为 'W'可连通，并且未访问，则以移动后的节点为起点继续移动
if(map[newx][newy] =='W' && vistied[newx][newy] ==0) {
vistied[newx][newy] = 1;//标记为已访问
dfs( newx, newy);
}
}
}
}Notiz
In der praktischen Anwendung, um zu verhindern, dass, wenn der Knoten beispielsweise auf der Grenze liegt, der Index des Knotens (0,0) ist und der Index seines linken Knotens (–1,0) ist, dann wird –1 kreuzen die Grenze. Daher ist die Größe zum Öffnen eines zweidimensionalen Arrays immer zwei Zeilen mehr als die im Titel angegebenen n*m , dh das Öffnen eines zweidimensionalen Arrays der Größe (n+2)*(m+2) .