java - 如何减少该程序的执行时间[关闭]

Question

int n, k;
int count = 0, diff;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] input;
input = br.readLine().split(" ");
n = Integer.parseInt(input[0]);
int[] a = new int[n];
k = Integer.parseInt(input[1]);
input = br.readLine().split(" ");
for (int i = 0; i < n; i++) {
  a[i] = Integer.parseInt(input[i]);
     for (int j = 0; j < i; j++) {
        diff = a[j] - a[i];
        if (diff == k || -diff == k) {
           count++;
        }
     }
}
System.out.print(count);

这是一个示例程序，我在其中打印特定的差异计数，其中 n 范围为

提前感谢您的建议

Answer 1

我不明白为什么你在另一个里面有一个循环。那边是O(n^2)。

您还可以将读取此整数数组与获取此计数混合在一起。我会将两者分开 - 阅读整个内容，然后扫描并获取差异计数。

也许我误解了你在做什么，但感觉就像你在内部循环中重新做了很多工作。

Answer 2

为什么不使用 java.util.Scanner 类而不是 BufferReader。

例如：-

Scanner sc = new Scanner(System.in); int number = sc.nextInt();

这可能会更快，因为它们涉及的包装器更少....See this link

Answer 3

由于split()使用正则表达式来分割字符串，你应该测量StringTokenizer是否会加快速度。

Answer 4

从文件中读取数字并将它们放入 Map（数字作为键，频率作为值）。遍历它们一次，并为每个数字检查地图是否包含添加了k 的数字。如果是这样，请增加您的计数器。如果您使用 HashMap，则它是 O(n)，而不是您的算法的 O(n^2)。

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int k = Integer.parseInt(br.readLine().split(" ")[1]);
Map<Integer, Integer> readNumbers = new HashMap<Integer, Integer>();

for (String aNumber : br.readLine().split(" ")) {
    Integer num = Integer.parseInt(aNumber);
    Integer freq = readNumbers.get(num);
    readNumbers.put(num, freq == null ? 1 : freq + 1);
}

int count = 0;
for (Integer aNumber : readNumbers.keySet()) {
    int freq = readNumbers.get(aNumber);
    if (k == 0) {
        count += freq * (freq - 1) / 2;
    } else if (readNumbers.containsKey(aNumber + k)) {
        count += freq * readNumbers.get(aNumber + k);
    }
}
System.out.print(count);

EDIT 修复了重复项和 k = 0

Answer 5

您正在尝试查找与k 不同的元素。试试这个：

• 对数组进行排序。
• 您可以在排序后一次性完成，方法是使用两个指针并根据差异大于或小于k 调整其中一个指针

Answer 6

值的稀疏映射，以及它们的出现频率。

SortedMap<Integer, Integer> a = new TreeMap<Integer, Integer>();
for (int i = 0; i < n; ++i) {
    int value = input[i];
    Integer old = a.put(value, 1);
    if (old != null) {
        a.put(value, old.intValue() + 1);
    }
}
for (Map.Entry<Integer, Integer> entry : a.entrySet()) {
    Integer freq = a.get(entry.getKey() + k);
    count += entry.getValue() * freq; // N values x M values further on.
}

这个 O(n)。

如果成本太高，您可以对输入数组进行排序并做类似的事情。

Answer 7

这里是@Socha23使用HashSet、TIntIntHashSet的方案与原方案的对比。

对于 100,000 个数字，我得到了以下结果（没有读取和解析）

对于 100 个唯一值，k=10

Set: 89,699,743 took 0.036 ms
Trove Set: 89,699,743 took 0.017 ms
Loops: 89,699,743 took 3623.2 ms

对于 1000 个唯一值，k=10

Set: 9,896,049 took 0.187 ms
Trove Set: 9,896,049 took 0.193 ms
Loops: 9,896,049 took 2855.7 ms

代码

import gnu.trove.TIntIntHashMap;
import gnu.trove.TIntIntProcedure;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

class Main {
    public static void main(String... args) throws Exception {
        Random random = new Random(1);
        int[] a = new int[100 * 1000];
        int k = 10;
        for (int i = 0; i < a.length; i++)
            a[i] = random.nextInt(100);

        for (int i = 0; i < 5; i++) {
            testSet(a, k);
            testTroveSet(a, k);
            testLoops(a, k);
        }
    }

    private static void testSet(int[] a, int k) {
        Map<Integer, Integer> readNumbers = new HashMap<Integer, Integer>();
        for (int num : a) {
            Integer freq = readNumbers.get(num);
            readNumbers.put(num, freq == null ? 1 : freq + 1);
        }

        long start = System.nanoTime();
        int count = 0;
        for (Integer aNumber : readNumbers.keySet()) {
            if (readNumbers.containsKey(aNumber + k)) {
                count += (readNumbers.get(aNumber) * readNumbers.get(aNumber + k));
            }
        }
        long time = System.nanoTime() - start;
        System.out.printf("Set: %,d took %.3f ms%n", count, time / 1e6);
    }

    private static void testTroveSet(int[] a, final int k) {
        final TIntIntHashMap readNumbers = new TIntIntHashMap();
        for (int num : a)
            readNumbers.adjustOrPutValue(num, 1,1);

        long start = System.nanoTime();
        final int[] count = { 0 };
        readNumbers.forEachEntry(new TIntIntProcedure() {
            @Override
            public boolean execute(int key, int keyCount) {
                count[0] += readNumbers.get(key + k) * keyCount;
                return true;
            }
        });
        long time = System.nanoTime() - start;
        System.out.printf("Trove Set: %,d took %.3f ms%n", count[0], time / 1e6);
    }

    private static void testLoops(int[] a, int k) {
        long start = System.nanoTime();
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < i; j++) {
                int diff = a[j] - a[i];
                if (diff == k || -diff == k) {
                    count++;
                }
            }
        }
        long time = System.nanoTime() - start;
        System.out.printf("Loops: %,d took %.1f ms%n", count, time / 1e6);
    }

    private static long free() {
        return Runtime.getRuntime().freeMemory();
    }
}

Answer 8

使用集合和地图，正如其他用户已经解释过的，所以我不再重复他们的建议。

我会提出其他建议。 停止使用String.split。它编译并使用正则表达式。 String.split 中有这一行：Pattern.compile(expr).split(this)。 如果您想沿单个字符拆分，您可以编写自己的函数，它会快得多。我相信 Guava (ex-Google collections API) 具有字符串拆分功能，它可以在不使用正则表达式的情况下拆分字符。