美国某前端职位面试题-- 寻找最大shape_shape人才模型-优快云博客

本文介绍了一种高效算法用于寻找给定矩阵中连续1的SHAPE的最大size，通过使用ArrayList和HashMap数据结构，实现了从矩阵中识别并计算连续1的SHAPE大小。同时提供了两种解法：一种利用ArrayList和HashMap记录SHAPE信息，另一种采用DFS深度优先搜索进行矩阵遍历。文章详细阐述了每种方法的原理和实现步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
     * 0 0 1 0 0
       0 0 1 0 0
       0 0 1 1 1
       1 0 0 0 0
     * */

连续的一片1，定义为一个shape, 在这里 有2个shape.

题目是寻找连续的1的SHAPE的最大size，在以上例子，最大的一块是5. 另外一块的size是1，所以这里应该返回5.

解法1是：

用一个arraylist来记录所有的shape的size

另外用一个hashmap来记录所有的 1 对应的在arraylist的SHAPE的 index.

遍历，并且在左边和上边找有没有1，如果有，则通过hashmap找到对应的另一个arraylist的索引，然后把size 加1，更新max.

如果没有相邻节点，则新建一个shape, 并且将它的索引添加到arraylist中。

package interview;

import java.util.ArrayList;
import java.util.HashMap;

public class GetMax {
    /*
     * 0 0 1 0 0
       0 0 1 0 0
       0 0 1 1 1
       1 0 0 0 0
     * */
    
    public static void main(String[] args) {
        int[][] in = {
                {0,0,1,0,0},
                {0,0,1,0,0},
                {0,0,1,1,1},
                {1,0,0,0,0}
        };
        System.out.println(getMax(in));
    }
    
    public static int getMax(int[][] input) {
        if (input == null || input.length == 0 || input[0].length == 0) {
            return 0;
        }
        
        
        
        HashMap indexMap = new HashMap(); 
        int maxSize = 0;
        
        int r = input.length;
        int c = input[0].length;
        
        // to record the number of every shape
        ArrayList list = new ArrayList();
        
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                int n = i * c + j;
                if (input[i][j] == 1) {
                    int index = -1;
                    // judge the element in the last line.
                    if (indexMap.containsKey(n - c)) {
                        index = indexMap.get(n - c);
                    // if the point in the left board, don't need to judge the last element.    
                    } else if (j > 0 && indexMap.containsKey(n - 1)){
                        index = indexMap.get(n - 1);
                    }
                    
                    if (index != -1) {
                        list.set(index, list.get(index) + 1);
                        indexMap.put(n, index);
                    } else {
                        list.add(1);
                        index = list.size() - 1;
                        indexMap.put(n, index);
                    }
                    
                    maxSize = Math.max(maxSize, list.get(index));
                }
            }
        }
        
        return maxSize;
    }

}

解法2：直接用DFS，将1的点的周边进行DFS，并且用一个二维ARRAY来存储访问过的标记，算法复杂度为O(n).

package interview;

import java.util.ArrayList;
import java.util.HashMap;

public class GetMax {
    /*
     * 0 0 1 0 0
       0 0 1 0 0
       0 0 1 1 1
       1 0 0 0 0
     * */
    
    public static void main(String[] args) {
        int[][] in = {
                {0,0,1,0,0},
                {0,0,1,0,0},
                {0,0,1,1,1},
                {1,0,0,0,0}
        };
        //System.out.println(getMax(in));
        System.out.println(getMaxDFS(in));
    }
    
    public static int getMaxDFS(int[][] input) {
        if (input == null || input.length == 0 || input[0].length == 0) {
            return 0;
        }
        
        int row = input.length;
        int col = input[0].length;
        
        int maxSize = 0;
        
        boolean[][] visit = new boolean[row][col];
        for (int i = 0; i < visit.length; i++) {
            for (int j = 0; j < visit[0].length; j++) {
                visit[i][j] = false;
            }
        }
        
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (input[i][j] == 1) {
                    int[] range = {0};
                    dfs(input, i, j, visit, range);
                    maxSize = Math.max(maxSize, range[0]);
                }
            }
        }
        
        return maxSize;
    }
    
    public static void dfs(int[][] input, int i, int j, boolean[][] visit, int[] range) {                
        int row = input.length;
        int col = input[0].length;
        if (i < 0 || i >= row || j < 0 || j >= col) {
            return;
        }
        
        if (visit[i][j] || input[i][j] == 0) {
            return;
        }
        
        visit[i][j] = true;        
        range[0]++;
        
        dfs(input, i + 1, j, visit, range);
        dfs(input, i - 1, j, visit, range);
        dfs(input, i, j + 1, visit, range);
        dfs(input, i, j - 1, visit, range);        
    }
}