# Solution For Sum Of Total Strength Of Wizards

Problem Statement:

You are given an integer array, representing the strengths of N wizards.

You have to perform a total of K operations.

In each operation, you can pick any two wizards and combine their strength. The cost of this operation is equal to the sum of strengths of the two wizards being combined.

You can perform the same operation multiple times, and combine the same two wizards multiple times.

You need to minimize the total cost of all the operations given that you can only combine two wizards at a time and you can only perform K operations.

Return the minimum total cost.

Solution:

To solve this problem, we can use a greedy approach. We can sort the array of wizard strengths in increasing order, and then start combining the weakest wizards first.

For each operation, we can pick the two weakest wizards, combine their strength, and update the array to reflect their new strength. We can keep track of the total cost of all the operations in a variable, and return this variable after performing K operations.

Algorithm:

- Sort the array of wizard strengths in increasing order.
- For K times:

a. Pick the two weakest wizards.

b. Combine their strength and update the array to reflect their new strength.

c. Add the cost of this operation to a variable that keeps track of the total cost. - Return the total cost.

Code:

The following is the Python code implementation of the algorithm described above.

def sum_total_strength_of_wizards(n, k, strengths):

strengths.sort()

total_cost = 0

for i in range(k):

a = strengths.pop(0)

b = strengths.pop(0)

new_strength = a + b

strengths.append(new_strength)

total_cost += new_strength

strengths.sort()

return total_cost

Explanation:

We first sort the array of wizard strengths in increasing order using the sort() method. We then loop through K times, where K is the total number of operations that we have to perform.

For each iteration of the loop, we pick the two weakest wizards by popping the first two elements from the sorted array. We then combine their strength to get the new strength and update the array to reflect this.

We calculate the cost of the operation as the sum of the strengths of the two wizards being combined. We add this cost to the total cost variable that keeps track of the total cost of all the operations done so far.

Finally, we sort the array again so that it remains in sorted order for the next iteration of the loop.

After the loop, we return the total cost variable as the answer to the problem.

Time Complexity:

The time complexity of this solution is O(KlogN), where N is the number of wizards and K is the number of operations to be performed. This is because we are sorting the array N times, which takes O(NlogN) time, and we are doing this K times, which takes O(KlogN) time.

Space Complexity:

The space complexity of this solution is O(N), where N is the number of wizards. This is because we are using an array of size N to store the strengths of the wizards.

## Step by Step Implementation For Sum Of Total Strength Of Wizards

class Solution { public int sumOfTotalStrength(Listwizards) { // Initialize total strength to 0 int totalStrength = 0; // Iterate through each wizard in the list for (Wizard w : wizards) { // Add the wizard's strength to the total totalStrength += w.strength; } // Return the total strength return totalStrength; } }

def sum_of_total_strength_of_wizards(arr): # initialize total strength to 0 total_strength = 0 # iterate over the array for i in range(len(arr)): # check if the element at index i is a wizard if arr[i]["is_wizard"] == True: # if so, add the strength to the total total_strength += arr[i]["strength"] # return the total strength return total_strength

var wizardStrength = function(wizards) { // your code goes here };

class Solution { public: int sumOfWizards(vector> wizards) { // TODO: Implement this function int sum = 0; for (auto wiz : wizards) { sum += wiz.first + wiz.second; } return sum; } };

public class Solution { public int SumOfTotalStrengthOfWizards(IList> wizards) { // TODO: Implement your solution here return 0; } }