Question

嗨，我正在解决这个问题，我似乎无法弄清楚为什么我的算法无效。

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;
}

Answer 1

这是一个有趣的问题！

考虑第二个示例案例：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。

您的程序无法到达，因为它只会在错误的顺序中交换元素。我的第一个交换移动1移动到2之后，它将它们从正确的顺序更改为错误的顺序......但是这个移动正在向右移动，并且是最低成本的解决方案。

因此解决方案是放宽假设您必须只交换乱序的内容。（您还需要重构算法，因为该假设是目前阻止无限递归的唯一因素。）

找不到逻辑错误，需要第二双眼睛

1 个答案: