一行中不重叠的最大元素数

给定两个具有相同大小N的数组X和L。 X _i表示在无限线上的位置。 L _i表示第i个元素可以在两侧覆盖的范围。任务是选择最大数量的元素，以使两个选定的元素覆盖右侧或左侧部分时不会重叠。

注意：数组X已排序。

例子：

Input : x[] = {10, 15, 19, 20} , L[] = {4, 1, 3, 1}
Output : 4
Suppose, first element covers left side segment [6, 10]
second element covers left side segment 14, 15]
Third element covers left side segment [16, 19]
Fourth element covers right side segment [20, 21]

Input : x[] = {1, 3, 4, 5, 8}, L[] = {10, 1, 2, 2, 5}
Output : 4

方法：
这个问题可以贪婪地解决。我们总是可以使第一个元素覆盖左段，最后一个元素覆盖右段。对于其他元素，如果可能的话，尝试给出左边的片段，否则尝试给出右边的片段。如果它们都不可行，则保留该元素。

下面是上述方法的实现：

C++

// CPP program to find maximum number of 
// elements without overlapping in a line
#include 
using namespace std;
  
// Function to find maximum number of 
// elements without overlapping in a line
int Segment(int x[], int l[], int n)
{
    // If n = 1, then answer is one
    if (n == 1)
        return 1;
      
    // We can always make 1st element to cover 
    // left segment and nth the right segment
    int ans = 2;
          
          
    for (int i = 1; i < n - 1; i++)
    {
        // If left segment for ith element doesnt overlap
        // with i - 1 th element then do left
        if (x[i] - l[i] > x[i - 1])
            ans++;
  
        // else try towards right if possible
        else if (x[i] + l[i] < x[i + 1])
        {
            // update x[i] to right endpoint of 
            // segment covered by it
            x[i] = x[i] + l[i];
            ans++;
        }
    }
      
    // Return the required answer
    return ans;
}
  
// Driver code
int main()
{
    int x[] = {1, 3, 4, 5, 8}, l[] = {10, 1, 2, 2, 5};
      
    int n = sizeof(x) / sizeof(x[0]);
  
    // Function call
    cout << Segment(x, l, n);
  
    return 0;
}

Java

// Java program to find maximum number of 
// elements without overlapping in a line
import java.util.*;
  
class GFG
{
  
// Function to find maximum number of 
// elements without overlapping in a line
static int Segment(int x[], int l[], int n)
{
    // If n = 1, then answer is one
    if (n == 1)
        return 1;
      
    // We can always make 1st element to cover 
    // left segment and nth the right segment
    int ans = 2;
          
    for (int i = 1; i < n - 1; i++)
    {
        // If left segment for ith element 
        // doesn't overlap with i - 1 th
        // element then do left
        if (x[i] - l[i] > x[i - 1])
            ans++;
  
        // else try towards right if possible
        else if (x[i] + l[i] < x[i + 1])
        {
            // update x[i] to right endpoint of 
            // segment covered by it
            x[i] = x[i] + l[i];
            ans++;
        }
    }
      
    // Return the required answer
    return ans;
}
  
// Driver code
public static void main(String[] args) 
{
    int x[] = {1, 3, 4, 5, 8},
        l[] = {10, 1, 2, 2, 5};
      
    int n = x.length;
  
    // Function call
    System.out.println(Segment(x, l, n));
}
}
  
// This code is contributed by 29AjayKumar

Python3

# Python3 program to find maximum number of
# elements without overlapping in a line
  
# Function to find maximum number of
# elements without overlapping in a line
def Segment(x, l, n):
      
    # If n = 1, then answer is one
    if (n == 1):
        return 1
  
    # We can always make 1st element to cover
    # left segment and nth the right segment
    ans = 2
      
    for i in range(1, n - 1):
          
        # If left segment for ith element doesnt overlap
        # with i - 1 th element then do left
        if (x[i] - l[i] > x[i - 1]):
            ans += 1
  
        # else try towards right if possible
        elif (x[i] + l[i] < x[i + 1]):
              
            # update x[i] to right endpoof
            # segment covered by it
            x[i] = x[i] + l[i]
            ans += 1
  
    # Return the required answer
    return ans
  
# Driver code
x = [1, 3, 4, 5, 8]
l = [10, 1, 2, 2, 5]
  
n = len(x)
  
# Function call
print(Segment(x, l, n))
  
# This code is contributed 
# by Mohit Kumar

C#

// C# program to find maximum number of 
// elements without overlapping in a line
using System;
      
class GFG
{
  
// Function to find maximum number of 
// elements without overlapping in a line
static int Segment(int []x, int []l, int n)
{
    // If n = 1, then answer is one
    if (n == 1)
        return 1;
      
    // We can always make 1st element to cover 
    // left segment and nth the right segment
    int ans = 2;
          
    for (int i = 1; i < n - 1; i++)
    {
        // If left segment for ith element 
        // doesn't overlap with i - 1 th
        // element then do left
        if (x[i] - l[i] > x[i - 1])
            ans++;
  
        // else try towards right if possible
        else if (x[i] + l[i] < x[i + 1])
        {
            // update x[i] to right endpoint of 
            // segment covered by it
            x[i] = x[i] + l[i];
            ans++;
        }
    }
      
    // Return the required answer
    return ans;
}
  
// Driver code
public static void Main(String[] args) 
{
    int []x = {1, 3, 4, 5, 8};
    int []l = {10, 1, 2, 2, 5};
      
    int n = x.Length;
  
    // Function call
    Console.WriteLine(Segment(x, l, n));
}
}
  
// This code is contributed by PrinciRaj1992

输出：

4 

时间复杂度： O(N)