Не могу найти логическую ошибку, и нужна вторая пара глаз

0

Привет, я работаю над этой проблемой acm, и я не могу понять, почему мой алгоритм не работает.

https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=482

Предполагается, что моя функция sillySort обнаруживает все разные подмассивы, а затем сводит к минимуму сумму измененных значений.

Мой вывод очень близок к их выходу, но я не уверен, что случилось. Я сел и даже написал проблему на доске. Может ли кто-нибудь это заметить?

#include <iostream>

void swap(int* array, int index1, int index2)
{
    int temp;
    temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
}

void printArray(int* array, int size)
{
    for(int i = 0; i < size; i++)
    {
        std::cout << array[i] << " ";
    }

    std::cout << "\n";
}

int sillySort(int* array, int size)
{
    int minSum = 0;
    bool firstSwap = true;

    printArray(array, size);

    for(int i = 0; i < size; i++)
    {
        for(int i2 = i + 1; i2 < size; i2++)
        {
            //Found a swappable pair
            if(array[i] > array[i2])
            {
                int sum = array[i] + array[i2];
                std::cout << "Swapping: " << array[i] << " and " << array[i2]  << " (" << sum << ")" << std::endl;

                //Temporary swap the array to call silly on it
                swap(array, i, i2);

                //Calculate silly on new array
                int minSilly = sillySort(array, size);

                //Found a new minimum
                if((minSilly + sum) < minSum || firstSwap)
                {
                    firstSwap = false;
                    minSum = minSilly + sum;
                }

                //Move array back into position
                swap(array, i, i2);
            }
        }
    }

    std::cout << "Returning: " << minSum << std::endl;
    return minSum;
}

int main()
{
    const int arraySize = 6;
    int array[arraySize];
    array[0] = 8;
    array[1] = 4;
    array[2] = 5;
    array[3] = 3;
    array[4] = 2;
    array[5] = 7;

    std::cout << sillySort(array, arraySize) << std::endl;
    return 0;
}
  • 0
    попробуйте с const int arraySize = 7;
  • 0
    Не выйдет ли это за пределы, так как массив имеет размер только 6, а последний индекс равен 5?
Показать ещё 9 комментариев
Теги:

1 ответ

0

Это была интересная проблема!

Рассмотрим второй пример: 4-элементный массив - это 8124. (Это проще было решить для 4-элементного массива, чем 7-элементный массив, и ваша программа не получила лучшего ответа на этот вопрос.)

Правильный ответ на лучшую стоимость - 17. Вот последовательность ходов (и я уверен, что она уникальна, но не доказала ее), которая предоставит вам отсортированный список со стоимостью 17.

Swap 1 and 2.  Cost is 3.  New sequence is 8214.
Swap 1 and 4.  Cost is 5.  New sequence is 8241.
Swap 1 and 8.  Cost is 9.  New sequence is 1248 (sorted).

Общая стоимость составляет 17.

Ваша программа не может попасть туда, потому что она только меняет элементы, когда они находятся в неправильном порядке. Мой первый swap переместил 1, чтобы появиться после 2, что изменило их из правильного порядка в неправильный порядок... но этот ход идет по пути вправо и с минимальными затратами.

Таким образом, решение состоит в том, чтобы ослабить предположение, что вы должны заменять только те вещи, которые вышли из строя. (Вам также потребуется перестроить алгоритм, поскольку это предположение в настоящее время является единственной вещью, которая предотвращает бесконечную рекурсию.)

Ещё вопросы

Сообщество Overcoder
Наверх
Меню