井字游戏的阶乘数组

Question

I am currently trying to teach myself C++ and programming in general. So as a beginner project i'm making a genetic algorithm that creates an optimal AI for a Tic-Tac-Toe game. I am not enrolled in any programming classes so this is not homework. I'm just really interested in AI.

So i am trying to create a multidimensional array of a factorial, in my case 9! . For example if you made one of 3! it would be array[3][6] = { {1, 2, 3}, {1, 3, 2}, {2, 3, 1}, {2, 1, 3}, {3, 2, 1}, {3, 1, 2}}. Basically 3! or 3*2*1 would be the amount of ways you could arrange 3 numbers in order.

I think that the solution should be simple yet im stuck trying to find out how to come up with a simple solution. I have tried to swap them, tried to shift them right, increment ect.. the methods that work are the obvious ones and i don't know how to code them.

So if you know how to solve it that's great. If you can give a coding format that's better . Any help is appreciated.

Also i'm coding this in c++.

Answer 1

You can use next_permutation function of STL

http://www.cplusplus.com/reference/algorithm/next_permutation/

Answer 2

I actually wrote an algorithm for this by hand once. Here it is:

bool incr(int z[NUM_INDICES]){
    int a=NUM_INDICES-1;
    for(int i=NUM_INDICES-2;i>=0;i--)
      if(z[i]>z[i+1]) a--;
      else break;
    if(a==0) return false;
    int b=2147483647,c;
    for(int i=a;i<=NUM_INDICES-1;i++)
      if(z[i]>z[a-1]&&z[i]-z[a-1]<b){
        b=z[i]-z[a-1];
        c=i;
      }
    int temp=z[a-1]; z[a-1]=z[c]; z[c]=temp;
    qsort(z+a,NUM_INDICES-a,sizeof(int),comp);
    return true;
}

This is the increment function (ie you have an array like [3,2,4,1], you pass it to this, and it modifies it to [3,4,1,2]). It works off the fact that if the last d elements of the array are in descending order, then the next array (in "alphabetical" order) should satisfy the following conditions: 1) the last d+1 elements are a permutation among themselves; 2) the d+1 -th to last element is the next highest element in the last d+1 elements; 3) the last d elements should be in ascending order. You can see this intuitively when you have something like [2,5,3, 8,7,6,4,1]: d = 5 in this case; the 3 turns into the next highest of the last d+1 = 6 elements; and the last d = 5 are arranged in ascending order, so it becomes [2,5,4, 1,3,6,7,8].

The first loop basically determines d . It loops over the array backwards, comparing consecutive elements, to determine the number of elements at the end that are in descending order. At the end of the loop, a becomes the first element that is in the descending order sequence. If a==0 , then the whole array is in descending order and nothing more can be done.

The next loop determines what the d+1 -th-to-last element should be. We specified that it should be the next highest element in the last d+1 elements, so this loop determines what that is. (Note that z[a-1] is the d+1 -th-to-last element.) By the end of that loop, b contains the lowest z[i]-z[a-1] that is positive; that is, z[i] should be greater than z[a-1] , but as low as possible (so that z[a-1] becomes the next highest element). c contains the index of the corresponding element. We discard b because we only need the index.

The next three lines swap z[a-1] and z[c] , so that the d+1 -th-to-last element gets the element next in line, and the other element ( z[c] ) gets to keep z[a-1] . Finally, we sort the last d elements using qsort ( comp must be declared elsewhere; see C++ documentation on qsort ).

Answer 3

If you want a hand crafted function for generating all permutations, you can use

#include <cstdio>
#define REP(i,n) FOR(i,0,n)
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define GI ({int t;scanf("%d",&t);t;})

int a[22], n;

void swap(int & a, int & b) {
    int t = a; a = b; b = t;
}

void perm(int pos) {
    if(pos==n) {
        REP(i,n) printf("%d ",a[i]); printf("\n");
        return;
    }
    FOR(i,pos,n) {
        swap(a[i],a[pos]);
        perm(pos+1);
        swap(a[pos],a[i]);
    }
    return;
}

int main (int argc, char const* argv[]) {

    n = GI;
    REP(i,n) a[i] = GI;
    perm(0);

    return 0;
}