Find triplet with minimum sum
Last Updated :
06 Apr, 2023
Given an array of distinct integers arr[]. The task is to find a triplet(a group of 3 elements) that has the minimum sum.
Note: The size of the array is always greater than two.
Examples:
Input : arr[] = {1, 2, 3, 4, -1, 5, -2}
Output : -2
1 - 1 - 2 = -2
Input : arr[] = {5, 6, 0, 0, 1}
Output : 1
0 + 0 + 1.
Naive Approach: The idea is to generate all possible triplets in the array and then compare sum of one triplet with other triplets, then find the minimum sum.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int getMinimumSum( int arr[] , int n)
{
int ans = INT_MAX;
for ( int i = 0; i < n - 2; i++) {
for ( int j = i + 1; j < n - 1; j++) {
for ( int k = j + 1; k < n; k++) {
ans = min(ans, arr[i] + arr[j] + arr[k]);
}
}
}
return ans;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, -1, 5, -2 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << getMinimumSum(arr, n) << endl;
return 0;
}
|
Java
class GFG
{
static int getMinimumSum( int arr[] , int n)
{
int ans = Integer.MAX_VALUE;
for ( int i = 0 ; i < n - 2 ; i++)
{
for ( int j = i + 1 ; j < n - 1 ; j++)
{
for ( int k = j + 1 ; k < n; k++)
{
ans = Math.min(ans, arr[i] +
arr[j] + arr[k]);
}
}
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , - 1 , 5 , - 2 };
int n = arr.length;
System.out.print(getMinimumSum(arr, n) + "\n" );
}
}
|
Python3
import sys
def getMinimumSum(arr, n):
ans = sys.maxsize;
for i in range (n - 2 ):
for j in range (i + 1 , n - 1 ):
for k in range (j + 1 , n):
ans = min (ans, arr[i] + arr[j] + arr[k]);
return ans;
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 5 , - 1 , 5 , - 2 ];
n = len (arr);
print (getMinimumSum(arr, n));
|
C#
using System;
class GFG
{
static int getMinimumSum( int []arr, int n)
{
int ans = int .MaxValue;
for ( int i = 0; i < n - 2; i++)
{
for ( int j = i + 1; j < n - 1; j++)
{
for ( int k = j + 1; k < n; k++)
{
ans = Math.Min(ans, arr[i] +
arr[j] + arr[k]);
}
}
}
return ans;
}
public static void Main()
{
int []arr = { 1, 2, 3, 4, 5, -1, 5, -2 };
int n = arr.Length;
Console.WriteLine(getMinimumSum(arr, n));
}
}
|
Javascript
<script>
function getMinimumSum(arr, n)
{
let ans = Number.MAX_SAFE_INTEGER;
for (let i = 0; i < n - 2; i++) {
for (let j = i + 1; j < n - 1; j++)
{
for (let k = j + 1; k < n; k++)
{
ans = Math.min(ans, arr[i] +
arr[j] + arr[k]);
}
}
}
return ans;
}
let arr = [ 1, 2, 3, 4, 5, -1, 5, -2 ];
let n = arr.length;
document.write(getMinimumSum(arr, n) + "<br>" );
</script>
|
Time Complexity: 0(n^3)
Auxiliary Space: 0(1)
Efficient approach: The idea is to traverse the array and compute minimum, second minimum and third minimum element present in the array and print the sum of these three elements.
Below is the implementation of the above approach:
CPP
#include <bits/stdc++.h>
using namespace std;
int getMinimumSum( int arr[] , int n)
{
int fMin = INT_MAX, sMin = INT_MAX, tMin = INT_MAX;
for ( int i = 0; i < n; i++) {
if (arr[i] < fMin) {
tMin = sMin;
sMin = fMin;
fMin = arr[i];
}
else if (arr[i] < sMin) {
tMin = sMin;
sMin = arr[i];
}
else if (arr[i] < tMin) {
tMin = arr[i];
}
}
return (fMin + sMin + tMin);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, -1, 5, -2 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << getMinimumSum(arr, n) << endl;
return 0;
}
|
Java
class GFG
{
static int getMinimumSum( int arr[] , int n)
{
int fMin = Integer.MAX_VALUE,
sMin = Integer.MAX_VALUE,
tMin = Integer.MAX_VALUE;
for ( int i = 0 ; i < n; i++)
{
if (arr[i] < fMin)
{
tMin = sMin;
sMin = fMin;
fMin = arr[i];
}
else if (arr[i] < sMin)
{
tMin = sMin;
sMin = arr[i];
}
else if (arr[i] < tMin)
{
tMin = arr[i];
}
}
return (fMin + sMin + tMin);
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , - 1 , 5 , - 2 };
int n = arr.length;
System.out.print(getMinimumSum(arr, n) + "\n" );
}
}
|
Python3
import sys
def getMinimumSum(arr, n):
fMin = sys.maxsize;
sMin = sys.maxsize;
tMin = sys.maxsize;
for i in range (n):
if (arr[i] < fMin):
tMin = sMin;
sMin = fMin;
fMin = arr[i];
elif (arr[i] < sMin):
tMin = sMin;
sMin = arr[i];
elif (arr[i] < tMin):
tMin = arr[i];
return (fMin + sMin + tMin);
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 5 , - 1 , 5 , - 2 ];
n = len (arr);
print (getMinimumSum(arr, n));
|
C#
using System;
class GFG
{
static int getMinimumSum( int []arr, int n)
{
int fMin = int .MaxValue,
sMin = int .MaxValue,
tMin = int .MaxValue;
for ( int i = 0; i < n; i++)
{
if (arr[i] < fMin)
{
tMin = sMin;
sMin = fMin;
fMin = arr[i];
}
else if (arr[i] < sMin)
{
tMin = sMin;
sMin = arr[i];
}
else if (arr[i] < tMin)
{
tMin = arr[i];
}
}
return (fMin + sMin + tMin);
}
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4, 5, -1, 5, -2 };
int n = arr.Length;
Console.Write(getMinimumSum(arr, n) + "\n" );
}
}
|
Javascript
<script>
function getMinimumSum(arr , n)
{
var fMin = 1000000000, sMin = 1000000000,
tMin = 1000000000;
for ( var i = 0; i < n; i++) {
if (arr[i] < fMin) {
tMin = sMin;
sMin = fMin;
fMin = arr[i];
}
else if (arr[i] < sMin) {
tMin = sMin;
sMin = arr[i];
}
else if (arr[i] < tMin) {
tMin = arr[i];
}
}
return (fMin + sMin + tMin);
}
var arr = [1, 2, 3, 4, 5, -1, 5, -2];
var n = arr.length;
document.write( getMinimumSum(arr, n));
</script>
|
Time Complexity: 0(n)
Auxiliary Space: 0(1)
Another Approach: Using Sorting
The idea is to sort the array given in the input. After that first three elements of the array will form a triplet that will give a minimum sum because those are the three minimum elements of the array.
Code-
C++
#include <bits/stdc++.h>
using namespace std;
int getMinimumSum( int arr[], int n)
{
sort(arr, arr + n);
return (arr[0] + arr[1] + arr[2]);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, -1, 5, -2 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << getMinimumSum(arr, n) << endl;
return 0;
}
|
Java
import java.util.*;
class Main
{
static int getMinimumSum( int arr[], int n) {
Arrays.sort(arr);
return (arr[ 0 ] + arr[ 1 ] + arr[ 2 ]);
}
public static void main(String[] args) {
int arr[] = { 1 , 2 , 3 , 4 , 5 , - 1 , 5 , - 2 };
int n = arr.length;
System.out.println(getMinimumSum(arr, n));
}
}
|
Python3
def getMinimumSum(arr, n):
arr.sort()
return (arr[ 0 ] + arr[ 1 ] + arr[ 2 ])
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 5 , - 1 , 5 , - 2 ]
n = len (arr)
print (getMinimumSum(arr, n))
|
C#
using System;
class Program {
static int GetMinimumSum( int [] arr, int n) {
Array.Sort(arr);
return (arr[0] + arr[1] + arr[2]);
}
static void Main( string [] args) {
int [] arr = { 1, 2, 3, 4, 5, -1, 5, -2 };
int n = arr.Length;
Console.WriteLine(GetMinimumSum(arr, n));
}
}
|
Javascript
function getMinimumSum(arr) {
arr.sort((a, b) => a - b);
return (arr[0] + arr[1] + arr[2]);
}
const arr = [1, 2, 3, 4, 5, -1, 5, -2];
console.log(getMinimumSum(arr));
|
Output-
-2
Time Complexity: O(nlogn),in sorting
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...