[ Post a Response | Puzzles Forum ]
Posted by Moby Dick
on 21/9/2009, 4:06 pm, in reply to "Re: SuperSalmon"
Agreed. Here's my output:
*** stage 1 - boat going forward ***
Swimming: c d
In boat: a b
Boat position for stage 1 is: 240
Time: 5 hours
*** stage 1 - boat returning ***
Swimming: b c d
In boat: a
Boat position: 96
Time: 3 hours
*** stage 2 - boat going forward ***
Swimming: b d
In boat: a c
Boat position for stage 3 is: 288
Time: 4 hours
*** stage 2 - boat returning ***
Swimming: b c d
In boat: a
Boat position: 240
Time: 1 hours
*** stage 3 - boat going forward ***
Swimming: b c
In boat: a d
Time: 1 hours
Here's the model (which, I can absolutely assure you, is nowhere near as clean and concise as it should be! 
):
set swimmer:= {"a", "b", "c", "d"};
param speed {i in swimmer};
var inboatfwd{s in swimmer, i in 1..3} binary; /* going forward stages */
var inboatbwd{s in swimmer, i in 1..2} binary; /* going backward stages */
var boatFwdTime{i in 1..3} >= 1, integer;
var boatBwdTime{i in 1..2} >= 1, integer;
var boatFwdDist{i in 1..3} >= 0, integer;
var boatBwdDist{i in 1..2} >=0, integer;
var timeInBoat{s in swimmer} >= 0, integer;
var timeInWater{s in swimmer} >= 0, integer;
var boatPos{i in 1..4};
var swimPos{s in swimmer, i in 1..4};
var boatA1fwd;
var boatA1bwd;
var boatA2fwd;
var boatA2bwd;
var boatA3fwd;
var boatB1fwd;
var boatB1bwd;
var boatB2fwd;
var boatB2bwd;
var boatB3fwd;
var boatC1fwd;
var boatC1bwd;
var boatC2fwd;
var boatC2bwd;
var boatC3fwd;
var boatD1fwd;
var boatD1bwd;
var boatD2fwd;
var boatD2bwd;
var boatD3fwd;
# needed to avoid non-linearity of multiplying variables (binary inboat * integer time in boat)
maximize boatTimeFix: sum{s in swimmer}timeInBoat[s];
# equations for boat
s.t. boatTime: sum{i in 1..3} boatFwdTime[ i ] + sum{i in 1..2} boatBwdTime[ i ] = 14;
s.t. FwdTimeDist{i in 1..2}: boatFwdDist[ i ] = boatFwdTime[ i ] * 48;
s.t. FwdTimeDist3: boatFwdDist[3] = boatFwdTime[3] * 48 + 24; /* salmon power */
s.t. BwdTimeDist{i in 1..2}: boatBwdDist[ i ] = boatBwdTime[ i ] * 48;
s.t. boatDist: sum{i in 1..3}boatFwdDist[ i ] - sum{i in 1..2}boatBwdDist[ i ] = 312;
s.t. boatTravel: sum{i in 1..3}boatFwdDist[ i ] + sum{i in 1..2}boatBwdDist[ i ] = 696;
s.t. boat1: boatPos[1] = boatFwdDist[1];
s.t. boat2: boatPos[2] = boatFwdDist[1] - boatBwdDist[1];
s.t. boat3: boatPos[3] = boatFwdDist[1] - boatBwdDist[1] + boatFwdDist[2];
s.t. boat4: boatPos[4] = boatFwdDist[1] - boatBwdDist[1] + boatFwdDist[2] - boatBwdDist[2];
# boat occupancy
s.t. twoforward{i in 1..3}: sum{s in swimmer} inboatfwd[s, i] = 2;
s.t. onebackward{i in 1..2}: sum{s in swimmer} inboatbwd[s, i] = 1;
# going backwards, occupant previously went forward
s.t. returnerWentFwd{s in swimmer, i in 1..2}: inboatfwd[s, i] - inboatbwd[s, i] >= 0;
# fix swimmer A
s.t. fixATime1: timeInBoat["a"] + timeInWater["a"] = 14;
s.t. fixATime2: timeInBoat["a"] = boatA1fwd + boatA2fwd + boatA3fwd + boatA1bwd + boatA2bwd;
s.t. fixABoatTime1_1: boatA1fwd <= boatFwdTime[1];
s.t. fixABoatTime1_2: boatA1fwd <= 14 * inboatfwd["a", 1];
s.t. fixABoatTime2_1: boatA2fwd <= boatFwdTime[2];
s.t. fixABoatTime2_2: boatA2fwd <= 14 * inboatfwd["a", 2];
s.t. fixABoatTime3_1: boatA3fwd <= boatFwdTime[3];
s.t. fixABoatTime3_2: boatA3fwd <= 14 * inboatfwd["a", 3];
s.t. fixABoatTime4_1: boatA1bwd <= boatBwdTime[1];
s.t. fixABoatTime4_2: boatA1bwd <= 14 * inboatbwd["a", 1];
s.t. fixABoatTime5_1: boatA2bwd <= boatBwdTime[2];
s.t. fixABoatTime5_2: boatA2bwd <= 14 * inboatbwd["a", 2];
s.t. fixDistanceA: speed["a"] * timeInWater["a"] + 48 * boatA1fwd
+ 48 * boatA2fwd + 48 * boatA3fwd + 24 * inboatfwd["a", 3]
- 48 * boatA1bwd - 48 * boatA2bwd = 312;
s.t. swimA1: swimPos["a", 1] = speed["a"] * boatFwdTime[1];
s.t. swimA2: swimPos["a", 2] = swimPos["a", 1] + speed["a"] * boatBwdTime[1];
s.t. swimA3: swimPos["a", 3] = swimPos["a", 2] + speed["a"] * boatFwdTime[2];
s.t. swimA4: swimPos["a", 4] = swimPos["a", 3] + speed["a"] * boatBwdTime[2];
# fix swimmer B
s.t. fixBTime: timeInBoat["b"] + timeInWater["b"] = 14;
s.t. fixBTime2: timeInBoat["b"] = boatB1fwd + boatB2fwd + boatB3fwd + boatB1bwd + boatB2bwd;
s.t. fixBBoatTime1_1: boatB1fwd <= boatFwdTime[1];
s.t. fixBBoatTime1_2: boatB1fwd <= 14 * inboatfwd["b", 1];
s.t. fixBBoatTime2_1: boatB2fwd <= boatFwdTime[2];
s.t. fixBBoatTime2_2: boatB2fwd <= 14 * inboatfwd["b", 2];
s.t. fixBBoatTime3_1: boatB3fwd <= boatFwdTime[3];
s.t. fixBBoatTime3_2: boatB3fwd <= 14 * inboatfwd["b", 3];
s.t. fixBBoatTime4_1: boatB1bwd <= boatBwdTime[1];
s.t. fixBBoatTime4_2: boatB1bwd <= 14 * inboatbwd["b", 1];
s.t. fixBBoatTime5_1: boatB2bwd <= boatBwdTime[2];
s.t. fixBBoatTime5_2: boatB2bwd <= 14 * inboatbwd["b", 2];
s.t. fixDistanceB: speed["b"] * timeInWater["b"] + 48 * boatB1fwd
+ 48 * boatB2fwd + 48 * boatB3fwd + 24 * inboatfwd["b", 3]
- 48 * boatB1bwd - 48 * boatB2bwd = 312;
s.t. swimB1: swimPos["b", 1] = speed["b"] * boatFwdTime[1];
s.t. swimB2: swimPos["b", 2] = swimPos["b", 1] + speed["b"] * boatBwdTime[1];
s.t. swimB3: swimPos["b", 3] = swimPos["b", 2] + speed["b"] * boatFwdTime[2];
s.t. swimB4: swimPos["b", 4] = swimPos["b", 3] + speed["b"] * boatBwdTime[2];
# fix swimmer C
s.t. fixCTime: timeInBoat["c"] + timeInWater["c"] = 14;
s.t. fixCTime2: timeInBoat["c"] = boatC1fwd + boatC2fwd + boatC3fwd + boatC1bwd + boatC2bwd;
s.t. fixCBoatTime1_1: boatC1fwd <= boatFwdTime[1];
s.t. fixCBoatTime1_2: boatC1fwd <= 14 * inboatfwd["c", 1];
s.t. fixCBoatTime2_1: boatC2fwd <= boatFwdTime[2];
s.t. fixCBoatTime2_2: boatC2fwd <= 14 * inboatfwd["c", 2];
s.t. fixCBoatTime3_1: boatC3fwd <= boatFwdTime[3];
s.t. fixCBoatTime3_2: boatC3fwd <= 14 * inboatfwd["c", 3];
s.t. fixCBoatTime4_1: boatC1bwd <= boatBwdTime[1];
s.t. fixCBoatTime4_2: boatC1bwd <= 14 * inboatbwd["c", 1];
s.t. fixCBoatTime5_1: boatC2bwd <= boatBwdTime[2];
s.t. fixCBoatTime5_2: boatC2bwd <= 14 * inboatbwd["c", 2];
s.t. fixDistanceC: speed["c"] * timeInWater["c"] + 48 * boatC1fwd
+ 48 * boatC2fwd + 48 * boatC3fwd + 24 * inboatfwd["c", 3]
- 48 * boatC1bwd - 48 * boatC2bwd = 312;
s.t. swimC1: swimPos["c", 1] = speed["c"] * boatFwdTime[1];
s.t. swimC2: swimPos["c", 2] = swimPos["c", 1] + speed["c"] * boatBwdTime[1];
s.t. swimC3: swimPos["c", 3] = swimPos["c", 2] + speed["c"] * boatFwdTime[2];
s.t. swimC4: swimPos["c", 4] = swimPos["c", 3] + speed["c"] * boatBwdTime[2];
# fix swimmer D
s.t. fixDTime: timeInBoat["d"] + timeInWater["d"] = 16;
s.t. fixDTime2: timeInBoat["d"] = boatD1fwd + boatD2fwd + boatD3fwd + boatD1bwd + boatD2bwd;
s.t. fixDBoatTime1_1: boatD1fwd <= boatFwdTime[1];
s.t. fixDBoatTime1_2: boatD1fwd <= 14 * inboatfwd["d", 1];
s.t. fixDBoatTime2_1: boatD2fwd <= boatFwdTime[2];
s.t. fixDBoatTime2_2: boatD2fwd <= 14 * inboatfwd["d", 2];
s.t. fixDBoatTime3_1: boatD3fwd <= boatFwdTime[3];
s.t. fixDBoatTime3_2: boatD3fwd <= 14 * inboatfwd["d", 3];
s.t. fixDBoatTime4_1: boatD1bwd <= boatBwdTime[1];
s.t. fixDBoatTime4_2: boatD1bwd <= 14 * inboatbwd["d", 1];
s.t. fixDBoatTime5_1: boatD2bwd <= boatBwdTime[2];
s.t. fixDBoatTime5_2: boatD2bwd <= 14 * inboatbwd["d", 2];
s.t. fixDistanceD: speed["d"] * timeInWater["d"] + 48 * boatD1fwd
+ 48 * boatD2fwd + 48 * boatD3fwd + 24 * inboatfwd["d", 3]
- 48 * boatD1bwd - 48 * boatD2bwd = 312;
s.t. swimD1: swimPos["d", 1] = speed["d"] * boatFwdTime[1] + 32;
s.t. swimD2: swimPos["d", 2] = swimPos["d", 1] + speed["d"] * boatBwdTime[1];
s.t. swimD3: swimPos["d", 3] = swimPos["d", 2] + speed["d"] * boatFwdTime[2];
s.t. swimD4: swimPos["d", 4] = swimPos["d", 3] + speed["d"] * boatBwdTime[2];
# after boating, must be ahead of swim pos
s.t. checkPos1{s in swimmer, p in {1, 3}}: swimPos[s, p] <= boatPos[p];
# ad-hoc constraints
s.t. dStartsInWater: inboatfwd["d", 1] + inboatbwd["d", 1] = 0;
solve;
for {stage in 1..3} {
printf "\n\n*** stage %s - boat going forward ***\n\n", stage;
printf "Swimming: ";
for {s in swimmer: inboatfwd[s, stage] = 0} {
printf "%s ", s;
}
printf "\nIn boat: ";
for {s in swimmer: inboatfwd[s, stage] = 1} {
printf "%s ", s;
}
for {1..1: stage < 3} {
printf "\nBoat position for stage %s is: %s", stage * 2 - 1, round(boatPos[stage * 2 - 1]);
}
printf "\nTime: %s hours", boatFwdTime[stage];
for {1..1: stage < 3} {
printf "\n\n*** stage %s - boat returning ***\n\n", stage;
printf "Swimming: ";
for {s in swimmer: inboatbwd[s, stage] = 0} {
printf "%s ", s;
}
printf "\nIn boat: ";
for {s in swimmer: inboatbwd[s, stage] = 1} {
printf "%s ", s;
}
for {1..1: stage < 3} {
printf "\nBoat position: %s", round(boatPos[stage * 2]);
}
printf "\nTime: %s hours", boatBwdTime[stage];
}
}
data;
param speed:=
"a" 4
"b" 8
"c" 12
"d" 16;
end;
Message Thread:
« Back to thread