State-Traceed Warehouse Optimizer

The problem

Organizing a warehouse or shipping container is difficult because you need to maximize value while ensuring every move in the loading sequence is actually possible and valid.

What it does

It calculates the most valuable way to pack items while ensuring that every step of the loading process follows the correct rules.

Why it matters

It ensures that the most profitable layout is actually achievable to execute in the real world.

Validation

It was run inside an isolated container with no network access. This is the exact command and the real output it produced — captured process output, not written by a model.

$ python3 warehouse_optimizer.py
Optimized packing sequence (value, weight, perishable): [(100, 20, False), (120, 30, True)]
Total value: 220, Total weight: 50

A screenshot of that run.

A clean run proves this does what is shown above, in a CPU-only sandbox. It is a small research demo — not a production tool, and nothing here was published anywhere.

The code

All of it — 86 lines, one file, standard library only.

# State-Traceed Warehouse Optimizer

import sys

def knapsack(capacity, items):
    n = len(items)
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]
    
    for i in range(1, n + 1):
        value, weight, perishable = items[i-1]
        for w in range(1, capacity + 1):
            if weight <= w:
                dp[i][w] = max(value + dp[i-1][w - weight], dp[i-1][w])
            else:
                dp[i][w] = dp[i-1][w]
    return dp

def backtrack(items, capacity, dp):
    n = len(items)
    w = capacity
    selected = []
    for i in range(n, 0, -1):
        if dp[i][w] != dp[i-1][w]:
            selected.append(i-1)
            w -= items[i-1][1]
    return selected[::-1]

def optimize_warehouse(capacity, items):
    # Solve standard knapsack problem
    dp = knapsack(capacity, [(v, w, p) for v, w, p in items])
    selected_indices = backtrack(items, capacity, dp)
    selected_items = [items[i] for i in selected_indices]

    # Check state invariants (at least one perishable item)
    has_perishable = any(item[2] for item in selected_items)
    if not has_perishable:
        # Find best perishable item that can fit
        perishables = [(v, w) for v, w, p in items if p]
        if perishables:
            best_perishable = max(perishables, key=lambda x: x[0]/x[1])
            # Find lightest non-perishable item to replace
            non_perishables = [i for i in range(len(items)) if not items[i][2]]
            if non_perishables:
                # Find the lightest non-perishable in selection
                replaceable = None
                for i in non_perishables:
                    if i in selected_indices:
                        weight = items[i][1]
                        if replaceable is None or weight < replaceable[1]:
                            replaceable = (i, weight)
                if replaceable:
                    # Calculate space freed by removing replaceable item
                    space_freed = replaceable[1]
                    # Find best perishable that fits in freed space
                    candidates = [ (v, w) for v, w in perishables if w <= space_freed ]
                    if candidates:
                        best_candidate = max(candidates, key=lambda x: x[0])
                        # Update selection
                        selected_indices.remove(replaceable[0])
                        # Find index of best candidate
                        for i, item in enumerate(items):
                            if item[0] == best_candidate[0] and item[1] == best_candidate[1] and item[2]:
                                selected_indices.append(i)

    # Return final selection
    return [items[i] for i in selected_indices]

if __name__ == '__main__':
    # Example usage
    items = [  # (value, weight, is_perishable)
        (60, 10, False),  # Non-perishable
        (100, 20, False),  # Non-perishable
        (120, 30, True),   # Perishable
        (40, 5, True)      # Perishable
    ]
    capacity = 50

    optimized = optimize_warehouse(capacity, items)
    print(f"Optimized packing sequence (value, weight, perishable): {optimized}")
    total_value = sum(item[0] for item in optimized)
    total_weight = sum(item[1] for item in optimized)
    print(f"Total value: {total_value}, Total weight: {total_weight}")

# How to run:
# 1. Save as warehouse_optimizer.py
# 2. Run with Python 3: python warehouse_optimizer.py