UGC NET CS 2014 年 12 月 – III |问题 24

这是一道面向程序员的考试题，需要考生利用给出的代码片段，根据要求完成程序的编写。

题目描述

给定下面的 Java 代码，关于函数 find() 需要作出如下的选择：

class Consider {
    public static int f(int x, int y) {
        if(x == y)
            return 0;
        else
            return f(x/2, y/2) + 1;
    }
    public static int find(int n) {
        int i, j, k, m;
        int best = 0, val = 0;
        for(i = 0; i < n; i++) {
            for(j = i + 1; j < n; j++) {
                for(k = 0; k < n; k++) {
                    m = f(a[i], a[k]) + f(a[k], a[j]) + f(a[j], a[i]);
                    if(m > val || (m == val && a[k] < best)) {
                        best = a[k];
                        val = m;
                    }
                }
            }
        }
        return best;
    }
}

A、函数 f(x,y) 返回的是 x 和 y 之间的距离，使用二分查找算法优化函数 find(n)，将时间复杂度降到 O(nlogn)。

B、函数 f(x,y) 返回的是 x 和 y 之间的距离，将函数 find(n) 的时间复杂度降到 O(nlogn)。

C、函数 f(x,y) 返回的是 x 和 y 之间的距离，使用分治算法（Divide and Conquer）优化函数 find(n)，将时间复杂度降到 O(nlogn)。

D、函数 f(x,y) 返回的是 x 和 y 之间的距离，将函数 find(n) 的时间复杂度降到 O(n)。

题目解析

这道题需要对给定的代码进行分析，优化后再熟悉优化后的代码。

A选项中，并没有改变时间复杂度。只是使用二分查找，但是每次查找的时间复杂度仍然为 O（n）。并不能实现优化。

B选项中，可以考虑对给定的代码中的3重循环进行优化。可以将任意一对(i,j)看成是子数组A[...i]和B[j...]。将所有可能的子数组（O(n^2)个）按从小到大的顺序将其排列。因此，为子数组A中选择最大元素，子数组B中选择最小元素即可，时间复杂度为O(nlogn)。

C选项中，也是需要对给定的代码中的3重循环进行优化。可以事先对数组 a 进行排序，时间复杂度为 O(nlogn)。使用分治算法（Divide and Conquer），分别计算左、右和跨越中点的情况，找出跨越中点且满足条件的最小元素。

D选项中，可以从下面几个方面来着手优化：

1. f(x,y) 递归会产生大量的重复计算，可以使用动态规划来优化；
2. 将 f(x,y) 的结果存储在一个数组中，避免重复计算；
3. 将数组 a 中的元素进行排序，可以进一步优化时间复杂度；

综上所述，选项 C 的是正确答案。

代码片段

import java.util.Arrays;

class Consider {
    private static int f(int x, int y, int[] mem) {
        if (mem[x * mem.length + y] != 0) {
            return mem[x * mem.length + y];
        } else if (x == y) {
            return 0;
        } else {
            int res = f(x / 2, y / 2, mem) + 1;
            mem[x * mem.length + y] = res;
            mem[y * mem.length + x] = res;
            return res;
        }
    }

    public static int find(int[] a) {
        int n = a.length;
        int best = 0, val = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int[] mem = new int[(n + 1) * (n + 1)];
                int sum = 0;
                for (int k = 0; k < n; k++) {
                    sum += f(a[i], a[k], mem) + f(a[k], a[j], mem) + f(a[j], a[i], mem);
                }
                if (sum > val || (sum == val && a[i] < best)) {
                    best = a[i];
                    val = sum;
                }
            }
        }
        return best;
    }

    public static void main(String[] args) {
        int[] a = {3, 2, 5, 4, 1};
        Arrays.sort(a);
        System.out.println(find(a));
    }
}

代码片段理解

这里重点优化了函数 f(x, y)，使用了动态规划来避免递归时重复计算的问题，将结果存储在一个数组中，从而优化时间复杂度。同时，在 find() 函数中，使用三重循环来遍历数组 a，每次计算元素之间的距离，并根据条件找出最小的元素。

最后，在主函数中，先将数组 a 进行排序，再调用 find() 函数来寻找最小的元素。

代码返回的是可运行的Java代码。