//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void  TForm1::main()
{
 char    *stime[30],*etime[30];
 __int64  tick1,tick2;

      tick1 = GetTickCount();

      Form1->Cursor = crHourGlass;

      fid    = fopen("log.txt","wt");

      time(&t1);
      *stime = ctime(&t1);
      fprintf(fid,"*** pazul started : %s \n",*stime);

      Edit1->Text = *stime;
      Edit3->Text = IntToStr(time(&t2)-t1);

      Form1->Refresh();

      exec();

      tick2 = GetTickCount();
      result = (int) (tick2 -tick1);

      time(&t2);
      *etime = ctime(&t2);
      fprintf(fid,"\n*** pazul  ended  time = %d ms  : %s \n",result,*etime);

      Edit2->Text = *etime;
      Edit3->Text = IntToStr(t2-t1);
      Edit4->Text = IntToStr(result);

      fclose(fid);

  // reset cursor mark
      Form1->Cursor = crDefault;

 }
//---------------------------------------------------------------------------
void    TForm1::exec()
{
 int    k;

        if ((Edit5->Text == "") | (Edit6->Text == "")) {
            fprintf(fid,"**** M,N undefined ****\n");
            return;
         }
        M  = StrToInt(Edit5->Text);
        N  = StrToInt(Edit6->Text);
        MN = M * N;
        if (MN > 4096) {
            fprintf(fid,"**** Too large problem ****\n");
            return;
         }
        Lightsout = (CheckBox1->Checked == true);
        TurnOver8 = (CheckBox2->Checked == true);
        if (Lightsout & TurnOver8) {
            fprintf(fid,"**** Switch Conflicted ****\n");
            return;
         }
        if (!(Lightsout | TurnOver8)) {
            fprintf(fid,"**** No Switch Selected ****\n");
            return;
         }
        Col= (MN+31) >> 5;

        for (k=0; k<32; k++) bit[k] = 0x80000000 >> k;

        init();
        printResult(0);
        solve();
        printResult(1);
 }
//---------------------------------------------------------------------------
void    TForm1::init()
{
 int    k,p,q,i;

        for (k=0; k<MN; k++) {
            for (i=0; i<=Col; i++) { X[k][i] = 0; V[k][i] = 0; }

            biton(V[k],k);

            p = k / N;
            q = k % N;

            if (Lightsout != 0) {
                biton(X[k],k);
                if (q < (N-1))   biton(X[k],k+1);
                if (q >     0)   biton(X[k],k-1);
                if (p < (M-1))   biton(X[k],k+N);
                if (p >     0)   biton(X[k],k-N);
             }
            if (TurnOver8 != 0) {
                if (q < (N-1))   biton(X[k],k+1);
                if (q >     0)   biton(X[k],k-1);
                if (p < (M-1))   biton(X[k],k+N);
                if (p >     0)   biton(X[k],k-N);
                if ((p >     0) & (q >    0))   biton(X[k],k-1-N);
                if ((p >     0) & (q < (N-1)))  biton(X[k],k+1-N);
                if ((p < (M-1)) & (q >    0))   biton(X[k],k-1+N);
                if ((p < (M-1)) & (q < (N-1)))  biton(X[k],k+1+N);
             }

         }
  }
//---------------------------------------------------------------------------
void    TForm1::biton(int X[],int pos)
{
 int    i,j;

        i = pos >> 5;
        j = pos & 0x1f;
        X[i] |= bit[j];

 }
//---------------------------------------------------------------------------
int     TForm1::bittest(int X[],int pos)
{
 int    i,j;

        i = pos >> 5;
        j = pos & 0x1f;
        return (X[i] & bit[j]);

 }
//---------------------------------------------------------------------------
void    TForm1::swap(int X[],int Y[])
{
 int    i,w;

        for (i=0; i<Col; i++) {
            w    = X[i];
            X[i] = Y[i];
            Y[i] = w;
         }
 }
//---------------------------------------------------------------------------
void    TForm1::solve()
{
 int    k,kk,i;

        for (k=0; k<MN; k++) {
             if (bittest(X[k],k) == 0) {
                for (kk=k+1; kk<MN; kk++) if (bittest(X[kk],k) != 0) break;
                if (kk == MN)           continue;
                swap(X[k],X[kk]);  swap(V[k],V[kk]);
             }
            for (kk=0; kk<MN; kk++) {
                if (k == kk)    continue;
                if (bittest(X[kk],k) == 0)  continue;
                for (i=0; i<Col; i++) X[kk][i] ^= X[k][i];
                for (i=0; i<Col; i++) V[kk][i] ^= V[k][i];
             }
         }
 }
//---------------------------------------------------------------------------
void    TForm1::printResult(int id)
{
 int    k,kk;
 const  ch[] = { 'a','b','c','d','e','f','g','h','i','j','k','l','m',
                 'n','o','p','q','r','s','t','u','v','w','x','y','z',
                 '0','1','2','3','4','5','6','7','8','9' };

        if (TurnOver8 != 0) {
            printTurnOver8(id);
            return;
         }
        (id == 0)?  fprintf(fid,"\n*** initial ***\n") :
                    fprintf(fid,"\n*** answer ***\n");

        for (k=0; k<MN; k++) {
            fprintf(fid,"  %2d    ",k+1);
            for (kk=0; kk<MN; kk++)
                (bittest(X[k],kk))?  fprintf(fid,"%d",(kk+1)%10) : fprintf(fid,"-");
            fprintf(fid,"   ");
            for (kk=0; kk<MN; kk++)
                (bittest(V[k],kk))?  fprintf(fid,"%c",ch[kk%36]) : fprintf(fid,"-");
            fprintf(fid,"\n");
         }
        fflush(fid);
 }
//---------------------------------------------------------------------------
void    TForm1::printTurnOver8(int id)
{
 int    k,kk,f,q,Q,p,s,push;
 unsigned int w;

        if (id == 0)  return;

        for (k=0; k<MN; k++) {
            X[k][Col] = count(X[k]);
            V[k][Col] = count(V[k]) & 0x01;
         }
        for (k=MN-1; k>=0; k--) {
            if (X[k][Col] != 0)  break;
            if (V[k][Col] != 0) {
                fprintf(fid,"*** Sorry, (%d,%d) has No Solution ***\n",M,N);
                return;
             }
            if ((MN-k) > 24) {
                f = 0;
                Q = 0;
                fprintf(fid,"*** (%d,%d) has Too many Frees, Non-optimal Solution ***\n",M,N);
                goto answer;
             }
            X[k][Col] = bit[32-(MN-k)];
         }
        f = MN - k - 1;

        p = (k+1) >> 5;
        s = (MN - 1) & 0x1f;
        for (kk=0; kk<=k; kk++) {
            w = X[kk][Col-1];
            X[kk][Col] = w >> (31-s);
            if (p != (Col-1)) X[kk][Col] |= X[kk][Col-2] << (s+1);
         }
      //find min solution
        push = MN;
        for (q=0; q <bit[31-f]; q++) {
            p = 0;
            for (k=0; k<MN; k++) p += count(X[k][Col] & q) ^ V[k][Col];
            if (p < push) { push = p; Q = q; }
         }

        (f == 0)?
          fprintf(fid,"*** (%d,%d) has Unique Solution.   %d pushes***\n",M,N,push) :
          fprintf(fid,"*** (%d,%d) has dgree(%d) Solutions.  min %d pushes ***\n",M,N,f,push);

     answer:
        for (k=0; k<MN; k++) {
            if ((k % N) == 0)  fprintf(fid,"\n    ");
            ((count(X[k][Col] & Q) ^ V[k][Col]) == 0)? fprintf(fid,"� ") : fprintf(fid,"�¡");
         }
        fprintf(fid,"\n");
        fflush(fid);
 }
//---------------------------------------------------------------------------
int     TForm1::count(int Q[])
{
 int    c,w,i;

        c = 0;
        for (i=0; i<Col; i++) {
            w = Q[i];
            while (w != 0) { c++; w &= w -1; };
         }
        return c;
 }
//---------------------------------------------------------------------------
int     TForm1::count(int Q)
{
 int    c,w;

        c = 0;
        w = Q;
        while (w != 0) { c++; w &= w -1; };
        return (c & 0x01);
 }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClick(TObject *Sender)
{
     main();
}
//---------------------------------------------------------------------------