695. 岛屿的最大面积

力扣 695. 岛屿的最大面积

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

#define ISLANDS_MAX_ROW_NUM 52
#define DIRECTION_NUM       4

bool g_visitFlag[ISLANDS_MAX_ROW_NUM][ISLANDS_MAX_ROW_NUM];

typedef struct QueueElement {
    int rowId;
    int columnId;
}QueueElement;

typedef struct QueueNode {
    QueueElement data;
    struct QueueNode *next;
} QueueNode;

typedef struct Queue {
    int size;
    QueueNode *front;
    QueueNode *rear;
} Queue;

Queue *CreateQueue()
{
    Queue *queue = (Queue *)malloc(sizeof(Queue));
    queue->size = 0;
    queue->front = NULL;
    queue->rear = NULL;
    return queue;
}

bool IsEmptyQueue(Queue *queue)
{
    if (queue->front == NULL) {
        return true;
    }
    return false;
}

void PushQueue(QueueElement data, Queue *queue)
{
    QueueNode *queueNode = (QueueNode *)malloc(sizeof(QueueNode));
    queueNode->data = data;
    queueNode->next = NULL;
    if (IsEmptyQueue(queue)) {
        queue->front = queueNode;
    } else {
        queue->rear->next = queueNode;
    }
    queue->size += 1;
    queue->rear = queueNode;
    return;
}

void PopQueue(Queue *queue)
{
    QueueNode *queueNode = NULL;
    if (IsEmptyQueue(queue) == true) {
        return;
    }
    queue->size -= 1;
    queueNode = queue->front;
    queue->front = queue->front->next;
    free(queueNode);
    queueNode = NULL;
}

QueueElement GetFront(Queue *queue)
{
    QueueElement queElement;
    queElement.rowId = 0;
    queElement.columnId = 0;

    if (IsEmptyQueue(queue) == false) {
        return queue->front->data;
    } else {
        printf("queue is empty!\n");
        return queElement;
    }
}

void CleanQueue(Queue *queue)
{
    QueueNode *queueNode = queue->front;
    QueueNode *queueTempNode = NULL;

    while (queueNode != NULL) {
        queue->size -= 1;
        queueTempNode = queueNode->next;
        free(queueNode);
        queueNode = queueTempNode;
    }
    queue->front = queueNode;
    queue->rear = queueNode;
}

void TraverseQueue(Queue *queue)
{
    QueueNode *queueNode = queue->front;

    if (IsEmptyQueue(queue) == true) {
        return;
    }

    while (queueNode != NULL) {
        printf("%d ", queueNode->data);
        queueNode = queueNode->next;
    }
    printf("\n");
}



/* 函 数 名: Bfs
 * 函数功能: 利用BFS遍历最大岛屿
 *    date             author          reason
 * 2019.09.27    zhendongzd@163.com    create
 */
int Bfs(int rowId, int columnId, int rowNum, int columnNum, int** grid, Queue * queue)
{
    int directionRow[] = {0, 1, -1, 0};
    int directionColumn[] = {1,0,0,-1};
    int i;
    int maxTemp = 0;
    QueueElement nowPoint;
    QueueElement nextPoint;

    nowPoint.rowId = rowId;
    nowPoint.columnId = columnId;

    maxTemp++;
    g_visitFlag[nowPoint.rowId][nowPoint.columnId] = true;
    PushQueue(nowPoint, queue);
    while (IsEmptyQueue(queue) == false) {
        nowPoint = GetFront(queue);
        PopQueue(queue);
        for (i = 0; i < DIRECTION_NUM; i++) {
            nextPoint.rowId = nowPoint.rowId + directionRow[i];
            nextPoint.columnId = nowPoint.columnId + directionColumn[i];

            if (nextPoint.rowId < 0 || nextPoint.columnId < 0 || nextPoint.rowId >= rowNum || nextPoint.columnId >= columnNum) {
                continue;
            }

            if (grid[nextPoint.rowId][nextPoint.columnId] == 0) {
                continue;
            }

            if (g_visitFlag[nextPoint.rowId][nextPoint.columnId] == true) {
                continue;
            }
            maxTemp++;
            g_visitFlag[nextPoint.rowId][nextPoint.columnId] = true;
            PushQueue(nextPoint, queue);
        }
    }
    return maxTemp;
}


/* 函 数 名: maxAreaOfIsland
 * 函数功能: 求最大岛屿入口
 *    date             author          reason
 * 2019.09.27    zhendongzd@163.com    create
 */
int maxAreaOfIsland(int** grid, int gridSize, int* gridColSize)
{
    int i;
    int j;
    int maxTemp = 0;
    int maxResult = 0;
    memset(g_visitFlag, false, sizeof(g_visitFlag));

    Queue *queue = CreateQueue();

    for (i = 0; i < gridSize; i++) {
        for (j = 0; j < gridColSize[i]; j++) {
            if ((grid[i][j] == 1) && (g_visitFlag[i][j] == false)) {
                maxTemp = Bfs(i, j, gridSize, gridColSize[i], grid, queue);
                maxResult = (maxTemp > maxResult) ? maxTemp : maxResult;
            }
        }
    }
    return maxResult;
}

int main()
{
#define ROW_NUM 8
#define COLUMN_NUM 13
    int i;
    int j;
    int *grid[ISLANDS_MAX_ROW_NUM];
    int gridSize = ROW_NUM;
    int gridColSize[ISLANDS_MAX_ROW_NUM];
    int input[][COLUMN_NUM] = {{0,0,1,0,0,0,0,1,0,0,0,0,0},
                               {0,0,0,0,0,0,0,1,1,1,0,0,0},
                               {0,1,1,0,1,0,0,0,0,0,0,0,0},
                               {0,1,0,0,1,1,0,0,1,0,1,0,0},
                               {0,1,0,0,1,1,0,0,1,1,1,0,0},
                               {0,0,0,0,0,0,0,0,0,0,1,0,0},
                               {0,0,0,0,0,0,0,1,1,1,0,0,0},
                               {0,0,0,0,0,0,0,1,1,0,0,0,0}};

    for (i = 0; i < gridSize; i++) {
        gridColSize[i] = COLUMN_NUM;
        grid[i] = (int *)malloc(gridColSize[i] * sizeof(int));
        for (j = 0; j < gridColSize[i]; j++) {
            grid[i][j] = input[i][j];
        }
    }

    printf("%d", maxAreaOfIsland(grid, gridSize, gridColSize));
    return 0;
}