Question

给出一个由N个正数组成的数组A。任务是找到平衡首先在阵列中发生的位置。数组中的平衡位置是这样的位置，使得其下面的元素之和等于其后的元素之和。

输入：输入的第一行包含一个整数T，表示测试用例的数量。然后是T测试用例。每个测试用例的第一行包含一个整数N，它表示数组的大小。然后在下一行是数组A的N个空格分隔的值。

输出：对于新行中的每个测试用例，如果没有平衡点，则打印元素处于平衡状态的位置，打印-1。

static int output[];
public static void main(String[] args) throws IOException 
{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(br.readLine()); 
    output = new int[t];
    for(int testcase = 0 ; testcase<t ; testcase++)
    {
        //output[testcase]=new StringBuffer();
        int size = Integer.parseInt(br.readLine());
        String input = br.readLine();
        String[] arr = input.split(" ");
        int[] intArr = new int[arr.length];
        for(int i = 0; i < arr.length; i++) {
            intArr[i] = Integer.parseInt(arr[i]);
        }
        output[testcase] = getEquilibrium(intArr);
    }
    for(int j = 0 ; j<t ; j++)
    {
        System.out.println(output[j]);
    }
}
static int getEquilibrium(int array[] )
{
    for(int i = 0 ; i < array.length ; i++)
    {
        int a = 0,b = 0;
        for(int j = i-1 ; j >= 0 ; j--)
        {
            a +=array[j];
        }
        for(int k = i+1 ; k < array.length ; k++ )
        {
            b +=array[k];
        }
        if(a == b)
            return ++i;
    }
    return -1;
}

Answer 1

您的代码有两个for循环，其复杂度为O（n ^ 2）。限制可能高达10 ^ 9（问题没有限制），因此您将获得TLE。
无论如何，该解决方案是不正确的，因为所使用的逻辑在许多情况下都会失败。

有效方法-O（n）

我的代码链接：https://paste.ee/p/2nDJ3
如果发现任何问题，请发表评论。
希望这会有所帮助：）

Answer 2

对O（n）尝试这种方法

public static void main(String[] args) {

    Scanner input = new Scanner(System.in);

    int T = input.nextInt();

    for (int t = 0; t < T; t++) {

        int N = input.nextInt();
        int[] A = new int[N];

        for (int n = 0; n < N; n++) {
            A[n] = input.nextInt();
        }

        if (N < 3) {
            System.out.println("-1");
        } else if (N == 3) {

            if (A[0] == A[2]) {
                System.out.println("1");
            } else {
                System.out.println("-1");
            }

        } else {
            System.out.println(getEquilibiriumPosition(A));
        }

    }
}

private static int getEquilibiriumPosition(int[] A) {

    int startPos = 0;
    int equilibriumPos = A.length - A.length / 2;
    int endPos = A.length - 1;

    int leftSum = A[startPos];
    int rightSum = A[endPos];

    for (int i = startPos + 1; i < equilibriumPos; i++) {
        leftSum += A[i];
    }

    for (int i = endPos - 1; i > equilibriumPos; i--) {
        rightSum += A[i];
    }

    if (leftSum > rightSum) {
        while (equilibriumPos != startPos) {
            if (leftSum == rightSum) {
                return equilibriumPos;
            }
            rightSum += A[equilibriumPos];
            equilibriumPos--;
            leftSum -= A[equilibriumPos];
        }
    } else if (leftSum < rightSum) {
        while (equilibriumPos != endPos) {
            if (leftSum == rightSum) {
                return equilibriumPos;
            }
            leftSum += A[equilibriumPos];
            equilibriumPos++;
            rightSum -= A[equilibriumPos];
        }
    } else {
        return equilibriumPos;
    }

    return -1;
}

Java中的TLE问题

2 个答案: