Question

我给出了一个像这样的数组形式的矩阵：

[3 2 3]
[4 5 6]     =>   [3 2 3 4 5 6 7 3 9]
[7 3 9]

我还给出了原始矩阵中的行数和列数（此处为3,3）以及需要计算其出现次数的元素（例如3）。

现在我想计算这个元素在特定区域出现的次数。

对于3X3矩阵，区域定义如下：

[3 2 3]      [3 2 3]
[4 5 6]  =>  [4 5 6]
[7 3 9]      [7 N 9]

和5X5矩阵：

[1 2 3 4 5]      [1 2 3 4 5]
[6 7 8 9 0]      [6 7 8 9 0]
[1 3 5 7 9]  =>  [1 3 5 7 9]
[2 4 6 8 0]      [2 4 N 8 0]
[9 6 3 1 2]      [9 N N N 2]

我想要计算出现次数的区域是未填充N的区域。我希望模式清晰。

我就这样做了：

int count_elem (int arr[], int rows, int cols, int elem) {
    // creating the 2D matrix
    int mat[][] = new int[rows][cols];
    int arr_in = 0;
    for (int i = 0; i<rows; i++) {
        for (int j = 0; j<cols; j++) {
            mat[i][j] = arr[arr_in];
            arr_in++;
        }
    }

    // counting the element
    int midCol = cols/2, colLen = rows, count = 0;
    for (int j = 0; j<cols; j++) {
        for (int i = 0; i<colLen; i++) {
            if (mat[i][j] == elem) count++;
        }
        if (j<midCol) colLen--;
        else  colLen++;
    }

    return count;
}

一些限制：

它总是一个方阵
行数或列数始终为奇数

我想知道是否有更好的方法来计算给定的元素，可能不需要我从数组中创建矩阵。

我想知道我的算法是否正确，所以请忽略我的代码中的任何错误。

Answer 1

有一个比从数组创建矩阵更好的解决方案。您可以使用

从矩阵中的x坐标和y坐标简单地计算数组索引

x + (y * dimX)

此外，不需要参数：行数和列数。这是因为你的条件：rows = columns。从数组长度获得正方形上的行数和列数。我的解决方案：

static int count_elem(int arr[], int elem) {
    int rows = (int) Math.sqrt(arr.length);
    int cols = (int) Math.sqrt(arr.length);

    int midCol = cols / 2, colLen = rows, count = 0;
    for (int j = 0; j < rows; j++) {
        for (int i = 0; i < colLen; i++) {
            if (arr[j + (i * rows)] == elem) count++;
        }
        if (j < midCol) colLen--;
        else colLen++;
    }
    return count;
}

我希望我的解决方案适合您的想法。

Answer 2

我们可以拨打我们正在搜索x的号码，然后我们就可以：

int array[1000000];

int numOfPatterns(int x, int n){               
    int count = 0, jump = 1, int finish = n*n;
    while(jump <= n/2){
        int lim = finish - jump;                         
        for(int i = finish - n + jump; i < lim; i++)
            if(array[i] == x) count++;
        jump = jump + 1;
        finish = finish - n;
    }
    return count;
}

这可能是计算该模式后某些数字的最有效方法。在这里，您只查看应该查看的数组的索引，忽略其他索引。

这是一个O（n ^ 2）解决方案，但事实上，遵循该查找模式，它总会执行类似O（n ^ 2/4）操作的事情。

关于代码：

n是矩阵的维度
jump是一个变量，它告诉它应该从哪里开始查看矩阵的每一行
while(jump <= n/2)表示它会在案例1 2 X 3 4
lim正是搜索结束的地方
finish是数组

有效计算数组中某种元素数量的方法

2 个答案: