hipersześcian i macierz sąsiedztw

Witam,
Mam wielki problem. Niedługo mam zaliczenie z programowania w c++ a w ramach pracy zaliczeniowej muszę napisać program generujący hipersześcian dowolnego stopnia a wynik swojej pracy ma zapisywać w pliku tekstowym w postaci macierzy sąsiedztw. Szukałem w sieci, ale nie mogę znależć nic na ten temat. Jeżeli ktoś wie jak to zrobić to bardzo proszę o pomoc.

Chodzi o taki odpowiednik sześcianu w przestrzeni 4-wymiarowej?
Widziałem coś takiego w wikipedii - w English - hypercube

Tak, jest tego <ort>mnÓstwo</ort> w sieci, ale wszystkie materiały te polsko i anglojezyczne jakie znalazłem opisują hipersześciany ale nie mogę znależć algorytmu, który pozwoliłby mi wygenerować macierz sąsiedztw "opisującą" hipersześcian n - tego stopnia.

liczba m-wymiarowych powierzchni (krawędzi, ścian, ...) w n-wymiarowym 'sześcianie':
2^(n-m)*(n po m)

np. 4-wymiarowy ma: 8 sześcianów (3D), 24 kwadraty(2D), 32 linie, i 16 wierzchołków.

Co z czym ma sąsiadować w tej macierzy sąsiedzctw?

Ten hipersześcian ma pełnić rolę topologii sieci komputerowej. Cały program będzie symulował poruszanie się pakietów w sieci. Niestety nie mogę posłużyć się gotowymi macierzami sąsiedztw tylko muszę napisać własną funkcję generującą taką macierz dowolnego stopnia.

Czyli chodzi o wierzchołki - przecież tu nie ma nic do roboty... :D

Może i nie ma ale nie potrafię sobie z tym poradzic. Jak możesz to bardzo proszę o pomoc :)

masz 2^n wierzchołków,
ich współrzędne to: (xyz...) = 0...0, 10...0, 010...0, ... 11...1
czyli są to liczby binarne od (0, 2^n-1),
dziesiętnie wygląda to tak: 0,1,2,3,4...

Wierzchołki sąsiadują, wtedy gdy różnią się jedną wsp. (po przekątnych nie ma krawędzi), czyli te liczby binarne różnią się jednym bitem - to wszystko.

zwykły sześcian: n = 3, 8 - wierzchołków

_++_+___
+__+_+__
+__+__+_
_++____+
+____++_
_+__+__+
__+_+__+
___+_++_

Kolumny i wiersze są identyczne - macierz symetryczna - wystarczy pamiętać połowę bez przekątnej.

dla n = 5, 32 wierz.

_++_+___+_______+_______________
+__+_+___+_______+______________
+__+__+___+_______+_____________
_++____+___+_______+____________
+____++_____+_______+___________
_+__+__+_____+_______+__________
__+_+__+______+_______+_________
___+_++________+_______+________
+________++_+___________+_______
_+______+__+_+___________+______
__+_____+__+__+___________+_____
___+_____++____+___________+____
____+___+____++_____________+___
_____+___+__+__+_____________+__
______+___+_+__+______________+_
_______+___+_++________________+
+________________++_+___+_______
_+______________+__+_+___+______
__+_____________+__+__+___+_____
___+_____________++____+___+____
____+___________+____++_____+___
_____+___________+__+__+_____+__
______+___________+_+__+______+_
_______+___________+_++________+
________+_______+________++_+___
_________+_______+______+__+_+__
__________+_______+_____+__+__+_
___________+_______+_____++____+
____________+_______+___+____++_
_____________+_______+___+__+__+
______________+_______+___+_+__+
_______________+_______+___+_++_

1. tworze tablice 2^n elementow. 1 oznacza ze wierzcholek jest wierzcholkiem sasiednim a 0 ze nie.
2. zeruje tablice
3. dla kazdego wierzcholka (od 0 do 2^{n-1) wyznaczam jego sasiadów (liczby rozniace sie o jeden bit). Sprawdzam po kolei wartosc bitow od najmlodszego do najstarszego (if (i & k)) gdzie k przyjmuje wartosc 1,2,4,8..2}n i zamieniam na przeciwny.. jesli 0 to (i|k) jesli 1 to (i&~k). W ten sposob otrzymuje numer sasiedniego wierzcholka wiec w odpowiednim polu tablicy wpisuje 1.
4. zapis wiersza macierzy do pliku

#include <iostream>
#include <fstream>
#include <cmath>

using namespace std;

int main(int argc, char *argv[])
{
    long n,pown;
    char* tab;
    
    cin >> n;
    if (n>32 || n<3)
      return 1;
    pown = static_cast<long>(pow(2.,static_cast<double>(n)));                   
    ofstream pisz("matrix.txt");            

    tab = new char[pown];                                   //*1
    for(long i=0 ; i<pown ; i++)
    {
      for(long x=0 ; x<pown ; x++)                      //*2
        tab[x]='0';
      for(long j=0,k=1 ; j<n ; j++,k*=2)               //*3
        if(i & k)                               
          tab[i&~k] = '1';                          
        else
          tab[i|k] = '1';                          
      for(long a=0; a<pown ; a++)                       //*4
        pisz << tab[a];
      pisz << endl; 
    }
    delete[] tab;
    system("PAUSE");
    return EXIT_SUCCESS;
}

mam nadzieje ze teraz bedzie to troche jasniejsze, przepraszam za wczesniejszy nielad

//wystarczy samo cpp bez code - foflik</cpp>

Przyglądam się temu kodowi, i jakoś trudno mi znaleźć miejsce, w którym uzyskujesz wiedzę: które liczby różnią się jednym bitem.

Jest ok.
Jedynie ten limit n = 32 jest lekko przesadzony:
potrzeba wtedy 4GB RAM na tę tablicę! :)