जावा (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=8में 50 से 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, कॉलम multisets के रूप में बराबर होना चाहिए। इसलिए प्रत्येक समूह के लिए, मैं समूह में एक मैट्रिक्स के लिए एक पंक्ति क्रमांकन लागू करके प्राप्त किए गए सभी कॉलम मल्टीसेट्स की गणना करता हूं। मल्टीसेट का एक कैनोनिकल प्रतिनिधित्व प्राप्त करने का आसान तरीका कॉलम को सॉर्ट करना है, और यह अगले चरण में भी उपयोगी है।
विशिष्ट कॉलम मल्टीसेट प्राप्त करने के बाद, हमें यह पता लगाने की आवश्यकता है कि 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)।