Intersección máxima posible al mover los centros de los segmentos de línea

Dados tres puntos en el eje X que denota el centro de tres segmentos de línea. La longitud del segmento de línea también se da como L. La tarea es mover el centro de los segmentos de línea dados una distancia de K para maximizar la longitud de la intersección entre las tres líneas. 
Ejemplos: 
 

Entrada: c1 = 1, c2 = 2, c3 = 3, L = 1, K = 0 
Salida: 0 
Como no se puede mover ningún centro, no hay intersección entre tres segmentos {(0.5, 1.5), (1.5, 2.5 ), (2.5, 3.5)}.
Entrada: c1 = 1, c2 = 2, c3 = 3, L = 1, K = 1 
Salida: 1 
Los centros 1 y 3 se pueden desplazar 1 unidad adelante y adelante respectivamente para superponerse con el centro 2

Los segmentos de línea serán los siguientes: 
 

1. Línea-Segmento 1: (Centro1-L/2, Centro1+L/2)
2. Segmento de línea 2: (Centro2-L/2, Centro2+L/2)
3. Línea-Segmento 3: (Centro3-L/2, Centro3+L/2)

Enfoque: inicialmente ordene los centros, ya que el segmento central nunca se moverá, ya que los segmentos izquierdo y derecho siempre pueden acercarse a su centro para aumentar la longitud de la intersección. Habrá tres casos que se tratarán: 
 

• Caso 1: Cuando la distancia entre los centros de la derecha y la izquierda es mayor o igual a 2*K+L en tal escenario la intersección siempre será cero. No es posible la superposición, ya que incluso después de desplazar ambos centros con una distancia K todavía, estarán alejados a una distancia L o más.
• Caso 2: Cuando la distancia entre los centros de la derecha y la izquierda es mayor o igual a 2*K en tal escenario existe una intersección que es igual a (2 * k – (centro[2] – centro[0] – longitud )) que se puede calcular usando matemáticas simples.
• Caso 3: Cuando la distancia entre los centros de la derecha y la izquierda es inferior a 2*K en tal caso ambos centros pueden coincidir con el centro medio. Por lo tanto, la intersección es L.

A continuación se muestra la implementación del enfoque anterior: 
 

#include <bits/stdc++.h>
using namespace std;
 
// Function to print the maximum intersection
int max_intersection(int* center, int length, int k)
{
    sort(center, center + 3);
 
    // Case 1
    if (center[2] - center[0] >= 2 * k + length) {
        return 0;
    }
 
    // Case 2
    else if (center[2] - center[0] >= 2 * k) {
        return (2 * k - (center[2] - center[0] - length));
    }
 
    // Case 3
    else
        return length;
}
 
// Driver Code
int main()
{
    int center[3] = { 1, 2, 3 };
    int L = 1;
    int K = 1;
    cout << max_intersection(center, L, K);
}

// Java implementation
// of above approach
import java.util.*;
 
class GFG
{
 
// Function to print the
// maximum intersection
static int max_intersection(int center[],
                            int length, int k)
{
    Arrays.sort(center);
 
    // Case 1
    if (center[2] - center[0] >= 2 * k + length)
    {
        return 0;
    }
 
    // Case 2
    else if (center[2] - center[0] >= 2 * k)
    {
        return (2 * k - (center[2] -
                center[0] - length));
    }
 
    // Case 3
    else
        return length;
}
 
// Driver Code
public static void main(String args[])
{
    int center[] = { 1, 2, 3 };
    int L = 1;
    int K = 1;
    System.out.println( max_intersection(center, L, K));
}
}
 
// This code is contributed
// by Arnab Kundu

# Python3 implementation of above approach
 
# Function to print the maximum intersection
def max_intersection(center, length, k):
 
    center.sort();
 
    # Case 1
    if (center[2] - center[0] >= 2 * k + length):
        return 0;
 
    # Case 2
    elif (center[2] - center[0] >= 2 * k):
        return (2 * k - (center[2] - center[0] - length));
 
    # Case 3
    else:
        return length;
 
# Driver Code
center = [1, 2, 3];
L = 1;
K = 1;
print(max_intersection(center, L, K));
 
# This code is contributed
# by mits

// C# implementation
// of above approach
using System;
 
class GFG
{
 
// Function to print the
// maximum intersection
static int max_intersection(int []center,
                            int length, int k)
{
    Array.Sort(center);
 
    // Case 1
    if (center[2] - center[0] >= 2 * k + length)
    {
        return 0;
    }
 
    // Case 2
    else if (center[2] -
             center[0] >= 2 * k)
    {
        return (2 * k - (center[2] -
                         center[0] - length));
    }
 
    // Case 3
    else
        return length;
}
 
// Driver Code
public static void Main()
{
    int []center = { 1, 2, 3 };
    int L = 1;
    int K = 1;
    Console.WriteLine(max_intersection(center, L, K));
}
}
 
// This code is contributed
// by Subhadeep Gupta

<?php
// PHP implementation
// of above approach
 
// Function to print the
// maximum intersection
function max_intersection($center,
                          $length, $k)
{
    sort($center);
 
    // Case 1
    if ($center[2] -
        $center[0] >= 2 * $k + $length)
    {
        return 0;
    }
 
    // Case 2
    else if ($center[2] -
             $center[0] >= 2 * $k)
    {
        return (2 * $k - ($center[2] -
             $center[0] - $length));
    }
 
    // Case 3
    else
        return $length;
}
 
// Driver Code
$center = array(1, 2, 3);
$L = 1;
$K = 1;
echo max_intersection($center, $L, $K);
 
// This code is contributed
// by mits
?>

<script>
 
// Javascript implementation
// of above approach
 
// Function to print the
// maximum intersection
function max_intersection(center,length, k)
{
    center.sort();
   
    // Case 1
    if (center[2] - center[0] >= 2 * k + length)
    {
        return 0;
    }
   
    // Case 2
    else if (center[2] - center[0] >= 2 * k)
    {
        return (2 * k - (center[2] -
                center[0] - length));
    }
   
    // Case 3
    else
        return length;
}
  
 
// driver program
     
    let center = [ 1, 2, 3 ];
    let L = 1;
    let K = 1;
    document.write( max_intersection(center, L, K));
    
</script>

1