Java (n = 8)
import java.util.*;
import java.util.concurrent.*;
public class HankelCombinatorics {
public static final int NUM_THREADS = 8;
private static final int[] FACT = new int[13];
static {
FACT[0] = 1;
for (int i = 1; i < FACT.length; i++) FACT[i] = i * FACT[i-1];
}
public static void main(String[] args) {
long prevElapsed = 0, start = System.nanoTime();
for (int i = 1; i < 12; i++) {
long count = count(i), elapsed = System.nanoTime() - start;
System.out.format("%d in %dms, total elapsed %dms\n", count, (elapsed - prevElapsed) / 1000000, elapsed / 1000000);
prevElapsed = elapsed;
}
}
@SuppressWarnings("unchecked")
private static long count(int n) {
int[][] perms = new int[FACT[n]][];
genPermsInner(0, 0, new int[n], perms, 0);
// We partition by canonical representation of the row sum multiset, discarding any with a density > 50%.
Map<CanonicalMatrix, Map<CanonicalMatrix, Integer>> part = new HashMap<CanonicalMatrix, Map<CanonicalMatrix, Integer>>();
for (int m = 0; m < 1 << (2*n-1); m++) {
int density = 0;
int[] key = new int[n];
for (int i = 0; i < n; i++) {
key[i] = Integer.bitCount((m >> i) & ((1 << n) - 1));
density += key[i];
}
if (2 * density <= n * n) {
CanonicalMatrix _key = new CanonicalMatrix(key);
Map<CanonicalMatrix, Integer> map = part.get(_key);
if (map == null) part.put(_key, map = new HashMap<CanonicalMatrix, Integer>());
map.put(new CanonicalMatrix(m, perms[0]), m);
}
}
List<Job> jobs = new ArrayList<Job>();
ExecutorService pool = Executors.newFixedThreadPool(NUM_THREADS);
for (Map.Entry<CanonicalMatrix, Map<CanonicalMatrix, Integer>> e : part.entrySet()) {
Job job = new Job(n, perms, e.getKey().sum() << 1 == n * n ? 0 : 1, e.getValue());
jobs.add(job);
pool.execute(job);
}
pool.shutdown();
try {
pool.awaitTermination(1, TimeUnit.DAYS); // i.e. until it's finished - inaccurate results are useless
}
catch (InterruptedException ie) {
throw new IllegalStateException(ie);
}
long total = 0;
for (Job job : jobs) total += job.subtotal;
return total;
}
private static int genPermsInner(int idx, int usedMask, int[] a, int[][] perms, int off) {
if (idx == a.length) perms[off++] = a.clone();
else for (int i = 0; i < a.length; i++) {
int m = 1 << (a[idx] = i);
if ((usedMask & m) == 0) off = genPermsInner(idx+1, usedMask | m, a, perms, off);
}
return off;
}
static class Job implements Runnable {
private volatile long subtotal = 0;
private final int n;
private final int[][] perms;
private final int shift;
private final Map<CanonicalMatrix, Integer> unseen;
public Job(int n, int[][] perms, int shift, Map<CanonicalMatrix, Integer> unseen) {
this.n = n;
this.perms = perms;
this.shift = shift;
this.unseen = unseen;
}
public void run() {
long result = 0;
int[][] perms = this.perms;
Map<CanonicalMatrix, Integer> unseen = this.unseen;
while (!unseen.isEmpty()) {
int m = unseen.values().iterator().next();
Set<CanonicalMatrix> equiv = new HashSet<CanonicalMatrix>();
for (int[] perm : perms) {
CanonicalMatrix canonical = new CanonicalMatrix(m, perm);
if (equiv.add(canonical)) {
result += canonical.weight() << shift;
unseen.remove(canonical);
}
}
}
subtotal = result;
}
}
static class CanonicalMatrix {
private final int[] a;
private final int hash;
public CanonicalMatrix(int m, int[] r) {
this(permuteRows(m, r));
}
public CanonicalMatrix(int[] a) {
this.a = a;
Arrays.sort(a);
int h = 0;
for (int i : a) h = h * 37 + i;
hash = h;
}
private static int[] permuteRows(int m, int[] perm) {
int[] cols = new int[perm.length];
for (int i = 0; i < perm.length; i++) {
for (int j = 0; j < cols.length; j++) cols[j] |= ((m >> (perm[i] + j)) & 1L) << i;
}
return cols;
}
public int sum() {
int sum = 0;
for (int i : a) sum += i;
return sum;
}
public int weight() {
int prev = -1, count = 0, weight = FACT[a.length];
for (int col : a) {
if (col == prev) weight /= ++count;
else {
prev = col;
count = 1;
}
}
return weight;
}
@Override public boolean equals(Object obj) {
// Deliberately unsuitable for general-purpose use, but helps catch bugs faster.
CanonicalMatrix that = (CanonicalMatrix)obj;
for (int i = 0; i < a.length; i++) {
if (a[i] != that.a[i]) return false;
}
return true;
}
@Override public int hashCode() {
return hash;
}
}
}
Сохранить как HankelCombinatorics.java, скомпилировать как javac HankelCombinatorics.java, запустить как java -Xmx2G HankelCombinatorics.
На NUM_THREADS = 4моей четырехъядерной машине он длится 20420819767436от n=850 до 55 секунд, с достаточной вариативностью между запусками; Я ожидаю, что он легко справится с тем же на вашей восьмиъядерной машине, но потребуется час или больше, чтобы получитьn=9 .
Как это устроено
Учитывая n, существуют 2^(2n-1)бинарные nх nганкелевы матрицы. Строки можно переставлять n!разными способами, а столбцы - n!разными способами. Все, что нам нужно сделать, это избежать двойного счета ...
Если вы вычисляете сумму каждой строки, то ни перестановка строк, ни перестановка столбцов не изменяют мультимножество сумм. Например
0 1 1 0 1
1 1 0 1 0
1 0 1 0 0
0 1 0 0 1
1 0 0 1 0
имеет многозначную сумму строк {3, 3, 2, 2, 2} , как и все матрицы Ханкеля, полученные из него. Это означает, что мы можем сгруппировать матрицы Ханкеля по этим мультимножествам суммы строк, а затем обрабатывать каждую группу независимо, используя несколько процессорных ядер.
Существует также эксплуатируемая симметрия: матрицы с большим числом нулей, чем единицы, находятся в биекции с матрицами с большим числом нулей.
Двойной учет имеет место , когда Ганкель матрица M_1с перестановкой строк r_1и перестановкой столбцов c_1соответствует матрице ганкелева M_2с перестановкой строк r_2и перестановкой столбцов c_2(до двух , но не все три M_1 = M_2, r_1 = r_2, c_1 = c_2). Строки и столбцы перестановки являются независимыми, так что если мы применим строки перестановку r_1к M_1и строке перестановку r_2в M_2столбцах как мультимножества должны быть равны. Поэтому для каждой группы я вычисляю все мультимножества столбцов, полученные путем применения перестановки строк к матрице в группе. Простой способ получить каноническое представление мультимножеств - это отсортировать столбцы, что также полезно на следующем шаге.
Получив различные мультимножества столбцов, нам нужно выяснить, сколько n!перестановок каждого из них уникально. На этом этапе двойной подсчет может иметь место только в том случае, если в заданном мультимножестве столбцов есть повторяющиеся столбцы: нам нужно подсчитать количество вхождений каждого отдельного столбца в мультимножестве, а затем вычислить соответствующий коэффициент многочлена. Поскольку столбцы отсортированы, подсчет легко выполнить.
Наконец мы добавляем их все.
Асимптотическая сложность не является тривиальной для вычисления с полной точностью, потому что мы должны сделать некоторые предположения о множествах. Мы оцениваем порядок 2^(2n-2) n!столбцов мультимножеств, принимая n^2 ln nвремя для каждого (включая сортировку); если группировка занимает не больше, чем ln nфактор, у нас есть сложность времени Theta(4^n n! n^2 ln n). Но поскольку экспоненциальные факторы полностью доминируют над полиномиальными, это так Theta(4^n n!) = Theta((4n/e)^n).