Related Articles

# Minimize total time taken by two persons to visit N cities such that none of them meet

• Difficulty Level : Hard
• Last Updated : 31 Mar, 2021

Given an array arr[] of size N, where arr[i] is the time required to visit ith city, the task is to find the minimum total time required to visit all N cities by two persons such that none of them meet in any of the cities.

Examples:

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.

Input: arr[] = {2, 8, 3}
Output: 16
Explanation:
Visiting cities in below given order will take minimum time:
First person: 2nd city → 1st city → 3rd city
Second person: 1st city → 3rd city → 2nd city.

Input: arr[]={1, 10, 6, 7, 5}
Output: 29

Approach: The given problem can be solved based on the following observations:

• Suppose ith city takes the longest time T to visit and the total time to visit all cities by one person is the sum of all array elements, say sum.
• If the 1st person visits the ith city, then in T time, the second person will visit other cities in that time, if possible.
• If the value T is at most (sum – T), then both people can visit the place individually in sum time.
• Otherwise, the 2nd person will have to wait to visit the ith city. Then, the total time required will be 2 * T as the 2nd person will be able to visit the ith city only if the first person comes out.
• Therefore, from the above observations, the answer will be the maximum of 2 * T and sum.

Therefore, from the above observations, find the sum of the array elements/a> and find the maximum element present in the array and print the maximum among twice the maximum element and the sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum time``// to visit all the cities such that``// both the person never meets``void` `minimumTime(``int``* arr, ``int` `n)``{``    ``// Initialize sum as 0``    ``int` `sum = 0;` `    ``// Find the maximum element``    ``int` `T = *max_element(arr, arr + n);` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Increment sum by arr[i]``        ``sum += arr[i];``    ``}` `    ``// Print maximum of 2*T and sum``    ``cout << max(2 * T, sum);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 8, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``minimumTime(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{``      ` `// Function to find the minimum time``// to visit all the cities such that``// both the person never meets``static` `void` `minimumTime(``int``[] arr, ``int` `n)``{``  ` `    ``// Initialize sum as 0``    ``int` `sum = ``0``;` `    ``// Find the maximum element``    ``int` `T = Arrays.stream(arr).max().getAsInt();` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Increment sum by arr[i]``        ``sum += arr[i];``    ``}` `    ``// Print maximum of 2*T and sum``    ``System.out.println(Math.max(``2` `* T, sum));``}``  ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``2``, ``8``, ``3` `};``    ``int` `N = arr.length;` `    ``// Function Call``    ``minimumTime(arr, N);``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum time``# to visit all the cities such that``# both the person never meets``def` `minimumTime(arr, n):``  ` `  ``# Initialize sum as 0``    ``sum` `=` `0` `    ``# Find the maximum element``    ``T ``=` `max``(arr)` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):``      ` `        ``# Increment sum by arr[i]``        ``sum` `+``=` `arr[i]` `    ``# Prmaximum of 2*T and sum``    ``print``(``max``(``2` `*` `T, ``sum``))` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``2``, ``8``, ``3``]``    ``N ``=` `len``(arr)` `    ``# Function Call``    ``minimumTime(arr, N)` `    ``# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Linq;``class` `GFG``{``      ` `// Function to find the minimum time``// to visit all the cities such that``// both the person never meets``static` `void` `minimumTime(``int``[] arr, ``int` `n)``{``  ` `    ``// Initialize sum as 0``    ``int` `sum = 0;` `    ``// Find the maximum element``    ``int` `T = arr.Min();` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `        ``// Increment sum by arr[i]``        ``sum += arr[i];``    ``}` `    ``// Print maximum of 2*T and sum``    ``Console.WriteLine(Math.Max(2 * T, sum));``}``  ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 2, 8, 3 };``    ``int` `N = arr.Length;` `    ``// Function Call``    ``minimumTime(arr, N);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`16`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up