选择距离最远点之间的距离小于等于L的三个点的方法

给定一组全部位于X轴上的n个不同点x ₁ ，x ₂ ，x ₃ …x _n和一个整数L，任务是找到选择三个点的方式数，以使两个点之间的距离最大。远点小于或等于L
注意：顺序并不重要，即点{3，2，1}和{1，2，3}代表三个点的相同集合
例子：

Input : x = {1, 2, 3, 4} 
L = 3 
Output : 4
Explanation: 
Ways to select three points such that the distance between 
the most distant points <= L are: 
1) {1, 2, 3} Here distance between farthest points = 3 – 1 = 2 <= L 
2) {1, 2, 4} Here distance between farthest points = 4 – 1 = 3 <= L 
3) {1, 3, 4} Here distance between farthest points = 4 – 1 = 3 <= L 
4) {2, 3, 4} Here distance between farthest points = 4 – 2 = 2 <= L
Thus, total number of ways = 4 
 

天真的方法：
首先，对点数组进行排序以生成三元组{a，b，c}，使得a和c是三元组中最远的点，a

C++

// C++ program to count ways to choose
// triplets such that the distance
// between the farthest points <= L
#include
using namespace std;
 
// Returns the number of triplets with
// distance between farthest points <= L
int countTripletsLessThanL(int n, int L, int* arr)
{
    // sort to get ordered triplets so that we can
    // find the distance between farthest points
    // belonging to a triplet
    sort(arr, arr + n);
 
    int ways = 0;
 
    // generate and check for all possible
    // triplets: {arr[i], arr[j], arr[k]}
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
 
                // Since the array is sorted the
                // farthest points will be a[i]
                // and a[k];
                int mostDistantDistance = arr[k] - arr[i];
                if (mostDistantDistance <= L) {
                    ways++;
                }
            }
        }
    }
 
    return ways;
}
 
// Driver Code
int main()
{
    // set of n points on the X axis
    int arr[] = { 1, 2, 3, 4 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
    int L = 3;
    int ans = countTripletsLessThanL(n, L, arr);
    cout << "Total Number of ways = " << ans << "\n";
    return 0;
}

Java

// Java program to count ways to choose
// triplets such that the distance
// between the farthest points <= L
import java .io.*;
import java .util.Arrays;
class GFG {
 
    // Returns the number of triplets with
    // distance between farthest points <= L
    static int countTripletsLessThanL(int n, int L,
                                        int []arr)
    {
         
        // sort to get ordered triplets
        // so that we can find the
        // distance between farthest
        // points belonging to a triplet
        Arrays.sort(arr);
     
        int ways = 0;
     
        // generate and check for all possible
        // triplets: {arr[i], arr[j], arr[k]}
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                for (int k = j + 1; k < n; k++) {
     
                    // Since the array is sorted the
                    // farthest points will be a[i]
                    // and a[k];
                    int mostDistantDistance =
                                    arr[k] - arr[i];
                    if (mostDistantDistance <= L)
                    {
                        ways++;
                    }
                }
            }
        }
     
        return ways;
    }
 
    // Driver Code
    static public void main (String[] args)
    {
         
        // set of n points on the X axis
        int []arr = {1, 2, 3, 4};
     
        int n =arr.length;
        int L = 3;
        int ans = countTripletsLessThanL(n, L, arr);
        System.out.println("Total Number of ways = "
                                             + ans);
    }
}
 
// This code is contributed by anuj_67.

Python3

# Python3 program to count ways to choose
# triplets such that the distance
# between the farthest points <= L
 
# Returns the number of triplets with
# distance between farthest points <= L
def countTripletsLessThanL(n, L, arr):
     
    # sort to get ordered triplets so that
    # we can find the distance between
    # farthest points belonging to a triplet
    arr.sort()
 
    ways = 0
 
    # generate and check for all possible
    # triplets: {arr[i], arr[j], arr[k]}
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
 
                # Since the array is sorted the
                # farthest points will be a[i]
                # and a[k];
                mostDistantDistance = arr[k] - arr[i]
                if (mostDistantDistance <= L):
                    ways += 1
 
    return ways
 
# Driver Code
if __name__ == "__main__":
 
    # set of n points on the X axis
    arr = [1, 2, 3, 4 ]
 
    n = len(arr)
    L = 3
    ans = countTripletsLessThanL(n, L, arr)
    print ("Total Number of ways =", ans)
 
# This code is contributed by ita_c

C#

// C# program to count ways to choose
// triplets such that the distance
// between the farthest points <= L
using System;
class GFG {
 
// Returns the number of triplets with
// distance between farthest points <= L
static int countTripletsLessThanL(int n, int L,
                                     int []arr)
{
     
    // sort to get ordered triplets
    // so that we can find the
    // distance between farthest
    // points belonging to a triplet
    Array.Sort(arr);
 
    int ways = 0;
 
    // generate and check for all possible
    // triplets: {arr[i], arr[j], arr[k]}
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
 
                // Since the array is sorted the
                // farthest points will be a[i]
                // and a[k];
                int mostDistantDistance = arr[k] - arr[i];
                if (mostDistantDistance <= L)
                {
                    ways++;
                }
            }
        }
    }
 
    return ways;
}
 
    // Driver Code
    static public void Main ()
    {
         
        // set of n points on the X axis
        int []arr = {1, 2, 3, 4};
     
        int n =arr.Length;
        int L = 3;
        int ans = countTripletsLessThanL(n, L, arr);
        Console.WriteLine("Total Number of ways = " + ans);
    }
}
 
// This code is contributed by anuj_67.

输出：

Total Number of ways = 4

时间复杂度： O(n ³ )用于生成所有可能的三元组。
高效方法：

• 通过使用二进制搜索可以解决此问题。
• 首先，对数组进行排序。
• 现在，对于数组中的每个元素，我们发现大于该元素的元素数量(通过保持点的排序顺序)并位于范围(x _i + 1，x _i + L)范围内(请注意，此处所有点都是不同的，因此我们需要考虑等于x _i本身的元素)。
• 这样做，我们找到所有这些点，其中最远的点之间的距离将始终小于或等于L。
• 现在让我们说第i^个点，我们有M个这样的点，它们小于或等于x _i + L，那么我们可以从M个这样的点中选择2个点的方法很简单
  M *(M – 1)/ 2

C++

// C++ program to count ways to choose
// triplets such that the distance between
// the farthest points <= L */
#include
using namespace std;
 
// Returns the number of triplets with the
// distance between farthest points <= L
int countTripletsLessThanL(int n, int L, int* arr)
{
    // sort the array
    sort(arr, arr + n);
 
    int ways = 0;
    for (int i = 0; i < n; i++) {
 
        // find index of element greater than arr[i] + L
        int indexGreater = upper_bound(arr, arr + n,
                                         arr[i] + L) - arr;
 
        // find Number of elements between the ith
        // index and indexGreater since the Numbers
        // are sorted and the elements are distinct
        // from the points btw these indices represent
        // points within range (a[i] + 1 and a[i] + L)
        // both inclusive
 
        int numberOfElements = indexGreater - (i + 1);
 
        // if there are at least two elements in between
        // i and indexGreater find the Number of ways
        // to select two points out of these
 
        if (numberOfElements >= 2) {
            ways += (numberOfElements
                        * (numberOfElements - 1) / 2);
        }
    }
 
    return ways;
}
 
// Driver Code
int main()
{
    // set of n points on the X axis
    int arr[] = { 1, 2, 3, 4 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
    int L = 4;
 
    int ans = countTripletsLessThanL(n, L, arr);
 
    cout << "Total Number of ways = " << ans << "\n";
 
    return 0;
}

Java

// Java program to count ways to choose
// triplets such that the distance between
// the farthest points <= L */
import java.util.*;
 
class GFG
{
 
// Returns the number of triplets with the
// distance between farthest points <= L
static int countTripletsLessThanL(int n, int L,
                                  int[] arr)
{
    // sort the array
    Arrays.sort(arr);
 
    int ways = 0;
    for (int i = 0; i < n; i++)
    {
 
        // find index of element greater than arr[i] + L
        int indexGreater = upper_bound(arr, 0, n,
                                       arr[i] + L);
 
        // find Number of elements between the ith
        // index and indexGreater since the Numbers
        // are sorted and the elements are distinct
        // from the points btw these indices represent
        // points within range (a[i] + 1 and a[i] + L)
        // both inclusive
        int numberOfElements = indexGreater - (i + 1);
 
        // if there are at least two elements in between
        // i and indexGreater find the Number of ways
        // to select two points out of these
 
        if (numberOfElements >= 2)
        {
            ways += (numberOfElements *
                    (numberOfElements - 1) / 2);
        }
    }
    return ways;
}
 
static int upper_bound(int[] a, int low,
                       int high, int element)
{
    while(low < high)
    {
        int middle = low + (high - low) / 2;
        if(a[middle] > element)
            high = middle;
        else
            low = middle + 1;
    }
    return low;
}
 
// Driver Code
public static void main(String[] args)
{
    // set of n points on the X axis
    int arr[] = { 1, 2, 3, 4 };
 
    int n = arr.length;
    int L = 4;
 
    int ans = countTripletsLessThanL(n, L, arr);
 
    System.out.println("Total Number of ways = " + ans);
}
}
 
// This code is contributed by 29AjayKumar

C＃

// C# program to count ways to choose
// triplets such that the distance between
// the farthest points <= L */
using System;
 
class GFG
{
 
// Returns the number of triplets with the
// distance between farthest points <= L
static int countTripletsLessThanL(int n, int L,
                                int[] arr)
{
    // sort the array
    Array.Sort(arr);
 
    int ways = 0;
    for (int i = 0; i < n; i++)
    {
 
        // find index of element greater than arr[i] + L
        int indexGreater = upper_bound(arr, 0, n,
                                    arr[i] + L);
 
        // find Number of elements between the ith
        // index and indexGreater since the Numbers
        // are sorted and the elements are distinct
        // from the points btw these indices represent
        // points within range (a[i] + 1 and a[i] + L)
        // both inclusive
        int numberOfElements = indexGreater - (i + 1);
 
        // if there are at least two elements in between
        // i and indexGreater find the Number of ways
        // to select two points out of these
        if (numberOfElements >= 2)
        {
            ways += (numberOfElements *
                    (numberOfElements - 1) / 2);
        }
    }
    return ways;
}
 
static int upper_bound(int[] a, int low,
                    int high, int element)
{
    while(low < high)
    {
        int middle = low + (high - low) / 2;
        if(a[middle] > element)
            high = middle;
        else
            low = middle + 1;
    }
    return low;
}
 
// Driver Code
public static void Main(String[] args)
{
    // set of n points on the X axis
    int []arr = { 1, 2, 3, 4 };
 
    int n = arr.Length;
    int L = 4;
 
    int ans = countTripletsLessThanL(n, L, arr);
 
    Console.WriteLine("Total Number of ways = " + ans);
}
}
 
// This code is contributed by PrinciRaj1992

Python3

# Python program to count ways to choose
# triplets such that the distance between
# the farthest points <= L '''
 
 
# Returns the number of triplets with the
# distance between farthest points <= L
def countTripletsLessThanL(n, L, arr):
    # sort the array
    arr = sorted(arr);
 
    ways = 0;
    for i in range(n):
 
        # find index of element greater than arr[i] + L
        indexGreater = upper_bound(arr, 0, n, arr[i] + L);
 
        # find Number of elements between the ith
        # index and indexGreater since the Numbers
        # are sorted and the elements are distinct
        # from the points btw these indices represent
        # points within range (a[i] + 1 and a[i] + L)
        # both inclusive
        numberOfElements = indexGreater - (i + 1);
 
        # if there are at least two elements in between
        # i and indexGreater find the Number of ways
        # to select two points out of these
 
        if (numberOfElements >= 2):
            ways += (numberOfElements * (numberOfElements - 1) / 2);
 
    return ways;
 
 
def upper_bound(a, low, high, element):
    while (low < high):
        middle = int(low + (high - low) / 2);
        if (a[middle] > element):
            high = middle;
        else:
            low = middle + 1;
 
    return low;
 
 
# Driver Code
if __name__ == '__main__':
    # set of n points on the X axis
    arr = [1, 2, 3, 4];
 
    n = len(arr);
    L = 4;
 
    ans = countTripletsLessThanL(n, L, arr);
 
    print("Total Number of ways = " , ans);
 
    # This code is contributed by 29AjayKumar

输出

Total Number of ways = 4

时间复杂度： O(NlogN) ，其中N是点数。