Question

写一个函数： int solution（int K，int A []，int N）; 在给定整数K和N个整数的非空零索引数组A的情况下，返回数组A的bounded_slices数。如果bounds_slices的数量大于1,000,000,000，则该函数应返回1,000,000,000。例如，给定： A [0] = 3 A [1] = 5 A [2] = 7 A [3] = 6 A [4] = 3 该函数应返回9，如上所述。假使，假设： •N是[1..100,000]范围内的整数; •K是[0..1,000,000,000]范围内的整数; •数组A的每个元素都是[-1,000,000,000..1,000,000,000]范围内的整数。复杂： •预期的最坏情况时间复杂度为O（N）; •预期的最坏情况空间复杂度为O（N），超出输入存储（不计入输入参数所需的存储空间）。 * /

我的代码没有在O（N）中运行，我想，任何建议？ import java.util.ArrayList;

公共类解决方案{

/**
 * @param args
 */

public int solution(int K, int[] A) 
{
    int numberOfSlices=0;
    ArrayList<Integer>listOfSlices=new ArrayList<Integer>();
    for(int i=0;i<A.length;i++)
    {
        for( int j=0;j<A.length;j++)
        {
            if((!listOfSlices.contains(A[i])
                &&!listOfSlices.contains(A[j]))&&(max(A[i],A[j])-min(A[i],A[j]))<=K)
            {
              numberOfSlices++;

            }
        }
          listOfSlices.add(A[i]);
    }



    return numberOfSlices;

}

/* return the max between two numbers */
public int max(int p,int q)
{
    if(p>q)
    {
        return p;
    }
    else
    {
        return q;
    }

}

/*return the min between two numbers */
public int min(int p,int q)
{
    if(p<q)
    {
        return p;
    }
    else 
    {
        return q;
    }

}
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Solution solution=new Solution();
    int[] array={3,5,7,6,3};
    System.out.println("the number of slices in the array is  "+solution.solution(2, array));

}

}

Answer 1

这个问题仍然存在，所以没有人会放弃太多，但我会指出你正确的方向（或者至少远离错误的方向）。

嵌套for循环是有风险的;因为，你基本上保证O（N ^ 2）。您需要找到一种减少池的方法，而不是为每个元素重复迭代。

然而，正如你所知，这将导致许多测试用例失败。如果蛮力失败，则意味着您错过了处理某些corner cases的方法。就像问题在完整描述中警告一样。

所以：

1）认识到暴力强制比指数要快得多，想想如何减少搜索所需的内容。

2）写出一些古怪的测试用例并找出为什么你的代码失败的地方，然后重新考虑你的解决方案。对于每个案例，答案都不是if语句。

你的代码肯定会失败（6，[4,5,8,5,1,4,6,8,7,2,2,5]），这应该返回44.考虑一下这个测试用例。

祝你好运。

代码共谋问题

1 个答案: