具有特定差异的最大对数之和

给定一个整数数组和一个数字k。如果两个数字之间的差严格小于k，我们可以配对两个数字。任务是找到不相交对的最大可能总和。 P对的总和是所有2P对的总和。

例子：

Input  : arr[] = {3, 5, 10, 15, 17, 12, 9}, K = 4
Output : 62
Explanation:
Then disjoint pairs with difference less than K are, (3, 5), (10, 12), (15, 17)  
So maximum sum which we can get is 3 + 5 + 12 + 10 + 15 + 17 = 62
Note that an alternate way to form disjoint pairs is, (3, 5), (9, 12), (15, 17), but this pairing produces lesser sum.

Input  : arr[] = {5, 15, 10, 300}, k = 12
Output : 25

方法：
首先，我们以给定的数组升序排序。数组排序后，我们遍历数组。对于每个元素，我们尝试首先将其与之前的元素配对。为什么我们更喜欢上一个元素?可以将arr [i]与arr [i-1]和arr [i-2]配对(即arr [i] – arr [i-1] 观察以上事实，我们可以制定出如下的动态编程解决方案，
令dp [i]表示使用数组的前i个元素可以实现的最大不相交对和。假设当前我们处于第i个位置，那么对我们来说有两种可能性。

Pair up i with (i-1)th element, i.e. 
      dp[i] = dp[i-2] + arr[i] + arr[i-1]
  Don't pair up, i.e. 
      dp[i] = dp[i-1] 

上面的迭代需要O(N)时间，而数组排序将花费O(N log N)时间，因此解决方案的总时间复杂度将是O(N log N)

C++

// C++ program to find maximum pair sum whose
// difference is less than K
#include 
using namespace std;
 
// method to return maximum sum we can get by
// finding less than K difference pair
int maxSumPairWithDifferenceLessThanK(int arr[], int N, int K)
{
    // Sort input array in ascending order.
    sort(arr, arr+N);
 
    // dp[i] denotes the maximum disjoint pair sum
    // we can achieve using first i elements
    int dp[N];
 
    //  if no element then dp value will be 0
    dp[0] = 0;
 
    for (int i = 1; i < N; i++)
    {
        // first give previous value to dp[i] i.e.
        // no pairing with (i-1)th element
        dp[i] = dp[i-1];
 
        // if current and previous element can form a pair
        if (arr[i] - arr[i-1] < K)
        {
            // update dp[i] by choosing maximum between
            // pairing and not pairing
            if (i >= 2)
                dp[i] = max(dp[i], dp[i-2] + arr[i] + arr[i-1]);
            else
                dp[i] = max(dp[i], arr[i] + arr[i-1]);
        }
    }
 
    //  last index will have the result
    return dp[N - 1];
}
 
//  Driver code to test above methods
int main()
{
    int arr[] = {3, 5, 10, 15, 17, 12, 9};
    int N = sizeof(arr)/sizeof(int);
 
    int K = 4;
    cout << maxSumPairWithDifferenceLessThanK(arr, N, K);
    return 0;
}

Java

// Java program to find maximum pair sum whose
// difference is less than K
 
import java.io.*;
import java.util.*;
 
class GFG {
     
    // method to return maximum sum we can get by
    // finding less than K difference pair
    static int maxSumPairWithDifferenceLessThanK(int arr[],
                                               int N, int K)
    {
         
        // Sort input array in ascending order.
        Arrays.sort(arr);
     
        // dp[i] denotes the maximum disjoint pair sum
        // we can achieve using first i elements
        int dp[] = new int[N];
     
        // if no element then dp value will be 0
        dp[0] = 0;
     
        for (int i = 1; i < N; i++)
        {
            // first give previous value to dp[i] i.e.
            // no pairing with (i-1)th element
            dp[i] = dp[i-1];
     
            // if current and previous element can form a pair
            if (arr[i] - arr[i-1] < K)
            {
                 
                // update dp[i] by choosing maximum between
                // pairing and not pairing
                if (i >= 2)
                    dp[i] = Math.max(dp[i], dp[i-2] + arr[i] +
                                                    arr[i-1]);
                else
                    dp[i] = Math.max(dp[i], arr[i] + arr[i-1]);
            }
        }
     
        // last index will have the result
        return dp[N - 1];
    }
 
    // Driver code to test above methods
    public static void main (String[] args) {
         
        int arr[] = {3, 5, 10, 15, 17, 12, 9};
        int N = arr.length;
        int K = 4;
         
        System.out.println ( maxSumPairWithDifferenceLessThanK(
                                                    arr, N, K));
         
    }
}
 
//This code is contributed by vt_m.

Python3

# Python3 program to find maximum pair
# sum whose difference is less than K
 
# method to return maximum sum we can
# get by get by finding less than K
# difference pair
def maxSumPairWithDifferenceLessThanK(arr, N, K):
 
    # Sort input array in ascending order.
    arr.sort()
 
    # dp[i] denotes the maximum disjoint
    # pair sum we can achieve using first
    # i elements
    dp = [0] * N
 
    # if no element then dp value will be 0
    dp[0] = 0
 
    for i in range(1, N):
     
        # first give previous value to
        # dp[i] i.e. no pairing with
        # (i-1)th element
        dp[i] = dp[i-1]
 
        # if current and previous element
        # can form a pair
        if (arr[i] - arr[i-1] < K):
         
            # update dp[i] by choosing
            # maximum between pairing
            # and not pairing
            if (i >= 2):
                dp[i] = max(dp[i], dp[i-2] + arr[i] + arr[i-1]);
            else:
                dp[i] = max(dp[i], arr[i] + arr[i-1]);
         
    # last index will have the result
    return dp[N - 1]
 
# Driver code to test above methods
arr = [3, 5, 10, 15, 17, 12, 9]
N = len(arr)
K = 4
print(maxSumPairWithDifferenceLessThanK(arr, N, K))
 
# This code is contributed by Smitha Dinesh Semwal

C#

// C# program to find maximum pair sum whose
// difference is less than K
using System;
 
class GFG {
     
    // method to return maximum sum we can get by
    // finding less than K difference pair
    static int maxSumPairWithDifferenceLessThanK(int []arr,
                                              int N, int K)
    {
         
        // Sort input array in ascending order.
        Array.Sort(arr);
     
        // dp[i] denotes the maximum disjoint pair sum
        // we can achieve using first i elements
        int []dp = new int[N];
     
        // if no element then dp value will be 0
        dp[0] = 0;
     
        for (int i = 1; i < N; i++)
        {
            // first give previous value to dp[i] i.e.
            // no pairing with (i-1)th element
            dp[i] = dp[i-1];
     
            // if current and previous element can form
            // a pair
            if (arr[i] - arr[i-1] < K)
            {
                 
                // update dp[i] by choosing maximum
                // between pairing and not pairing
                if (i >= 2)
                    dp[i] = Math.Max(dp[i], dp[i-2]
                                + arr[i] + arr[i-1]);
                else
                    dp[i] = Math.Max(dp[i], arr[i]
                                        + arr[i-1]);
            }
        }
     
        // last index will have the result
        return dp[N - 1];
    }
 
    // Driver code to test above methods
    public static void Main () {
         
        int []arr = {3, 5, 10, 15, 17, 12, 9};
        int N = arr.Length;
        int K = 4;
         
        Console.WriteLine(
          maxSumPairWithDifferenceLessThanK(arr, N, K));
         
    }
}
 
// This code is contributed by anuj_67.

PHP

= 2)
                $dp[$i] = max($dp[$i], $dp[$i-2] + $arr[$i] + $arr[$i-1]);
            else
                $dp[$i] = max($dp[$i], $arr[$i] + $arr[$i-1]);
        }
    }
 
    // last index will have the result
    return $dp[$N - 1];
}
 
    // Driver code
 
    $arr = array(3, 5, 10, 15, 17, 12, 9);
    $N = sizeof($arr) ;
 
    $K = 4;
    echo maxSumPairWithDifferenceLessThanK($arr, $N, $K);
 
 
    // This code is contributed by Ryuga
?>

Javascript

 
// Javascript program to find maximum pair sum whose
// difference is less than K
 
    // method to return maximum sum we can get by
    // finding less than K difference pair
    function maxSumPairWithDifferenceLessThanK(arr,
                                               N, K)
    {
          
        // Sort input array in ascending order.
        arr.sort();
      
        // dp[i] denotes the maximum disjoint pair sum
        // we can achieve using first i elements
        let dp = [];
      
        // if no element then dp value will be 0
        dp[0] = 0;
      
        for (let i = 1; i < N; i++)
        {
            // first give previous value to dp[i] i.e.
            // no pairing with (i-1)th element
            dp[i] = dp[i-1];
      
            // if current and previous element can form a pair
            if (arr[i] - arr[i-1] < K)
            {
                  
                // update dp[i] by choosing maximum between
                // pairing and not pairing
                if (i >= 2)
                    dp[i] = Math.max(dp[i], dp[i-2] + arr[i] +
                                                    arr[i-1]);
                else
                    dp[i] = Math.max(dp[i], arr[i] + arr[i-1]);
            }
        }
      
        // last index will have the result
        return dp[N - 1];
    }
 
// Driver code to test above methods
 
        let arr = [3, 5, 10, 15, 17, 12, 9];
        let N = arr.length;
        let K = 4;
          
        document.write( maxSumPairWithDifferenceLessThanK(
                                                    arr, N, K));
// This code is contributed by avijitmondal1998.

输出

62

时间复杂度： O(N Log N)
辅助空间： O(N)

下面给出了Amit Sane提供的优化解决方案，

C++

// C++ program to find maximum pair sum whose
// difference is less than K
#include 
using namespace std;
 
// Method to return maximum sum we can get by
// finding less than K difference pairs
int maxSumPair(int arr[], int N, int k)
{
    int maxSum = 0;
 
    // Sort elements to ensure every i and i-1 is closest
    // possible pair
    sort(arr, arr + N);
 
    // To get maximum possible sum,
    // iterate from largest to
    // smallest, giving larger
    // numbers priority over smaller
    // numbers.
    for (int i = N - 1; i > 0; --i)
    {
        // Case I: Diff of arr[i] and arr[i-1]
        //  is less then K,add to maxSum      
        // Case II: Diff between arr[i] and arr[i-1] is not
        // less then K, move to next i since with
        // sorting we know, arr[i]-arr[i-1] <
        // rr[i]-arr[i-2] and so on.
        if (arr[i] - arr[i - 1] < k)
        {
            // Assuming only positive numbers.
            maxSum += arr[i];
            maxSum += arr[i - 1];
 
            // When a match is found skip this pair
            --i;
        }
    }
 
    return maxSum;
}
 
// Driver code
int main()
{
    int arr[] = { 3, 5, 10, 15, 17, 12, 9 };
    int N = sizeof(arr) / sizeof(int);
 
    int K = 4;
    cout << maxSumPair(arr, N, K);
    return 0;
}

Java

// Java program to find maximum pair sum whose
// difference is less than K
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Method to return maximum sum we can get by
    // finding less than K difference pairs
    static int maxSumPairWithDifferenceLessThanK(int arr[],
                                                 int N,
                                                 int k)
    {
        int maxSum = 0;
 
        // Sort elements to ensure every i and i-1 is
        // closest possible pair
        Arrays.sort(arr);
 
        // To get maximum possible sum,
        // iterate from largest
        // to smallest, giving larger
        // numbers priority over
        // smaller numbers.
        for (int i = N - 1; i > 0; --i)
        {
            // Case I: Diff of arr[i] and arr[i-1] is less
            // then K, add to maxSum
            // Case II: Diff between arr[i] and arr[i-1] is
            // not less then K, move to next i
            // since with sorting we know, arr[i]-arr[i-1] <
            // arr[i]-arr[i-2] and so on.
            if (arr[i] - arr[i - 1] < k)
            {
                // Assuming only positive numbers.
                maxSum += arr[i];
                maxSum += arr[i - 1];
 
                // When a match is found skip this pair
                --i;
            }
        }
 
        return maxSum;
    }
 
    // Driver code
    public static void main(String[] args)
    {
 
        int arr[] = { 3, 5, 10, 15, 17, 12, 9 };
        int N = arr.length;
        int K = 4;
 
        System.out.println(
            maxSumPairWithDifferenceLessThanK(arr, N, K));
    }
}
 
// This code is contributed by vt_m.

Python3

# Python3 program to find maximum pair sum
# whose difference is less than K
 
# Method to return maximum sum we can
# get by finding less than K difference
# pairs
 
 
def maxSumPairWithDifferenceLessThanK(arr, N, k):
 
    maxSum = 0
 
    # Sort elements to ensure every i and
    # i-1 is closest possible pair
    arr.sort()
 
    # To get maximum possible sum, iterate
    # from largest to smallest, giving larger
    # numbers priority over smaller numbers.
    i = N - 1
    while (i > 0):
 
        # Case I: Diff of arr[i] and arr[i-1]
        #     is less then K, add to maxSum
        # Case II: Diff between arr[i] and
        #     arr[i-1] is not less then K,
        #     move to next i since with sorting
        #     we know, arr[i]-arr[i-1] < arr[i]-arr[i-2]
        #     and so on.
        if (arr[i] - arr[i - 1] < k):
 
            # Assuming only positive numbers.
            maxSum += arr[i]
            maxSum += arr[i - 1]
 
            # When a match is found skip this pair
            i -= 1
        i -= 1
 
    return maxSum
 
 
# Driver Code
arr = [3, 5, 10, 15, 17, 12, 9]
N = len(arr)
 
K = 4
print(maxSumPairWithDifferenceLessThanK(arr, N, K))
 
# This code is contributed by mits

C＃

// C# program to find maximum pair sum whose
// difference is less than K
using System;
class GFG {
     
    // Method to return maximum sum we can get by
    // finding less than K difference pairs
    static int maxSumPairWithDifferenceLessThanK(int []arr,
                                               int N, int k)
    {
        int maxSum = 0;
     
        // Sort elements to ensure
        // every i and i-1 is closest
        // possible pair
        Array.Sort(arr);
     
        // To get maximum possible sum,
        // iterate from largest
        // to smallest, giving larger
        // numbers priority over
        // smaller numbers.
        for (int i = N-1; i > 0; --i)
        {
             
            /* Case I: Diff of arr[i] and
                       arr[i-1] is less then K,
                       add to maxSum
               Case II: Diff between arr[i] and
                        arr[i-1] is not less
                        then K, move to next i
                        since with sorting we
                        know, arr[i]-arr[i-1] <
                        arr[i]-arr[i-2] and
                        so on.*/
            if (arr[i] - arr[i-1] < k)
            {
                 
                // Assuming only positive numbers.
                maxSum += arr[i];
                maxSum += arr[i - 1];
     
                // When a match is found
                // skip this pair
                --i;
            }
        }
     
        return maxSum;
    }
 
    // Driver Code
    public static void Main ()
    {
        int []arr = {3, 5, 10, 15, 17, 12, 9};
        int N = arr.Length;
        int K = 4;
         
        Console.Write( maxSumPairWithDifferenceLessThanK(arr,
                                                         N, K));
    }
}
 
// This code is contributed by nitin mittal.

的PHP

 0; --$i)
    {
        // Case I: Diff of arr[i] and arr[i-1]
        //           is less then K, add to maxSum
        // Case II: Diff between arr[i] and
        //            arr[i-1] is not less then K,
        //          move to next i since with sorting
        //          we know, arr[i]-arr[i-1] < arr[i]-arr[i-2]
        //            and so on.
        if ($arr[$i] - $arr[$i - 1] < $k)
        {
            // Assuming only positive numbers.
            $maxSum += $arr[$i];
            $maxSum += $arr[$i - 1];
 
            // When a match is found skip this pair
            --$i;
        }
    }
 
    return $maxSum;
}
 
// Driver Code
$arr = array(3, 5, 10, 15, 17, 12, 9);
$N = sizeof($arr);
 
$K = 4;
echo maxSumPairWithDifferenceLessThanK($arr, $N, $K);
 
// This code is contributed
// by Sach_Code   
?>

输出

62

时间复杂度： O(N Log N)
辅助空间： O(1)