Question

我已经完成了这个任务来解决：

编写一个读取整数数组的程序，并从中删除最少数量的元素，使剩余的数组按递增顺序排序。打印需要删除的最少数量的元素，以便对数组进行排序。

时限0.1秒。

样品测试：

输入：

1， 4， 3， 3， 6， 3， 2， 3

输出：

3

不幸的是，我的程序速度较慢。这是我的代码：

using System;
static bool CheckAscending(List<int> list)
{
    bool ascending = true;

    for (int i = 0; i < list.Count - 1; i++)
    {
        if (list[i] > list[i + 1])
        {
            ascending = false;
        }
    }

    return ascending;
}

static void Main()
{
    int n;
    n = int.Parse(Console.ReadLine());
    List<int> arr = new List<int>();
    List<int> sorted = new List<int>();
    int maxSubsetLenght = 0;

    for (int i = 0; i < n; i++)
    {
        arr.Add(int.Parse(Console.ReadLine()));
    }


    for (int i = 1; i <= (int)Math.Pow(2, n) - 1; i++)
    {
        int tempSubsetLenght = 0;
        List<int> temp = new List<int>();


        for (int j = 1; j <= n; j++)
        {
            if (((i >> (j - 1)) & 1) == 1)
            {
                temp.Add(arr[j - 1]);
                tempSubsetLenght++;
            }

        }

        if ((tempSubsetLenght > maxSubsetLenght) && (CheckAscending(temp)))
        {
            sorted = temp;
            maxSubsetLenght = tempSubsetLenght;
        }
    }

    Console.WriteLine(n - sorted.Count);
}

有人可以帮助我让我的程序更快一点。如果你能在不久的将来回答，我将很高兴。

Answer 1

好的我找到了如何摆脱它并感谢@Gabor的帮助:)。这是我的解决方案：

using System;

static void Main(string[] args)
{
    int n = int.Parse(Console.ReadLine());
    List<int> numbers = new List<int>();

    for (int i = 0; i < n; i++)
    {
        int currentNumber = int.Parse(Console.ReadLine());
        numbers.Add(currentNumber);
    }
    int[] size = new int[numbers.Count];

    // Define each number as subsequence.
    for (int i = 0; i < numbers.Count; i++)
    {
        size[i] = 1;
    }

    int max = 1;
    // Compare current number with the numbers before.
    for (int i = 1; i < numbers.Count; i++)
    {
        for (int j = 0; j < i; j++)
        {
            if (numbers[i] >= numbers[j] && size[i] <= size[j] + 1)
            {
                size[i] = size[j] + 1;
                // Update max increasing subsequence.
                if (max < size[i])
                {
                    max = size[i];
                }
            }
        }
    }

    // Print numbers to remove as a result.
    int numbersToRemove = n - max;
    Console.WriteLine(numbersToRemove);
}

我认为对于像我这样有同样任务的其他人会有所帮助。

Answer 2

更新＃2

当有减少时，我们不仅要删除当前的数字，而且要删除之前的所有数字都超过新的minValue。

Stopwatch位于System.Diagnostic名称空间中。

// int?[] numbers = new int?[] { 8, 1, 4, 3, 3, 6, 3, 2, 3 };
int?[] numbers = new int?[] { -7, -7, -7, -100, -100, -99, 4, -90, -80, -70 };

Console.WriteLine("Array: [{0}]", String.Join(", ", numbers));

System.Diagnostics.Stopwatch watch = new Stopwatch();
watch.Start();

int minValue = Int32.MinValue;

for (int i = 0; i < numbers.Length - 1; i++)
{
    var currentNumber = numbers[i];
    var nextNumber = numbers[i + 1];

    if (currentNumber > nextNumber)
    {
        if (nextNumber < minValue)
        {
            numbers[i + 1] = null;
        }
        else
        {
            minValue = nextNumber.Value;

            for (int j = i; j >= 0; j--)
            {
                if (numbers[j] > minValue)
                {
                    numbers[j] = null;
                }
            }
        }
    }
}

watch.Stop();

Console.WriteLine("Result: {0}; Time: {1} ms", numbers.Count(number => number == null), watch.ElapsedMilliseconds);

Console.WriteLine("Array: [{0}]", String.Join(", ", numbers));

重新转换数组，以便可以在C＃中进行排序

2 个答案: