总统座位回溯

Question

I have a problem in front of me that I can't grasp, even though I grasp the concept of backtracking well. I have been unable to find any information on this specific problem, and I am unaware if it goes by another name. The problem is to construct a backtracking algorithm that will print out the list of combinations of seating that N number of "presidents" can sit at a round table without sitting next to the same person twice. For example, you give it an input 8, it gives you the output,

1 2 3 4 5 6 7 8

1 3 5 2 6 8 4 7

1 4 2 7 5 8 3 6

Now I have constructed my own backtracking algorithms for simple games (checkers, n-queens, tic-tac-toe), however these that I have worked with have started with a blank canvas and didn't require this type of implementation. What I am asking for is a bit of guidance and insight, or links to more information to this problem as all that was given was about a page and a half, mostly talking about how the combination 1 2 3 4 is effectively the same as 1 4 3 2 in this particular problem. This needs to be done using a backtracking method and that's what is making me confused. If we were give free rein to find solutions I could easily do it. Any help is appreciated.

Thanks!

Answer 1

I'm thinking you'll have to add information about who sat next to who already to the backtracking algorithm state:

• You start with, say 1 . You seat 2 next to him, and record this "pairing" in the current partial solution. _{(Literally just an unordered pair of president IDs. An easy way of implementing an unordered pair of numbers is to have the constructor of that class store the smaller ID in the first element of the pair, and the greater ID in the second element.)} So you have a partial solution 1 2 … , with the pairing 1-2 .
• When you reach to a complete solution, you add all its pairings to a "global" list of pairings. This will be used in future searches. Ie if you get the solution 1 2 3 4 5 6 7 8 , you save the pairings 1-2 , 2-3 , 3-4 , 4-5 , 5-6 , 6-7 , 7-8 , 1-8 .

• Now, when doing a search, you have a partial solution xyz … – the last president seated so far is z , and the pairings in this partial solution are xy and yz . To seat the next president, you need to look at every president that's:

  1. Not seated so far. (And thus not included in the partial solution's pairings.)
  2. Not paired with z in the global pairings.

  If no such president is available, you discard the partial solution and backtrack.

That said, I'm working off the top of my head here, so you'd be well advised to actually doublecheck if I missed any edge cases by using a straightforward brute force implementation and comparing the results.

Answer 2

A very rough pseudocode will look like this:

global flag // I know it is a bad practice but can't think of a better idea at this point
back (PresidentList, chairNumber, computedList)
if (PresidentList.size() == 0) 
    if (computedList doesn't violate any global distribution)
        add computedList to globalList
        add distirbution of computedList to global distirbution
        set flag;
    else return;
else if (flag is set and chairNumber > 2) return;
else if (flag is set and chairNumber = 2) un set flag; return;
else if (chairNumber == maxChairs-1)
    // at this point there should be only one president in PresidentList
    if (PresidentList.back() can sit with computedList.back() and computedList.front())
        remove president from PreseidentList, add president to computedList
        back(PresidenList, chairNumber+1,computedList)
    else return;
else
    for every president in PresidentList
        if (president can sit with computedList.back()) 
             remove president from PreseidentList, add president to computedList
             back(PresidentList,chairNumber+1,computedList);

You always check if a president can sit near some other president only according to the global distribution variable.

In the main function just run a loop for PresidentList that will start back with that president being as the first one.

The idea of the flag is as follows: when you add a distribution and a list to the global list, back runs already a lot of branches which have the same prefix as the list you just added and hence are already bad. To close all those lists you force the back to stop branching and return to the point when it can set a new 2nd element in the list to compute ie get back to the loop if the last else branch of the function.