Bomb dropping algorithm
I have an n x m matrix consisting of non-negative integers. For example:
2 3 4 7 1
1 5 2 6 2
4 3 4 2 1
2 1 2 4 1
3 1 3 4 1
2 1 4 3 2
6 9 1 6 4
-
To minimize the number of bombs, we have to maximize effect of every bomb. To achive this, on every step we have to select the best target. For each point summing it and it's eight neighbours - could be used as an efficiency quantity of bombing this point. This will provide close to optimal sequence of bombs.
UPD: We should also take number of zeros into account, becouse bombin them is inefficiently. In fact the problem is to minimize number of hitted zeros. But we can not know how any step gets us closer to this aim. I agree with idea that the problem is NP-complete. I sugest a greedy approach, which will give an answer close to real.
讨论(0) -
Well, suppose we number the board positions 1, 2, ..., n x m. Any sequence of bomb drops can be represented by a sequence of numbers in this set, where numbers can repeat. However, the effect on the board is the same regardless of what order you drop the bombs in, so really any choice of bomb drops can be represented as a list of n x m numbers, where the first number represents the number of bombs dropped on position 1, the second number represents the number of bombs dropped on position 2, etc. Let's call this list of n x m numbers the "key".
You could try first calculating all board states resulting from 1 bomb drop, then use these to calculate all board states resulting from 2 bomb drops, etc until you get all zeros. But at each step you would cache the states using the key I defined above, so you can use these results in calculating the next step (a "dynamic programming" approach).
But depending on the size of n, m, and the numbers in the grid, the memory requirements of this approach might be excessive. You can throw away all the results for N bomb drops once you've calculated all the results for N + 1, so there's some savings there. And of course you could not cache anything at the cost of having it take a lot longer -- the dynamic programming approach trades memory for speed.
讨论(0) -
This was an answer to the first asked question. I hadn't noticed that he changed the parameters.
Create a list of all targets. Assign a value to the target based on the number of positive values impacted by a drop (itself, and all neighbors). Highest value would be a nine.
Sort the targets by the number of targets impacted (Descending), with a secondary descending sort on the sum of each impacted target.
Drop a bomb on the highest ranked target, then re-calculate targets and repeat until all target values are zero.
Agreed, this is not always the most optimal. For example,
100011 011100 011100 011100 000000 100011This approach would take 5 bombs to clear. Optimally, though, you could do it in 4. Still, pretty darn close and there is no backtracking. For most situations it will be optimal, or very close.
Using the original problem numbers, this approach solves in 28 bombs.
Adding code to demonstrate this approach (using a form with a button):
private void button1_Click(object sender, EventArgs e) { int[,] matrix = new int[10, 10] {{5, 20, 7, 1, 9, 8, 19, 16, 11, 3}, {17, 8, 15, 17, 12, 4, 5, 16, 8, 18}, { 4, 19, 12, 11, 9, 7, 4, 15, 14, 6}, { 17, 20, 4, 9, 19, 8, 17, 2, 10, 8}, { 3, 9, 10, 13, 8, 9, 12, 12, 6, 18}, {16, 16, 2, 10, 7, 12, 17, 11, 4, 15}, { 11, 1, 15, 1, 5, 11, 3, 12, 8, 3}, { 7, 11, 16, 19, 17, 11, 20, 2, 5, 19}, { 5, 18, 2, 17, 7, 14, 19, 11, 1, 6}, { 13, 20, 8, 4, 15, 10, 19, 5, 11, 12}}; int value = 0; List<Target> Targets = GetTargets(matrix); while (Targets.Count > 0) { BombTarget(ref matrix, Targets[0]); value += 1; Targets = GetTargets(matrix); } Console.WriteLine( value); MessageBox.Show("done: " + value); } private static void BombTarget(ref int[,] matrix, Target t) { for (int a = t.x - 1; a <= t.x + 1; a++) { for (int b = t.y - 1; b <= t.y + 1; b++) { if (a >= 0 && a <= matrix.GetUpperBound(0)) { if (b >= 0 && b <= matrix.GetUpperBound(1)) { if (matrix[a, b] > 0) { matrix[a, b] -= 1; } } } } } Console.WriteLine("Dropped bomb on " + t.x + "," + t.y); } private static List<Target> GetTargets(int[,] matrix) { List<Target> Targets = new List<Target>(); int width = matrix.GetUpperBound(0); int height = matrix.GetUpperBound(1); for (int x = 0; x <= width; x++) { for (int y = 0; y <= height; y++) { Target t = new Target(); t.x = x; t.y = y; SetTargetValue(matrix, ref t); if (t.value > 0) Targets.Add(t); } } Targets = Targets.OrderByDescending(x => x.value).ThenByDescending( x => x.sum).ToList(); return Targets; } private static void SetTargetValue(int[,] matrix, ref Target t) { for (int a = t.x - 1; a <= t.x + 1; a++) { for (int b = t.y - 1; b <= t.y + 1; b++) { if (a >= 0 && a <= matrix.GetUpperBound(0)) { if (b >= 0 && b <= matrix.GetUpperBound(1)) { if (matrix[ a, b] > 0) { t.value += 1; t.sum += matrix[a,b]; } } } } } }A class you will need:
class Target { public int value; public int sum; public int x; public int y; }讨论(0) -
Here's my solution.. I won't write it out in code yet since I don't have time, but I believe this should produce an optimal number of moves each time - though I'm not sure how efficient it would be at finding the points to bomb.
Firstly, as @Luka Rahne stated in one of the comments, the order in which you bomb is not important- only the combination.
Secondly, as many others have stated, bombing 1-off the diagonal from the corners is optimal because it touches more points than the corners.
This generates the basis for my version of the algorithm: We can bomb the '1-off from the corners' first or last, it doesn't matter (in theory) We bomb those first because it makes later decisions easier (in practice) We bomb the point which affects the most points, while simultaneously bombing those corners.
Let's define Points Of Resistance to be the points in the board with the most non-bombable points + largest number of 0's around them
non-bombable points can be defined as points which don't exist in our current scope of the board we're looking at.
I'll also define 4 bounds which will handle our scope: Top=0, Left=0, Bottom=k,right=j. (values to start)
Finally, I'll define optimal bombs as bombs which are dropped on points that are adjacent to points of resistance and are touching (1) the highest valued point of resistance and (2) the largest number of points possible.
Regarding the approach- it's obvious we're working from the outside in. We will be able to work with 4 'bombers' at the same time.
The first points of resistance are obviously our corners. The 'out of bound' points are not bombable (there are 5 points outside the scope for each corner). So we bomb the points diagonally one off the corners first.
Algorithm:
- Find the 4 optimal bomb points.
- If a bomb point is bombing a resistance point which is touching 2 bounds (i.e. a corner), bomb till that point is 0. Otherwise, bomb each until one of the points of resistance touching the optimal bomb point is 0.
- for each bound: if(sum(bound)==0) advance bound
repeat until TOP=BOTTOM and LEFT=RIGHT
I will try to write the actual code later
讨论(0) -
Here's another idea:
Let's start by assigning a weight to each space on the board for how many numbers would be reduced by dropping a bomb there. So if the space has a non-zero number, it gets a point, and if any space adjacent to it has a non-zero number, it gets an additional point. So if there is a 1000-by-1000 grid, we have a weight assigned to each of the 1 million spaces.
Then sort the list of spaces by weight, and bomb the one with the highest weight. This is getting the most bang for our buck, so to speak.
After that, update the weight of every space whose weight is affected by the bomb. This will be the space you bombed, and any space immediately adjacent to it, and any space immediately adjacent to those. In other words, any space which could have had its value reduced to zero by the bombing, or the value of a neighboring space reduced to zero.
Then, re-sort the list spaces by weight. Since only a small subset of spaces had their weight changed by the bombing, you won't need to resort the whole list, just move those ones around in the list.
Bomb the new highest weight space, and repeat the procedure.
This guarantees that every bombing reduces as many spaces as possible (basically, it hits as few spaces which are already zero as possible), so it would be optimal, except that their can be ties in weights. So you may need to do some back tracking when there is a tie for the top weight. Only a tie for the top weight matters, though, not other ties, so hopefully it's not too much back-tracking.
Edit: Mysticial's counterexample below demonstrates that in fact this isn't guaranteed to be optimal, regardless of ties in weights. In some cases reducing the weight as much as possible in a given step actually leaves the remaining bombs too spread out to achieve as high a cummulative reduction after the second step as you could have with a slightly less greedy choice in the first step. I was somewhat mislead by the notion that the results are insensitive to the order of bombings. They are insensitive to the order in that you could take any series of bombings and replay them from the start in a different order and end up with the same resulting board. But it doesn't follow from that that you can consider each bombing independently. Or, at least, each bombing must be considered in a way that takes into account how well it sets up the board for subsequent bombings.
讨论(0) -
I can't think of a way to calculate the actual number without just computing the bombing campaign using my best heuristic and hope I get a reasonable result.
So my method is to compute a bombing efficiency metric for each cell, bomb the cell with the highest value, .... iterate the process until I've flattened everything. Some have advocated using simple potential damage (i.e. score from 0 to 9) as a metric, but that falls short by pounding high value cells and not making use of damage overlap. I'd calculate
cell value - sum of all neighbouring cells, reset any positive to 0 and use the absolute value of anything negative. Intuitively this metric should make a selection that help maximise damage overlap on cells with high counts instead of pounding those directly.The code below reaches total destruction of the test field in 28 bombs (note that using potential damage as metric yields 31!).
using System; using System.Collections.Generic; using System.Linq; namespace StackOverflow { internal class Program { // store the battle field as flat array + dimensions private static int _width = 5; private static int _length = 7; private static int[] _field = new int[] { 2, 3, 4, 7, 1, 1, 5, 2, 6, 2, 4, 3, 4, 2, 1, 2, 1, 2, 4, 1, 3, 1, 3, 4, 1, 2, 1, 4, 3, 2, 6, 9, 1, 6, 4 }; // this will store the devastation metric private static int[] _metric; // do the work private static void Main(string[] args) { int count = 0; while (_field.Sum() > 0) { Console.Out.WriteLine("Round {0}:", ++count); GetBlastPotential(); int cell_to_bomb = FindBestBombingSite(); PrintField(cell_to_bomb); Bomb(cell_to_bomb); } Console.Out.WriteLine("Done in {0} rounds", count); } // convert 2D position to 1D index private static int Get1DCoord(int x, int y) { if ((x < 0) || (y < 0) || (x >= _width) || (y >= _length)) return -1; else { return (y * _width) + x; } } // Convert 1D index to 2D position private static void Get2DCoord(int n, out int x, out int y) { if ((n < 0) || (n >= _field.Length)) { x = -1; y = -1; } else { x = n % _width; y = n / _width; } } // Compute a list of 1D indices for a cell neighbours private static List<int> GetNeighbours(int cell) { List<int> neighbours = new List<int>(); int x, y; Get2DCoord(cell, out x, out y); if ((x >= 0) && (y >= 0)) { List<int> tmp = new List<int>(); tmp.Add(Get1DCoord(x - 1, y - 1)); tmp.Add(Get1DCoord(x - 1, y)); tmp.Add(Get1DCoord(x - 1, y + 1)); tmp.Add(Get1DCoord(x, y - 1)); tmp.Add(Get1DCoord(x, y + 1)); tmp.Add(Get1DCoord(x + 1, y - 1)); tmp.Add(Get1DCoord(x + 1, y)); tmp.Add(Get1DCoord(x + 1, y + 1)); // eliminate invalid coords - i.e. stuff past the edges foreach (int c in tmp) if (c >= 0) neighbours.Add(c); } return neighbours; } // Compute the devastation metric for each cell // Represent the Value of the cell minus the sum of all its neighbours private static void GetBlastPotential() { _metric = new int[_field.Length]; for (int i = 0; i < _field.Length; i++) { _metric[i] = _field[i]; List<int> neighbours = GetNeighbours(i); if (neighbours != null) { foreach (int j in neighbours) _metric[i] -= _field[j]; } } for (int i = 0; i < _metric.Length; i++) { _metric[i] = (_metric[i] < 0) ? Math.Abs(_metric[i]) : 0; } } //// Compute the simple expected damage a bomb would score //private static void GetBlastPotential() //{ // _metric = new int[_field.Length]; // for (int i = 0; i < _field.Length; i++) // { // _metric[i] = (_field[i] > 0) ? 1 : 0; // List<int> neighbours = GetNeighbours(i); // if (neighbours != null) // { // foreach (int j in neighbours) _metric[i] += (_field[j] > 0) ? 1 : 0; // } // } //} // Update the battle field upon dropping a bomb private static void Bomb(int cell) { List<int> neighbours = GetNeighbours(cell); foreach (int i in neighbours) { if (_field[i] > 0) _field[i]--; } } // Find the best bombing site - just return index of local maxima private static int FindBestBombingSite() { int max_idx = 0; int max_val = int.MinValue; for (int i = 0; i < _metric.Length; i++) { if (_metric[i] > max_val) { max_val = _metric[i]; max_idx = i; } } return max_idx; } // Display the battle field on the console private static void PrintField(int cell) { for (int x = 0; x < _width; x++) { for (int y = 0; y < _length; y++) { int c = Get1DCoord(x, y); if (c == cell) Console.Out.Write(string.Format("[{0}]", _field[c]).PadLeft(4)); else Console.Out.Write(string.Format(" {0} ", _field[c]).PadLeft(4)); } Console.Out.Write(" || "); for (int y = 0; y < _length; y++) { int c = Get1DCoord(x, y); if (c == cell) Console.Out.Write(string.Format("[{0}]", _metric[c]).PadLeft(4)); else Console.Out.Write(string.Format(" {0} ", _metric[c]).PadLeft(4)); } Console.Out.WriteLine(); } Console.Out.WriteLine(); } } }The resulting bombing pattern is output as follows (field values on the left, metric on the right)
Round 1: 2 1 4 2 3 2 6 || 7 16 8 10 4 18 6 3 5 3 1 1 1 9 || 11 18 18 21 17 28 5 4 [2] 4 2 3 4 1 || 19 [32] 21 20 17 24 22 7 6 2 4 4 3 6 || 8 17 20 14 16 22 8 1 2 1 1 1 2 4 || 14 15 14 11 13 16 7 Round 2: 2 1 4 2 3 2 6 || 5 13 6 9 4 18 6 2 4 2 1 1 [1] 9 || 10 15 17 19 17 [28] 5 3 2 3 2 3 4 1 || 16 24 18 17 17 24 22 6 5 1 4 4 3 6 || 7 14 19 12 16 22 8 1 2 1 1 1 2 4 || 12 12 12 10 13 16 7 Round 3: 2 1 4 2 2 1 5 || 5 13 6 7 3 15 5 2 4 2 1 0 1 8 || 10 15 17 16 14 20 2 3 [2] 3 2 2 3 0 || 16 [24] 18 15 16 21 21 6 5 1 4 4 3 6 || 7 14 19 11 14 19 6 1 2 1 1 1 2 4 || 12 12 12 10 13 16 7 Round 4: 2 1 4 2 2 1 5 || 3 10 4 6 3 15 5 1 3 1 1 0 1 8 || 9 12 16 14 14 20 2 2 2 2 2 2 [3] 0 || 13 16 15 12 16 [21] 21 5 4 0 4 4 3 6 || 6 11 18 9 14 19 6 1 2 1 1 1 2 4 || 10 9 10 9 13 16 7 Round 5: 2 1 4 2 2 1 5 || 3 10 4 6 2 13 3 1 3 1 1 0 [0] 7 || 9 12 16 13 12 [19] 2 2 2 2 2 1 3 0 || 13 16 15 10 14 15 17 5 4 0 4 3 2 5 || 6 11 18 7 13 17 6 1 2 1 1 1 2 4 || 10 9 10 8 11 13 5 Round 6: 2 1 4 2 1 0 4 || 3 10 4 5 2 11 2 1 3 1 1 0 0 6 || 9 12 16 11 8 13 0 2 2 2 2 0 2 0 || 13 16 15 9 14 14 15 5 4 [0] 4 3 2 5 || 6 11 [18] 6 11 15 5 1 2 1 1 1 2 4 || 10 9 10 8 11 13 5 Round 7: 2 1 4 2 1 0 4 || 3 10 4 5 2 11 2 1 3 1 1 0 0 6 || 8 10 13 9 7 13 0 2 [1] 1 1 0 2 0 || 11 [15] 12 8 12 14 15 5 3 0 3 3 2 5 || 3 8 10 3 8 15 5 1 1 0 0 1 2 4 || 8 8 7 7 9 13 5 Round 8: 2 1 4 2 1 0 4 || 1 7 2 4 2 11 2 0 2 0 1 0 0 6 || 7 7 12 7 7 13 0 1 1 0 1 0 2 0 || 8 8 10 6 12 14 15 4 2 0 3 3 [2] 5 || 2 6 8 2 8 [15] 5 1 1 0 0 1 2 4 || 6 6 6 7 9 13 5 Round 9: 2 1 4 2 1 0 4 || 1 7 2 4 2 11 2 0 2 0 1 0 0 6 || 7 7 12 7 6 12 0 1 1 0 1 0 [1] 0 || 8 8 10 5 10 [13] 13 4 2 0 3 2 2 4 || 2 6 8 0 6 9 3 1 1 0 0 0 1 3 || 6 6 6 5 8 10 4 Round 10: 2 1 4 2 1 0 4 || 1 7 2 4 2 10 1 0 2 [0] 1 0 0 5 || 7 7 [12] 7 6 11 0 1 1 0 1 0 1 0 || 8 8 10 4 8 9 10 4 2 0 3 1 1 3 || 2 6 8 0 6 8 3 1 1 0 0 0 1 3 || 6 6 6 4 6 7 2 Round 11: 2 0 3 1 1 0 4 || 0 6 0 3 0 10 1 0 1 0 0 0 [0] 5 || 4 5 5 5 3 [11] 0 1 0 0 0 0 1 0 || 6 8 6 4 6 9 10 4 2 0 3 1 1 3 || 1 5 6 0 5 8 3 1 1 0 0 0 1 3 || 6 6 6 4 6 7 2 Round 12: 2 0 3 1 0 0 3 || 0 6 0 2 1 7 1 0 1 0 0 0 0 4 || 4 5 5 4 1 7 0 1 0 0 0 0 [0] 0 || 6 8 6 4 5 [9] 8 4 2 0 3 1 1 3 || 1 5 6 0 4 7 2 1 1 0 0 0 1 3 || 6 6 6 4 6 7 2 Round 13: 2 0 3 1 0 0 3 || 0 6 0 2 1 6 0 0 1 0 0 0 0 3 || 4 5 5 4 1 6 0 1 [0] 0 0 0 0 0 || 6 [8] 6 3 3 5 5 4 2 0 3 0 0 2 || 1 5 6 0 4 6 2 1 1 0 0 0 1 3 || 6 6 6 3 4 4 0 Round 14: 2 0 3 1 0 [0] 3 || 0 5 0 2 1 [6] 0 0 0 0 0 0 0 3 || 2 5 4 4 1 6 0 0 0 0 0 0 0 0 || 4 4 4 3 3 5 5 3 1 0 3 0 0 2 || 0 4 5 0 4 6 2 1 1 0 0 0 1 3 || 4 4 5 3 4 4 0 Round 15: 2 0 3 1 0 0 2 || 0 5 0 2 1 4 0 0 0 0 0 0 0 2 || 2 5 4 4 1 4 0 0 0 0 0 0 0 0 || 4 4 4 3 3 4 4 3 1 0 3 0 [0] 2 || 0 4 5 0 4 [6] 2 1 1 0 0 0 1 3 || 4 4 5 3 4 4 0 Round 16: 2 [0] 3 1 0 0 2 || 0 [5] 0 2 1 4 0 0 0 0 0 0 0 2 || 2 5 4 4 1 4 0 0 0 0 0 0 0 0 || 4 4 4 3 3 3 3 3 1 0 3 0 0 1 || 0 4 5 0 3 3 1 1 1 0 0 0 0 2 || 4 4 5 3 3 3 0 Round 17: 1 0 2 1 0 0 2 || 0 3 0 1 1 4 0 0 0 0 0 0 0 2 || 1 3 3 3 1 4 0 0 0 0 0 0 0 0 || 4 4 4 3 3 3 3 3 1 [0] 3 0 0 1 || 0 4 [5] 0 3 3 1 1 1 0 0 0 0 2 || 4 4 5 3 3 3 0 Round 18: 1 0 2 1 0 0 2 || 0 3 0 1 1 4 0 0 0 0 0 0 0 2 || 1 3 3 3 1 4 0 0 0 0 0 0 0 0 || 3 3 2 2 2 3 3 3 [0] 0 2 0 0 1 || 0 [4] 2 0 2 3 1 1 0 0 0 0 0 2 || 2 4 2 2 2 3 0 Round 19: 1 0 2 1 0 [0] 2 || 0 3 0 1 1 [4] 0 0 0 0 0 0 0 2 || 1 3 3 3 1 4 0 0 0 0 0 0 0 0 || 2 2 2 2 2 3 3 2 0 0 2 0 0 1 || 0 2 2 0 2 3 1 0 0 0 0 0 0 2 || 2 2 2 2 2 3 0 Round 20: 1 [0] 2 1 0 0 1 || 0 [3] 0 1 1 2 0 0 0 0 0 0 0 1 || 1 3 3 3 1 2 0 0 0 0 0 0 0 0 || 2 2 2 2 2 2 2 2 0 0 2 0 0 1 || 0 2 2 0 2 3 1 0 0 0 0 0 0 2 || 2 2 2 2 2 3 0 Round 21: 0 0 1 1 0 0 1 || 0 1 0 0 1 2 0 0 0 0 0 0 0 1 || 0 1 2 2 1 2 0 0 0 0 0 0 0 0 || 2 2 2 2 2 2 2 2 0 0 2 0 [0] 1 || 0 2 2 0 2 [3] 1 0 0 0 0 0 0 2 || 2 2 2 2 2 3 0 Round 22: 0 0 1 1 0 0 1 || 0 1 0 0 1 2 0 0 0 0 0 0 0 1 || 0 1 2 2 1 2 0 [0] 0 0 0 0 0 0 || [2] 2 2 2 2 1 1 2 0 0 2 0 0 0 || 0 2 2 0 2 1 1 0 0 0 0 0 0 1 || 2 2 2 2 2 1 0 Round 23: 0 0 1 1 0 0 1 || 0 1 0 0 1 2 0 0 0 [0] 0 0 0 1 || 0 1 [2] 2 1 2 0 0 0 0 0 0 0 0 || 1 1 2 2 2 1 1 1 0 0 2 0 0 0 || 0 1 2 0 2 1 1 0 0 0 0 0 0 1 || 1 1 2 2 2 1 0 Round 24: 0 0 0 0 0 0 1 || 0 0 0 0 0 2 0 0 0 0 0 0 0 1 || 0 0 0 0 0 2 0 0 0 [0] 0 0 0 0 || 1 1 [2] 2 2 1 1 1 0 0 2 0 0 0 || 0 1 2 0 2 1 1 0 0 0 0 0 0 1 || 1 1 2 2 2 1 0 Round 25: 0 0 0 0 0 [0] 1 || 0 0 0 0 0 [2] 0 0 0 0 0 0 0 1 || 0 0 0 0 0 2 0 0 0 0 0 0 0 0 || 1 1 1 1 1 1 1 1 0 0 1 0 0 0 || 0 1 1 0 1 1 1 0 0 0 0 0 0 1 || 1 1 1 1 1 1 0 Round 26: 0 0 0 0 0 0 0 || 0 0 0 0 0 0 0 0 0 0 0 0 0 0 || 0 0 0 0 0 0 0 [0] 0 0 0 0 0 0 || [1] 1 1 1 1 0 0 1 0 0 1 0 0 0 || 0 1 1 0 1 1 1 0 0 0 0 0 0 1 || 1 1 1 1 1 1 0 Round 27: 0 0 0 0 0 0 0 || 0 0 0 0 0 0 0 0 0 0 0 0 0 0 || 0 0 0 0 0 0 0 0 0 [0] 0 0 0 0 || 0 0 [1] 1 1 0 0 0 0 0 1 0 0 0 || 0 0 1 0 1 1 1 0 0 0 0 0 0 1 || 0 0 1 1 1 1 0 Round 28: 0 0 0 0 0 0 0 || 0 0 0 0 0 0 0 0 0 0 0 0 0 0 || 0 0 0 0 0 0 0 0 0 0 0 0 0 0 || 0 0 0 0 0 0 0 0 0 0 0 0 [0] 0 || 0 0 0 0 0 [1] 1 0 0 0 0 0 0 1 || 0 0 0 0 0 1 0 Done in 28 rounds讨论(0)
加载中...
- 热议问题