请结合Bronkerbosch算法描述查看,该方法是在朴素的Bronkerbosch算法上进行改进,属于
带轴的Bron_Kerbosch算法
import org.apache.spark.graphx.{EdgeDirection, GraphLoader}
import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.immutable.{Set => ImmutableSet}
import scala.collection.mutable.Set
val graph = GraphLoader.edgeListFile(sc,"hdfs://master:9000/ljq/10W")
val neighbourVerticesMap = graph.collectNeighborIds(EdgeDirection.Either).collect().map(vertex => (vertex._1.asInstanceOf[Long], vertex._2.toSet)).toMap;
var keySet = neighbourVerticesMap.keySet
//ress 可以为邻点集合 也可以为一步之内的集合
var ress = scala.collection.mutable.Map.empty[Long,ImmutableSet[Long]]
for (key<-keySet){
/*var newSet = neighbourVerticesMap.get(key).get
for (s<-newSet){
newSet = newSet.union(neighbourVerticesMap.get(s).get)
}
ress.put(key,newSet.-(key))*/
ress.put(key,neighbourVerticesMap.get(key).get)
}
val vert =graph.vertices.map(x=>{
x._1.toLong
})
var count = 0
def findCliques(potentialClique: Set[Long],candidates: Set[Long], alreadyFound: Set[Long],cliques: Set[Set[Long]])
: Unit = {
// println(count)
count = count+1
if (candidates.isEmpty && alreadyFound.isEmpty) {
cliques.add(potentialClique)
}else {
var diffSet = candidates.diff(ress.get(candidates.union(alreadyFound).last).get)//轴
diffSet.foreach(candidateVertex => {
//每个点对应的N步长以内的点集合
var neighbourVertices = ress.get(candidateVertex).get
findCliques(potentialClique ++ Set(candidateVertex),
candidates.intersect(neighbourVertices), //交集
alreadyFound.intersect(neighbourVertices),cliques)
alreadyFound += candidateVertex
candidates.remove(candidateVertex)
})
}
}
def runAlgorithm = {
var potentialClique = Set[Long]()
var candidates =Set[Long]()
vert.collect().foreach(x=>{
candidates.add(x)
})
var alreadyFound = Set[Long]()
var cliques = Set[Set[Long]]()
var start: Long = System.currentTimeMillis()
findCliques(potentialClique,candidates ,alreadyFound, cliques)
println(System.currentTimeMillis()-start+"ms-------------")
cliques
}
var bk= runAlgorithm