仅更改第一个值时如何求助Javascript数组

Question

I've got a little app that recalculates the apportionment of seats in Congress in each state as the user changes the population hypothetically by moving counties between states. There are functionally infinite combinations, so I need to compute this on the fly.

The method is fairly straightforward : You give each state 1 seat, then assign the remaining 385 iteratively by weighting them according to population / ((seats * (seats + 1)) and assigning the seat to the top priority state.

I've got this working fine the obvious way:

function apportion(states) {
    var totalReps = 435;

    // assign one seat to each state
    states.forEach(function(state) {
        state.totalReps = 1;
        totalReps -= 1;
        state.priority = state.data.population / Math.sqrt(2); //Calculate default quota
    });

    // sort function
    var topPriority = function(a, b) {
        return b.priority - a.priority;
    };

    // assign the remaining 385
    for (totalReps; totalReps > 0; totalReps -= 1) {
        states.sort(topPriority);    
        states[0].totalReps += 1;
        // recalculate the priority for this state
        states[0].priority = states[0].data.population / Math.sqrt(states[0].totalReps * (states[0].totalReps + 1));
    }    
    return states;
}

However, it drags a little when called several times a second. I'm wondering whether there's a better way to place the state that received the seat back in the sorted array other than by resorting the whole array. I don't know a ton about the Javascript sort() function and whether it will already do this with maximal efficiency without being told that all but the first element in the array is already sorted. Is there a more efficient way that I can implement by hand?

jsFiddle here: http://jsfiddle.net/raphaeljs/zoyLb9g6/1/

Answer 1

Using a strategy of avoiding sorts, the following keeps an array of priorities that is aligned with the states object and uses Math.max to find the highest priority value, then indexOf to find its position in the array, then updates the states object and priorities array.

As with all performance optimisations, it has very different results in different browsers (see http://jsperf.com/calc-reps ), but is at least no slower (Chrome) and up to 4 times faster (Firefox).

function apportion1(states) {
    var totalReps = 435;
    var sqrt2 = Math.sqrt(2);
    var priorities = [];
    var max, idx, state, n;

    // assign one seat to each state
    states.forEach(function(state) {
        state.totalReps = 1;
        state.priority = state.data.population / sqrt2; //Calculate default quota
        priorities.push(state.priority);
    });

    totalReps -= states.length;

    while (totalReps--) {
      max = Math.max.apply(Math, priorities);
      idx = priorities.indexOf(max);
      state = states[idx];
      n = ++state.totalReps;
      state.priority = state.data.population / Math.sqrt(n * ++n);
      priorities[idx] = state.priority;
    }
    return states;
}

For testing I used an assumed states object with only 5 states, but real population data. Hopefully, with the full 50 states the benefit will be larger.

Another strategy is to sort on population since that's how the priorities are distributed, assign at least one rep to each state and calculate the priority, then run from 0 adding reps and recalculating priorities. There will be a threshold below which a state should not get any more reps.

Over to you. ;-)

Edit

Here's a really simple method that apportions based on population. If may allocation one too many or one too few. In the first case, find the state with the lowest priority and at least 2 reps (and recalc priority if you want) and take a rep away. In the second, find the state with the highest priority and add one rep (and recalc priority if required).

function simple(states) {
  var totalPop = 0;
  var totalReps = 435
  states.forEach(function(state){totalPop += state.data.population});
  var popperrep = totalPop/totalReps;
  states.forEach(function(state){
    state.totalReps = Math.round(state.data.population / popperrep);
    state.priority = state.data.population / Math.sqrt(state.totalReps * (state.totalReps + 1));
  });
  return states;
}

Untested, but I'll bet it's very much faster than the others. ;-)

I've updated the test example for the simple function to adjust if the distribution results in an incorrect total number of reps. Tested across a variety of scenarios, it gives identical results to the original code even though it uses a very different algorithm. It's several hundred times faster than the original with the full 50 states.

Here's the final version of the simple function:

function simple(states) {
  var count = 0;
  var state, diff;
  var totalPop = states.reduce(function(prev, curr){return prev + curr.data.population},0);
  var totalReps = 435
  var popperrep = totalPop/totalReps;

  states.forEach(function(state){
    state.totalReps = Math.round(state.data.population / popperrep) || 1;
    state.priority = state.data.population / Math.sqrt(state.totalReps * (state.totalReps + 1));
    count += state.totalReps;
  });

  // If too many reps distributed, trim from lowest priority with 2 or more
  // If not enough reps distributed, add to highest priority
  while ((diff = count - totalReps)) {
    state = states[getPriority(diff < 0)];
    state.totalReps += diff > 0? -1 : 1;
    count += diff > 0? -1 : 1;
    state.priority = state.data.population / Math.sqrt(state.totalReps * (state.totalReps + 1));
    // console.log('Adjusted ' + state.data.name + ' ' + diff);
  }

  return states;

  // Get lowest priority state with 2 or more reps,
  // or highest priority state if high is true
  function getPriority(high) {
    var idx, p = high? 0 : +Infinity;
    states.forEach(function(state, i){

      if (( high && state.priority > p) || (!high && state.totalReps > 1 && state.priority < p)) {
        p = state.priority;
        idx = i;
      }
    });
    return idx;
  }
}