一个二进制字符串是只包含绘制字符的字符串01。甲平衡二进制串是包含完全一样多一个二进制串0 S作为1秒。

您会得到一个正整数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个选择10个长度为20的平衡二进制字符串。

输出量

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个掩码，其中包括从pastebin下载测试用例所花费的时间。

红宝石，相当快，但这取决于输入

现在，通过从字符串转换为整数，速度提高了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

通过二项式系数可以很容易地计算出单个掩模的匹配数。因此，例如122020需要2填充3 s，即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匹配。

如果我们采用两个遮罩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)

两个单独的遮罩由3 + 1 = 4个字符串匹配，交叉遮罩由一个字符串匹配，因此有3 + 1-1 = 3个唯一的字符串与一个或两个遮罩匹配。

我称N（m_1，m_2，...）匹配所有m_i的字符串数。应用与上述相同的逻辑，我们可以计算出至少一个掩码匹配的唯一字符串的数量，这由包含排除原理给出，并且也如下所示：

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个掩码的情况，然后分别调用0和和1。我们采用每个平衡的二进制字符串，并根据其匹配的掩码进行分类。c0是那些只匹配掩盖的数量0，c1那些仅匹配的nunber 1，c01那些匹配掩模0和1。

设s0每个掩码的匹配数的总和（它们可能重叠）。让s1是匹配的对的掩模的每对（2-组合）的数量的总和。让s_i成为掩模的每个第（i + 1）的组合匹配的数目的总和。n个掩码的匹配数是与所有掩码匹配的二进制字符串的数。

如果存在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。c__i代表c具有（i + 1）个索引的所有s的，例如c__1 = c01对于n = 2和c__1 = c01 + c02 + c12n == 3。

对于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，（j + 2）个蒙版的交集有y个不同的组合，其中包含C
• 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（每个组合都有两个索引的两个c），z = 4（c012，c013，c023，c123）。

总共有（j + 1）个索引的x*y系数，并且系数不同，因此每个系数出现的时间称为系数。通过简单的代数，我们得到。czx*y/zk_ijk_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排列！也许中等大小的数据集可能是一个好主意？