Ņemot vērā lielumu masīvu n uzdevums ir padarīt visu elementu vērtību vienādu ar minimālās izmaksas . Vērtības maiņas no x uz y izmaksas ir abs(x - y).
Piemēri:
Ievade: arr[] = [1 100 101]
Izvade : 100
Paskaidrojums: Mēs varam mainīt visas tā vērtības uz 100 ar minimālām izmaksām
|1 - 100| + |100 - 100| + |101 - 100| = 100Ievade : arr[] = [4 6]
Izvade : 2
Paskaidrojums: Mēs varam mainīt visas tā vērtības uz 5 ar minimālām izmaksām
|4 - 5| + |5 - 6| = 2Ievade: arr[] = [5 5 5 5]
Izvade:
Paskaidrojums: Visas vērtības jau ir vienādas.
[Naīvā pieeja] Izmantojot 2 ligzdotas cilpas — O(n^2) laiks un O(1) telpa
C++Lūdzu, ņemiet vērā, ka mūsu atbilde vienmēr var būt viena no masīva vērtībām. Pat otrajā iepriekš minētajā piemērā mēs varam alternatīvi izveidot abus kā 4 vai abus kā 6 par vienādām izmaksām.
Ideja ir apsvērt katru masīva vērtību kā potenciālo mērķa vērtību, pēc tam aprēķināt kopējās izmaksas, kas saistītas ar visu pārējo elementu pārveidošanu šajā mērķa vērtībā. Pārbaudot visas iespējamās mērķa vērtības, mēs varam atrast to, kas nodrošina minimālās kopējās reklāmguvumu izmaksas.
// C++ program to Make all array // elements equal with minimum cost #include
// Java program to Make all array // elements equal with minimum cost import java.util.*; class GfG { // Function which finds the minimum // cost to make array elements equal static int minCost(int[] arr) { int n = arr.length; int ans = Integer.MAX_VALUE; // Try each element as the target value for (int i = 0; i < n; i++) { int currentCost = 0; // Calculate cost of making all // elements equal to arr[i] for (int j = 0; j < n; j++) { currentCost += Math.abs(arr[j] - arr[i]); } // Update minimum cost if current cost is lower ans = Math.min(ans currentCost); } return ans; } public static void main(String[] args) { int[] arr = {1 100 101}; System.out.println(minCost(arr)); } }
# Python program to Make all array # elements equal with minimum cost # Function which finds the minimum # cost to make array elements equal def minCost(arr): n = len(arr) ans = float('inf') # Try each element as the target value for i in range(n): currentCost = 0 # Calculate cost of making all # elements equal to arr[i] for j in range(n): currentCost += abs(arr[j] - arr[i]) # Update minimum cost if current cost is lower ans = min(ans currentCost) return ans if __name__ == '__main__': arr = [1 100 101] print(minCost(arr))
// C# program to Make all array // elements equal with minimum cost using System; class GfG { // Function which finds the minimum // cost to make array elements equal static int minCost(int[] arr) { int n = arr.Length; int ans = int.MaxValue; // Try each element as the target value for (int i = 0; i < n; i++) { int currentCost = 0; // Calculate cost of making all // elements equal to arr[i] for (int j = 0; j < n; j++) { currentCost += Math.Abs(arr[j] - arr[i]); } // Update minimum cost if current cost is lower ans = Math.Min(ans currentCost); } return ans; } static void Main() { int[] arr = {1 100 101}; Console.WriteLine(minCost(arr)); } }
// JavaScript program to Make all array // elements equal with minimum cost // Function which finds the minimum // cost to make array elements equal function minCost(arr) { let n = arr.length; let ans = Number.MAX_SAFE_INTEGER; // Try each element as the target value for (let i = 0; i < n; i++) { let currentCost = 0; // Calculate cost of making all // elements equal to arr[i] for (let j = 0; j < n; j++) { currentCost += Math.abs(arr[j] - arr[i]); } // Update minimum cost if current cost is lower ans = Math.min(ans currentCost); } return ans; } let arr = [1 100 101]; console.log(minCost(arr));
Izvade
100
[Paredzamā pieeja — 1] Izmantojot bināro meklēšanu — O(n Log (diapazons)) laiks un O(1) telpa
Ideja ir izmantot bināro meklēšanu, lai efektīvi atrastu optimālo vērtību, uz kuru jāpārvērš visi masīva elementi. Tā kā kopējo izmaksu funkcija veido izliektu līkni (vispirms samazinās, tad palielinās) iespējamo vērtību diapazonā, mēs varam izmantot bināro meklēšanu, lai atrastu šīs līknes minimālo punktu, salīdzinot izmaksas viduspunktā ar izmaksām viduspunktā mīnus viena, kas norāda, kurā virzienā meklēt tālāk.
Soli pa solim pieeja:
- Atrodiet masīvā minimālo un maksimālo vērtību, lai noteiktu meklēšanas diapazonu
- Izmantojiet bināro meklēšanu starp minimālo un maksimālo vērtību, lai atrastu optimālo mērķa vērtību
- Katrai izmēģinājuma vērtībai aprēķiniet kopējās izmaksas par visu masīva elementu pārveidošanu šajā vērtībā
- Lai noteiktu meklēšanas virzienu, salīdziniet izmaksas pašreizējā viduspunktā ar izmaksām viduspunktā mīnus viens
- Turpiniet sašaurināt meklēšanas diapazonu, līdz atrodat minimālo izmaksu konfigurāciju
// C++ program to Make all array // elements equal with minimum cost #include
// Java program to Make all array // elements equal with minimum cost import java.util.*; class GfG { // Function to find the cost of changing // array values to mid. static int findCost(int[] arr int mid) { int n = arr.length; int ans = 0; for (int i = 0; i < n; i++) { ans += Math.abs(arr[i] - mid); } return ans; } // Function which finds the minimum cost // to make array elements equal. static int minCost(int[] arr) { int n = arr.length; int mini = Integer.MAX_VALUE maxi = Integer.MIN_VALUE; // Find the minimum and maximum value. for (int i = 0; i < n; i++) { mini = Math.min(mini arr[i]); maxi = Math.max(maxi arr[i]); } int s = mini e = maxi; int ans = Integer.MAX_VALUE; while (s <= e) { int mid = s + (e - s) / 2; int cost1 = findCost(arr mid); int cost2 = findCost(arr mid - 1); if (cost1 < cost2) { ans = cost1; s = mid + 1; } else { e = mid - 1; } } return ans; } public static void main(String[] args) { int[] arr = {1 100 101}; System.out.println(minCost(arr)); } }
# Python program to Make all array # elements equal with minimum cost # Function to find the cost of changing # array values to mid. def findCost(arr mid): n = len(arr) ans = 0 for i in range(n): ans += abs(arr[i] - mid) return ans # Function which finds the minimum cost # to make array elements equal. def minCost(arr): n = len(arr) mini = float('inf') maxi = float('-inf') # Find the minimum and maximum value. for i in range(n): mini = min(mini arr[i]) maxi = max(maxi arr[i]) s = mini e = maxi ans = float('inf') while s <= e: mid = s + (e - s) // 2 cost1 = findCost(arr mid) cost2 = findCost(arr mid - 1) if cost1 < cost2: ans = cost1 s = mid + 1 else: e = mid - 1 return ans if __name__ == '__main__': arr = [1 100 101] print(minCost(arr))
// C# program to Make all array // elements equal with minimum cost using System; class GfG { // Function to find the cost of changing // array values to mid. static int findCost(int[] arr int mid) { int n = arr.Length; int ans = 0; for (int i = 0; i < n; i++) { ans += Math.Abs(arr[i] - mid); } return ans; } // Function which finds the minimum cost // to make array elements equal. static int minCost(int[] arr) { int n = arr.Length; int mini = int.MaxValue maxi = int.MinValue; // Find the minimum and maximum value. for (int i = 0; i < n; i++) { mini = Math.Min(mini arr[i]); maxi = Math.Max(maxi arr[i]); } int s = mini e = maxi; int ans = int.MaxValue; while (s <= e) { int mid = s + (e - s) / 2; int cost1 = findCost(arr mid); int cost2 = findCost(arr mid - 1); if (cost1 < cost2) { ans = cost1; s = mid + 1; } else { e = mid - 1; } } return ans; } static void Main() { int[] arr = {1 100 101}; Console.WriteLine(minCost(arr)); } }
// JavaScript program to Make all array // elements equal with minimum cost // Function to find the cost of changing // array values to mid. function findCost(arr mid) { let n = arr.length; let ans = 0; for (let i = 0; i < n; i++) { ans += Math.abs(arr[i] - mid); } return ans; } // Function which finds the minimum cost // to make array elements equal. function minCost(arr) { let n = arr.length; let mini = Number.MAX_SAFE_INTEGER maxi = Number.MIN_SAFE_INTEGER; // Find the minimum and maximum value. for (let i = 0; i < n; i++) { mini = Math.min(mini arr[i]); maxi = Math.max(maxi arr[i]); } let s = mini e = maxi; let ans = Number.MAX_SAFE_INTEGER; while (s <= e) { let mid = Math.floor(s + (e - s) / 2); let cost1 = findCost(arr mid); let cost2 = findCost(arr mid - 1); if (cost1 < cost2) { ans = cost1; s = mid + 1; } else { e = mid - 1; } } return ans; } let arr = [1 100 101]; console.log(minCost(arr));
Izvade
100
[Paredzamā pieeja — 2] Izmantojot kārtošanu — O(n Log n) laiks un O(1) telpa
Ideja ir atrast optimālo vērtību, līdz kurai būtu jāizlīdzina visi elementi, kuriem jābūt vienam no esošajiem masīva elementiem. Vispirms kārtojot masīvu un pēc tam atkārtojot katru elementu kā potenciālo mērķa vērtību, mēs aprēķinām visu pārējo elementu pārveidošanas izmaksas uz šo vērtību, efektīvi izsekojot elementu summu pa kreisi un pa labi no pašreizējās pozīcijas.
Soli pa solim pieeja:
- Kārtojiet masīvu, lai apstrādātu elementus augošā secībā.
- Katram elementam kā potenciālajai mērķa vērtībai aprēķiniet divas izmaksas: mazāku elementu pacelšana uz augšu un lielāku elementu uz leju.
- Izsekojiet summas pa kreisi un pa labi, lai efektīvi aprēķinātu šīs izmaksas nemainīgā laikā vienā iterācijā.
- Mazāku elementu palielināšana izmaksām: (pašreizējā vērtība × mazāku elementu skaits) - (mazāku elementu summa)
- Lielāku elementu samazināšana izmaksām: (lielāko elementu summa) - (pašreizējā vērtība × lielāko elementu skaits)
- Salīdziniet pašreizējās izmaksas ar minimālajām izmaksām.
// C++ program to Make all array // elements equal with minimum cost #include
// Java program to Make all array // elements equal with minimum cost import java.util.*; class GfG { // Function which finds the minimum cost // to make array elements equal. static int minCost(int[] arr) { int n = arr.length; // Sort the array Arrays.sort(arr); // Variable to store sum of elements // to the right side. int right = 0; for (int i = 0; i < n; i++) { right += arr[i]; } int ans = Integer.MAX_VALUE; int left = 0; for (int i = 0; i < n; i++) { // Remove the current element from right sum. right -= arr[i]; // Find cost of incrementing left side elements int leftCost = i * arr[i] - left; // Find cost of decrementing right side elements. int rightCost = right - (n - 1 - i) * arr[i]; ans = Math.min(ans leftCost + rightCost); // Add current value to left sum left += arr[i]; } return ans; } public static void main(String[] args) { int[] arr = {1 100 101}; System.out.println(minCost(arr)); } }
# Python program to Make all array # elements equal with minimum cost # Function which finds the minimum cost # to make array elements equal. def minCost(arr): n = len(arr) # Sort the array arr.sort() # Variable to store sum of elements # to the right side. right = sum(arr) ans = float('inf') left = 0 for i in range(n): # Remove the current element from right sum. right -= arr[i] # Find cost of incrementing left side elements leftCost = i * arr[i] - left # Find cost of decrementing right side elements. rightCost = right - (n - 1 - i) * arr[i] ans = min(ans leftCost + rightCost) # Add current value to left sum left += arr[i] return ans if __name__ == '__main__': arr = [1 100 101] print(minCost(arr))
// C# program to Make all array // elements equal with minimum cost using System; class GfG { // Function which finds the minimum cost // to make array elements equal. static int minCost(int[] arr) { int n = arr.Length; // Sort the array Array.Sort(arr); // Variable to store sum of elements // to the right side. int right = 0; for (int i = 0; i < n; i++) { right += arr[i]; } int ans = int.MaxValue; int left = 0; for (int i = 0; i < n; i++) { // Remove the current element from right sum. right -= arr[i]; // Find cost of incrementing left side elements int leftCost = i * arr[i] - left; // Find cost of decrementing right side elements. int rightCost = right - (n - 1 - i) * arr[i]; ans = Math.Min(ans leftCost + rightCost); // Add current value to left sum left += arr[i]; } return ans; } static void Main() { int[] arr = {1 100 101}; Console.WriteLine(minCost(arr)); } }
// JavaScript program to Make all array // elements equal with minimum cost // Function which finds the minimum cost // to make array elements equal. function minCost(arr) { let n = arr.length; // Sort the array arr.sort((a b) => a - b); // Variable to store sum of elements // to the right side. let right = 0; for (let i = 0; i < n; i++) { right += arr[i]; } let ans = Number.MAX_SAFE_INTEGER; let left = 0; for (let i = 0; i < n; i++) { // Remove the current element from right sum. right -= arr[i]; // Find cost of incrementing left side elements let leftCost = i * arr[i] - left; // Find cost of decrementing right side elements. let rightCost = right - (n - 1 - i) * arr[i]; ans = Math.min(ans leftCost + rightCost); // Add current value to left sum left += arr[i]; } return ans; } let arr = [1 100 101]; console.log(minCost(arr));
Izvade
100Izveidojiet viktorīnu