Question

我正在尝试实现一种方法，该方法可以找到给定大小的组数。输入是一个n×n的二维数组，其中每个单元格的值为0或1.如果单元格是水平或垂直相邻（不是对角线），则它们都被认为是在同一组中值为1.
组大小是该组中的单元格数。与二维数组一起，还传递整数数组“t”。对于每个整数t [i]，函数应确定大小等于该值的组的数量。该信息以整数数组“answer”返回。我试图解决这个问题，但是没有通过所有提供的测试用例，其中我看不到输入或输出。我尝试了很多自定义测试用例，但没有发现任何问题。是否存在我的功能无法正常运行的情况？

static int[] countGroups(int[][] m, int[] t) {

    int[] answer;
    answer = new int[t.length];
    Arrays.fill(answer, 0);
    int[] sizes;
    int length = m.length;
    sizes = new int[(length * length)];
    Arrays.fill(sizes, 0);
    int[] subList;
    subList = new int[length * length];
    Arrays.fill(subList, 0);
    int groupID = 2;

    for(int j = 0; j < length; j++){
        for(int k = 0; k < length; k++){
            if(m[j][k] > 0){
                if((j != 0) && (k != 0)){
                    if((m[j-1][k] > 0) && (m[j][k-1] > 0)){
                        if(m[j-1][k] != m[j][k-1]){
                            if(m[j-1][k] < m[j][k-1]){
                                subList[(subList[(m[j][k-1])])] = m[j-1][k];
                                subList[(m[j][k-1])] = m[j-1][k];
                                m[j][k] = m[j-1][k];
                            }
                            else{
                                subList[(subList[(m[j-1][k])])] = m[j][k-1];
                                subList[(m[j-1][k])] = m[j][k-1];
                                m[j][k] = m[j][k-1];
                            }
                        }
                        else{
                            m[j][k] = m[j-1][k];
                        }
                    }
                    else if(m[j][k-1] > 0){
                        m[j][k] = m[j][k-1];
                    }
                    else if(m[j-1][k] > 0){
                        m[j][k] = m[j-1][k];
                    }
                    else{
                        groupID++;
                        m[j][k] = groupID;
                    }
                }
                else if((j == 0) && (k == 0)){
                    m[j][k] = groupID;
                }
                else if(k != 0){
                    if(m[j][k-1] > 0){
                        m[j][k] = m[j][k - 1];
                    }
                    else{
                        groupID++;
                        m[j][k] = groupID;
                    }
                }
                else if(k == 0){
                    if(m[j-1][k] > 0){
                        m[j][k] = m[j-1][k];
                    }
                    else{
                        groupID++;
                        m[j][k] = groupID;
                    }

                }
            }
            else{
            }
        }
    }
    for(int j = 0; j < length; j++){
        for(int k = 0; k < length; k++){
            if(m[j][k] > 0){
                if(subList[(m[j][k])] > 0){
                    m[j][k] = subList[(m[j][k])];
                }
            }
        }
    }
    for(int j = 0; j < length; j++){
        for(int k = 0; k < length; k++){
            if(m[j][k] > 0){
                sizes[(m[j][k])]++;
            }
        }
    }
    for(int x = 0; x < t.length; x++){
        for(int n = 0; n < sizes.length; n++){
            if(sizes[n] == t[x]){
                answer[x]++;
            }
        }
    }
    return answer;
}

Answer 1

问题分为两部分：

1）识别群体

2）计算每组的大小

问题1）需要稳定器算法：

为每个单元格赋予唯一值
对于每对相邻单元格，将具有最高值的单元格更改为相邻单元格的（较低）值
重复上述内容直到不再发生更改

问题2变得相当简单，它只是所有出现值的频率表

Java中的连接组件标签

1 个答案: