Annettu joukko kokoja n tehtävänä on tehdä kaikkien elementtien arvoksi yhtä suuri vähimmäiskustannukset . Arvon muuttaminen x:stä y:ksi maksaa abs(x - y).
Esimerkkejä:
Syöte: arr[] = [1 100 101]
Lähtö : 100
Selitys: Voimme muuttaa kaikki sen arvot 100:aan pienin kustannuksin
|1 - 100| + |100 - 100| + |101 - 100| = 100Syöte : arr[] = [4 6]
Lähtö : 2
Selitys: Voimme muuttaa kaikki sen arvot 5:ksi pienin kustannuksin
|4 - 5| + |5 - 6| = 2Syöte: arr[] = [5 5 5 5]
Lähtö:
Selitys: Kaikki arvot ovat jo samat.
[Naiivi lähestymistapa] Käyttämällä kahta sisäkkäistä silmukkaa - O(n^2) aika ja O(1) avaruus
C++Huomaa, että vastauksemme voi aina olla jokin taulukon arvoista. Jopa yllä olevassa toisessa esimerkissä voimme vaihtoehtoisesti tehdä molemmat 4:ksi tai molemmat 6:ksi samalla hinnalla.
Ajatuksena on pitää jokaista taulukon arvoa mahdollisena tavoitearvona ja laskea sitten kaikkien muiden elementtien muuntamisen kokonaiskustannukset kyseiseksi tavoitearvoksi. Tarkistamalla kaikki mahdolliset tavoitearvot voimme löytää sen, joka johtaa pienimpään konversion kokonaiskustannuksiin.
// 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));
Lähtö
100
[Odotettu lähestymistapa - 1] Binäärihaun käyttäminen - O(n Log (Range)) -aika ja O(1)-avaruus
Ajatuksena on hyödyntää binäärihakua löytääkseen tehokkaasti optimaalinen arvo, johon kaikki taulukon elementit tulisi muuntaa. Koska kokonaiskustannusfunktio muodostaa kuperan käyrän (ensin laskeva sitten kasvava) mahdollisten arvojen alueella, voimme käyttää binäärihakua tämän käyrän minimipisteen paikantamiseen vertaamalla keskipisteen kustannuksia keskipisteen kustannuksiin miinus yksi, mikä kertoo, mihin suuntaan etsiä edelleen.
Askel askeleelta lähestymistapa:
- Etsi taulukosta minimi- ja maksimiarvot hakualueen määrittämiseksi
- Käytä binäärihakua minimi- ja maksimiarvon välillä löytääksesi optimaalisen kohdearvon
- Laske jokaiselle koearvolle kokonaiskustannukset, jotka aiheutuvat kaikkien taulukon elementtien muuntamisesta kyseiseen arvoon
- Vertaa nykyisen keskipisteen kustannuksia keskipisteen kustannuksiin miinus yksi määrittääksesi hakusuunnan
- Jatka hakualueen kaventamista, kunnes löydät minimikustannuskonfiguraation
// 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));
Lähtö
100
[Odotettu lähestymistapa - 2] Lajittelun käyttö - O(n Log n) aika ja O(1) tila
Ajatuksena on löytää optimaalinen arvo, johon kaikki alkiot tasoitetaan, jonka on oltava jokin olemassa olevista taulukon elementeistä. Lajittelemalla taulukko ensin ja iteroimalla sitten jokaisen elementin läpi mahdollisena kohdearvona laskemme kaikkien muiden elementtien muuntamisen kustannukset kyseiseen arvoon seuraamalla tehokkaasti nykyisen sijainnin vasemmalla ja oikealla puolella olevien elementtien summaa.
Askel askeleelta lähestymistapa:
- Lajittele taulukko käsitelläksesi elementtejä nousevassa järjestyksessä.
- Laske jokaiselle elementille mahdolliseksi tavoitearvoksi kaksi kustannusta: pienempien elementtien nostaminen ylös ja suurempien elementtien alas.
- Seuraa vasemman ja oikean summia laskeaksesi nämä kustannukset tehokkaasti vakioajassa iteraatiota kohden.
- Pienten elementtien tuominen kustannuksiin: (nykyarvo × pienempien elementtien lukumäärä) - (pienempien elementtien summa)
- Suurempien elementtien alentaminen kustannuksissa: (suurempien elementtien summa) - (nykyarvo × suurempien elementtien lukumäärä)
- Vertaa tämänhetkisiä kustannuksia vähimmäiskustannuksiin.
// 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));
Lähtö
100Luo tietokilpailu