Balance weights using backtracking algorithm in Swift - swift

Question

I'm trying to implement a solution using the backtracking algorithm.
I have some weights [1,2,7,10,20,70,100,200,700...] and I want to return the weights after a given input/
For example input => 12 should return [2,10]
For example input => 8 should return [1,7]
My code seem's not to work well. It works only for some input numbers like 13 or 8
for targetValue in [13] {
var currentValue = 0
var usedWeights: [Int] = []
for weight in weights {
if targetValue > weight {
currentValue += weight
usedWeights.append(weight)
} else if weight > targetValue {
let rememberLast = usedWeights.last ?? 0
usedWeights.remove(at: usedWeights.count-1)
currentValue -= rememberLast
if currentValue > targetValue || currentValue < targetValue {
let last = usedWeights.remove(at: usedWeights.count-1)
currentValue -= last
usedWeights.append(rememberLast)
currentValue -= rememberLast
print(usedWeights) /// [1, 2, 10] Yeah it work's :) but only for some number ..:(
}
}
}
}
The used weights should be unique.
I have some trouble to find the weights.
This is how the algorithm work
Input => 13
1
1+2
1+2+7
1+2+7+10 //currentValue is now 20
1+2+7 // still no solution get the last removed element and remove the current last element
1+2+10 // Correct weights
I hope you can help me and I explain what I'm doing wrong.

Answer 1

Here's one solution. Iterate in reverse through the weights. If the weight is less than or equal to the current total, use the weight.
let weights = [1,2,7,10,20,70,100,200,700] // the weights you have
let needed = 12 // The total weight you want
var total = needed // The current working total
var needs = [Int]() // The resulting weights needed
for weight in weights.reversed() {
if weight <= total {
needs.append(weight)
total -= weight
}
}
if total == 0 {
print("Need \(needs) for \(needed)")
} else {
print("No match for \(needed)")
}

Answer 2

I don't know how you set the weight.
But consider:
[2,3,6,10,20]
and needed = 21
Then the algorithm will not find it (no match), when there is a solution obviously: 2 + 3 + 6 + 10
So, you should call recursively the search algorithm when it fails, after removing from the weights the first you picked.
This is not very clean, but seem to work (in code, some issue in playground)
func searchIt(weightsSearch: [Int], neededSearch: Int) -> (needs: [Int], remainingWeights: [Int], found: Bool) {
var total = neededSearch // The current working total
var needs = [Int]() // The resulting weights needed
var remaining = weightsSearch
var firstNotYetSelected = true
var position = weightsSearch.count - 1
for weight in weightsSearch.reversed() {
if weight <= total {
needs.append(weight)
total -= weight
if firstNotYetSelected {
remaining.remove(at : position)
}
firstNotYetSelected = false
position -= 1
}
}
return (needs, remaining, total == 0)
}
var needs = [Int]() // The resulting weights needed
var remainingWeights = weights
var foundIt: Bool
repeat {
(needs, remainingWeights, foundIt) = searchIt(weightsSearch: remainingWeights, neededSearch: needed)
if foundIt {
print("Need \(needs) for \(needed)")
break
} else {
print("No match yet for \(needed)")
}
} while remainingWeights.count >= 1
with the test case
let weights = [2,3,6,10,20]
let needed = 21
we get
No match yet for 21
Need [10, 6, 3, 2] for 21
If you want ALL the solutions, replace break statement by continue.
With the test case
let weights = [2,3,6,10,15,20]
let needed = 21
we get the 2 solutions
No match for 21
No match for 21
Need [15, 6] for 21
Need [10, 6, 3, 2] for 21
No match for 21
No match for 21
No match for 21