งาน

เขียนโปรแกรมที่อ่านจำนวนเต็มสามจำนวนm , nไม่ว่าจาก STDIN หรือเป็นอาร์กิวเมนต์บรรทัดคำสั่งพิมพ์การเอียงที่เป็นไปได้ทั้งหมดของขนาดสี่เหลี่ยมผืนผ้าm × nคูณ2 × 1และ1 × 2และในที่สุดก็ถึงจำนวนการเอียงที่ถูกต้อง

Dominos ของแต่ละการเรียงต่อกันจะต้องมีเครื่องหมายสองขีด ( -) สำหรับ2 × 1และสองแถบแนวตั้ง ( |) สำหรับ1 × 2 Dominos แต่ละการเรียงต่อกัน (รวมถึงอันสุดท้าย) จะต้องตามด้วยตัวป้อนบรรทัด

เพื่อจุดประสงค์ในการให้คะแนนคุณต้องยอมรับการตั้งค่าสถานะจาก STDIN หรือเป็นอาร์กิวเมนต์บรรทัดคำสั่งที่ทำให้โปรแกรมของคุณพิมพ์เฉพาะจำนวนการเอียงที่ถูกต้อง แต่ไม่ใช่การเอียง

โปรแกรมของคุณอาจมีขนาดไม่เกิน 1024 ไบต์ มันจะต้องมีการทำงานสำหรับปัจจัยการผลิตทั้งหมดเช่นว่าม. × n ≤ 64

(ได้แรงบันดาลใจจากพิมพ์โดมิโนเอียงของสี่เหลี่ยมผืนผ้า 4x6ทั้งหมด)

ตัวอย่าง

$ sdt 4 2
----
----

||--
||--

|--|
|--|

--||
--||

||||
||||

5
$ sdt 4 2 scoring
5

เกณฑ์การให้คะแนน

คะแนนของคุณจะถูกกำหนดโดยเวลาดำเนินการของโปรแกรมของคุณสำหรับการป้อนข้อมูล8 8พร้อมชุดธง

เพื่อให้เป็นรหัสที่เร็วที่สุดแทนที่จะท้าทายกับคอมพิวเตอร์ที่เร็วที่สุดฉันจะเรียกใช้การส่งทั้งหมดในคอมพิวเตอร์ของฉัน (Intel Core i7-3770, 16 GiB PC3-12800 RAM) เพื่อกำหนดคะแนนอย่างเป็นทางการ

กรุณาทิ้งคำแนะนำโดยละเอียดเกี่ยวกับวิธีการรวบรวมและ / หรือรันรหัสของคุณ หากคุณต้องการคอมไพเลอร์ / ล่ามภาษาของคุณในเวอร์ชันที่เฉพาะเจาะจง

ฉันขอสงวนสิทธิ์ในการออกจากการส่งที่ไม่ได้รับคะแนนถ้า

• ไม่มีคอมไพเลอร์ / ล่ามฟรี (เหมือนในเบียร์) สำหรับระบบปฏิบัติการของฉัน (Fedora 21, 64 บิต)

• แม้จะมีความพยายามของเรารหัสของคุณไม่ทำงานและ / หรือสร้างผลลัพธ์ที่ไม่ถูกต้องในคอมพิวเตอร์ของฉัน

• การรวบรวมหรือการดำเนินการใช้เวลานานกว่าหนึ่งชั่วโมง

• รหัสหรือคอมไพเลอร์ / ล่ามที่มีอยู่เท่านั้นของคุณมีการเรียกระบบrm -rf ~หรือสิ่งที่เท่าเทียมกัน

ลีดเดอร์บอร์ด

ฉันให้คะแนนการส่งทั้งหมดอีกครั้งโดยรันทั้งการรวบรวมและการประมวลผลแบบวนซ้ำ 10,000 รอบสำหรับการรวบรวมและระหว่าง 100 ถึง 10,000 ซ้ำสำหรับการดำเนินการ (ขึ้นอยู่กับความเร็วของรหัส) และการคำนวณค่าเฉลี่ย

ผลลัพธ์เหล่านี้คือ:

User          Compiler   Score                              Approach

jimmy23013    GCC (-O0)    46.11 ms =   1.46 ms + 44.65 ms  O(m*n*2^n) algorithm.
steveverrill  GCC (-O0)    51.76 ms =   5.09 ms + 46.67 ms  Enumeration over 8 x 4.
jimmy23013    GCC (-O1)   208.99 ms = 150.18 ms + 58.81 ms  Enumeration over 8 x 8.
Reto Koradi   GCC (-O2)   271.38 ms = 214.85 ms + 56.53 ms  Enumeration over 8 x 8.

ค

การใช้งานที่ไม่ซับซ้อน ...

#include<stdio.h>
int a,b,c,s[65],l=0,countonly;
unsigned long long m=0;
char r[100130];
void w(i,x,o){
    int j,k;
    j=(1<<b)-1&~x;
    if(i<a-1){
        s[i+1]=j;
        w(i+1,j,1);
        for(k=j&j/2&-o;j=k&-k;k&=~j)
            w(i,x|3*j,j);
    }
    else if((j/3|j/3*2)==j)
        if(countonly)
            m++;
        else{
            if(c==b)
                for(k=0;k<b;r[k++,l++]=10)
                    for(j=0;j<a;j++)
                        r[l++]=45+79*!((s[j]|s[j+1])&(1<<k));
            else
                for(j=0;j<a;r[j++,l++]=10)
                    for(k=0;k<b;k++)
                        r[l++]=124-79*!((s[j]|s[j+1])&(1<<k));
            r[l++]=10;
            if(l>=100000){
                fwrite(r,l,1,stdout);
                l=0;
            }
        }
}

int main(){
    scanf("%d %d %d",&a,&b,&countonly);
    c=b;
    if(a<b){a^=b;b^=a;a^=b;}
    s[0]=s[a]=0;
    w(0,0,1);
    if(countonly)
        printf("%llu\n",m);
    else if(l)
        fwrite(r,l,1,stdout);
}

รุ่นโกง

#include<stdio.h>
#include<string.h>
int a,b,c,s[65],l=0,countonly;
unsigned long long m=0,d[256];
char r[100130];
void w2(){
    int i,j,k,x;
    memset(d,0,sizeof d);
    d[0]=1;
    j=0;
    for(i=0;i<a-1;i++){
        for(k=1;k<(1<<(b-1));k*=2)
            for(x=0;x<(1<<(b-2));x++)
                d[(x+x/k*k*3+k*3)^j]+=d[(x+x/k*k*3)^j];
        j^=(1<<b)-1;
    }
    for(x=0;x<(1<<b);x++)
        if((x/3|x/3*2)==x)
            m+=d[x^((1<<b)-1)^j];
    printf("%llu\n",m);
}

void w(i,x,o){
    int j,k;
    j=(1<<b)-1&~x;
    if(i<a-1){
        s[i+1]=j;
        w(i+1,j,1);
        for(k=j&j/2&-o;j=k&-k;k&=~j)
            w(i,x|3*j,j);
    }
    else if((j/3|j/3*2)==j){
        if(c==b)
            for(k=0;k<b;r[k++,l++]=10)
                for(j=0;j<a;j++)
                    r[l++]=45+79*!((s[j]|s[j+1])&(1<<k));
        else
            for(j=0;j<a;r[j++,l++]=10)
                for(k=0;k<b;k++)
                    r[l++]=124-79*!((s[j]|s[j+1])&(1<<k));
        r[l++]=10;
        if(l>=100000){
            fwrite(r,l,1,stdout);
            l=0;
        }
    }
}

int main(){
    scanf("%d %d %d",&a,&b,&countonly);
    c=b;
    if(a<b){a^=b;b^=a;a^=b;}
    s[0]=s[a]=0;
    if(countonly)
        w2();
    else{
        w(0,0,1);
        if(l)
            fwrite(r,l,1,stdout);
    }
}

คำอธิบายของอัลกอริทึมที่เร็วขึ้น

มันสแกนจากซ้ายไปขวาและรักษาสถานะd[i][j]ที่:

• iอยู่ใน[0,m)ซึ่งหมายถึงคอลัมน์ปัจจุบัน
• jเป็นเวกเตอร์ขนาดnบิตโดยบิตจะเป็น 1 หากตำแหน่งที่สอดคล้องกันในคอลัมน์iนั้นถูกครอบครองอยู่ก่อนที่จะเริ่มทำงานในคอลัมน์นี้ --คือมันถูกครอบครองโดยครึ่งขวาของ
• d[i][j] คือจำนวนรวมของการเอียงที่แตกต่างกัน

แล้วพูดe[i][j]= ผลรวมของd[i][k]ที่คุณสามารถใส่แต้มแนวตั้งฐานบนฟอร์มk จะเป็นจำนวน tilings ที่แต่ละบิต 1 ในครอบครองโดยอะไร แต่ครึ่งซ้ายของ เติมด้วยและคุณจะได้รับ= . หรือเป็นคำตอบสุดท้ายje[i][j]j----d[i+1][~j]e[i][j]e[m-1][every bit being 1]d[m][0]

การนำไปปฏิบัติที่ไร้เดียงสาจะทำให้คุณมีเวลาที่ซับซ้อนใกล้เคียงg[n]=2*g[n-1]+g[n-2] = O((sqrt(2)+1)^n)(เร็วพอถ้า n = m = 8) แต่ก่อนอื่นคุณสามารถวนซ้ำสำหรับโดมิโนแต่ละอันที่เป็นไปได้และลองเพิ่มลงในทุก ๆ เรียงลำดับที่สามารถเพิ่มโดมิโนนี้และรวมผลลัพธ์เข้ากับอาร์เรย์เดิมd(เช่นอัลกอริธึมสำหรับปัญหาเป้) และนี่จะกลายเป็น O (n * 2 ^ n) และทุกอย่างอื่นคือรายละเอียดการใช้งาน รหัสทั้งหมดทำงานใน O (m * n * 2 ^ n)

ค

หลังจากรอบของการเพิ่มประสิทธิภาพและปรับให้เข้ากับกฎที่แก้ไข:

typedef unsigned long u64;

static int W, H, S;
static u64 RM, DM, NSol;
static char Out[64 * 2 + 1];

static void place(u64 cM, u64 vM, int n) {
  if (n) {
    u64 m = 1ul << __builtin_ctzl(cM); cM -= m;

    if (m & RM) {
      u64 nM = m << 1;
      if (cM & nM) place(cM - nM, vM, n - 1);
    }

    if (m & DM) {
      u64 nM = m << W;
      vM |= m; vM |= nM; place(cM - nM, vM, n - 1);
    }
  } else if (S) {
    ++NSol;
  } else {
    char* p = Out;
    for (int y = 0; y < H; ++y) {
      for (int x = 0; x < W; ++x) { *p++ = vM & 1 ? '|' : '-'; vM >>= 1; }
      *p++ = '\n';
    }
    *p++ = '\0';
    puts(Out);
    ++NSol;
  }
}

int main(int argc, char* argv[]) {
  W = atoi(argv[1]); H = atoi(argv[2]); S = (argc > 3);

  int n = W * H;
  if (n & 1) return 0;

  for (int y = 0; y < H; ++y) {
    RM <<= W; RM |= (1ul << (W - 1)) - 1;
  }
  DM = (1ul << (W * (H - 1))) - 1;

  place(-1, 0, n >> 1);
  printf("%lu\n", NSol);

  return 0;
}

ฉันเริ่มชนในขีดจำกัดความยาว 1024 อักขระดังนั้นฉันจึงต้องลดความสามารถในการอ่านได้บ้าง ชื่อตัวแปรที่สั้นกว่ามาก ฯลฯ

สร้างคำแนะนำ:

> gcc -O2 Code.c

เรียกใช้โดยเปิดใช้งานโซลูชันทางออก:

> ./a.out 8 8 >/dev/null

ทำงานด้วยจำนวนโซลูชันเท่านั้น:

> ./a.out 8 8 s

ความคิดเห็นบางส่วน:

• ด้วยตัวอย่างการทดสอบที่ใหญ่ขึ้นฉันต้องการการเพิ่มประสิทธิภาพทันที ในขณะที่ระบบของฉันแตกต่าง (Mac) -O2ดูเหมือนว่ารอบดี
• รหัสช้าลงสำหรับเคสที่สร้างเอาต์พุต นี่เป็นความเสียสละเพื่อการปรับโหมด "นับเท่านั้น" และเพื่อลดความยาวของรหัส
• จะมีคำเตือนคอมไพเลอร์เล็กน้อยเนื่องจากขาดการรวมและการประกาศภายนอกสำหรับฟังก์ชันระบบ มันเป็นวิธีที่ง่ายที่สุดในการทำให้ฉันต่ำกว่า 1024 อักขระในที่สุดโดยไม่ทำให้โค้ดอ่านไม่ได้เลย

โปรดทราบว่ารหัสยังคงสร้างโซลูชันจริงแม้ในโหมด "นับเท่านั้น" เมื่อใดก็ตามที่พบวิธีแก้ปัญหาvMbitmask จะมี1ตำแหน่งที่มีแถบแนวตั้งและ0ตำแหน่งที่มีแถบแนวนอน เฉพาะการแปลง bitmask นี้ในรูปแบบ ASCII และเอาต์พุตจริงเท่านั้นที่จะถูกข้าม

ค

แนวคิดคือการค้นหาการจัดเรียงโดมิโนแนวนอนที่เป็นไปได้ทั้งหมดก่อนอื่นเก็บไว้ใน r[]และจากนั้นจัดระเบียบเพื่อให้การจัดเรียงโดมิโนแนวตั้งที่เป็นไปได้ทั้งหมด

รหัสสำหรับการวางตำแหน่งโดมิโนแนวนอนในแถวนั้นได้รับการแก้ไขจากคำตอบของฉัน: https://codegolf.stackexchange.com/a/37888/15599 https://codegolf.stackexchange.com/a/37888/15599มันช้าสำหรับกริดที่กว้างขึ้น แต่นั่นไม่ใช่ปัญหาสำหรับเคส 8x8

นวัตกรรมเป็นวิธีการประกอบแถว หากบอร์ดมีจำนวนแถวคี่มันจะถูกหมุน 90 องศาในการแยกวิเคราะห์อินพุตดังนั้นตอนนี้จะมีจำนวนแถวเท่ากัน ตอนนี้ฉันวางโดมิโนแนวตั้งลงบนศูนย์กลาง เนื่องจากความสมมาตรหากมีcวิธีการจัดการโดมิโนที่เหลือในครึ่งล่างก็จะต้องมีcวิธีการจัดการโดมิโนที่เหลือในครึ่งบนซึ่งหมายความว่าสำหรับการจัดเรียงของแต้มโดมิโนแนวตั้งบนศูนย์กลางจะมีc*cวิธีแก้ปัญหาที่เป็นไปได้ . ดังนั้นจะมีการวิเคราะห์เฉพาะศูนย์รวมครึ่งหนึ่งของกระดานเมื่อโปรแกรมจำเป็นต้องพิมพ์จำนวนโซลูชั่นเท่านั้น

f()สร้างตารางการจัดเรียงของแต้มโดมิโนแนวนอนที่เป็นไปได้และสแกนผ่านการจัดเรียงแต้มโดมิโนแนวตั้งที่เป็นไปได้บนศูนย์กลาง มันจะเรียกฟังก์ชั่นวนซ้ำg()ซึ่งเติมในแถว หากจำเป็นต้องทำการพิมพ์ฟังก์ชันh()จะถูกเรียกให้ทำเช่นนี้

g()เรียกว่ามี 3 พารามิเตอร์ yคือแถวปัจจุบันและ dเป็นทิศทาง (ขึ้นหรือลง) ที่เราเติมกระดานจากกึ่งกลางออกไปด้านนอก xประกอบด้วยบิตแมปบ่งชี้ว่าโดมิโนแนวตั้งที่ไม่สมบูรณ์จากแถวก่อนหน้า พยายามจัดเรียงแต้มโดมิโนทั้งหมดที่อยู่ในแถวจาก r [] ในอาเรย์นี้ 1 หมายถึงโดมิโนแนวตั้งและศูนย์คู่โดมิโนแนวนอน รายการที่ถูกต้องในอาร์เรย์ต้องมีอย่างน้อย 1 พอที่จะเสร็จสิ้นแต้มแนวตั้งไม่สมบูรณ์ใด ๆ (x&r[j])==xจากแถวสุดท้าย: อาจมีมากกว่า 1 อันซึ่งบ่งชี้ว่าโดมิโนแนวดิ่งใหม่กำลังเริ่มขึ้น สำหรับแถวถัดไปเราต้องการโดมิโนใหม่เท่านั้นดังนั้นเราจึงเรียกขั้นตอนอีกครั้งด้วยx^r[j]สำหรับแถวถัดไปแล้วเราต้องการเพียงแต้มใหม่เพื่อที่เราเรียกขั้นตอนอีกครั้งกับ

หากถึงแถวสุดท้ายและไม่มีโดมิโนแนวตั้งแขวนอยู่ด้านบนหรือด้านล่างของบอร์ดx^r[j]==0จนครบครึ่งแล้วก็สำเร็จ หากเราไม่ได้พิมพ์ก็เพียงพอที่จะทำครึ่งล่างและใช้c*cเพื่อจัดการจำนวนทั้งหมด h()ถ้าเรากำลังพิมพ์ก็จะมีความจำเป็นที่จะเสร็จสมบูรณ์ยังครึ่งบนแล้วโทรฟังก์ชั่นการพิมพ์

รหัส

unsigned int W,H,S,n,k,t,r[1<<22],p,q[64];
long long int i,c,C;


//output: ascii 45 - for 0, ascii 45+79=124 | for 1
h(){int a;
  for(a=n;a--;a%W||puts(""))putchar(45+(q[a/W]>>a%W)%2*79);
  puts("");
}

g(y,d,x){int j;
  for(j=0;j<p;j++)if((x&r[j])==x){
    q[y]=r[j];
    if(y%(H-1)==0){
       (x^r[j])==0?
        y?c++,S||g(H/2-1,-1,i):h() 
       :0;
    }else{
      g(y+d,d,x^r[j]);
    }

  }    
}

e(z){int d;
  for(d=0;z;d++)z&=z-1;return n/2+1+d&1; 
}

f(){
  //k=a row full of 1's
  k=(1ULL<<W)-1;

  //build table of possible arrangements of horizontal dominoes in a row;
  //flip bits so that 1=a vertical domino and save to r[]
  for(i=0;i<=k;i++)(i/3|i/3<<1)==i?r[p++]=i^k:0;

  //for each arrangement of vertical dominoes on the centreline, call g()
  for(i=0;i<=k;i++)e(i)?c=0,g(H/2,1,i),C+=c*c:0;
  printf("%llu",C);
}


main(int argc, char* argv[]) {
  W = atoi(argv[1]); H = atoi(argv[2]); S = (argc > 3);
  1-(n=W*H)%2?
      H%2?W^=H,H^=W,W^=H,t=1:0,f()
    :puts("0");

}

โปรดทราบว่าอินพุตที่มีจำนวนแถวคี่และจำนวนคอลัมน์จะถูกเปิดแม้ว่า 90 องศาในเฟสการแยกวิเคราะห์ หากไม่สามารถยอมรับได้ฟังก์ชันการพิมพ์h()สามารถเปลี่ยนเพื่อรองรับได้ (แก้ไข: ไม่จำเป็นต้องดูความคิดเห็น)

แก้ไข: ฟังก์ชั่นใหม่e()ถูกนำมาใช้เพื่อตรวจสอบความเท่าเทียมกันของi(เช่นจำนวนของแต้มโดมิโนคร่อมศูนย์) ความเท่าเทียมกันของi(จำนวนครึ่งโดมิโนบนกึ่งกลางที่ยื่นออกมาในแต่ละครึ่งของคณะกรรมการ) จะต้องเหมือนกับ ความแปลกประหลาดของจำนวนช่องว่างทั้งหมดในแต่ละครึ่ง (กำหนดโดยn/2) เนื่องจากโดมิโนเท่านั้นที่สามารถเติมเต็มพื้นที่ว่างทั้งหมดได้ การแก้ไขนี้กำจัดค่าครึ่งหนึ่งของ i ดังนั้นจึงทำให้โปรแกรมของฉันเร็วขึ้นประมาณสองเท่า