Member 13277493 Ответов: 2

Каково наибольшее произведение четырех соседних чисел в одном направлении(вверх, вниз, влево, вправо или по диагонали)


<pre>
#include <iostream>
#include <vector>

long largestProduct(std::vector<std::vector<int> >arr)
{


    std::vector<long>products;
    for(int row=0; row<20; row++)
        {


            for(int col=0; col<20; col++)
                {

                    int left=col-4;
                    int right=col+4;

                    int down=row+4;
                    int up=row-4;

                    while(up<0)
                        {
                            up++;
                        }
                    while(down>20)
                        {
                            down--;
                        }

                    if(down-up>=4)
                        {
                            for(up; up<=down-4; up++)
                                {
                                    long product=1;
                                    int rowCount=up;
                                    int rowDist=rowCount+4;
                                    for(rowCount; rowCount<rowDist; rowCount++)
                                        {
                                            product=product*arr[rowCount][col];
                                        }
                                    products.push_back(product);
                                }
                        }





                    while(left<0)
                        {
                            left++;
                        }
                    while(right>20)
                        {
                            right--;
                        }

                     if(right-left>=4)
                        {

                            for(left; left<=right-4; left++)
                                {
                                    long product=1;
                                    int colCount=left;
                                    int colDist=colCount+4;
                                    for(colCount; colCount<colDist; colCount++)
                                        {
                                            product=product*arr[row][colCount];
                                        }
                                    products.push_back(product);
                                }
                        }



                            down=row+4;
                            up=row-4;
                            left=col-4;
                            right=col+4;

                            while(down>20)
                                {
                                    down--;
                                }
                            while(up<0)
                                {
                                    up++;
                                }
                            while(left<0)
                                {
                                    left++;
                                }
                            while(right>20)
                                {
                                    right--;
                                }


                     if(down-up>=4 && right-left>=4)
                        {

                            for(up; up<=down-4; up++)
                                {
                                    for(left; left<=right-4; left++)
                                        {
                                            int rowCount=left;
                                            int rowDist=rowCount+4;
                                            int colCount=left;
                                            int colDist=colCount+4;

                                            while(rowCount<rowDist)
                                                {
                                                    long product=1;
                                                    while(colCount<colDist)
                                                        {

                                                            product=product*arr[rowCount][colCount];
                                                            rowCount=rowCount+1;
                                                            colCount=colCount+1;

                                                        }
                                                        products.push_back(product);

                                                }


                                        }
                                }
                        }

                }
        }

        long MAX=0;
        for(int i=0; i<products.size(); i++)
            {

                if(products[i]>MAX)
                    {
                        MAX=products[i];
                    }

            }
            return MAX;
}

int main()
{
    std::vector< std::vector<int> >arr{

                                        {8,   2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8},
                                        {49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0},
                                        {81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30,  3, 49, 13, 36, 65},
                                        {52, 70, 95, 23,  4, 60, 11, 42, 69, 24, 68, 56,  1, 32, 56, 71, 37,  2, 36, 91},
                                        {22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80},
                                        {24, 47, 32, 60, 99,  3, 45,  2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50},
                                        {32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70},
                                        {67, 26, 20, 68,  2, 62, 12, 20, 95, 63, 94, 39, 63,  8, 40, 91, 66, 49, 94, 21},
                                        {24, 55, 58,  5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72},
                                        {21, 36, 23,  9, 75,  0, 76, 44, 20, 45, 35, 14,  0, 61, 33, 97, 34, 31, 33, 95},
                                        {78, 17, 53, 28, 22, 75, 31, 67, 15, 94,  3, 80,  4, 62, 16, 14,  9, 53, 56, 92},
                                        {16, 39,  5, 42, 96, 35, 31, 47, 55, 58, 88, 24,  0, 17, 54, 24, 36, 29, 85, 57},
                                        {86, 56,  0, 48, 35, 71, 89,  7,  5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58},
                                        {19, 80, 81, 68,  5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77,  4, 89, 55, 40},
                                        { 4, 52,  8, 83, 97, 35, 99, 16,  7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66},
                                        {88, 36, 68, 87, 57, 62, 20, 72,  3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69},
                                        { 4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18,  8, 46, 29, 32, 40, 62, 76, 36},
                                        {20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74,  4, 36, 16},
                                        {20, 73, 35, 29, 78, 31, 90,  1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57,  5, 54},
                                        { 1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52,  1, 89, 19, 67, 48}

    };
    std::cout<<largestProduct(arr);

}


Что я уже пробовал:

Я пробовал отлаживать, но это становится сложным, я знаю, что есть некоторые значения, которые считаются более одного раза, но я решу это, теперь моя главная проблема заключается в том, что я хочу понять, что идет не так

2 Ответов

Рейтинг:
19

OriginalGriff

Начните с рассмотрения того, что вы делаете, и упрощения этого. Вы постоянно делаете такие вещи:

while(down>20)
    {
        down--;
    }
Который не нуждается в петле:
if (down > 20) down = 20;
Или даже
down = down > 20 ? 20 : down;
было бы намного лучше.
Затем у вас есть вложенные циклы внутри вложенных циклов, внутри вложенных циклов - это беспорядочно, а также трудно следовать, а также неэффективно.
Вместо этого напишите функцию, которая принимает адреса x и y в качестве параметров и возвращает сумму соседних ячеек. Это довольно тривиально (единственные осложнения-игнорирование краевых эффектов, но это понятный код для написания) и вообще не нуждается в цикле.
Проверьте это, а затем вызовите его внутри цикла, сравнивая результат с последним максимумом, и весь код станет намного легче читать, понимать и отлаживать.


Member 13277493

Спасибо!

OriginalGriff

Всегда пожалуйста!

Рейтинг:
10

Patrice T

Цитата:
Каково наибольшее произведение четырех соседних чисел в одном направлении(вверх, вниз, влево, вправо или по диагонали)

Похоже, ты слишком быстро перешел к программированию.
Всегда полезно сделать анализ проблемы: результат умножения один и тот же, независимо от порядка чисел.
Так А*Б*С*Д = Д*С*Б*С
Это означает, что для любого продукта вниз, у вас есть продукт вверх, который идентичен, то же самое для левого и правого. Так что вы можете упасть и уйти. если вы проверяете 4 диагонали, это то же самое.
Итак, проверяя горизонталь, вертикаль и 2 диагонали, вы проверяете все.

Я думаю, что код, делающий все горизонтали, затем код, делающий все вертикали, а затем диагонали, будет проще писать и проверять.
long largestProduct(std::vector<std::vector<int> >arr)
{
// Check horizontal

// check vertical

// check diagonal

}


Для max вам не нужно использовать вектор, просто фактическое значение max
и когда новый продукт больше, чем Макс, сделайте его новым Максом.


Member 13277493

Спасибо!