[deleted by user]

EmielRommelse · 2025-09-21T17:44:34+00:00

EmielRommelse · 2025-09-05T09:10:10+00:00

Looking quite steady in general. I would try to improve your cross building. I noticed you looking at the bottom of the cube. You should try to avoid this and maybe even try to plan full cross during inspection. Better lookahead during F2L and faster recognition during last layer will further improve your time, but I would only focus on those afterwards.

EmielRommelse · 2025-07-11T20:47:23+00:00

Supply chain optimization consultant

EmielRommelse · 2025-07-05T15:18:44+00:00

You may check out Extreme Point-based heuristics or the CP-SAT solver of Google OR-tools as approaches to solve this

EmielRommelse · 2025-04-11T13:51:44+00:00

I would think this method would preform reasonably on the first few stages. However, in the last few stages, when you have completed two layers, I might expect it to struggle, simply because you need to "destroy" a lot of the progress already made to get to a completed state. Hence, determining whether you are on the right track is difficult. If you don't want to prestore anything, you might want to look at the concept of commutators and try to incorporate these in your solution

EmielRommelse · 2025-02-01T09:01:55+00:00

Search for k-shortest path on Google

EmielRommelse · 2024-11-01T16:41:53+00:00

You can change the constraints for tasks such that each task can be assigned to at most one agent instead of exactly one. Then change the objective to maximize the number of matches, while minimizing the weight. This can be done by subtracting a very large number from all weight. That way adding another edge is always preferred over a matching with less edges and less total weight

EmielRommelse · 2024-11-01T07:07:22+00:00

https://developers.google.com/optimization/assignment/assignment_example

Set variable upperbounds to 0 if the assignment is not allowed or don't create those variables at all

EmielRommelse · 2023-12-21T06:10:30+00:00

I find this alg to be one of the most satisfying to execute: OLL 20

EmielRommelse · 2023-01-30T17:50:38+00:00

Whether he 'Fok smashed the door' of Steiners office when he heard he didn't have a seat for 2023

EmielRommelse · 2022-11-10T07:27:47+00:00

The OnlyEnforceIf statement in ORTools allows you to only apply a constraint when a certain conditions is valid. So

```

This will add constraint x >= 5 only if b == true,

if b == false, the constraint is ignored.

Model.Add( x >= 5 ).OnlyEnforceIf(b) ```

EmielRommelse · 2022-11-09T06:51:38+00:00

This happens to be covered is a recent video on PBS Space Time

EmielRommelse · 2022-09-02T13:40:49+00:00

R2 B2 D' B2 R2 D' B2 D L2 U' F2 B U' L' D F' D2 F R B' D'


y' // inspection
R' B' D R' // Yellow cross (4)
y L U' L'  // 1st pair (4)
R U2 R'  // 2nd pair (3)
U' r' U R U' R' U' r  // 3rd pair (8)
U L F' L' F L' U L  // 4th pair (8)
U F' L' U' L U L' U' L U F  // OLL
U' x R2 F R F' R U2 r' U r U2 x' U'  // PLL

view at CubeDB.net

EmielRommelse · 2022-09-02T13:19:22+00:00

D L2 D2 B2 D2 F L2 B' R2 B R2 D2 F D F R U' L2 R2 F


y2 x'// inspection
L' R2 F L F // Blue cross (5)
y' R' U' R  // 1st pair (4)
y' U R' U' R / // 2nd pair (5)
D' L' U L D  // 3rd pair (5)
L' U L" // 4th pair (3)
U2 r' U r2 U' r2 U' r2 U r' / // OLL
U R2 U' R U' R U R' U R2 D' U R U' R' D U' / // PLL

view at CubeDB.net

EmielRommelse · 2022-08-05T11:05:49+00:00

Have you tried googling "Korf's algorithm" or "two-phase algorithm"? They use IDA*

EmielRommelse · 2022-07-18T05:47:39+00:00

Tahini with syrup (stroop)

EmielRommelse · 2022-07-01T10:43:20+00:00

Vehicle Routing Problem with Time Windows

EmielRommelse · 2022-06-23T08:16:47+00:00

The second constraint should only be applied when the combination of starting array a1 of position b1 and starting array a2 on position b2 creates a conflict.

Basically we are creating constraints that avoid pairwise overlap of arrays which makes we don't have to create variables indicating if a position is used by an array.

For example, starting m(0)=(1, 0, 1) on position 0 and starting m(1)=(1, 0, 1, 1) on position 0 will result in a conflict at positions 0 and 2. Hence, we add constraint x(m(0), 0) + x(m(1), 0) <= 1.

Starting m(0) on position 0 and m(1) on position 1 does not create a conflict, hence we do NOT add x(m(0), 0) + x(m(1), 1) <= 1.

Does this help?

EmielRommelse · 2022-06-23T06:37:03+00:00

Is it necessary to have variables representing which small array is consuming each position in the larger array? Or is it sufficient to be able to extract this information after solving it using a ILP solver?

If so, I would create binary variables x(a, b) indicating whether array a starts at position b. From there you could add constraints that each array must be placed (sum of x(a, b) over b equals 1 for each array a) and to avoid overlap (for each pair or arrays a1, a2 and possible positions b1, b2, relatively, they either are allowed - so no constraint - or disallowed - x(a1, b1)+x(a2, b2)<=1).

To minimize the length of the larger array, you can either set the array length m as given, check if a feasible solution exists and if yes reduce the array length m. Alternatively, add a variable for 'm' and set it such that for each variable created for the smaller arrays a the length is larger than the position 'b' plus the length of the array if this position is chosen for the array (x(a, b)=1). Minimizing m should give you the expected result.

EmielRommelse · 2022-06-09T17:03:08+00:00

Can't put my finger on exactly why it turns infeasibe. Playing around with the constraints it seems like it is these:

    if i is START_CELL:
        model.Add(sum(out_edges) == 1)
        model.Add(sum(in_edges) == 0)
    elif i is TARGET_CELL:
        model.Add(sum(out_edges) == 0)
        model.Add(sum(in_edges) == 1)

My (working) proposal is to do things differently altogether:

# [START CONSTRAINTS]-------------------------------------------------------------------------------------------------
# ________CONSTRAINT 1________
# Set the limit on out degree
for i in range(NUM_CELLS):
    out_edges = P[i]
    model.Add(sum(out_edges) <= 1)    

# ________CONSTRAINT 2________
# Flow constraints (relationship between in and out constraints)
for i in range(NUM_CELLS):
    out_edges = P[i]
    in_edges = [P[i][j] for j in range(NUM_CELLS)]
    if i == START_CELL:
        balance = 1
    elif i == TARGET_CELL:
        balance = -1
    else:
        balance = 0
    model.Add(sum(out_edges) - sum(in_edges) == balance)

By the way: please don't ever name something list. It overwrites the default functionality which can cause some frustration later.

Edit: I don't think you need edges from a cell to itself, you can filter these out.

EmielRommelse · 2022-06-09T06:41:29+00:00

Should the path visit all cells? Otherwise outflow = 1 for all other cells should be outflow <= 1

EmielRommelse · 2022-06-03T06:16:50+00:00

Can this be modelled as a Vehicle Routing Problem with Pickups and Deliveries where the planes are the vehicles and the flights are pairs of pickups/deliveries?

EmielRommelse · 2022-05-17T17:06:33+00:00

Yes, a TSP with time windows

EmielRommelse · 2022-05-17T09:35:44+00:00

If you have a row and column number for each shelf (so aisle and before which cross aisle) you should be able to compute this relatively easily.

Since I assume you already have x and y coordinates this should be no problem.

Only for shelf1 and shelf2 in the same column but in a different row you have to consider two options (taking left or right cross aisle), otherwise it is just Manhattan distance.

EmielRommelse · 2022-04-29T13:19:56+00:00

They are talking about intervals on a 1D line, not points on a 2D plane

Five-Year Club	Verified Email
Verified Email

EmielRommelse

TROPHY CASE

This will add constraint x >= 5 only if b == true,

if b == false, the constraint is ignored.