请教一下该怎么用java怎么实现A*算法？

Question

用java怎么实现A*算法

Answer 1

123456789101112131415161718192021222324252627282930313233343536373839404142434445

from operator import and_from itertools import combinationsclass AprioriAssociationRule:    def __init__(self, inputfile):        self.transactions = []        self.itemSet = set([])        inf = open(inputfile, 'rb')        for line in inf.readlines():            elements = set(filter(lambda entry: len(entry)>0, line.strip().split(',')))            if len(elements)>0:                self.transactions.append(elements)                for element in elements:                    self.itemSet.add(element)        inf.close()        self.toRetItems = {}        self.associationRules = []     def getSupport(self, itemcomb):        if type(itemcomb) != frozenset:            itemcomb = frozenset([itemcomb])        within_transaction = lambda transaction: reduce(and_, [(item in transaction) for item in itemcomb])        count = len(filter(within_transaction, self.transactions))        return float(count)/float(len(self.transactions))     def runApriori(self, minSupport=0.15, minConfidence=0.6):        itemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,                                  map(lambda item: (frozenset([item]), self.getSupport(item)), self.itemSet))        currentLset = set(map(lambda freqpair: freqpair[0], itemCombSupports))        k = 2        while len(currentLset)>0:            currentCset = set([i.union(j) for i in currentLset for j in currentLset if len(i.union(j))==k])            currentItemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,                                             map(lambda item: (item, self.getSupport(item)), currentCset))            currentLset = set(map(lambda freqpair: freqpair[0], currentItemCombSupports))            itemCombSupports.extend(currentItemCombSupports)            k += 1        for key, supportVal in itemCombSupports:            self.toRetItems[key] = supportVal        self.calculateAssociationRules(minConfidence=minConfidence)     def calculateAssociationRules(self, minConfidence=0.6):        for key in self.toRetItems:            subsets = [frozenset(item) for k in range(1, len(key)) for item in combinations(key, k)]            for subset in subsets:                confidence = self.toRetItems[key] / self.toRetItems[subset]                if confidence > minConfidence:                    self.associationRules.append([subset, key-subset, confidence])

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253

用Scala也大概六十多行：import scala.io.Sourceimport scala.collection.immutable.Listimport scala.collection.immutable.Setimport java.io.Fileimport scala.collection.mutable.Mapclass AprioriAlgorithm(inputFile: File) {  var transactions : List[Set[String]] = List()  var itemSet : Set[String] = Set()  for (line<-Source.fromFile(inputFile).getLines()) {    val elementSet = line.trim.split(',').toSet    if (elementSet.size > 0) {      transactions = transactions :+ elementSet      itemSet = itemSet ++ elementSet    }  }  var toRetItems : Map[Set[String], Double] = Map()  var associationRules : List[(Set[String], Set[String], Double)] = List()   def getSupport(itemComb : Set[String]) : Double = {    def withinTransaction(transaction : Set[String]) : Boolean = itemComb                                                                  .map( x => transaction.contains(x))                                                                  .reduceRight((x1, x2) => x1 && x2)    val count = transactions.filter(withinTransaction).size    count.toDouble / transactions.size.toDouble  }   def runApriori(minSupport : Double = 0.15, minConfidence : Double = 0.6) = {    var itemCombs = itemSet.map( word => (Set(word), getSupport(Set(word))))                           .filter( wordSupportPair => (wordSupportPair._2 > minSupport))    var currentLSet : Set[Set[String]] = itemCombs.map( wordSupportPair => wordSupportPair._1).toSet    var k : Int = 2    while (currentLSet.size > 0) {      val currentCSet : Set[Set[String]] = currentLSet.map( wordSet => currentLSet.map(wordSet1 => wordSet | wordSet1))                                                      .reduceRight( (set1, set2) => set1 | set2)                                                      .filter( wordSet => (wordSet.size==k))      val currentItemCombs = currentCSet.map( wordSet => (wordSet, getSupport(wordSet)))                                        .filter( wordSupportPair => (wordSupportPair._2 > minSupport))      currentLSet = currentItemCombs.map( wordSupportPair => wordSupportPair._1).toSet      itemCombs = itemCombs | currentItemCombs      k += 1    }    for (itemComb<-itemCombs) {      toRetItems += (itemComb._1 -> itemComb._2)    }    calculateAssociationRule(minConfidence)  }   def calculateAssociationRule(minConfidence : Double = 0.6) = {    toRetItems.keys.foreach(item =>      item.subsets.filter( wordSet => (wordSet.size<item.size & wordSet.size>0))          .foreach( subset => {associationRules = associationRules :+ (subset, item diff subset,                                                                       toRetItems(item).toDouble/toRetItems(subset).toDouble)                              }                  )    )    associationRules = associationRules.filter( rule => rule._3>minConfidence)  }}