Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Minimum length of the shortest path of a triangle

  • Last Updated : 03 May, 2021

Given N points on the plane, ( X1, Y1 ), ( X2, Y2 ), ( X3, Y3 ), ……, ( XN, YN ). The task is to calculate the minimum length of the shorter side of the triangle. and the path or points to place an isosceles triangle with any two sides of the triangle on the coordinate axis ( X axis and Y axis ) to cover all points.
Note: A point is covered if it lies inside the triangle or on the side of the triangle.
Examples:
 

Input: (1, 3), (1, 1), (2, 1), (2, 2) 
Output: Length -> 4 , Path -> ( 1, 4 ) and ( 4, 1 )
Input: (1, 2), (1, 1), (2, 1) 
Output: Length -> 3 , Path -> ( 1, 3 ) and ( 3, 1 )

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 



 

In the first example, the minimum length of the shortest path is equal to the maximum sum of the points, which is 1+3 or 2+2. So the path which will cover all the points is (1, 4) and (4, 1) on the coordinate axis.
Below is the step by step algorithm to solve this problem: 
 

  1. Initialize ‘N’ points on a plane.
  2. Traverse through each point and find the sum of each point and store it in a variable ‘answer’.
  3. Replace the next maximum sum of the points with the previous sum.
  4. Then you will get the path on a coordinate axis ( 1, answer ) and ( answer, 1 ) which will cover all the points of isosceles triangle.

Below is the implementation of above algorithm: 
 

C++




// C++ program to illustrate
// the above problem
#include <bits/stdc++.h>
using namespace std;
#define ll long long
 
// function to get the minimum length of
// the shorter side of the triangle
void shortestLength(int n, int x[], int y[])
{
        int answer = 0;
 
    // traversing through each points on the plane
    int i = 0;
    while (n--) {
        // if sum of a points is greater than the
        // previous one, the maximum gets replaced
        if (x[i] + y[i] > answer)
            answer = x[i] + y[i];
 
        i++;
    }
 
    // print the length
    cout << "Length -> " << answer << endl;
    cout << "Path -> "
         << "( 1, " << answer << " )"
         << "and ( " << answer << ", 1 )";
}
 
// Driver code
int main()
{
    // initialize the number of points
    int n = 4;
 
    // points on the plane
    int x[n] = { 1, 4, 2, 1 };
    int y[n] = { 4, 1, 1, 2 };
 
    shortestLength(n, x, y);
 
    return 0;
}

Java




// Java program to illustrate
// the above problem
class GFG
{
 
// function to get the minimum length of
// the shorter side of the triangle
static void shortestLength(int n, int x[],
                           int y[])
{
    int answer = 0;
 
    // traversing through each
    // points on the plane
    int i = 0;
    while (n != 0 && i < x.length)
    {
        // if sum of a points is greater
        // than the previous one, the
        // maximum gets replaced
        if (x[i] + y[i] > answer)
            answer = x[i] + y[i];
 
        i++;
    }
 
    // print the length
    System.out.println("Length -> " + answer );
    System.out.println("Path -> " +
                       "( 1, " + answer + " )" +
                       "and ( " + answer + ", 1 )");
}
 
// Driver code
public static void main(String[] args)
{
    // initialize the number of points
    int n = 4;
 
    // points on the plane
    int x[] = new int[] { 1, 4, 2, 1 };
    int y[] = new int[] { 4, 1, 1, 2 };
 
    shortestLength(n, x, y);
}
}
 
// This code is contributed
// by Prerna Saini

Python 3




# Python 3 program to illustrate
# the above problem
 
# function to get the minimum length of
# the shorter side of the triangle
def shortestLength(n, x, y):
    answer = 0
 
    # traversing through each
    # points on the plane
    i = 0
    while n > 0:
         
        # if sum of a points is greater
        # than the previous one, the
        # maximum gets replaced
        if (x[i] + y[i] > answer):
            answer = x[i] + y[i]
 
        i += 1
        n -= 1
 
    # print the length
    print("Length -> "+ str(answer))
    print( "Path -> "+
        "( 1, " +str(answer)+ " )"+
        "and ( "+str( answer) +", 1 )")
 
# Driver code
if __name__ == "__main__":
     
    # initialize the number of points
    n = 4
 
    # points on the plane
    x = [ 1, 4, 2, 1 ]
    y = [ 4, 1, 1, 2 ]
    shortestLength(n, x, y)
 
# This code is contributed
# by ChitraNayal

C#




// C# program to illustrate
// the above problem
using System;
 
class GFG
{
 
// function to get the minimum
// length of the shorter side
// of the triangle
static void shortestLength(int n, int[] x,
                           int[] y)
{
    int answer = 0;
 
    // traversing through each
    // points on the plane
    int i = 0;
    while (n != 0 && i < x.Length)
    {
        // if sum of a points is greater
        // than the previous one, the
        // maximum gets replaced
        if (x[i] + y[i] > answer)
            answer = x[i] + y[i];
 
        i++;
    }
 
    // print the length
    Console.WriteLine("Length -> " + answer);
    Console.WriteLine("Path -> " +
                      "( 1, " + answer + " )" +
                      "and ( " + answer + ", 1 )");
}
 
// Driver code
static public void Main ()
{
     
    // initialize the
    // number of points
    int n = 4;
 
    // points on the plane
    int[] x = new int[] { 1, 4, 2, 1 };
    int[] y = new int[] { 4, 1, 1, 2 };
 
    shortestLength(n, x, y);
}
}
 
// This code is contributed by Mahadev

PHP




<?php
// PHP program to illustrate
// the above problem
 
// function to get the minimum length of
// the shorter side of the triangle
function shortestLength($n, &$x, &$y)
{
    $answer = 0;
 
    // traversing through each
    // points on the plane
    $i = 0;
    while ($n--)
    {
         
        // if sum of a points is greater
        // than the previous one, the
        // maximum gets replaced
        if ($x[$i] + $y[$i] > $answer)
            $answer = $x[$i] + $y[$i];
 
        $i++;
    }
 
    // print the length
    echo "Length -> ".$answer."\n";
    echo "Path -> ". "( 1, " .$answer ." )".
         "and ( " .$answer . ", 1 )";
}
 
// Driver code
 
// initialize the number of points
$n = 4;
 
// points on the plane
$x = array(1, 4, 2, 1 );
$y = array(4, 1, 1, 2 );
 
shortestLength($n, $x, $y);
 
// This code is contributed
// by ChitraNayal
?>

Javascript




<script>
 
// Javascript program to illustrate
// the above problem
 
// function to get the minimum length of
// the shorter side of the triangle
function shortestLength(n, x, y)
{
    let answer = 0;
 
    // traversing through each
    // polets on the plane
    let i = 0;
    while (n != 0 && i < x.length)
    {
        // if sum of a polets is greater
        // than the previous one, the
        // maximum gets replaced
        if (x[i] + y[i] > answer)
            answer = x[i] + y[i];
 
        i++;
    }
 
    // prlet the length
    document.write("Length -> " + answer + "<br/>");
    document.write("Path -> " +
                       "( 1, " + answer + " )" +
                       "and ( " + answer + ", 1 )");
}
 
 
// Driver Code
 
    // initialize the number of polets
    let n = 4;
 
    // polets on the plane
    let x = [ 1, 4, 2, 1 ];
    let y = [ 4, 1, 1, 2 ];
 
    shortestLength(n, x, y);
 
</script>
Output: 
Length -> 5
Path -> ( 1, 5 )and ( 5, 1 )

 




My Personal Notes arrow_drop_up

Start Your Coding Journey Now!