技術標籤：# 專題一 簡單搜尋

夜空深處，閃亮的星星以星群的形式出現在人們眼中，形態萬千。

一個星群是指一組非空的在水平，垂直或對角線方向相鄰的星星的集合。

一個星群不能是一個更大星群的一部分。

星群可能是相似的。

如果兩個星群的形狀、包含星星的數目相同，那麼無論它們的朝向如何，都認為它們是相似的。

通常星群可能有 8 種朝向，如下圖所示：

現在，我們用一個二維 01 矩陣來表示夜空，如果一個位置上的數字是 1，那麼說明這個位置上有一個星星，否則這個位置上的數字應該是 0。

給定一個夜空二維矩陣，請你將其中的所有星群用小寫字母進行標記，標記時相似星群用同一字母，不相似星群用不同字母。

標註星群就是指將星群中所有的 1 替換為小寫字母。

輸入格式

第一行包含一個整數 W，表示矩陣寬度。

第二行包含一個整數 H，表示矩陣高度。

接下來 H 行，每行包含一個長度為 W 的 01 序列，用來描述整個夜空矩陣。

輸出格式

輸出標記完所有星群后的二維矩陣。

用小寫字母標記星群的方法很多，我們將整個輸出讀取為一個字串，能夠使得這個字串字典序最小的標記方式，就是我們想要的標記方式。

輸出這個標記方式標出的最終二維矩陣。

資料範圍

0≤W,H≤100,
0≤ 星群數量 ≤500,
0≤ 不相似星群數量 ≤26,
1≤ 星群中星星的數量 ≤160

輸入樣例：

23
15
10001000000000010000000
01111100011111000101101
01000000010001000111111
00000000010101000101111
00000111010001000000000
00001001011111000000000

輸出樣例：

a000a0000000000b0000000
0aaaaa000ccccc000d0dd0d
0a0000000c000c000dddddd
000000000c0b0c000d0dddd
00000eee0c000c000000000
0000e00e0ccccc000000000
b000000e000000000000000
00b0f000000ccccc00a0000
0000f000000c000c00aaaaa
0000000ddd0c0b0c0a000a0
00000b00dd0c000c0000000
000g000ddd0ccccc0000000
00g0000ddd0000000e00000
0000b000d0000f000e00e0b
0000000ddd000f000eee000

用到了dfs和雜湊的思想

不僅要記錄星群的點數，還要記錄星群的形狀

對於點數，可以用一個變數cnt來記錄

對於形狀，有一個技巧，計算星群中任意兩點的距離之和再累加，距離的累加和是獨一無二的，即：

∑ x ∈ D , y ∈ D ( x ≠ y ) ∣ ∣ x − y ∣ ∣ ∑_{x∈D,y∈D~(x≠y)}||x-y||

將所有算得的距離放入一個數組中，每次遍歷陣列的值判斷是否相等，看當前的距離之和是否出現過

並且因為是double型別，判等時需要加一個eps

#include <bits/stdc++.h>
using namespace std;
const int N = 105;
#define x first
#define y second

int n, m, cnt; // cnt表示當前連通塊的點數
char g[N][N], mark;
bool vis[N][N];
typedef pair<int, int> PII;
PII shape[N * N]; // 記錄每個連通塊的所有位置
// 計算兩點間的距離
double get_dist(PII a, PII b)
{
    double x = a.x - b.x;
    double y = a.y - b.y;
    return sqrt(x * x + y * y);
}
// 得到距離之和
double get_hash()
{
    double res = 0;
    for (int i = 0; i < cnt; i++) {
        for (int j = i + 1; j < cnt; j++) {
            res += get_dist(shape[i], shape[j]);
        }
    }
    return res;
}
// 得到連通塊的標記
char get_id(double v)
{
    static double hash[N]; // 記錄所有連通塊的距離
    static int cnt = 0;
    for (int i = 0; i < cnt; i++) {
        if (fabs(v - hash[i]) < 1e-6) {
            return 'a' + i;
        }
    }
    hash[cnt++] = v;
    return 'a' + cnt - 1;
}

void dfs(int x, int y)
{
    // 記錄位置
    shape[cnt++] = {x, y};
    //cout << cnt << endl;
    vis[x][y] = 1;
    for (int dx = -1; dx <= 1; dx++) {
        for (int dy = -1; dy <= 1; dy++) {
            int nx = x + dx, ny = y + dy;
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && g[nx][ny] == '1' && vis[nx][ny] == 0) {
                dfs(nx, ny);
            }
        }
    }
}

int main(void)
{
    cin >> m >> n;
    for (int i = 0; i < n; i++) {
        cin >> g[i];
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> g[i][j];
            if (g[i][j] == '1') {
                // 初始化連通塊的點數
                cnt = 0;
                dfs(i, j);
                // 得到雜湊（距離之和）
                double hash = get_hash();
                // 得到對應的標記
                mark = get_id(hash);
                // 標記連通塊
                for (int k = 0; k < cnt; k++) {
                    g[shape[k].x][shape[k].y] = mark;
                }
            }
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << g[i][j];
        }
        cout << endl;
    }
    
    return 0;
}