Java 如何在第一枪中考虑O（nlogn）解决方案？

我总是会想出一个解决办法，那就是

O（n^2）

（蛮力），但我从来没有在最初几分钟内或在我通读问题的一段时间后（我指的是思维过程），达到

O（nlogn）

或

O（n）

。对于较大的数据集，

O（n^2）

总是失败。如何思考问题以获得最佳解决方案。你能谈谈这方面的想法吗。这里有一个我正在研究的问题，它对于较大的数据集超时（完整描述）

代码：-

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    static int pairs(int[] a,int k) {

        if( a.length==0 || a==null )
        return 0;

        int counter=0;        

        for( int i=0;i<a.length;i++ ){
            for( int j=i+1;j<a.length;j++) {
                if( Math.abs(a[i]-a[j])==k )
                    counter++;
            }
        }
        return counter;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int res;

        String n = in.nextLine();
        String[] n_split = n.split(" ");

        int _a_size = Integer.parseInt(n_split[0]);
        int _k = Integer.parseInt(n_split[1]);

        int[] _a = new int[_a_size];
        int _a_item;
        String next = in.nextLine();
        String[] next_split = next.split(" ");

        for(int _a_i = 0; _a_i < _a_size; _a_i++) {
            _a_item = Integer.parseInt(next_split[_a_i]);
            _a[_a_i] = _a_item;
        }

        res = pairs(_a,_k);
        System.out.println(res);
    }
}

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
静态整数对（int[]a，int k）{
如果（a.length==0 | | a==null）
返回0；
int计数器=0；
对于（inti=0；i我做的一件事就是坐下来，看看你作为一个人类如何解决这个问题。寻找捷径或模式

在这个问题中，你要寻找两个相隔k的数字。迭代这些数字。在你进行的过程中，将它们添加到一个集合中。然后，如果这个数字加上或减去k在集合中，增加你的计数器

伪代码：

Set<Integer> set;
for(int i:a){
  set.add(i);
  if(set.contains(i-k)
    counter++;
  if(set.contains(i+k)
    counter++;
}
Return counter;

Set；
对于（int i:a）{
增加（i）；
if（集合包含（i-k）
计数器++；
if（集合包含（i+k）
计数器++；
}
返回计数器；

O（n）解决方案
一个小规模的Scala解决方案，因为vikarjramun没有修复其答案中的错误：

导入scala.collection.mutable_
对象解{
def main（参数：数组[字符串]）{
val lines=scala.io.Source.stdin.getLines（）
val k=lines.next（）.split（“”）（1）.toInt
val arr=lines.next（）.split（“”）.map（uu.toInt）
val set=HashSet[Int]（）
变量计数=0
对于（我认为这是一个模糊的问题。每个问题都是不同的，即使有一些技术可以帮助你以最佳方式解决某些类型的问题，也没有奇迹。优化算法可能很难，除非你是天才，否则你总是需要思考几分钟以上才能找到问题的聪明答案如果你想得到关于你具体问题的帮助，我建议你发布一个链接到它的描述。这将是一个更好、更集中的问题，人们可以真正回答。你能帮我解决这个问题吗（代码）我已经发布了…是的，如果你发布了问题描述。对数组进行排序。然后线性地扫描数组。鉴于数组中的值是唯一的，如果你修复了一个小错误，你的方法就会起作用：如果
I-k
和
I+k
都在集合中，你应该数两对而不是一对对不起，不是吗直到现在才看到你的信息这没关系。我实际上错过了一个事实，即你也在最后返回两倍的总和，而不是自己的总和。我很有信心上面的代码可以工作，因为它通过了HackerRank的测试。无论如何，我对你的答案投了赞成票，因为你是第一个提出线性解决方案的人。我实际上没有阅读这个问题lem声明，我也误读了Teja的代码，所以你的解决方案是正确的。