バイナリ文字列がから引き出された文字のみを含む文字列である01。バランスバイナリ文字列が正確に多くのように含むバイナリ文字列である0としてS 1 S。

正の整数nと任意の数のマスクが与えられます。各マスクの長さは2n文字で、012から描画された文字のみが含まれます。バイナリ文字列とマスクは、長さが同じで、マスクに2がないすべての位置の文字と一致する場合に一致します。例えば、マスク011022試合バイナリ文字列011000、011001、011010、011011を。

与えられたN及び（改行で区切られた）入力としてマスクは、出力マスクの一つ以上に一致する別個の平衡バイナリ文字列の数をしなければなりません。

例

入力

3
111222
000112
122020
122210
102120

推論

• 唯一バランスバイナリ文字列マッチング111222である111000。
• 000112に一致する唯一のバランスのとれたバイナリ文字列は000111です。
• マッチングバランスバイナリストリング122020がある111000（既にカウント）、110010及び101010。
• 122210に一致するバランスのとれたバイナリ文字列は、110010（既にカウント済み）、101010（すでにカウント済み）、および100110です。
• 102120に一致するバランスのとれたバイナリ文字列は、101100と100110です（すでにカウントされています）。

したがって、出力は

6

入力

10
22222222222222222222

推論

• 20があり、長さ20の10個のバランスのとれたバイナリ文字列があります。

出力

184756

勝者

勝者は、競争の入力を最も速く計算し、もちろん他の入力と同じように扱います。（私は明確な勝者を持ち、異なる入力が異なる勝者を与えるケースを避けるために決定されたコードを使用します。最速のコードを見つけるためのより良い方法を考えたら、そう教えてください）。

コンテスト入力

http://pastebin.com/2Dg7gbfV

C

Linuxを使用していない場合、またはコンパイルに問題がある場合は、おそらくタイミングコード（clock_gettime）を削除する必要があります。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

long int binomial(int n, int m) {
  if(m > n/2) {
    m = n - m;
  }
  int i;
  long int result = 1;
  for(i = 0; i < m; i++) {
    result *= n - i;
    result /= i + 1;
  }
  return result;
}

typedef struct isct {
  char *mask;
  int p_len;
  int *p;
} isct;

long int mask_intersect(char *mask1, char *mask2, char *mask_dest, int n) {

  int zero_count = 0;
  int any_count = 0;
  int i;
  for(i = 0; i < n; i++) {
    if(mask1[i] == '2') {
      mask_dest[i] = mask2[i];
    } else if (mask2[i] == '2') {
      mask_dest[i] = mask1[i];
    } else if (mask1[i] == mask2[i]) {
      mask_dest[i] = mask1[i];
    } else {
      return 0;
    }
    if(mask_dest[i] == '2') {
      any_count++;
    } else if (mask_dest[i] == '0') {
      zero_count++;
    }
  }
  if(zero_count > n/2 || any_count + zero_count < n/2) {
    return 0;
  }
  return binomial(any_count, n/2 - zero_count);
}

int main() {

  struct timespec start, end;
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);

  int n;
  scanf("%d", &n);
  int nn = 2 * n;

  int m = 0;
  int m_max = 1024;

  char **masks = malloc(m_max * sizeof(char *));

  while(1) {
    masks[m] = malloc(nn + 1);
    if (scanf("%s", masks[m]) == EOF) {
      break;
    }
    m++;
    if (m == m_max) {
      m_max *= 2;
      masks = realloc(masks, m_max * sizeof(char *));
    }
  }

  int i = 1;
  int i_max = 1024 * 128;

  isct *iscts = malloc(i_max * sizeof(isct));

  iscts[0].mask = malloc(nn);
  iscts[0].p = malloc(m * sizeof(int));

  int j;
  for(j = 0; j < nn; j++) {
    iscts[0].mask[j] = '2';
  }
  for(j = 0; j < m; j++) {
    iscts[0].p[j] = j;
  }
  iscts[0].p_len = m;

  int i_start = 0;
  int i_end = 1;
  int sign = 1;

  long int total = 0;

  int mask_bin_len = 1024 * 1024;
  char* mask_bin = malloc(mask_bin_len);
  int mask_bin_count = 0;

  int p_bin_len = 1024 * 128;
  int* p_bin = malloc(p_bin_len * sizeof(int));
  int p_bin_count = 0;


  while (i_end > i_start) {
    for (j = i_start; j < i_end; j++) {
      if (i + iscts[j].p_len > i_max) {
        i_max *= 2;
        iscts = realloc(iscts, i_max * sizeof(isct));
      }
      isct *isct_orig = iscts + j;
      int x;
      int x_len = 0;
      int i0 = i;
      for (x = 0; x < isct_orig->p_len; x++) {
        if(mask_bin_count + nn > mask_bin_len) {
          mask_bin_len *= 2;
          mask_bin = malloc(mask_bin_len);
          mask_bin_count = 0;
        }
        iscts[i].mask = mask_bin + mask_bin_count;
        mask_bin_count += nn;
        long int count =
            mask_intersect(isct_orig->mask, masks[isct_orig->p[x]], iscts[i].mask, nn);
        if (count > 0) {
          isct_orig->p[x_len] = isct_orig->p[x];
          i++;
          x_len++;
          total += sign * count;
        }
      }
      for (x = 0; x < x_len; x++) {
        int p_len = x_len - x - 1;
        iscts[i0 + x].p_len = p_len;
        if(p_bin_count + p_len > p_bin_len) {
          p_bin_len *= 2;
          p_bin = malloc(p_bin_len * sizeof(int));
          p_bin_count = 0;
        }
        iscts[i0 + x].p = p_bin + p_bin_count;
        p_bin_count += p_len;
        int y;
        for (y = 0; y < p_len; y++) {
          iscts[i0 + x].p[y] = isct_orig->p[x + y + 1];
        }
      }
    }

    sign *= -1;
    i_start = i_end;
    i_end = i;

  }

  printf("%lld\n", total);

  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);

  int seconds = end.tv_sec - start.tv_sec;
  long nanoseconds = end.tv_nsec - start.tv_nsec;
  if(nanoseconds < 0) {
    nanoseconds += 1000000000;
    seconds--;
  }

  printf("%d.%09lds\n", seconds, nanoseconds);
  return 0;
}

事例：

robert@unity:~/c/se-mask$ gcc -O3 se-mask.c -lrt -o se-mask
robert@unity:~/c/se-mask$ head testcase-long
30
210211202222222211222112102111220022202222210122222212220210
010222222120210221012002220212102220002222221122222220022212
111022212212022222222220111120022120122121022212211202022010
022121221020201212200211120100202222212222122222102220020212
112200102110212002122122011102201021222222120200211222002220
121102222220221210220212202012110201021201200010222200221002
022220200201222002020110122212211202112011102220212120221111
012220222200211200020022121202212222022012201201210222200212
210211221022122020011220202222010222011101220121102101200122
robert@unity:~/c/se-mask$ ./se-mask < testcase-long
298208861472
0.001615834s
robert@unity:~/c/se-mask$ head testcase-hard
8
0222222222222222
1222222222222222
2022222222222222
2122222222222222
2202222222222222
2212222222222222
2220222222222222
2221222222222222
2222022222222222
robert@unity:~/c/se-mask$ ./se-mask < testcase-hard
12870
3.041261458s
robert@unity:~/c/se-mask$ 

（時間は4.1 GHzのi7-4770K CPUの場合です。）testcase-hard約3〜4 GBのメモリーを使用することに注意してください。

これは、ほとんど含まれている包含​​/除外メソッドblutorangeの実装ですが、あらゆる深さの交差を処理できるように行われています。 記述されたコードはメモリ割り当てに多くの時間を費やしており、メモリ管理を最適化するとさらに速くなります。

で約25％削り落としましたtestcase-hardが、testcase-longメモリ割り当てがあまり行われていないため、元の（）のパフォーマンスはほとんど変わっていません。呼び出す前に、もう少し調整します。25％-50％の改善が見込めるかもしれませtestcase-longん。

Mathematica

これが#SATの問題であることに気付いたら、Mathematicaの組み込み機能を使用できることに気づきましたSatisfiabilityCount。

AbsoluteTiming[
 (* download test case *)
 input = Map[FromDigits, 
   Characters[
    Rest[StringSplit[
      Import["http://pastebin.com/raw.php?i=2Dg7gbfV", 
       "Text"]]]], {2}]; n = Length[First[input]];
 (* create boolean function *)
 bool = BooleanCountingFunction[{n/2}, n] @@ Array[x, n] && 
   Or @@ Table[
     And @@ MapIndexed[# == 2 || Xor[# == 1, x[First[#2]]] &, i], {i, 
      input}];
 (* count instances *)
 SatisfiabilityCount[bool, Array[x, n]]
]

出力：

{1.296944, 298208861472}

これは、ペーストビンからのテストケースのダウンロードに費やされた時間を含め、1.3秒（i7-3517U @ 1.9 GHz）で298,208,861,472マスクです。

ルビー、かなり高速ですが、入力に依存します

文字列から整数に切り替えることで、2倍から2.5倍にスピードアップします。

使用法：

cat <input> | ruby this.script.rb

例えば。

mad_gaksha@madlab ~/tmp $ ruby c50138.rb < c50138.inp2
number of matches: 298208861472
took 0.05726237 s

1つのマスクの一致数は、二項係数によって容易に計算されます。たとえば、1220203 2と1 0と2 が必要1です。したがって、nCr(3,2)=nCr(3,1)=3!/(2!*1!)=3このマスクに一致するさまざまなバイナリ文字列があります。

n個のマスクm_1、m_2、... m_nの共通部分はマスクqであり、バイナリ文字列sはすべてのマスクm_iに一致する場合にのみqに一致します。

2つのマスクm_1とm_2を取る場合、その交差は簡単に計算されます。m_1 [i] == 2の場合は、m_1 [i] = m_2 [i]と設定します。交差点の間122020と111222です111020。

122020 (matched by 3 strings, 111000 110010 101010)
111222 (matched by 1 string, 111000)
111020 (matched by 1 string, 111000)

2つの個別のマスクは3 + 1 = 4文字列で一致し、交差マスクは1つの文字列で一致するため、1つまたは両方のマスクに一致する3 + 1-1 = 3個の一意の文字列があります。

N（m_1、m_2、...）を、すべてのm_iに一致する文字列の数と呼びます。上記と同じロジックを適用して、包含除外の原則によって与えられた、少なくとも1つのマスクと一致する一意の文字列の数を計算できます。以下のように、このように表示されます。

N(m_1) + N(m_2) + ... + N(m_n) - N(m_1,m_2) - ... - N(m_n-1,m_n) + N(m_1,m_2,m_3) + N(m_1,m_2,m_4) + ... N(m_n-2,m_n-1,m_n) - N(m_1,m_2,m_3,m_4) -+ ...

たとえば200枚のうち30枚のマスクをとるには、たくさんの組み合わせがあります。

したがって、このソリューションは、定型入力の高次の交差が多く存在しないことを前提としています。n> 2マスクのほとんどのnタプルには、一般的な一致はありません。

ここのコードを使用してください。ideoneのコードは古くなっている可能性があります。

• テストケース1：一致数：6
• テストケース2：一致数：184756
• テストケース3：一致数：298208861472
• テストケース4：一致数：5

remove_duplicates入力の前処理とマスクの削除に使用できる関数を追加し、m_iそれに一致するすべての文字列が別のマスクにも一致するようにしましたm_j。なので、以下のコードでは関数はまだデータに適用されていません。

コード：

# factorial table
FAC = [1]
def gen_fac(n)
  n.times do |i|
    FAC << FAC[i]*(i+1)
  end
end

# generates a mask such that it is matched by each string that matches m and n
def diff_mask(m,n)
  (0..m.size-1).map do |i|
    c1 = m[i]
    c2 = n[i]
    c1^c2==1 ? break : c1&c2
  end
end

# counts the number of possible balanced strings matching the mask
def count_mask(m)
  n = m.size/2
  c0 = n-m.count(0)
  c1 = n-m.count(1)
  if c0<0 || c1<0
    0
  else
    FAC[c0+c1]/(FAC[c0]*FAC[c1])
  end
end

# removes masks contained in another
def remove_duplicates(m)
  m.each do |x|
    s = x.join
    m.delete_if do |y|
      r = /\A#{s.gsub(?3,?.)}\Z/
      (!x.equal?(y) && y =~ r) ? true : false
    end
  end
end

#intersection masks of cn masks from m.size masks
def mask_diff_combinations(m,n=1,s=m.size,diff1=[3]*m[0].size,j=-1,&b)
  (j+1..s-1).each do |i|
    diff2 = diff_mask(diff1,m[i])
    if diff2
      mask_diff_combinations(m,n+1,s,diff2,i,&b) if n<s
      yield diff2,n
    end
  end
end

# counts the number of balanced strings matched by at least one mask
def count_n_masks(m)
  sum = 0
  mask_diff_combinations(m) do |mask,i|
    sum += i%2==1 ? count_mask(mask) : -count_mask(mask)
  end
  sum
end

time = Time.now

# parse input
d = STDIN.each_line.map do |line|
  line.chomp.strip.gsub('2','3')
end
d.delete_if(&:empty?)
d.shift
d.map!{|x|x.chars.map(&:to_i)}

# generate factorial table
gen_fac([d.size,d[0].size].max+1)

# count masks
puts "number of matches: #{count_n_masks(d)}"
puts "took #{Time.now-time} s"

これは包含除外の原則と呼ばれますが、誰かが私に指摘する前に、私は自分の証拠を持っていました。しかし、自分で何かをすることは素晴らしいと感じます。

2つのマスクの場合を考えてみましょう。最初にthen 0とを呼び出します1。すべてのバランスのとれたバイナリ文字列を取得し、一致するマスクに従って分類します。c0マスクのみ一致するものの数であり0、c1唯一の一致するもののnunber 1、c01それらに一致マスク0とは1。

ましょうs0各マスクの一致の数（これらは重複していてもよい）の数の和です。ましょうs1マスクの各対の一致の数（2-組み合わせ）の和です。させるs_iマスクの各（i + 1）の組み合わせに対する一致数の和であること。n-masksの一致数は、すべてのマスクに一致するバイナリ文字列の数です。

n個のマスクがある場合、必要な出力は、すべてcのの合計です。c = c0+...+cn+c01+c02+...+c(n-2)(n-1)+c012+...+c(n-3)(n-2)(n-1)+...+c0123...(n-2)(n-1)。プログラムが計算するのは、すべてsのの交互合計です。s = s_0-s_1+s_2-+...+-s_(n-1)。それを証明したいと思いs==cます。

n = 1は明らかです。n = 2を考えます。マスクのすべての一致をカウントする0与えるc0+c01（両方のみ0 +ものマッチングを一致文字列の数0と1）、全ての一致カウント1が得られるがc1+c02。これを次のように説明できます。

0: c0 c01
1: c1 c10

定義により、s0 = c0 + c1 + c12。s1は、の各2つの組み合わせの一致の合計数です[0,1]。すべてのuniqye c_ijs。それを覚えておいてくださいc01=c10。

s0 = c0 + c1 + 2 c01
s1 = c01
s = s0 - s1 = c0 + c1 + c01 = c

したがってs=c、n = 2の場合。

ここでn = 3を考えます。

0  : c0 + c01 + c02 + c012
1  : c1 + c01 + c12 + c012
2  : c2 + c12 + c02 + c012
01 : c01 + c012
02 : c02 + c012
12 : c12 + c012
012: c012

s0 = c0 + c1 + c2 + 2 (c01+c02+c03) + 3 c012
s1 = c01 + c02 + c12 + 3 c012
s2 = c012

s0 = c__0 + 2 c__1 + 3 c__2
s1 =          c__1 + 3 c__2
s2 =                   c__2

s = s0 - s1 + s2 = ... = c0 + c1 + c2 + c01 + c02 + c03 + c012 = c__0 + c__1 + c__2 = c

したがってs=c、n = 3の場合。たとえば、n = 2およびn == 3 の場合、（i + 1）インデックスを持つc__iすべてcののを表します。c__1 = c01c__1 = c01 + c02 + c12

n = 4の場合、パターンが出現し始めます。

0:   c0 + c01 + c02 + c03 + c012 + c013 + c023 + c0123
1:   c1 + c01 + c12 + c13 + c102 + c103 + c123 + c0123
2:   c2 + c02 + c12 + c23 + c201 + c203 + c213 + c0123
3:   c3 + c03 + c13 + c23 + c301 + c302 + c312 + c0123

01:  c01 + c012 + c013 + c0123
02:  c02 + c012 + c023 + c0123
03:  c03 + c013 + c023 + c0123
12:  c11 + c012 + c123 + c0123
13:  c13 + c013 + c123 + c0123
23:  c23 + c023 + c123 + c0123

012:  c012 + c0123
013:  c013 + c0123
023:  c023 + c0123
123:  c123 + c0123

0123: c0123

s0 = c__0 + 2 c__1 + 3 c__2 + 4 c__3
s1 =          c__1 + 3 c__2 + 6 c__3
s2 =                   c__2 + 4 c__3
s3 =                            c__3

s = s0 - s1 + s2 - s3 = c__0 + c__1 + c__2 + c__3 = c

したがってs==c、n = 4の場合。

一般に、次のような二項係数を取得します（↓はi、→はj）。

   0  1  2  3  4  5  6  .  .  .

0  1  2  3  4  5  6  7  .  .  .
1     1  3  6  10 15 21 .  .  .
2        1  4  10 20 35 .  .  .
3           1  5  15 35 .  .  .
4              1  6  21 .  .  .
5                 1  7  .  .  .
6                    1  .  .  . 
.                       .
.                          .
.                             .

これを確認するには、一部のiおよびについて、次のことを考慮してくださいj。

• x = ncr（n、i + 1）：nのうち（i + 1）マスクの共通部分の組み合わせC
• y = ncr（ni-1、ji）：上記のCの組み合わせごとに、Cを含むマスクのうち（j + 2）マスクの共通部分にyの異なる組み合わせがあります。
• z = ncr（n、j + 1）：nのうち（j + 1）マスクの共通部分のさまざまな組み合わせ

混乱するかもしれませんが、ここでは例に適用された定義を示します。i = 1、j = 2、n = 4の場合、次のようになります（上記を参照）：

01:  c01 + c012 + c013 + c0123
02:  c02 + c012 + c023 + c0123
03:  c03 + c013 + c023 + c0123
12:  c11 + c012 + c123 + c0123
13:  c13 + c013 + c123 + c0123
23:  c23 + c023 + c123 + c0123

したがって、ここではx = 6（01、02、03、12、13、23）、y = 2（各組み合わせに対して3つのインデックスを持つ2つのc）、z = 4（c012、c013、c023、c123）です。

合計で、（j + 1）インデックスを持つx*y係数cがあり、z異なるものがあるため、それぞれが発生するx*y/z時間であり、これを係数と呼びますk_ij。簡単な代数で、が得られk_ij = ncr(n,i+1) ncr(n-i-1,j-i) / ncr(n,j+1) = ncr(j+1,i+1)ます。

したがって、インデックスは次のように与えられk_ij = nCr(j+1,i+1)ます。すべての定義を思い出した場合、表示する必要があるのは、各列の交互合計が1になることだけです。

したがって、交互合計s0 - s1 + s2 - s3 +- ... +- s(n-1)は次のように表すことができます。

s_j = c__j * ∑［(-1)^(i+j) k_ij］ for i=0..n-1
     = c__j * ∑［(-1)^(i+j) nCr(j+1,i+1)］ for i=0..n-1
     = c__j * ∑［(-1)^(i+j) nCr(j+1,i)］｛i=0..n｝ - (-1)^0 nCr(j+1,0)
     = (-1)^j c__j

s   = ∑［(-1)^j  s_j］ for j = 0..n-1
    = ∑［(-1)^j (-1)^j c__j)］ for j=0..n-1
    = ∑［c__j］ for j=0..n-1
    = c

したがってs=c、すべてのn = 1、2、3、...

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gsl/gsl_combination.h>

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

    printf ("reading\n");
    char buffer[100];
    gets(buffer);
    char n = atoi(buffer);

    char *masks[1000];
    masks[0] = malloc(2 * n * sizeof(char));
    char c,nrows,j,biggestzerorun,biggestonerun,currentzerorun,currentonerun = 0;

    while ((c = getchar()) && c != EOF) {
        if (c == '\n') {
            nrows++;
            if (currentonerun > biggestonerun) {
                biggestonerun = currentonerun;
            }
            if (currentzerorun > biggestzerorun) {
                biggestzerorun = currentzerorun;
            }
            j=currentonerun=currentzerorun=0;
            masks[nrows] = malloc(2 * n * sizeof(char));
        } else if (c == '0') {
            masks[nrows][j++] = 1;
            currentzerorun++;
            if (currentonerun > biggestonerun) {
                biggestonerun = currentonerun;
            }
            currentonerun=0;
        } else if (c == '1') {
            masks[nrows][j++] = 2;
            currentonerun++;
            if (currentzerorun > biggestzerorun) {
                biggestzerorun = currentzerorun;
            }
            currentonerun=0;
        } else if (c == '2') {
            masks[nrows][j++] = 3;
            currentonerun++;
            currentzerorun++;
        }
    }
    if (currentonerun > biggestonerun) {
        biggestonerun = currentonerun;
    }
    if (currentzerorun > biggestzerorun) {
        biggestzerorun = currentzerorun;
    }

    printf("preparing combinations\n");

    int nmatches=0;

    gsl_combination *combination = gsl_combination_calloc(2*n, n);

    printf("entering loop:\n");

    do {
        char vector[2*n];
        char currentindex, previousindex;
        currentonerun = 0;
        memset(vector, 1, 2*n);


        // gsl_combination_fprintf (stdout, combination, "%u ");
        // printf(": ");

        for (char k=0; k<n; k++) {
            previousindex = currentindex;
            currentindex = gsl_combination_get(combination, k);
            if (k>0) {
                if (currentindex - previousindex == 1) {
                    currentonerun++;
                    if (currentonerun > biggestonerun) {
                        goto NEXT;
                    }
                } else {
                    currentonerun=0;
                    if (currentindex - previousindex > biggestzerorun) {
                        goto NEXT;
                    }
                }
            }
            vector[currentindex] = 2;
        }

        for (char k=0; k<=nrows; k++) {
            char ismatch = 1;
            for (char l=0; l<2*n; l++) {
                if (!(vector[l] & masks[k][l])) {
                    ismatch = 0;
                    break;
                }
            }
            if (ismatch) {
                nmatches++;
                break;
            }
        }

        NEXT: 1;

    } while (
        gsl_combination_next(combination) == GSL_SUCCESS
    );

    printf ("RESULT: %i\n", nmatches);

    gsl_combination_free(combination);
    for (; nrows>=0; nrows--) {
        free(masks[nrows]);
    }
}

これで実行するために大きな入力を得るために頑張ってください-それはおそらく一晩で完了するのに一晩かかるでしょう。60 ^ 30順列！多分中間サイズのデータ​​セットが良い考えかもしれませんか？