चूंकि लंबाई को एक मानदंड के रूप में सूचीबद्ध किया गया है, यहां 1681 वर्णों पर गोल्फ संस्करण है (शायद अभी भी 10% तक सुधार किया जा सकता है):
import java.io.*;import java.util.*;public class W{public static void main(String[]
a)throws Exception{int n=a.length<1?5:a[0].length(),p,q;String f,t,l;S w=new S();Scanner
s=new Scanner(new
File("sowpods"));while(s.hasNext()){f=s.next();if(f.length()==n)w.add(f);}if(a.length<1){String[]x=w.toArray(new
String[0]);Random
r=new Random();q=x.length;p=r.nextInt(q);q=r.nextInt(q-1);f=x[p];t=x[p>q?q:q+1];}else{f=a[0];t=a[1];}H<S>
A=new H(),B=new H(),C=new H();for(String W:w){A.put(W,new
S());for(p=0;p<n;p++){char[]c=W.toCharArray();c[p]='.';l=new
String(c);A.get(W).add(l);S z=B.get(l);if(z==null)B.put(l,z=new
S());z.add(W);}}for(String W:A.keySet()){C.put(W,w=new S());for(String
L:A.get(W))for(String b:B.get(L))if(b!=W)w.add(b);}N m,o,ñ;H<N> N=new H();N.put(f,m=new
N(f,t));N.put(t,o=new N(t,t));m.k=0;N[]H=new
N[3];H[0]=m;p=H[0].h;while(0<1){if(H[0]==null){if(H[1]==H[2])break;H[0]=H[1];H[1]=H[2];H[2]=null;p++;continue;}if(p>=o.k-1)break;m=H[0];H[0]=m.x();if(H[0]==m)H[0]=null;for(String
v:C.get(m.s)){ñ=N.get(v);if(ñ==null)N.put(v,ñ=new N(v,t));if(m.k+1<ñ.k){if(ñ.k<ñ.I){q=ñ.k+ñ.h-p;N
Ñ=ñ.x();if(H[q]==ñ)H[q]=Ñ==ñ?null:Ñ;}ñ.b=m;ñ.k=m.k+1;q=ñ.k+ñ.h-p;if(H[q]==null)H[q]=ñ;else{ñ.n=H[q];ñ.p=ñ.n.p;ñ.n.p=ñ.p.n=ñ;}}}}if(o.b==null)System.out.println(f+"\n"+t+"\nOY");else{String[]P=new
String[o.k+2];P[o.k+1]=o.k-1+"";m=o;for(q=m.k;q>=0;q--){P[q]=m.s;m=m.b;}for(String
W:P)System.out.println(W);}}}class N{String s;int k,h,I=(1<<30)-1;N b,p,n;N(String S,String
d){s=S;for(k=0;k<d.length();k++)if(d.charAt(k)!=S.charAt(k))h++;k=I;p=n=this;}N
x(){N r=n;n.p=p;p.n=n;n=p=this;return r;}}class S extends HashSet<String>{}class H<V>extends
HashMap<String,V>{}
Ungolfed संस्करण, जो पैकेज नाम और विधियों का उपयोग करता है और चेतावनी नहीं देता है या केवल उन्हें उर्फ करने के लिए कक्षाएं बढ़ाता है:
package com.akshor.pjt33;
import java.io.*;
import java.util.*;
// WordLadder partially golfed and with reduced dependencies
//
// Variables used in complexity analysis:
// n is the word length
// V is the number of words (vertex count of the graph)
// E is the number of edges
// hash is the cost of a hash insert / lookup - I will assume it's constant, but without completely brushing it under the carpet
public class WordLadder2
{
private Map<String, Set<String>> wordsToWords = new HashMap<String, Set<String>>();
// Initialisation cost: O(V * n * (n + hash) + E * hash)
private WordLadder2(Set<String> words)
{
Map<String, Set<String>> wordsToLinks = new HashMap<String, Set<String>>();
Map<String, Set<String>> linksToWords = new HashMap<String, Set<String>>();
// Cost: O(Vn * (n + hash))
for (String word : words)
{
// Cost: O(n*(n + hash))
for (int i = 0; i < word.length(); i++)
{
// Cost: O(n + hash)
char[] ch = word.toCharArray();
ch[i] = '.';
String link = new String(ch).intern();
add(wordsToLinks, word, link);
add(linksToWords, link, word);
}
}
// Cost: O(V * n * hash + E * hash)
for (Map.Entry<String, Set<String>> from : wordsToLinks.entrySet()) {
String src = from.getKey();
wordsToWords.put(src, new HashSet<String>());
for (String link : from.getValue()) {
Set<String> to = linksToWords.get(link);
for (String snk : to) {
// Note: equality test is safe here. Cost is O(hash)
if (snk != src) add(wordsToWords, src, snk);
}
}
}
}
public static void main(String[] args) throws IOException
{
// Cost: O(filelength + num_words * hash)
Map<Integer, Set<String>> wordsByLength = new HashMap<Integer, Set<String>>();
BufferedReader br = new BufferedReader(new FileReader("sowpods"), 8192);
String line;
while ((line = br.readLine()) != null) add(wordsByLength, line.length(), line);
if (args.length == 2) {
String from = args[0].toUpperCase();
String to = args[1].toUpperCase();
new WordLadder2(wordsByLength.get(from.length())).findPath(from, to);
}
else {
// 5-letter words are the most interesting.
String[] _5 = wordsByLength.get(5).toArray(new String[0]);
Random rnd = new Random();
int f = rnd.nextInt(_5.length), g = rnd.nextInt(_5.length - 1);
if (g >= f) g++;
new WordLadder2(wordsByLength.get(5)).findPath(_5[f], _5[g]);
}
}
// O(E * hash)
private void findPath(String start, String dest) {
Node startNode = new Node(start, dest);
startNode.cost = 0; startNode.backpointer = startNode;
Node endNode = new Node(dest, dest);
// Node lookup
Map<String, Node> nodes = new HashMap<String, Node>();
nodes.put(start, startNode);
nodes.put(dest, endNode);
// Heap
Node[] heap = new Node[3];
heap[0] = startNode;
int base = heap[0].heuristic;
// O(E * hash)
while (true) {
if (heap[0] == null) {
if (heap[1] == heap[2]) break;
heap[0] = heap[1]; heap[1] = heap[2]; heap[2] = null; base++;
continue;
}
// If the lowest cost isn't at least 1 less than the current cost for the destination,
// it can't improve the best path to the destination.
if (base >= endNode.cost - 1) break;
// Get the cheapest node from the heap.
Node v0 = heap[0];
heap[0] = v0.remove();
if (heap[0] == v0) heap[0] = null;
// Relax the edges from v0.
int g_v0 = v0.cost;
// O(hash * #neighbours)
for (String v1Str : wordsToWords.get(v0.key))
{
Node v1 = nodes.get(v1Str);
if (v1 == null) {
v1 = new Node(v1Str, dest);
nodes.put(v1Str, v1);
}
// If it's an improvement, use it.
if (g_v0 + 1 < v1.cost)
{
// Update the heap.
if (v1.cost < Node.INFINITY)
{
int bucket = v1.cost + v1.heuristic - base;
Node t = v1.remove();
if (heap[bucket] == v1) heap[bucket] = t == v1 ? null : t;
}
// Next update the backpointer and the costs map.
v1.backpointer = v0;
v1.cost = g_v0 + 1;
int bucket = v1.cost + v1.heuristic - base;
if (heap[bucket] == null) {
heap[bucket] = v1;
}
else {
v1.next = heap[bucket];
v1.prev = v1.next.prev;
v1.next.prev = v1.prev.next = v1;
}
}
}
}
if (endNode.backpointer == null) {
System.out.println(start);
System.out.println(dest);
System.out.println("OY");
}
else {
String[] path = new String[endNode.cost + 1];
Node t = endNode;
for (int i = t.cost; i >= 0; i--) {
path[i] = t.key;
t = t.backpointer;
}
for (String str : path) System.out.println(str);
System.out.println(path.length - 2);
}
}
private static <K, V> void add(Map<K, Set<V>> map, K key, V value) {
Set<V> vals = map.get(key);
if (vals == null) map.put(key, vals = new HashSet<V>());
vals.add(value);
}
private static class Node
{
public static int INFINITY = Integer.MAX_VALUE >> 1;
public String key;
public int cost;
public int heuristic;
public Node backpointer;
public Node prev = this;
public Node next = this;
public Node(String key, String dest) {
this.key = key;
cost = INFINITY;
for (int i = 0; i < dest.length(); i++) if (dest.charAt(i) != key.charAt(i)) heuristic++;
}
public Node remove() {
Node rv = next;
next.prev = prev;
prev.next = next;
next = prev = this;
return rv;
}
}
}
जैसा कि आप देख सकते हैं, चल लागत विश्लेषण है O(filelength + num_words * hash + V * n * (n + hash) + E * hash)। यदि आप मेरी धारणा को स्वीकार करेंगे कि हैश टेबल प्रविष्टि / लुकअप निरंतर समय है, तो O(filelength + V n^2 + E)। सोपोड्स में ग्राफ के विशेष आंकड़ों का मतलब है कि O(V n^2)वास्तव में O(E)अधिकांश के लिए हावी है n।
नमूना आउटपुट:
IDOLA, IDOLS, IDYLS, ODYLS, ODALS, OVALS, OVELS, OVENS, EVENS, ETENS, STENS, SKENS, स्किन, स्पाइन, 13
WICCA, PROSY, ओए
BRINY, BRINS, TRINS, TAINS, TARNS, YARNS, YAWNS, YAWPS, YAPPS, 7
GALES, GASES, GASTS, GESTS, GESTE, GESSE, DESSE, 5
आकृति, डक्ट, ड्यून्स, डाइन, डिंग, डिंगी, ४
LICHT, LIGHT, BIGHT, BIGOT, BIGOS, BIROS, GIROS, GIRNS, GURNS, GUANS, GUANA, RUANA, 10
SARGE, SERGE, SERRE, SERRS, SEERS, DEERS, DYERS, ओएयर्स, OVERS, OVELS, OVALS, ODALS, ODYLS, IDYLS, 12
KEIRS, SEIRS, SEERS, BEERS, BRERS, BRERE, BREME, CREME, CREPE, 7
यह 6 सबसे लंबे रास्तों में से एक है:
GAINEST, FAINEST, FAIREST, SAIREST, SADEST, SADDEST, MADDEST, MADDEST, MILDEST, WILDEST, WILIEST, WILIEST, WANIEST, CANIEST, CANTEST, CONESTEST, CONFESS, CONFESS, CONFERS, CONKERS, CONKERS, CONKERS, COK POPPITS, POPPIES, POPSIES, MOPSIES, MOUSIES, MOUSSES, POUSSES, PLUSISSES, PLISSES, PRISSES, PRREES, PREASES, UREASES, UNEASES, UNCASES, UNCASED, UNBASED, UNBASED, UNMATE, UNMET, UNMET, UNMET, UNIMM INDEXES, INDENES, INDENTS, INCENTS, INCESTS, INFESTS, INFECTS, INJECTS, 56
और सबसे खराब घुलनशील 8-अक्षर वाले जोड़े में से एक:
एन्रोबिंग, UNROBING, UNROPING, UNCOPING, UNCAPING, UNCAGING, ENCAGING, ENRACING, ENLACING, ENLACING, UNLACING, SPLAYING, STRAY, STROYING, STROYING, STY CRIMPING, CRISPING, CRISPINS, CRISPENS, CRIMPERS, CRAMPERS, CLAMPERS, CLASPERS, CLASHERS, स्लैथर्स, स्मूथर्स, स्मूथर्स, स्मूथर्स, स्मूथर्स, सूट्स, मूछें, मूछें, मूछें, मूछें, मूवर्स, मूछें, मूवर्स, मूवर्स LUNCHERS, LYNCHERS, LYNCHETS, LINCHETS, 52
अब जब मुझे लगता है कि मुझे प्रश्न की सभी आवश्यकताएं पूरी हो गई हैं, तो मेरी चर्चा।
एक COMPSci के लिए प्रश्न स्पष्ट रूप से एक ग्राफ जी में सबसे छोटा रास्ता कम कर देता है जिसके कोने शब्द हैं और जिनके किनारों को एक अक्षर में अलग-अलग शब्द जोड़ते हैं। ग्राफ को कुशलतापूर्वक उत्पन्न करना तुच्छ नहीं है - मुझे वास्तव में एक विचार है कि मुझे ओ (वी एन हैश + ई) की जटिलता को कम करने के लिए फिर से विचार करने की आवश्यकता है। जिस तरह से मैं करता हूं उसमें एक ग्राफ बनाना शामिल है जो अतिरिक्त वर्टिस (एक वाइल्डकार्ड वर्ण के साथ शब्दों के अनुसार) सम्मिलित करता है और प्रश्न में ग्राफ के लिए होमोमोर्फिक है। मैंने G को कम करने के बजाय उस ग्राफ का उपयोग करने पर विचार किया था और मुझे लगता है कि गोल्फ के दृष्टिकोण से मुझे ऐसा करना चाहिए था - इस आधार पर कि 3 से अधिक किनारों वाला वाइल्डकार्ड नोड ग्राफ में किनारों की संख्या को कम करता है, और सबसे छोटी पथ एल्गोरिदम का मानक खराब समय चल रहा है O(V heap-op + E)।
हालाँकि, पहली चीज़ जो मैंने की थी, उसमें ग्राफ़ के कुछ विश्लेषणों को अलग-अलग शब्द लंबाई के लिए चलाना था, और मुझे पता चला कि वे 5 या अधिक अक्षरों के शब्दों के लिए बेहद विरल हैं। 5-लेटर ग्राफ में 12478 कोने और 40759 किनारे हैं; लिंक नोड्स जोड़ने से ग्राफ खराब होता है। जब तक आप 8 अक्षरों तक होते हैं तब तक नोड्स की तुलना में कम किनारों होते हैं, और शब्दों के 3/7 "अलोफ" होते हैं। इसलिए मैंने उस अनुकूलन विचार को वास्तव में मददगार नहीं माना।
जो विचार मददगार साबित हुआ वह था ढेर की जांच करना। मैं ईमानदारी से कह सकता हूं कि मैंने अतीत में कुछ मामूली विदेशी ढेरों को लागू किया है, लेकिन इस तरह से कोई भी विदेशी नहीं है। मैं A- स्टार का उपयोग करता हूं (चूंकि C, ढेर का कोई लाभ नहीं दे रहा है जो मैं उपयोग कर रहा हूं) लक्ष्य से अलग अक्षरों की संख्या के स्पष्ट हेयूरिस्टिक के साथ, और थोड़ा विश्लेषण बताता है कि किसी भी समय 3 से अधिक भिन्न प्राथमिकताएं नहीं हैं ढेर में। जब मैं एक नोड को पॉप करता हूं जिसकी प्राथमिकता (लागत + हेयुरिस्टिक) है और उसके पड़ोसियों को देखें, तो तीन मामले हैं जिन पर मैं विचार कर रहा हूं: 1) पड़ोसी की लागत लागत + 1 है; पड़ोसी का हेयुरिस्टिक हेयुरिस्टिक -1 है (क्योंकि यह जो अक्षर बदलता है वह "सही" हो जाता है); 2) लागत + 1 और हेयुरिस्टिक + 0 (क्योंकि यह जो अक्षर बदलता है वह "गलत" से "अभी भी गलत" हो जाता है; 3) लागत + 1 और हेयुरिस्टिक + 1 (क्योंकि यह जो अक्षर बदलता है वह "सही" से "गलत" हो जाता है)। इसलिए अगर मैं पड़ोसी को आराम देता हूं तो मैं इसे उसी प्राथमिकता, प्राथमिकता + 1, या प्राथमिकता + 2 में सम्मिलित करने जा रहा हूं। परिणामस्वरूप मैं ढेर के लिए लिंक की गई सूचियों के 3-तत्व सरणी का उपयोग कर सकता हूं।
मुझे अपनी धारणा के बारे में एक नोट जोड़ना चाहिए कि हैश लुकअप स्थिर हैं। बहुत अच्छी तरह से, आप कह सकते हैं, लेकिन हैश अभिकलन के बारे में क्या? इसका उत्तर यह है कि मैं उन्हें दूर कर रहा हूं: java.lang.Stringइसके कैश करता है hashCode(), इसलिए कंप्यूटिंग हैश में बिताया गया कुल समय O(V n^2)(ग्राफ बनाने में) है।
एक और बदलाव है जो जटिलता को प्रभावित करता है, लेकिन यह सवाल है कि क्या यह एक अनुकूलन है या नहीं यह आंकड़ों के बारे में आपकी धारणाओं पर निर्भर करता है। (मानदंड के रूप में "सबसे अच्छा बिग ओ समाधान" डालते हुए IMO एक गलती है क्योंकि एक सरल कारण के लिए सबसे अच्छी जटिलता नहीं है: एक एकल चर नहीं है)। यह परिवर्तन ग्राफ पीढ़ी के कदम को प्रभावित करता है। उपरोक्त कोड में, यह है:
Map<String, Set<String>> wordsToLinks = new HashMap<String, Set<String>>();
Map<String, Set<String>> linksToWords = new HashMap<String, Set<String>>();
// Cost: O(Vn * (n + hash))
for (String word : words)
{
// Cost: O(n*(n + hash))
for (int i = 0; i < word.length(); i++)
{
// Cost: O(n + hash)
char[] ch = word.toCharArray();
ch[i] = '.';
String link = new String(ch).intern();
add(wordsToLinks, word, link);
add(linksToWords, link, word);
}
}
// Cost: O(V * n * hash + E * hash)
for (Map.Entry<String, Set<String>> from : wordsToLinks.entrySet()) {
String src = from.getKey();
wordsToWords.put(src, new HashSet<String>());
for (String link : from.getValue()) {
Set<String> to = linksToWords.get(link);
for (String snk : to) {
// Note: equality test is safe here. Cost is O(hash)
if (snk != src) add(wordsToWords, src, snk);
}
}
}
वह है O(V * n * (n + hash) + E * hash)। लेकिन यह O(V * n^2)हिस्सा प्रत्येक लिंक के लिए एक नया एन-कैरेक्टर स्ट्रिंग उत्पन्न करने और फिर इसके हैशकोड की गणना करने से आता है। एक सहायक वर्ग के साथ इससे बचा जा सकता है:
private static class Link
{
private String str;
private int hash;
private int missingIdx;
public Link(String str, int hash, int missingIdx) {
this.str = str;
this.hash = hash;
this.missingIdx = missingIdx;
}
@Override
public int hashCode() { return hash; }
@Override
public boolean equals(Object obj) {
Link l = (Link)obj; // Unsafe, but I know the contexts where I'm using this class...
if (this == l) return true; // Essential
if (hash != l.hash || missingIdx != l.missingIdx) return false;
for (int i = 0; i < str.length(); i++) {
if (i != missingIdx && str.charAt(i) != l.str.charAt(i)) return false;
}
return true;
}
}
फिर ग्राफ पीढ़ी का पहला आधा हिस्सा बन जाता है
Map<String, Set<Link>> wordsToLinks = new HashMap<String, Set<Link>>();
Map<Link, Set<String>> linksToWords = new HashMap<Link, Set<String>>();
// Cost: O(V * n * hash)
for (String word : words)
{
// apidoc: The hash code for a String object is computed as
// s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
// Cost: O(n * hash)
int hashCode = word.hashCode();
int pow = 1;
for (int j = word.length() - 1; j >= 0; j--) {
Link link = new Link(word, hashCode - word.charAt(j) * pow, j);
add(wordsToLinks, word, link);
add(linksToWords, link, word);
pow *= 31;
}
}
हैशकोड की संरचना का उपयोग करके हम लिंक को उत्पन्न कर सकते हैं O(V * n)। हालाँकि, यह एक नॉक-ऑन प्रभाव है। मेरी धारणा में निहित है कि हैश लुकअप निरंतर समय है एक धारणा है कि समानता के लिए वस्तुओं की तुलना करना सस्ता है। हालांकि, लिंक की समानता परीक्षण O(n)सबसे खराब स्थिति में है। सबसे खराब स्थिति यह है कि जब हमारे पास अलग-अलग शब्दों से उत्पन्न दो समान लिंक के बीच हैश टकराव होता है - यानी यह O(E)ग्राफ पीढ़ी के दूसरे छमाही में होता है । इसके अलावा, गैर-समान लिंक के बीच हैश टकराव की संभावना के अलावा, हम अच्छे हैं। इसलिए हमने इसके लिए कारोबार किया O(V * n^2)है O(E * n * hash)। आंकड़ों के बारे में मेरा पिछला बिंदु देखें।
HOUSEके लिएGORGEरिपोर्ट किया गया है 2. के रूप में मुझे लगता है 2 मध्यवर्ती शब्द देखते हैं, तो यह मेकअप भावना करता है, लेकिन आपरेशन के # अधिक सहज ज्ञान युक्त होगा।