logo

TechCodeview

Naj bodo vsi elementi niza enaki z minimalnimi stroški

Glede na niz velikosti n naloga je, da se vrednost vseh elementov izenači z minimalni stroški . Stroški spreminjanja vrednosti iz x v y so abs(x - y).

Primeri:  

Vnos: arr[] = [1 100 101]
Izhod : 100
Pojasnilo: Vse njegove vrednosti lahko spremenimo na 100 z minimalnimi stroški
|1 - 100| + |100 - 100| + |101 - 100| = 100



Vnos : arr[] = [4 6]
Izhod : 2
Pojasnilo: Vse njegove vrednosti lahko spremenimo na 5 z minimalnimi stroški
|4 - 5| + |5 - 6| = 2

Vnos: arr[] = [5 5 5 5]
Izhod:
Pojasnilo: Vse vrednosti so že enake.

[Naivni pristop] Uporaba 2 ugnezdenih zank - O(n^2) časa in O(1) prostora

Upoštevajte, da je naš odgovor lahko vedno ena od vrednosti polja. Tudi v drugem zgornjem primeru lahko alternativno naredimo oba kot 4 ali oba kot 6 za isto ceno.
Ideja je, da vsako vrednost v matriki obravnavamo kot potencialno ciljno vrednost, nato pa izračunamo skupne stroške pretvorbe vseh drugih elementov v to ciljno vrednost. S preverjanjem vseh možnih ciljnih vrednosti lahko najdemo tisto, ki povzroči najnižjo skupno ceno konverzije.

C++ 
// C++ program to Make all array  // elements equal with minimum cost #include    using namespace std; // Function which finds the minimum  // cost to make array elements equal int minCost(vector<int> &arr) {  int n = arr.size();  int ans = INT_MAX;    // 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 += abs(arr[j] - arr[i]);  }    // Update minimum cost if current cost is lower  ans = min(ans currentCost);  }    return ans; } int main() {  vector<int> arr = {1 100 101};  cout << minCost(arr) << endl;    return 0; }
Java 
// 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 
# 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# 
// 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 
// 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));

Izhod 
100

[Pričakovani pristop - 1] Uporaba binarnega iskanja - O(n Log (Range)) čas in O(1) prostor

Ideja je uporabiti binarno iskanje za učinkovito iskanje optimalne vrednosti, v katero naj se pretvorijo vsi elementi polja. Ker funkcija celotnega stroška tvori konveksno krivuljo (najprej padajočo in nato naraščajočo) v razponu možnih vrednosti, lahko uporabimo binarno iskanje, da poiščemo najnižjo točko te krivulje, tako da primerjamo strošek na sredini s ceno na sredini minus ena, kar nam pove, v katero smer naj iščemo naprej.

Pristop korak za korakom:

  1. Poiščite najmanjšo in največjo vrednost v matriki, da določite obseg iskanja
  2. Uporabite binarno iskanje med najmanjšo in največjo vrednostjo, da poiščete optimalno ciljno vrednost
  3. Za vsako poskusno vrednost izračunajte skupne stroške pretvorbe vseh elementov polja v to vrednost
  4. Primerjajte ceno na trenutni srednji točki s ceno na srednji točki minus ena, da določite smer iskanja
  5. Nadaljujte z oženjem obsega iskanja, dokler ne najdete konfiguracije z najnižjo ceno
C++ 
// C++ program to Make all array  // elements equal with minimum cost #include    using namespace std; // Function to find the cost of changing // array values to mid. int findCost(vector<int> &arr int mid) {  int n = arr.size();  int ans = 0;  for (int i=0; i<n; i++) {  ans += abs(arr[i] - mid);  }  return ans; } // Function which finds the minimum cost  // to make array elements equal. int minCost(vector<int> &arr) {  int n = arr.size();  int mini = INT_MAX maxi = INT_MIN;    // Find the minimum and maximum value.  for (int i=0; i<n; i++) {  mini = min(mini arr[i]);  maxi = max(maxi arr[i]);  }    int s = mini e = maxi;  int ans = INT_MAX;    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; } int main() {  vector<int> arr = {1 100 101};  cout << minCost(arr);    return 0; }
Java 
// 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 
# 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# 
// 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 
// 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));

Izhod 
100

[Pričakovan pristop - 2] Uporaba razvrščanja - O(n Log n) čas in O(1) prostor

Ideja je najti optimalno vrednost, na katero naj se izenačijo vsi elementi, ki mora biti eden od obstoječih elementov polja. Če najprej razvrstimo matriko in nato ponovimo vsak element kot potencialno ciljno vrednost, izračunamo stroške pretvorbe vseh drugih elementov v to vrednost z učinkovitim sledenjem vsoti elementov levo in desno od trenutnega položaja.

Pristop korak za korakom:

  1. Razvrstite matriko za obdelavo elementov v naraščajočem vrstnem redu.
  2. Za vsak element kot potencialno ciljno vrednost izračunajte dva stroška: povečanje manjših elementov in znižanje večjih elementov.
  3. Sledite levim in desnim vsotam, da učinkovito izračunate te stroške v konstantnem času na ponovitev.
    • Stroški dviga manjših elementov: (trenutna vrednost × število manjših elementov) - (vsota manjših elementov)
    • Zmanjšanje stroškov večjih elementov: (vsota večjih elementov) - (trenutna vrednost × število večjih elementov)
  4. Primerjajte trenutne stroške z minimalnimi stroški.
C++ 
// C++ program to Make all array  // elements equal with minimum cost #include    using namespace std; // Function which finds the minimum cost  // to make array elements equal. int minCost(vector<int> &arr) {  int n = arr.size();  // Sort the array  sort(arr.begin() arr.end());    // 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_MAX;  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 = min(ans leftCost + rightCost);    // Add current value to left sum   left += arr[i];  }    return ans; } int main() {  vector<int> arr = {1 100 101};  cout << minCost(arr);    return 0; }
Java 
// 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 
# 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# 
// 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 
// 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));

Izhod 
100
Ustvari kviz