У меня есть 2d массив, как это:

arr = [0 3 1 0
       1 2 0 2
       0 0 2 0
       1 2 0 0]

Моя цель - не перебирать столбец, как только мы найдем в нем максимальное число.

В первой итерации максимальное число составляет 3 во 2-м столбце , поэтому , поэтому не переходите во второй столбец в будущих итерациях.

Точно так же в моей второй итерации максимальное число равно 2 в 4-м столбце (поскольку мы больше не переходим ко 2-му столбцу).

Вот что я пробовал:

    #include <iostream>
    using namespace std;

    int main()
    {
     //Input 2d array
     int arr[4][4];
     //Take the input
     for(int i=0; i<4; i++)
     {
      for(int j=0; j<4; j++)
        cin>>arr[i][j];
     }
     //Index array to store index of maximum number column
     int index[4] = {-1,-1,-1,-1}
     //Array to store max number in each row
     int max_arr[4] = {0,0,0,0};

    for(int i=0; i<4; i++)
    {
     int max_num = -1;
     for(int j=0; j<4; j++)
      {
        if(j!=index[0] && j!=index[1] && j!=index[2] && j!=index[3])
         {
           if(max_num<arr[i][j])
            {
              max_num = arr[i][j];
              index[j] = j;
            }
         }
      }
      max_arr[i] = max_num;
    }

return 0;
}
c++
-1
user11106530 10 Фев 2020 в 10:12

3 ответа

Лучший ответ

Лучший способ сделать это - просто оценить массив по столбцам. Это может быть сделано с небольшой математикой. В вашем случае вы используете массив 4х4. Начните с индекса 0, прибавьте 4, прибавьте 4, прибавьте 4, затем вычтите 11 (приведя вас к позиции 1). Добавьте 4, добавьте 4, добавьте 4, вычтите 11 (приведя вас к позиции 2). Так далее...

Вот код, который я использовал, который работает и выполним для массива любого размера!

#include <iostream>

int main()
{
    constexpr size_t ARR_ROWS = 4;
    constexpr size_t ARR_COLS = 4;
    constexpr size_t ARR_SIZE = ARR_ROWS * ARR_COLS;

    int arr[ARR_SIZE] {
        0, 3, 1, 0,
        1, 2, 0, 2,
        0, 0, 2, 0,
        1, 2, 0, 0
    };

    // Store max values for columns
    int cols_max[ARR_COLS] { -1, -1, -1, -1 };

    // Start at index 0, then at 4 (3 times) to evaluate first
    // column. Next, subtract 11 from current index (12) to get
    // to index 1 (start of column 2). Add 4 (3 times) to
    // evaluate second column. Next, subtract 11 from current
    // index (13) to get to index 2 (start of column 3). Etc...
    size_t cur_index = 0;
    size_t cur_col = 0;
    const size_t subtract_to_start_next_col = ARR_SIZE - (ARR_COLS + 1);
    while (cur_index < ARR_SIZE)
    {
        // Max function for 'cols_max'
        if (cols_max[cur_col] < arr[cur_index])
            cols_max[cur_col] = arr[cur_index];

        if ( // When index is at the column's end (besides last value)
            (cur_index >= ARR_SIZE - ARR_COLS) && 
            (cur_index <= ARR_SIZE - 2)
        )
        {
            cur_index -= subtract_to_start_next_col;
            cur_col++;
        }
        else if (cur_index == ARR_SIZE - 1)
        { // When index is last value, add 1 to break loop
            cur_index++;
        }
        else
        { // Nothing special, just go to next value in column
            cur_index += ARR_COLS;
        }
    }

    // Print columns' max values (optional)...
    for (size_t i = 0; i < ARR_COLS; ++i)
    {
        std::cout 
            << "Max for column " << (i + 1) << ": " << cols_max[i] 
            << std::endl;
    }
}

Не стесняйтесь спрашивать, если у вас есть вопросы!

2
Drake Johnson 10 Фев 2020 в 08:36

Вам нужно 3 цикла: первый для итераций, второй для строк, третий для столбцов. Если вы нашли max в столбце, скажем, 0, то вам следует занести этот столбец в черный список и так далее.

#include <iostream>

int main()
{
    int m[ 4 ][ 4 ] = {  { 0, 3, 1, 0 } ,
                         { 1, 2, 0, 2 } ,
                         { 0, 0, 2, 0 } ,
                         { 1, 2, 0, 0 } };

    constexpr int max_number_of_itr { 4 };
    bool blacklisted[4] { false };

    for ( auto itr = 0; itr < max_number_of_itr; ++itr )
    {
        auto max { -1 };
        auto max_col_idx { -1 };

        for ( auto row = 0; row < 4; ++row )
        {
            for ( auto col = 0; col < 4; ++col )
            {
                if ( blacklisted[ col ] )
                    continue;

                auto val = m[ row ][ col ];
                if ( val > max )
                {
                    max = val;
                    max_col_idx = col;
                }
            }
        }

        blacklisted[ max_col_idx ] = true;

        std::cout << "max is " << max << " col " << max_col_idx << " ignored." << std::endl;
    }
}
-1
arnes 10 Фев 2020 в 07:42
index[ j ] = j; 

Измените это на

index[ i ] = j;
-1
idris 10 Фев 2020 в 08:31