Question

您将获得A个n个数组和k个值。您必须按A增加或减少k中的每个元素，并且每个元素只能执行一次。目标是最小化结果数组A中最大和最小元素之间的差异（修改后）并输出这种差异。

例如，A=[1,7]，k=4，我们需要将A修改为[5,3]，然后差异为2，这是我们的最小差异可以实现。

有人可以帮我解决这个问题吗？

Answer 1

这是考虑它的一种方式（想象一个排序的数组，x是a[i] + k而y是a[i] - k）

x
  x
      x
           x
y              
  y             x[i](min?)
      y                   x
           y                  x[n-1]
                y[i](min?)     
                          y   
                              y

如果您选择y[i]作为最低要求，则您选择的最大值为：

max( y[0], x[i + 1] )

如果你选择x[i]作为最低限度......哦，你不能，因为在这个排序的安排中任何a[j] ± k, j > i必须更小。

如果您选择x[n-1]作为最低要求，则您选择的最大值将是所有min(x[j],y[j]) where both x[j] and y[j] are greater than or equal to x[n-1] (or just x[j] if y[j] < x[n-1])中最大的。

如果您选择y[0]作为最低要求，则只要所有max(x[j])大于或等于x[j]，您选择的最大值为y[0]。

Answer 2

这是一个订单为O(n*log(n))的算法：

public class MinDiff 
{
    public static void main(String[] args) 
    {
        int A[] = {1,7};
        int k = 4;
        System.out.println("Input a:=" + Arrays.toString(A) + ", k:=" + k);
        find(A, k);
        System.out.println("Output a´:=" + Arrays.toString(A));
    }

    private static void find(int a[], int k) 
    {       
        Arrays.sort(a);

        int n = a.length;
        if (k > a[n - 1] - a[0])
        {
            for (int i = 0; i < n; i++)
                a[i] += k;
            return;
        }

        a[0] = a[0] + k;
        a[n - 1] = a[n - 1] - k;

        int max = Math.max(a[0], a[n - 1]);
        int min = Math.min(a[0], a[n - 1]);

        for (int index = 1; index < n - 1; index++) 
        {
            if (a[index] < min)
                a[index] += k;
            else if (a[index] > max)
                a[index] -= k;
            else if ((a[index] - min) > (max - a[index]))
                a[index] -= k;
            else
                a[index] += k;

            max = Math.max(a[index], max);
            min = Math.min(a[index], min);
        }
    }
}

输入： a：= [1,7]，k：= 4

输出： a'：= [5,3]

Answer 3

我在C ++中的递归动态编程解决方案。时间复杂度是 O（N3） -

    #include <iostream>
    #include <vector>
    #include <map>
    #include <cmath>
    #include <limits>

    using namespace std;

    vector <int> v;
    map < pair <int, pair <int,int> >, int > mp;

    int k, n;

    int solve(int index, int minimum, int maximum)
    {
            if(index == n)
                    return maximum - minimum;
            pair <int, pair <int,int> > p = pair <int, pair <int,int> > (index, pair <int,int> (minimum, maximum));
            if(mp.find(p) != mp.end())
                    return mp[p];
            int x = v[index] - k, y = v[index] + k;
            return mp[p] = min(solve(index + 1, min(x, minimum), max(x, maximum)), solve(index + 1, min(y, minimum), max(y, maximum)));
    }

    int main()
    {
            int p = std::numeric_limits<int>::max();
            int q = std::numeric_limits<int>::min();
            cin >> k >> n;
            int x;
            for(int i = 0;i < n;i++)
            {
                    cin >> x;
                    v.push_back(x);
            }
            cout << solve(0, p, q) << endl;
            return 0;
    }

修改数组以最小化差异

3 个答案: