Java代码简化与高效运行：如何替代多层嵌套循环实现多对象价格组合筛选

Hey there! Great question—dealing with hard-coded nested loops for combinatorial filtering gets messy fast, especially when you scale up to 10 layers. Let’s break this down into OOP-friendly solutions that clean up your code and boost efficiency at the same time.

The core idea here is to replace your fixed-number nested loops with a generic recursive function that handles any number of fruit types. This plays perfectly with OOP because we can abstract all your fruit objects behind a common interface.

First, define a base Fruit class so all your apple/orange/tomato objects share a consistent way to expose their prices:

class Fruit {
public:
    virtual const std::vector<double>& getPrices() const = 0;
    virtual ~Fruit() = default;
};

// Example derived class for Apples
class Apples : public Fruit {
private:
    std::vector<double> prices;
public:
    Apples(std::vector<double> p) : prices(std::move(p)) {}
    const std::vector<double>& getPrices() const override { return prices; }
};

// Repeat this pattern for Oranges, Tomatoes, etc.

Then write a recursive function that iterates through each fruit type one by one, building combinations and checking the total:

void findValidCombos(const std::vector<Fruit*>& fruits, 
                     int currentFruitIndex, 
                     double currentTotal, 
                     std::vector<double>& currentCombo, 
                     std::vector<std::vector<double>>& validCombos) {
    // Stop when we've checked all fruit types
    if (currentFruitIndex == fruits.size()) {
        if (currentTotal < 1000.0) {
            validCombos.push_back(currentCombo);
        }
        return;
    }

    const auto& prices = fruits[currentFruitIndex]->getPrices();
    for (double price : prices) {
        // Early pruning: if adding this price pushes us over 1000, skip it (and any larger prices if sorted)
        if (currentTotal + price >= 1000.0) {
            continue;
        }
        // Add the price to our current combo
        currentCombo.push_back(price);
        // Recurse to the next fruit type
        findValidCombos(fruits, currentFruitIndex + 1, currentTotal + price, currentCombo, validCombos);
        // Backtrack: remove the price to try the next option
        currentCombo.pop_back();
    }
}

The recursive approach already cleans up your code, but we can make it way faster by cutting out unnecessary work:

• Sort prices first: Sort each fruit's price list in ascending order. Once you hit a price that pushes the total over 1000, you can break the loop entirely (since all remaining prices are larger).
• Filter out invalid prices upfront: Remove any single price that’s already ≥1000—there’s no way combining it with others will stay under the threshold.
• Early termination: As shown in the recursive function, if adding a price makes the total exceed 1000, we skip that path immediately instead of wasting time recursing further.

Here’s how to add preprocessing to your setup:

// Before calling the recursive function:
std::vector<Fruit*> fruits = {&apples, &oranges, &tomatoes}; // Add all your fruit objects here

for (auto fruit : fruits) {
    // Get mutable access to prices (adjust if your design prefers immutable objects)
    auto& prices = const_cast<std::vector<double>&>(fruit->getPrices());
    // Filter out prices >= 1000
    prices.erase(std::remove_if(prices.begin(), prices.end(), [](double p) { return p >= 1000.0; }), prices.end());
    // Sort remaining prices ascending
    std::sort(prices.begin(), prices.end());
}

This approach leverages OOP’s strengths perfectly:

• Extensibility: Add a new fruit type (like Bananas) by just creating a new derived Fruit class—no changes needed to the recursive function.
• Abstraction: The function doesn’t care what type of fruit it’s handling; it only needs the getPrices() method from the base interface.
• Clean separation: Your fruit data and the combinatorial logic are decoupled, making code easier to test and maintain.

If recursion feels risky (though 10 layers is trivial for most call stacks), you can implement the same logic iteratively using a stack or queue to track the state of each combination in progress. The core logic (pruning, preprocessing) stays identical—just the implementation style changes.

内容的提问来源于stack exchange，提问作者B.C.L.