Question

我从我的教授那里得到了这个问题。

取整数N和具有X整数的数组A（非空）。您需要将阵列A分成两部分，第一个数组Ax（左数组）包含数字等于整数N和数组Ay（右数组）包含相同数量的非N整数。

意味着A的指数（I）应为0 < = I＆lt; X

Ax中的元素必须等于整数X，Ay中的元素不能等于整数X

A [0..I-1]中等于X的元素数与A [I..N-1]中与X不同的元素数相同。（对于K = 0，A [ 0..I-1]不包含任何元素。对于I = N，A [I ..N-1]不包含任何元素。）

例如如果X = 3且数组var A = [3,3,4,9,2,5,3]

不对称指数I = 4

对于I = 3，阵列A的部分将是Ax = [3,3,4,9]并且Ay = [2,5,3]。其中Array Ax的两个元素等于N，而Array Ay中的两个元素不等于X

假设， X是整数，可以是1至100000

N是整数，可以是0到100000

数组A的元素是整数，可以是0到100000

WorstCase时间复杂度必须为O（N）
WorstCase空间复杂度必须为O（1），不考虑输入的存储。

可以修改输入数组的元素

    public static int Test1Method(int X, int[] A)
    {
                    int c, j;
        int countLeft, countRight;
        int returnIndex = 0;
        for (int i = 0; i < A.Length; i++)
        {
            countLeft = 0;
            countRight = 0;
            for (j = 0; j <= i; j++)
            {
                if (A[j] == X)
                    countLeft = countLeft + 1;
            }
            for (c = A.Length - 1; c > i; c--)
            {
                if (A[c] != X)
                    countRight = countRight + 1;
            }
            if (countRight == countLeft)
                returnIndex = i + 1;
        }

        int countX = 0;
        for (int i = 0; i < returnIndex; i++)
        {
            if (A[i] == X)
                countX++;
        }

        if (countX == 0)
            return A.Length;

        return returnIndex;
    }

我被告知，我的解决方案仅适用于10％。但我不知道为什么，我已经尝试了所有可能的例子，它对我有用。

Answer 1

我认为您当前的解决方案有效，但它的运行复杂度为O（N ^ 2）。

这是一个以O（N）复杂度运行的解决方案，首先计算数组中X的数量，然后寻找平衡两个计数的点，计算countX in开头帮助我们避免代码中的两个内部for循环。

public static int FindIndexSplit(int X, int[] A)
{
    var countX = A.Count(a => a == X);
    var countXLeft = 0;
    var countNonXRight = A.Length - countX;
    for (var i = 0; i < A.Length; i++)
    {
        if (countXLeft == countNonXRight) return i;
        if (A[i] == X)
        {
            countXLeft += 1;
        }
        else
        {
            countNonXRight -= 1;
        }
    }
    return A.Length;
}

数组拆分bz计数

1 个答案: