Related Articles
Minimize total time taken by two persons to visit N cities such that none of them meet
• Difficulty Level : Medium
• Last Updated : 19 Jan, 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:

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`

Output:

`16`

Time Complexity: O(N)
Auxiliary Space: O(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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :