Rearranging Fruits

Rearranging Fruits - Problem

You have two fruit baskets containing n fruits each. You are given two 0-indexed integer arrays basket1 and basket2 representing the cost of fruit in each basket.

You want to make both baskets equal. To do so, you can use the following operation as many times as you want:

Choose two indices i and j, and swap the i^th fruit of basket1 with the j^th fruit of basket2.
The cost of the swap is min(basket1[i], basket2[j]).

Two baskets are considered equal if sorting them according to the fruit cost makes them exactly the same baskets.

Return the minimum cost to make both the baskets equal or -1 if impossible.

Input & Output

Example 1 — Impossible Case

$ Input: basket1 = [4,1,2,1], basket2 = [1,4,3,2]

› Output: -1

💡 Note: Fruit 1 appears 3 times total (2+1) and fruit 3 appears 1 time total. Since these are odd counts, equal distribution is impossible.

Example 2 — Single Swap

$ Input: basket1 = [1,2,3,4], basket2 = [1,2,3,4]

› Output: 0

💡 Note: Baskets are already equal, no swaps needed.

Example 3 — Optimal Swaps

$ Input: basket1 = [4,1,2,1], basket2 = [1,4,1,2]

› Output: 1

💡 Note: Both baskets have same fruit counts: 1 appears 2+2=4 times, 2 appears 1+1=2 times, 4 appears 1+1=2 times. Need to swap one element with cost min(any pair) = 1.

Constraints

1 ≤ basket1.length, basket2.length ≤ 10⁵
basket1.length == basket2.length
1 ≤ basket1[i], basket2[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is using frequency analysis to determine if equal distribution is possible, then greedily matching excess elements. The optimal approach uses counting and sorting to achieve O(n log n) time complexity with O(n) space.

Common Approaches

✓ Brute Force - Try All Swaps

⏱️ Time: O(2^(n²)) Space: O(n)

Generate all possible ways to swap elements between baskets and find the minimum cost combination that makes them equal. This involves checking every possible subset of swaps.

Frequency Analysis + Greedy

⏱️ Time: O(n log n) Space: O(n)

First check if it's possible by comparing total frequencies. Then identify which elements need to be swapped out and in for each basket, and greedily match them with minimum cost swaps.

Brute Force - Try All Swaps — Algorithm Steps

Generate all possible swap combinations
For each combination, calculate total cost
Check if baskets become equal after swaps
Return minimum cost among valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Pairs

Create all possible (i,j) swap positions

Try Combinations

Test each subset of swaps

Find Minimum

Return cheapest valid solution

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

long long solution(int *basket1, int *basket2, int n) {
    // Count frequency of each fruit across both baskets
    int max_val = 0;
    for (int i = 0; i < n; i++) {
        if (basket1[i] > max_val) max_val = basket1[i];
        if (basket2[i] > max_val) max_val = basket2[i];
    }
    
    int *count = (int*)calloc(max_val + 1, sizeof(int));
    
    // Count total fruits
    for (int i = 0; i < n; i++) {
        count[basket1[i]]++;
        count[basket2[i]]++;
    }
    
    // Check if equal distribution is possible
    for (int i = 0; i <= max_val; i++) {
        if (count[i] % 2 != 0) {
            free(count);
            return -1;
        }
    }
    
    // Find fruits that need to be swapped
    int *excess1 = (int*)malloc(n * sizeof(int));
    int *excess2 = (int*)malloc(n * sizeof(int));
    int e1_count = 0, e2_count = 0;
    
    // Reset count for tracking per basket
    memset(count, 0, (max_val + 1) * sizeof(int));
    
    // Count what each basket has
    for (int i = 0; i < n; i++) {
        count[basket1[i]]++;
    }
    
    // Find excess in basket1 and deficit in basket2
    int *count2 = (int*)calloc(max_val + 1, sizeof(int));
    for (int i = 0; i < n; i++) {
        count2[basket2[i]]++;
    }
    
    for (int fruit = 0; fruit <= max_val; fruit++) {
        int target = (count[fruit] + count2[fruit]) / 2;
        
        while (count[fruit] > target) {
            excess1[e1_count++] = fruit;
            count[fruit]--;
        }
        
        while (count2[fruit] > target) {
            excess2[e2_count++] = fruit;
            count2[fruit]--;
        }
    }
    
    // Sort excess arrays
    qsort(excess1, e1_count, sizeof(int), compare);
    qsort(excess2, e2_count, sizeof(int), compare);
    
    // Find minimum cost in both baskets
    int min_cost = INT_MAX;
    for (int i = 0; i < n; i++) {
        if (basket1[i] < min_cost) min_cost = basket1[i];
        if (basket2[i] < min_cost) min_cost = basket2[i];
    }
    
    // Calculate minimum swap cost using greedy approach
    long long total_cost = 0;
    for (int i = 0; i < e1_count; i++) {
        // Direct swap cost vs using minimum element twice
        int direct = (excess1[i] < excess2[e1_count - 1 - i]) ? 
                     excess1[i] : excess2[e1_count - 1 - i];
        int indirect = 2 * min_cost;
        
        total_cost += (direct < indirect) ? direct : indirect;
    }
    
    free(count);
    free(count2);
    free(excess1);
    free(excess2);
    
    return total_cost;
}

int main() {
    char line[10000];
    int basket1[100], basket2[100];
    int n1 = 0, n2 = 0;
    
    // Read first line
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    char *ptr = line;
    while (*ptr) {
        if (*ptr >= '0' && *ptr <= '9') {
            basket1[n1++] = (int)strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    // Read second line
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    ptr = line;
    while (*ptr) {
        if (*ptr >= '0' && *ptr <= '9') {
            basket2[n2++] = (int)strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    printf("%lld\n", solution(basket1, basket2, n1));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n²))

For each pair of elements across baskets, we decide to swap or not swap, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current basket states during recursion

⚡ Linearithmic Space

25.4K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Swaps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler