Weighted Randomized Ordering

Question

The problem:

I have items that have weights. The higher the weight, the greater chance they have the item will go first. I need to have a clean, simple way of doing this that is based on core Java (no third party libraries, jars, etc.).

I've done this for 2 items, by summing the weights then randomly pick a number using Math.random() within that range. Very simple. But for items greater than 2, I can either do more samples in the same range chancing misses, or I can recompute the sum of the weights of the remaining items and select again (recursive approach). I think that there might be something out there can can do this faster/cleaner. This code will be used over and over, so I'm looking for an effective solution.

In essence, its like randomized weight permutations.

Some Examples:

1. A has weight of 1, B has weight of 99. If I ran the simulation with this, I would expect to get BA 99% of the time and AB 1% of the time.

2. A has the weight of 10, B has the weight of 10, and C has the weight of 80. If I ran simulations with this, I would expect C to be the first item in the ordering 80% of the time, in those cases, A and B would have an equal chance of being the next character.

Extra Details:

For my particular problem, there is a small number of items with potentially large weights. Say 20 to 50 items with weights that are stored in the form of a long, where the minimum weight is at least a 1000. The number of items may increase quite a bit too, so if we can find a solution that doesn't require the items to be small, that would be preferred.

Answer 1

You have items with weights:

• Item A, weight 42
• Item B, weight 5
• Item C, weight 96
• Item D, weight 33

First add up all the weights: 42 + 5 + 96 + 33 = 176

Now pick a random number, r, from 0 up to the sum of the weights: 0 <= r < 176. I have used integers, but you could use reals if required.

Compare r with the ranges defined by the weights:

• 0 <= r < 42: select item A.
• 42 <= r < 47 (= 42 + 5): select item B.
• 47 <= r < 143 (= 47 + 96): select item C.
• 143 <= r < 176 (= 143 + 33): select item D.

When you have picked the first item, then repeat the process with the three remaining items and a reduced sum of all the weights. Keep repeating until there are no more items to pick.

Answer 2

This seems to work fine:

// Can do a weighted sort on weighted items.
public interface Weighted {
    int getWeight();
}

/**
 * Weighted sort of an array - orders them at random but the weight of each
 * item makes it more likely to be earlier.
 *
 * @param values
 */
public static void weightedSort(Weighted[] values) {
    // Build a list containing as many of each item to make up the full weight.
    List<Weighted> full = new ArrayList<>();
    for (Weighted v : values) {
        // Add a v weight times.
        for (int i = 0; i < v.getWeight(); i++) {
            full.add(v);
        }
    }
    // Shuffle it.
    Collections.shuffle(full);
    // Roll them out in the order required.
    int i = 0;
    do {
        // Get the first one in the shuffled list.
        Weighted next = full.get(0);
        // Put it back into the array.
        values[i++] = next;
        // Remove all occurrences of that one from the list.
        full.remove(next);
    } while (!full.isEmpty());
}

// A bunch of weighted items.
enum Heavies implements Weighted {

    Rare(1),
    Few(3),
    Common(6);
    final int weight;

    Heavies(int weight) {
        this.weight = weight;
    }

    @Override
    public int getWeight() {
        return weight;
    }
}

public void test() {
    Weighted[] w = Heavies.values();
    for (int i = 0; i < 10; i++) {
        // Sort it weighted.
        weightedSort(w);
        // What did we get.
        System.out.println(Arrays.toString(w));
    }
}

Essentially for each item to be sorted I add it as many times as needed to a new list. I then shuffle the list and pull the top one out and clar all occurrences of it from the remaining.

The last test run produced:

[Rare, Common, Few]
[Common, Rare, Few]
[Few, Common, Rare]
[Common, Few, Rare]
[Common, Rare, Few]
[Few, Rare, Common]

which seems to be about right.

NB - this algorithm will fail under at least the following conditions:

1. The original array has the same object in it more than once.
2. The weights of the items are insanely huge.
3. Zero or negative weights will almost certainly mess with the results.

Added

This implements Rossum's idea - please be sure to give him the credit for the algorithm.

public static void weightedSort2(Weighted[] values) {
    // Calculate the total weight.
    int total = 0;
    for (Weighted v : values) {
        total += v.getWeight();
    }
    // Start with all of them.
    List<Weighted> remaining = new ArrayList(Arrays.asList(values));
    // Take each at random - weighted by it's weight.
    int which = 0;
    do {
        // Pick a random point.
        int random = (int) (Math.random() * total);
        // Pick one from the list.
        Weighted picked = null;
        int pos = 0;
        for (Weighted v : remaining) {
            // Pick this ne?
            if (pos + v.getWeight() > random) {
                picked = v;
                break;
            }
            // Move forward by that much.
            pos += v.getWeight();
        }
        // Removed picked from the remaining.
        remaining.remove(picked);
        // Reduce total.
        total -= picked.getWeight();
        // Record picked.
        values[which++] = picked;
    } while (!remaining.isEmpty());
}

Answer 3

public class RandomPriorityQueue {

    private TreeMap<Integer, List<WeightedElement>> tree = new TreeMap();
    private Random random = new Random();

    public void add(WeightedElement e) {
        int priority = random.nextInt(e.getWeight());
        if (tree.containsKey(priority)) {
            List<WeightedElement> list = new LinkedList();
            list.add(e);
            tree.put(priority, list);
        } else {
            List<WeightedElement> list = tree.get(priority);
            list.add(random.nextInt(list.size()), e);
        }
    }

    public WeightedElement poll() {
        Map.Entry<Integer, List<WeightedElement>> entry = tree.lastEntry();
        if (entry == null){
            return null;
        }
        List<WeightedElement> list = entry.getValue();
        if (list.size() == 1){
            tree.remove(entry.getKey());
        }
        return list.remove(0);
    }
}

Of course we would have betterperformence if we would rewrite TreeMap so it allow us to add duplication keys, we would have better performance.

Answer 4

I have found a solution on another answer - cannot find it right now, but it uses exponential distribution:

To an i-th element with weight w_i, assign a key power(random(0,1),1.0/w_i) (in pseudocode) and then sort the elements by keys. This takes O(n*log(n)) time, complexity independent of the actual weights.

Answer 5

Anyway, for N items you will need N-1 random numbers (at minimum). Then, lets think about effective way to choose item by random number.

If the items are not too much, I would use iterative method, similar to your recursive approach. I would add boolean flag to the items, for skipping chosen ones in the previous iterations. When I choose one in the current iteration, I will set its flag to true and the next times I will skip it from calculations. Subtract its weight from the sum and go for next iteration.

If the items are big number and one and the same set will be used many times, then different approach is better. Make sorted list of them and use a copy of this list in your recursive approach. And in every recursion step - binary search in it, then removing the chosen item.

Actually, the last can be done iteratively too.