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;
}
}
}
Farklı kaydet HankelCombinatorics.java, farklı derle javac HankelCombinatorics.java, farklı çalıştır java -Xmx2G HankelCombinatorics.
İle NUM_THREADS = 4zaman çekirdekli makinede bu alır 20420819767436için n=850 ila 55 saniye işlem arasındaki değişkenlik adil bir miktar ile, geçen olarak; Sekiz çekirdekli makinenizde aynı şeyi kolayca yönetmesini bekliyorum, ancak alınması bir saat veya daha fazla sürecek n=9.
Nasıl çalışır
Verilen n, 2^(2n-1)ikili nx nHankel matrisleri vardır. Satırlara n!ve sütunlara da izin verilebilir n!. Tek yapmamız gereken çift sayımdan kaçınmak ...
Her satırın toplamını hesaplarsanız, ne satırlara ne de sütunlara izin vermek toplamların çoklu kümesini değiştirmez. Örneğin
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
satır toplamı çoklu {3, 3, 2, 2, 2}kümesine sahiptir ve ondan türetilen tüm Hankelable matrisleri de öyle. Bu, Hankel matrislerini bu satır toplamı çoklu kümelerine göre gruplayabildiğimiz ve daha sonra her bir grubu bağımsız olarak işleyerek birden fazla işlemci çekirdeğinden yararlanabileceğimiz anlamına gelir.
Ayrıca sömürülebilir bir simetri vardır: sıfırdan daha fazla sıfır olan matrisler, sıfırdan daha fazla olan matrislerle birlikte.
Hankel matrisi zaman çift sayma meydana M_1satır permütasyon ile r_1ve sütun permütasyon c_1Hankel matris eşleşen M_2satır permütasyon ile r_2ve sütun permütasyon c_2(iki adede kadar olan, ancak hepsi değil, üç M_1 = M_2, r_1 = r_2, c_1 = c_2). Satır ve sütun permütasyon biz satır permütasyonu uygulamak eğer öyleyse, bağımsız r_1etmek M_1ve satır permütasyon r_2için M_2, sütunlar MULTISETS olarak eşit olmalıdır. Her grup için, gruptaki bir matrise bir satır permütasyonu uygulayarak elde edilen tüm sütun çoklu setlerini hesaplıyorum. Çoklu kümelerin standart bir gösterimini elde etmenin kolay yolu sütunları sıralamaktır ve bu bir sonraki adımda da yararlıdır.
Farklı sütun çoklu setlerini elde ettikten sonra n!, her birinin permütasyonlarının kaçının benzersiz olduğunu bulmamız gerekir . Bu noktada, çift sayma yalnızca belirli bir sütun çoklu kümesinin yinelenen sütunları varsa oluşabilir: yapmamız gereken, çoklu kümedeki her farklı sütunun yineleme sayısını saymak ve daha sonra karşılık gelen çok uluslu katsayıyı hesaplamaktır. Sütunlar sıralandığından, sayımı yapmak kolaydır.
Sonunda hepsini topladık.
Asimptotik karmaşıklık tam hassasiyetle hesaplamak için önemsiz değildir, çünkü setler hakkında bazı varsayımlar yapmamız gerekir. Her biri için zaman 2^(2n-2) n!ayırarak n^2 ln n(sıralama dahil) sütun çoklu kümelerinin sırasını değerlendiririz ; gruplama bir ln nfaktörden fazlasını almazsa , zaman karmaşıklığımız vardır Theta(4^n n! n^2 ln n). Fakat üstel faktörler polinom faktörlerine tamamen hakim olduğundan, öyle Theta(4^n n!) = Theta((4n/e)^n).