Найдите самый большой кластер в 2D-массиве

Существуют более эффективные с точки зрения памяти методы, но: вы можете построить другую матрицу того же размера и инициализировать ее всеми нулями. Пусть это матрица B.

Начните сканирование первой матрицы A со счетчиком N, установленным на 1, и как только вы обнаружите в A «1» с «0» в B (т. Е. Aij = 1, Bij = 0), поместите его в list и инициализируйте M значением 0.

Затем, пока список не станет пустым:

• выберите элемент из списка и увеличьте M.
• посмотрите на его соседей (вам нужны только (x-1, y), (x + 1, y), (y + 1, x-1), (y + 1, x) и (y + 1, x + 1) )) и если у них Ax'y '= 1 и Bx'y' = 0, установите Bx'y 'в N и добавьте их в список.

Когда список пуст, вы нашли M элементов в кластере N, поэтому установите ClusterSize[N]=M.

Когда вы закончите, найдите максимальное значение ClusterSize, предположим, что это ClusterSize [K]; то все элементы, где Bij = K, принадлежат кластеру мощности M.

Алгоритм однократно обращается ко всем элементам матрицы. Вам нужно не более W * H / 4 элементов для массива Cluster (у вас не может быть более W * H / 4 кластеров с одним элементом без некоторых элементов, соединяющих и уменьшающих количество кластеров), не более W * H для AncillaryMatrix , и элементы W * H для List. Вы можете динамически распределять и перераспределять их по своему желанию, но, если не требуется для экономии памяти, я бы просто использовал пессимистическое значение.

Псевдокод:

int **AncillaryMatrix;

if (NULL == (AncillaryMatrix = malloc(sizeof(int *)*H))) {
    return ERROR_OUTOFMEMORY;
}
for (j = 0; j < H; j++) {
    if (NULL == (AncillaryMatrix[j] = malloc(sizeof(int)*W))) {
        while (--j) {
             free(AncillaryMatrix[j]); AncillaryMatrix[j] = NULL;
        }
        free(AncillaryMatrix); AncillaryMatrix = NULL;
        return ERROR_OUTOFMEMORY;
    }
    for (i = 0; i < W; i++) {
        AncillaryMatrix[j][i] = 0;
    }
}
N = 1;
for (j = 0; j < H; j++) {
    for (i = 0; i < W; i++) {
        if (0 == BaseMatrix[j][i]) {
            continue;
        }
        if (0 != AncillaryMatrix[j][i]) {
            continue;
        }
        if (0 == (Cluster[N] = FillMatrix(BaseMatrix, AncillaryMatrix, W, H, i, j, N)) {
            // Handle out of memory error.
        }
        N++;
    }
}
// Free ancillarymatrix, unless you need to know the items in the K-th cluster
j = H; while (j--) {
     free(AncillaryMatrix[j]); AncillaryMatrix[j] = NULL;
}
free(AncillaryMatrix); AncillaryMatrix = NULL;

// Find maximum value in Cluster[1..N-1].
// Cluster[0] is not used because "0" in AncillaryMatrix means "no cluster here"
// So the number of clusters is really N-1.
for (j = 1, i = 2; i < N; i++) {
     if (Cluster[i] > Cluster[j]) {
         j = i;
     }
}
// Largest cluster identified by j, has Cluster[j] members.

////

int FillMatrix(int **B, int **A, int W, int H, int i, int j, int N) {
    int M = 0;
    typedef struct Item { int x, int y } *List;
    if (null == (List = malloc(sizeof(Item)*W*H))) {
         return 0;
    }
    List[l].x = i;
    List[l].y = j;
    A[j][i] = N;
    l++;
    while (l) {
        l--; M++;
        int ii = List[l].x;
        int jj = List[l].y;
        // Add neighbours. NOTE: add code to handle case when jj or ii is 0
        // or jj is H-1 or ii is W-1.

        // check jj,ii-1 (could use a macro)
        if (B[jj][ii-1]) {
            if (0 == A[jj][ii-1]) {
                List[l].x = ii-1;
                List[l].y = jj;
                l++;
            }
        }
        CHECK(jj, ii+1)
        CHECK(jj+1, ii-1)
        CHECK(jj+1, ii)
        CHECK(jj+1, ii+1)
    }
    free(List); // List = NULL;
    return M;
}

Ребята, я наконец нашел действительно простое решение этой проблемы, просто посмотрите сюда ...

void cluster(int rows, int cols) { 

    int ma4[4][5] = {{0, 1, 0, 0, 0}, // 1. Zeile
                     {1, 1, 0, 0, 0}, // 2. Zeile
                     {1, 1, 0, 1, 0}, // 3. Zeile
                     {0, 1, 0, 0, 0}};  // 4. Zeile
    int i = 0;
    int j = 0;
    int target = 0;
    printf("\n+++++++++++++++++++++++++++++++\nbiggst cluster\n\n");
    for(j = 0; j < cols; j++) { 
        for (i = 0; i < rows; i++) {
        if (ma4[j][i] == 1) {
        if (ma4[j-1][i] || ma4[j][i-1] || ma4[j+1][i] || ma4[j][i+1] || ma4[j-1][i-1] || ma4[j+1][i+1] || ma4[j-1][i+1] || ma4[j+1][i-1] == 1)
           target += 1;
            }
        }


    }
printf("%d ", target);
}