#### cuBerBruce

##### Member
There was a similar thread awhile back where I posted Visual C++ source code in [post=536867]this post[/post] for a program that did something similar to what is being discussed in this thread. I note I only considered 13! letter orderings rather than full 21! orderings. But I posted source code so you can try to adapt it as you please.

#### Stefan

##### Member
I now have doubts about the feasibility. At least it's not trivial. The AUFs are killing it.

I'd like to use dynamic programming with a table like this:
ways[SET][CASE] = number of ways to order the PLLs in the set SET and end up with case CASE

ways[NONE][SOLVED] = 1

Then fill the table from there and read the result from:
ways[ALL][SOLVED]

Here's my problem: Let's say
ways[{Aa,R,J,H}][H] = 23
ways[{Aa,R,J,H}][E] = 42

and I'd like to compute
ways[{Aa,R,J,H,T}][F]
and consider T as the last in the order.

Using T we can get to F from both H and E, so we should add their numbers to the new cell, right? Sadly not, as because of AUFs, the same order of {Aa,R,J,H} can lead to both H and E, so just adding them together we'd double count.

However, this still works to tell *whether* there is any way to use a set of PLLs to reach a case. And I've envisioned that as the main application anyway - starting your PLL attack some way you want, and have the program tell you whether you can get back to solved using the remaining PLLs (and perhaps show one or several possible ways). On the other hand, I suspect that with six or so left, it's always possible, and that's small enough to brute-force anyway.

Last edited:

over 9000