সুপারসোনিক ডোমিনো টিলিংস

কার্য

একটি প্রোগ্রাম লিখুন যা তিনটি পূর্ণসংখ্যার এম , এন পাঠায় এসটিডিএন থেকে বা কমান্ড-লাইন আর্গুমেন্ট হিসাবে, মাত্রাগুলির একটি আয়তক্ষেত্রের সমস্ত সম্ভাবনামূলক ছাতাগুলি মুখ্য করে m × n দ্বারা 2 × 1 এবং 1 × 2 ডেমোপোজ এবং অবশেষে বৈধ tilings এর সংখ্যা।

একজন ব্যক্তি টালি দ্বারা আচ্ছাদন এর Dominos দুই ড্যাশ (দ্বারা প্রতিনিধিত্ব করা থাকতে হবে -জন্য) 2 × 1 এবং দুই উল্লম্ব বার ( |জন্য) 1 × 2 dominos। প্রতিটি টাইলিং (শেষটি সহ) একটি লাইনফিড অনুসরণ করতে হবে।

স্কোরিংয়ের উদ্দেশ্যে, আপনাকে এসটিডিআইএন থেকে বা কমান্ড লাইন আর্গুমেন্ট হিসাবে একটি পতাকাও গ্রহণ করতে হবে যা আপনার প্রোগ্রামটিকে কেবল বৈধ tilings সংখ্যা প্রিন্ট করে তোলে, তবে নিজেই tilings নয়।

আপনার প্রোগ্রামটি 1024 বাইটের বেশি হতে পারে না। এটি × m ≤ 64 এর মতো সমস্ত ইনপুটগুলির জন্য কাজ করতে হবে ।

( 4x6 আয়তক্ষেত্রের সমস্ত ডোমিনো টিলিংস মুদ্রণ দ্বারা অনুপ্রাণিত ।)

উদাহরণ

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

||--
||--

|--|
|--|

--||
--||

||||
||||

5
$ sdt 4 2 scoring
5

স্কোরিং

পতাকাটি সেট সহ 8 8 ইনপুটটির জন্য আপনার স্কোরটি আপনার প্রোগ্রামের সম্পাদনের সময় দ্বারা নির্ধারিত হয় ।

দ্রুততম কম্পিউটার চ্যালেঞ্জের চেয়ে এটিকে দ্রুততম কোড হিসাবে তৈরি করার জন্য , আমি আনুষ্ঠানিক স্কোর নির্ধারণ করতে আমি নিজের কম্পিউটারে (ইন্টেল কোর আই 7-3770, 16 জিআইবি পিসি 3-12800 র‌্যাম) সমস্ত সাবমিশন চালাব।

আপনার কোডটি কীভাবে সংকলন করবেন এবং / অথবা কার্যকর করবেন সে সম্পর্কে দয়া করে বিশদ নির্দেশাবলী রেখে দিন। আপনার ভাষার সংকলক / দোভাষীর যদি আপনার নির্দিষ্ট সংস্করণ প্রয়োজন হয় তবে সেই বিষয়ে একটি বিবৃতি দিন।

আমি জমাগুলি আনস্কার্ড ছাড়ার অধিকার সংরক্ষণ করি যদি:

আমার অপারেটিং সিস্টেমের জন্য কোনও বিনামূল্যে (বিয়ারের মতো) সংকলক / দোভাষী নেই (ফেডোরা 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.

— ডেনিস
সূত্র

কেন এটিকে জিএলএফ প্রতিযোগিতা করবেন না? :(

— orlp

আপনি যদি স্যান্ডবক্সে পরামর্শ দেন তবে আমার কাছে থাকতে পারে। এটি আমার সিপিইউ এবং আমাকে অনেক কাজ বাঁচাতে পারত ...

— ডেনিস

@ kirbyfan64sos আমি এটি যেভাবে বুঝতে পারি, সেখানে কেবলমাত্র এক ধরণের ডোমিনো রয়েছে, যা আপনি ঘোরান। যদি অনুভূমিক, এটি ভালো দেখায়: --। এটি উল্লম্ব হলে এটি দুটি |, একে অপরের নীচে।

— রেটো কোরাডি

আপনার চ্যালেঞ্জ খারাপ নয়। সমস্যাটি হ'ল আমাদের শীর্ষ কোডারগুলি খুব শক্ত। আমার সমাধান যা সারি এবং কলামগুলির মেয়াদ পরীক্ষা করে 6x8 এর জন্য 1 মিনিটের কাছাকাছি থাকে।

— edc65

আমার মনে হয় জটিলতার সময় থেকে মুক্তি পেতে এখন সেরা কৌশল হ'ল সমাবেশটি ব্যবহার করা এবং 1024 বাইটের চেয়ে কম বাইনারি ফাইল নেওয়ার চেষ্টা করা।

— জিমি 23013

উত্তর:

সি

একটি সরল বাস্তবায়ন ...

#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, যেখানে iএই কলামটিতে কাজ শুরু করার আগে কলামে সংশ্লিষ্ট অবস্থানটি ইতিমধ্যে দখল করা থাকলে বিটটি 1 হবে । অর্থাৎ এটি একটি এর ডান অর্ধেক দ্বারা দখল করা হয়েছে --।
d[i][j] বিভিন্ন tilings মোট সংখ্যা।

তারপর বলবে e[i][j]= এর সমষ্টি d[i][k]যেখানে আপনি উপর উল্লম্ব dominoes বেস লাগাতে পারেন kএকটি ফর্ম j। e[i][j]টিলিংয়ের সংখ্যা হবে যেখানে প্রতিটি 1 বিট এ 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(ন্যাপস্যাক সমস্যার জন্য অ্যালগোরিদমের মতো)। এবং এটি ও (এন * 2 ^ n) হয়ে যায়। এবং অন্য সব কিছুই বাস্তবায়নের বিশদ। পুরো কোডটি ও (এম * এন * 2 ^ n) এ চলে।

— jimmy23013
সূত্র

@ ডেনিস আপনি সম্ভবত এটি পরিবর্তন করার জন্য একটি পোল শুরু করতে চান।

— জিমি 23013

@ ডেনিস নিশ্চিত না যে আকার বাড়ানো অনেক সাহায্য করবে। যদিও এটি গণনার সময়কে যথেষ্ট পরিমাণে বাড়ায়, এটি প্রায় 100 গুণ বেশি আউটপুটও উত্পাদন করে। তুলনামূলকভাবে বলতে গেলে, আউটপুটটির পরিমাণটি আসলে বেশি।

— রেটো কোরাাদি

1 ম সংস্করণ কার্যকর: 0.286 গুলি সংকলন: 0.053 গুলি যোগফল: 0.339 s এর দ্বিতীয় সংস্করণ নির্বাহ: 0.002 s সংকলন: 0.061 গুলি যোগফল: 0.063 গুলি (এখানে কী ঘটেছিল?)

— ডেনিস

@ ডেনিস পতাকাটি সেট করা থাকলে এটি ও (এম * এন * 2 ^ n) এ অন্য একটি অ্যালগরিদম ব্যবহার করেছে।

— জিমি 23013

এক্সেকিউশন: 190 MS সংকলন: 68 MS যোগফল: 258 এমএস ( -O1মিষ্টি স্পট হবে বলে মনে হয় আমি সব অপ্টিমাইজেশান মাত্রা চেষ্টা করেছি।।)

— ডেনিস

সি

একাধিক অপ্টিমাইজেশনের পরে এবং পরিবর্তিত নিয়মের সাথে মানিয়ে নেওয়া:

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

কিছু মন্তব্য:

বৃহত্তর পরীক্ষার উদাহরণ সহ, আমি এখনই অপটিমাইজেশন চাই। আমার সিস্টেমটি অন্যরকম (ম্যাক) থাকাকালীন -O2ভাল বলে মনে হচ্ছে।
কোড আউটপুট উত্পাদিত হয় ক্ষেত্রে ক্ষেত্রে ধীর হয়ে গেছে। এটি "কেবল গণনা" মোডটি অনুকূলকরণের জন্য এবং কোডের দৈর্ঘ্য হ্রাস করার জন্য একটি সচেতন ত্যাগ ছিল।
সিস্টেমের ফাংশনগুলির জন্য অন্তর্ভুক্ত এবং বাহ্যিক ঘোষণার কারণে কয়েকটি সংকলক সতর্কতা থাকবে। কোডটি সম্পূর্ণ অপঠনযোগ্য না করে শেষ পর্যন্ত আমাকে 1024 টির চেয়ে কম অক্ষরের নীচে নিয়ে যাওয়ার সহজতম উপায় ছিল।

এছাড়াও নোট করুন যে কোডটি এখনও "গণনা কেবল" মোডে এমনকি আসল সমাধানগুলি উত্পন্ন করে। যখনই কোনও সমাধান পাওয়া যায়, vMবিটমাস্কে 1উল্লম্ব দণ্ডযুক্ত 0অবস্থানগুলির জন্য একটি এবং একটি অনুভূমিক দণ্ডযুক্ত অবস্থানগুলির জন্য একটি থাকে। কেবলমাত্র এই বিটমাস্ককে ASCII ফর্ম্যাটে রূপান্তর করা এবং আসল আউটপুট এড়ানো যায়।

— রেটো কোরাদি
সূত্র

@ ডেনিস নতুন সংস্করণ। এক্সিকিউশনটি অপরিবর্তিত হওয়া উচিত তবে দ্রুত সংকলন করা উচিত। সংকলনের সময়টির জন্য আমাদের যদি অনুকূলিতকরণ প্রয়োজন হয় তবে আমাদের কোনও সিস্টেম শিরোনামের প্রয়োজন নেই!

— রেটো কোরাদি

@ ডেনিস নতুন স্কোর করার জন্য এবং একাধিক অনুকূলকরণের জন্য আপডেট হয়েছে। নোট করুন যে আমি এখনই অপটিমাইজেশন চাই, এর মতো -O2ভালো কিছু হওয়া উচিত।

— রেটো কোরাাদি

সম্পাদন: 256 এমএস সংকলন: 65 এমএস যোগফল: 321 এমএস ( -O2এটি মিষ্টি স্পট বলে মনে হচ্ছে I've আমি সমস্ত অপটিমাইজেশন স্তর চেষ্টা করেছি।)

— ডেনিস

সি

ধারণাটি হ'ল প্রথমে সারিবদ্ধভাবে অনুভূমিক ডোমিনোজের সমস্ত সম্ভাব্য বিন্যাস সন্ধান করা, সেগুলিতে সংরক্ষণ করা r[]এবং তারপরে উল্লম্ব ডোমিনোজের সমস্ত সম্ভাব্য ব্যবস্থা দেওয়ার জন্য তাদের সংগঠিত করা।

এক সারি অনুভূমিক ডোমিনোয় অবস্থানের জন্য কোডটি আমার এই উত্তর থেকে পরিবর্তিত হয়েছে: https://codegolf.stackexchange.com/a/37888/15599 । এটি বৃহত্তর গ্রিডগুলির জন্য ধীর হলেও 8x8 ক্ষেত্রে এটি কোনও সমস্যা নয়।

নতুনত্বটি সারিগুলি একত্রিত করার পথে। বোর্ডে যদি সারিগুলির একটি বিজোড় সংখ্যা থাকে তবে এটি ইনপুট পার্সিংয়ে 90 ডিগ্রি হয়ে যায়, সুতরাং এখন এটির একটিও সংখ্যক সারি রয়েছে। এখন আমি কেন্দ্রিকরেখা জুড়ে কিছু উল্লম্ব ডোমিনোজ রাখি। প্রতিসামগ্রহের কারণে, যদি cনীচের অর্ধেকটিতে cঅবশিষ্ট ডোমিনোজগুলি সাজানোর উপায় রয়েছে তবে উপরের অর্ধে অবশিষ্ট ডোমিনোজগুলি সাজানোর উপায়গুলিও থাকতে হবে , অর্থাত কেন্দ্রীভূমিতে উল্লম্ব ডোমিনোজের একটি নির্দিষ্ট ব্যবস্থা করার জন্য, c*cসম্ভাব্য সমাধান রয়েছে । সুতরাং যখন প্রোগ্রামটি কেবলমাত্র সমাধানের সংখ্যা মুদ্রণের জন্য প্রয়োজন তখন কেবলমাত্র কেন্দ্রবিন্দু প্লাসের অর্ধেক অংশ বিশ্লেষণ করা হয়।

f()অনুভূমিক ডোমিনোজের সম্ভাব্য বিন্যাসের সারণী তৈরি করে এবং কেন্দ্ররেখায় উল্লম্ব ডোমিনোজের সম্ভাব্য বিন্যাসের মাধ্যমে স্ক্যান করে। এটি তখন পুনরাবৃত্ত ফাংশনকে কল করে g()যা সারিগুলিতে পূর্ণ হয়। মুদ্রণের প্রয়োজন হলে এটি করার জন্য ফাংশনটি h()বলা হয়।

g()3 পরামিতি সহ বলা হয়। yবর্তমান সারিটি এবং dএটি দিক (উপরে বা নীচে) যেখানে আমরা কেন্দ্র থেকে বাইরের দিকে বোর্ডটি পূরণ করছি। xবিটম্যাপ রয়েছে এমন উল্লম্ব ডোমিনোসগুলি নির্দেশ করে যা পূর্ববর্তী সারির থেকে অসম্পূর্ণ। R [] থেকে পরপর ডোমিনোজের সমস্ত সম্ভাব্য বিন্যাস চেষ্টা করা হয়। এই অ্যারেতে, 1 টি উল্লম্ব ডোমিনো এবং একজোড়া শেরোয় একটি অনুভূমিক ডোমিনো উপস্থাপন করে। অ্যারের মধ্যে কোন বৈধ প্রবেশ শেষ সারি থেকে কোন অসম্পূর্ণ উল্লম্ব dominoes শেষ করতে অন্তত যথেষ্ট 1 এর থাকা আবশ্যক: (x&r[j])==x। এটিতে আরও 1 টি থাকতে পারে যা সূচিত করে যে নতুন উল্লম্ব ডোমিনোজগুলি শুরু হচ্ছে। পরবর্তী সারি জন্য, তারপর, আমরা শুধুমাত্র নতুন dominoes প্রয়োজন তাই আমরা দিয়ে আবার প্রসিডিউর কল 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(যেমন centreline straddling dominoes সংখ্যা।) এর সমতা i(centreline বোর্ডের প্রতিটি অর্ধেক মধ্যে protruding উপর অর্ধ dominoes সংখ্যা) একই হওয়া আবশ্যক প্রতিটি অর্ধেক জায়গার মোট সংখ্যার বিশিষ্টতা (প্রদত্ত n/2) কারণ কেবলমাত্র তখনই ডমিনোজগুলি সমস্ত উপলব্ধ স্থান পূরণ করতে পারে। এই সম্পাদনাটি আমার অর্ধেক মানগুলি মুছে ফেলে এবং তাই আমার প্রোগ্রামটিকে প্রায় দ্বিগুণ দ্রুত করে তোলে।

— স্তর নদী সেন্ট
সূত্র

এক্সেকিউশন: 18 MS সংকলন: 50 MS যোগফল: 68 MS ( -O0মোট মিষ্টি স্পট ছিল অন্যান্য অপশন নিচে সংকলন মন্থর করে দেয়।।)

— ডেনিস

এটি হয় কখনই শেষ হয় না, বা অন্তত ইনপুটটির জন্য খুব দীর্ঘ সময় নেয় 32 2 s। আমি প্রায় 15 মিনিটের পরে এটি বন্ধ করেছিলাম।

— রেটো কোরাাদি

@ রিটোকোরাদি আসলেই ততক্ষণে 2 32 sচলে। সমস্ত সম্ভাব্য উল্লম্ব ডোমিনোসগুলির মাধ্যমে স্ক্যান করা H=2মামলার পক্ষে অত্যন্ত অপব্যয়কারী , কারণ বাস্তবে আমাদের কাছে ইতিমধ্যে সমস্ত প্রয়োজনীয় তথ্য রয়েছে r[]। 8 8 sআপনি যে মামলার উল্লেখ করেছেন তার জন্য এখানে একটি প্যাচ দেওয়ার জন্য আমি অফিসিয়াল সময়টি নিয়ে অত্যন্ত সন্তুষ্ট : if(H==2){C=p;if(!S)for(i=0;i<p;i++)q[0]=q[1]=r[i],h();}else for(i=0;i<=k;i++)c=0,g(H/2,1,i),C+=c*c;আপনি দেখতে পাচ্ছেন H=2 পতাকা স্লট সহ এই স্নিপেটটি তাত্ক্ষণিকভাবে চলবে । সামগ্রিক রানটাইমটি তখন বিল্ডিং দ্বারা সীমাবদ্ধ r[]যার মধ্যে অবশ্যই উন্নতির জন্য জায়গা রয়েছে।

— স্তর নদী সেন্ট

সম্পূর্ণতার জন্য এখানে আউটপুটটিকে সঠিক উপায়ে পরিণত করার জন্য প্যাচ রয়েছে, প্রয়োজনে:

if(t)for(a=n;a--;a%H||puts(""))putchar(124-(q[a%H]>>a/H)%2*79);else for(a=n;a--;a%W||puts(""))putchar(45+(q[a/W]>>a%W)%2*79);

কোডলেথটি এখনও 1000 বাইটের নিচে রয়েছে এবং সংকলনের সময়টির প্রভাব ন্যূনতম হওয়া উচিত। আমি খুব ক্লান্ত হয়ে পড়েছিলাম বলে কাল রাতে আমি এই প্যাচগুলি অন্তর্ভুক্ত করিনি।

— স্তর নদী সেন্ট

আমি গত রাতে মন্তব্য করতে চেয়েছিলাম, কিন্তু আমি ভুলে গিয়েছিলাম। যেহেতু স্কোরিং স্কোয়ারে করা হয়, তাই আমি একটি নির্দিষ্ট ক্রমের জন্য জোর দিচ্ছি না।

— ডেনিস