c++ - C ++查找矩阵的最小和最大元素之间的元素之和

Question

所以，我的程序可以正常工作，但前提是最小和最大元素在对角。所以我的问题是如何将二维数组从一个特定元素迭代到另一个元素（也许摆脱一些嵌套循环）。我应该将此数组转换为一维吗？

这是代码的正确工作：

这是出现问题的时候。元素 {0}{1} 和 {1}{1} 丢失了。

这是代码的缩短变体：

#include <iostream>

using namespace std;

void matrix_count(int a[5][5],int min, int max, int min_i, int min_j, int max_i, int max_j) {
    int suma = 0;
    int counter = 0;
    if (min_i <= max_i && min_j <= max_j) { 
        for (int i = 0; i < 5; i++) {       //iterating all matrix
            for (int j = 0; j < 5; j++) {
                if (a[i][j] == min) {       //start a new cycle when find min
                    for (int i = min_i; i < 5; i++) {
                        for (int j = min_j; j < 5; j++) {
                            if (a[i][j] == max) { i = 5; break; }
                            else if (a[i][j] != min) {
                                counter++;
                                suma += a[i][j];
                                cout << a[i][j] << " ";
                            }
                        }
                    }
                }
            }
        }
    }
    else if (min_i >= max_i && min_j <= max_j) {} // min[i]<max[i] min[j]<max[j]
    else if (min_i <= max_i && min_j >= max_j) {} // min[i]<max[i] min[j]>max[j]
    else if (min_i >= max_i && min_j >= max_j) {} // min[i]>max[i] min[j]>max[j]
    cout << endl;
    cout << suma << endl;
    cout << counter << endl;
}

int main()
{
    int a[5][5] = { 
        {0,4,6,3,5},
        {7,1,5,6,2},
        {6,8,8,5,2},
        {4,1,5,2,2},
        {4,3,6,5,9} };
    int min = a[0][0];
    int max = a[0][0];
    int max_i = 0;
    int min_i = 0;
    int max_j = 0;
    int min_j = 0;

// finding the max
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (a[i][j] > max) {
                max = a[i][j];
                max_i = i;
                max_j = j;
            }
        }
    }

// finding the min
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (a[i][j] < min) {
                min = a[i][j];
                min_i = i;
                min_j = j;
            }
        }
    }

    matrix_count(a, min, max, min_i, min_j, max_i, max_j);

    return 0;
}

标签： c++matrix

Answer 1

正如我的评论所述，一种解决方案是实现二维数组在连续内存中的数据布局。因此获得最小值、最大值和总和变得简单，因为您将以与一维数组相同的方式遍历二维数组。

这是使用 C++ 算法函数的解决方案。

#include <algorithm>
#include <iostream>
#include <numeric>

int main()
{
    int a[5][5] = {
        {0,4,6,3,5},
        {7,1,5,6,2},
        {6,8,8,5,2},
        {4,1,5,2,2},
        {4,3,6,5,9} };

    // Get both the position of the minimum and maximum element in the array  
    auto pr = std::minmax_element(&a[0][0], &a[4][5]);

    // add up all elements between the min and max elements 
    int answer = std::accumulate(std::next(pr.first), pr.second, 0);

    // output results
    std::cout << answer;
}

输出：

100

是的，这就是整个代码。

那么做了什么？

首先，我们使用std::minmax_element遍历数组，从指向第一个元素的指针 ( &a[0][0]) 到传递最后一个元素的指针 ( &a[4][5])。请注意该函数的参数——之所以有效，是因为二维数组具有我前面提到的连续布局。所以这只是弄清楚开始和结束位置的问题。

的返回值std::minmax_element是std::pair<int*, int*>指向最小元素 (the first) 和最大元素 (the second) 的 a。这就是所pr表示的。

完成后，我们可以通过使用std::accumulate和我们拥有的指针快速将最小元素和最大元素之间的项相加pr。

请注意，第一个参数std::accumulate是找到的最小值之后的下一个值。这就是第一个参数中的原因std::next——它将我们带到下一个值。