精华内容
下载资源
问答
  • 集合之间的关系: 1.两个集合是否相等: 可以使用运算符 == 或者 != 进行判断 2.一个集合是否是另一个集合的子集: 可以使用issubset()来判断 3.一个集合是否是另一个集合的超集: 可以调用方法issuperset...
    集合之间的关系:
        1.两个集合是否相等:
            可以使用运算符 == 或者 != 进行判断
        2.一个集合是否是另一个集合的子集:
            可以使用issubset()来判断
        3.一个集合是否是另一个集合的超集:
            可以调用方法issuperset()进行判断
        4.两个集合是否有交集:
            可以调用方法isdisjoint进行判断
    

    代码

    """
        集合之间的关系:
            1.两个集合是否相等:
                可以使用运算符 == 或者 != 进行判断
            2.一个集合是否是另一个集合的子集:
                可以使用issubset()来判断
            3.一个集合是否是另一个集合的超集:
                可以调用方法issuperset()进行判断
            4.两个集合是否有交集:
                可以调用方法isdisjoint进行判断
    """
    set2 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
    set3 = {9, 8, 7, 6, 4, 5, 1, 2, 3}
    set4 = {1, 2, 3, 4, 5, 6}
    print(set2 == set3)
    print(set2 != set3)
    print(set2.issubset(set3))  # set2是set3的子集
    print(set4.issubset(set2))  # set4是set2的子集
    print(set2.issuperset(set4))  # set2是set4的超集
    
    
    

    截图
    在这里插入图片描述

    展开全文
  • 背景最近遇到一个有趣问题,如何在CityEgnine中判断有接触或相交关系的模型,从而自动进行建模?这个问题有点抽象,我们来看个实例,了解下问题背景:以往绝大多数情况下,我们拿到2D建筑物底面(FootPrint)都...

    背景

    最近遇到一个有趣的问题,如何在CityEgnine中判断有接触或相交关系的模型,从而自动进行建模?

    这个问题有点抽象,我们来看个实例,了解下问题的背景:

    以往绝大多数情况下,我们拿到的2D建筑物底面(FootPrint)都是一个建筑对应一个面,也就是这样的:

    实际生活中的的建筑物可能是更复杂的,例如商场、大型会议中心、复杂居民楼等参差不齐的多栋联合建筑,我们可以采集多个底面来表示建筑物,例如这样:

    使用多个底面表示一栋复杂建筑物的做法可以很大程度上简化建模的工作,因此无可厚非。 但是问题来了,因为是彼此独立的Footprint,建模时若不加判断,就会出现如下图所示的情况,好像“空中地下室”。这样的房子既不美观也不实际。


    解决方法

    CityEngine的真正魅力在于“动态”建模,这是CE的创作者一直想要传播的理念。 CityEgnine提供很多内置函数解决这些问题,其中有一组为:Occlusion Functions,包含:insideoverlapstouches 三个函数。 我们可以利用 touches() 来实现判断。

    先写段简单的来了解下函数用法:

    Init --> 
         extrude(40) Mass
    Mass -->
         comp(f){top:NIL| side:Side} 
    Side --> 
         case touches(): color(1,0,0) ShareSide
         else: Walls

    针对前面“空中地下室”的问题,可以在楼层切割到窗户和墙体的时候做个判断,楼层不touch其他楼层时,再进行分割。

    可以实现这个样子:

    全部 CGA 代码共享给大家:

    /**
     * File:    TestTouches.cga
     * Created: 1 Apr 2016 13:00:24 GMT
     * Author:  kikita
     */
    
    version "2015.2"
    
    # Define Attributes
    attr AVG_HEIGHT = 0
    attr WindowsWidth = 8
    attr WallWidth = 2.5
    
    # Building Schmetic
    Init --> 
         extrude(AVG_HEIGHT) Mass
    Mass -->
         comp(f){top:Top|side:Walls}
    Walls -->
         split(y) { 15 : GroundFloor | {~10 : UpperFloors } * }
    
    # Ground Floor
    GroundFloor --> 
       setupProjection(0, scope.xy, '1, '1)
       projectUV(0) 
       texture("GroundFloor.jpg") 
    
    # All Upper Floors
    UpperFloors --> 
    
    # Use touches() function
        case touches():
             setupProjection(0, scope.xy, 10, 10)
             projectUV(0) 
             texture("Wall/wall_grey.jpg")
        else:
             split(x){ ~WallWidth : AllWalls |
                     { ~WindowsWidth : WindowTiles |
                       ~WallWidth : AllWalls } * }                 
             WindowTiles -->
                split(y){ ~WallWidth/2: AllWalls |
                          ~WindowsWidth : Windows|
                          ~WallWidth/2 :AllWalls }
    
    # Wall Texture      
    AllWalls -->    
          setupProjection(0, scope.xy, 10, 10)
          projectUV(0) 
          texture("Wall/wall_grey.jpg")
    
    # Windows  
    Windows --> 
          color("DAFAF3")
          i("Windows/sash_window.obj") 
          s('1,'1,'2)          
    
    # Roofs
    Top --> 
          offset(-0.5)
          comp(f){ border : RoofEdge | inside : RoofFlat }     
    RoofFlat -->
          setupProjection(0, scope.xy, '1, '1)
          projectUV(0) 
          texture("flatroof6.bw.jpg")     
    RoofEdge --> 
          extrude(1) 
    

    明天就放假了

    节日愉快

    我说的是愚人节

    Also available Here .

    展开全文
  • 有向图中判断已选节点间的关系

    千次阅读 2015-08-15 12:36:07
    本算法通过遍历整个有向图来获取已选节点的关系,通过本算法,可以轻松的获得已选节点在其有向图中的流向关系,如下图,通过本算法我们可以和容易的发现A与C的流向关系是A -> C 而不是 A \ 本算法的实现步骤是...

    本算法通过遍历整个有向图来获取已选节点的关系,通过本算法,可以轻松的获得已选节点在其有向图中的流向关系,如下图,通过本算法我们可以和容易的发现A与C的流向关系是A -> C 而不是 A <- C

    \

    本算法的实现步骤是:

    1.遍历整个有向图

    2.每次遍历,查看当前节点是否为已选节点之一,

    3.若是,建立集合存储已选节点(这里暂且称为临时集合),实现中用的是集合是HashMap

    4.若果临时集合元素个数不为0,则将刚加入临时集合的节点名称放入临时集合已有元素的containNode字段中,containNode字段的值是一个类型为String的HashSet

    5.若临时集合已有的某个节点的所以子孙节点已遍历完毕,则将该节点所对应的元素从临时集合中删除。

    由于本算法需要遍历整个有向图,因此时间复杂度是遍历整个有向图的复杂度;另,关于有向图的遍历方法,在文章《有向图闭环检测值java代码实现》中有论述,这里就不再说明了,当然本算法实现也是有文章《有向图闭环检测值java代码实现》的实现修改得来,对于遍历的修改点如下:

    1.修改了traverseInDigraph()方法,取消了对"isFrozen"属性值得检测,因为本算法需要深度的遍历整个有向图。

    2.修改了getNextNodeIndexInDigraph()方法,增加了对"isFrozen"的属性值检测,确保可以深度遍历整个有向图。

    3.修改了traverseInDigraph(),在前进时将下一节点放入临时集合,后退时将临时集合里对应的元素放入返回之中,同时删除临时集合中对应的元素

    具体实现代码如下:

    /**
    	 * 
    	 * 功能:在有向图中寻找 已选节点的关系
    	 * 作者:EugeneJao
    	 * @param nodeCollections
    	 * @param nodes
    	 * @return
    	 * @throws Exception
    	 */
    	public Map<String,Map<String,Object>> seekRelation(Map<String,Map<String,Object>> nodeCollections , List<String> nodes) throws Exception{
    		
    		Map<String,Map<String,Object>> ret = new HashMap<String, Map<String,Object>>();
    		/**
    		 * 如果前进至某已选节点则将该已选节点放入inn,
    		 * 若已从相应已选节点中后退,则从inn移出该节点
    		 * ,感觉就像是供游客暂歇的旅馆
    		 */
    		Map <String,Map<String,Object>> inn = new HashMap<String, Map<String,Object>>();
    		/**
    		 * 初始化"起点
    		 */
    		String startNode = getOriginInDigraph(nodeCollections);
    		/**
    		 * 初始化"视野"
    		 */
    		Map<String,String> nodeName = new HashMap<String, String>() ;
    		nodeName.put("nextNode", startNode);
    		nodeName.put("curNode", startNode);
    		nodeName.put("beforeNode", startNode);
    
    		while(!(nodeName.get("beforeNode").equals(nodeName.get("curNode")) 
    				&& nodeName.get("nextNode") == null )){
    			/**
    			 * 遍历每个节点
    			 */
    			nodeName = traverseInDigraphForSeek(nodeCollections, nodeName, inn, nodes,ret);
    			
    			
    		}
    		
    		return ret;
    	}
    		
    	/**
    	 * 
    	 * 功能:在有向图中访问某个网络节点
    	 * 作者:EugeneJao
    	 * @param nodeCollections
    	 * @param nodeName
    	 * @param inn
    	 * @param ret 
    	 * @return
    	 * @throws Exception
    	 */
    	private Map<String,String> traverseInDigraphForSeek(Map<String,Map<String,Object>> nodeCollections , Map<String,String> nodeName ,
    			Map<String, Map<String, Object>> inn , List<String> nodes, Map<String, Map<String, Object>> ret) throws Exception{
    		/**
    		 * 判断前进节点在网络中存不存在
    		 */
    		if(nodeName.get("nextNode") != null){
    			if(!(nodeCollections.containsKey(nodeName.get("nextNode")))){
    				throw new Exception("节点网络构建异常,网络中不存在节点:" + nodeName);
    			}
    		}
    		
    		if(nodeName.get("curNode") == null || nodeName.get("beforeNode") == null){
    			throw new Exception("traverse()方法入参异常:curNode和beforeNode不能为空" + nodeName);
    		}
    		if(nodeName.get("nextNode") != null 
    				&& nodeCollections.get(nodeName.get("nextNode"))== null ){
    			throw new Exception("节点"+ nodeName.get("nextNode") +"在节点集合中不存在");
    		}
    		String nextNodeName =  nodeName.get("nextNode") ;
    		String curNodeName = nodeName.get("curNode") ;
    		if( nextNodeName  == null){
    			if(isSelectedNode(curNodeName, nodes)){
    				record(inn, ret, curNodeName);
    				this.checkOut(curNodeName, inn);
    			}
    			nodeName = backInDigraphForSeek(nodeCollections, nodeName);
    			
    		}else{
    			if(isSelectedNode(nextNodeName, nodes)){
    				this.checkIn(nextNodeName, inn);
    			}
    			nodeName = headInDigraphForSeek(nodeCollections, nodeName);
    			
    		}	
    	 /**
    	  * 如果不是起始"视野",但是nextNode和curNode相同的,
    	  * 说明在一个节点上可能存在包含自身的关系,这样的数据是异常数据
    	  * 顺序不可调整至调用head()和back()的语句前面
    	  */
    		if(nodeName.get("curNode").equals(nodeName.get("nextNode")) &&
    				!nodeName.get("curNode").equals(nodeName.get("beforeNode"))){
    			int curRelIndex = (Integer) nodeCollections.get(nodeName.get("curNode")).get("curRelIndex") ;
    			throw new Exception("节点参数异常:节点" + nodeName.get("curNode")+
    					"的关系节点不能包含自身,在relList的第"+ 
    					(curRelIndex + 1)+"元素上");
    		}
    		
    		return nodeName ;
    		
    	}
    	
    	/**
    	 * 
    	 * 功能:判断节点是否为已选节点
    	 * 作者:EugeneJao
    	 * @param curNodeName
    	 * @param nodes
    	 * @return
    	 */
    	private boolean isSelectedNode(String curNodeName,List<String> nodes){
    		
    		boolean ret = false ;
    		
    		Iterator it = nodes.iterator() ;
    		while(it.hasNext()){
    			String tmpNodeName = (String) it.next() ;
    			if(tmpNodeName.equals(curNodeName)){
    				ret = true ;
    				break ;
    			}
    		}
    		
    		return ret;
    		
    	}
    	
    	/**
    	 * 
    	 * 功能:将节点放入inn中,并进行相关操作
    	 * 作者:EugeneJao
    	 * @param curNodeName
    	 * @param inn
    	 */
    	private void checkIn(String curNodeName , Map<String,Map<String,Object>> inn){
    		
    		/**
    		 * 将已在inn中的节点的relList增加当前节点
    		 */
    		Set keySet = inn.entrySet();
    		Iterator it = keySet.iterator() ;
    				
    		while(it.hasNext()){
    			Entry tmpSet = (Entry) it.next() ;
    			String tmpKey = (String) tmpSet.getKey();
    			Map<String, Object> tmpNode = inn.get(tmpKey);
    			Set<String> tmpList = (Set<String>) tmpNode.get("containNode");
    			tmpList.add(curNodeName);			
    			tmpNode.put("containNode", tmpList);
    			inn.put(tmpKey, tmpNode);
    		}
    		
    		/**
    		 * 往inn中新增节点
    		 */
    		Map<String,Object> traverNode = new HashMap<String, Object>();
    		Set<String> relList= new HashSet<String>();
    		traverNode.put("nodeName",curNodeName);
    		traverNode.put("containNode", relList);
    		inn.put(curNodeName, traverNode) ;
    		
    	}
    	
    	/**
    	 * 
    	 * 功能:将已选节点从inn中删除
    	 * 作者:EugeneJao
    	 * @param curNodeName
    	 * @param inn
    	 */
    	private void checkOut(String curNodeName , Map<String,Map<String,Object>> inn){
    		
    		inn.remove(curNodeName);
    		
    	}
    	
    	
    	/** 功能:在有向图中前进至下一个节点
    	* 作者:EugeneJao
    	* @param nodeCollections
    	* @param nodeName
    	* @param inn
    	* @return
    	 * @throws Exception 
    	**/
    	@SuppressWarnings("unchecked")
    	private Map<String,String> headInDigraphForSeek(Map<String,Map<String,Object>> nodeCollections , Map<String,String> nodeName) throws Exception{
    		String  curNodeName = nodeName.get("nextNode") ; //传入参数的nextNode在本方法中即是当前节点
    		String beforeNodeName = nodeName.get("curNode") ;//传入参数的curNode在本方法中即是前一节点
    		Map<String,Object> curNode = nodeCollections.get(curNodeName);
    		List<String> relList = (List<String>) curNode.get("relList") ;
    		curNode.put("beforeNode",beforeNodeName) ;//传入参数的beforeNode在本方法中即是当前节点
    		int curRelIndex = getNextNodeIndexInDigraphForSeek(curNode);
    		/**
    		 * 获取下一个前进的目标节点名称,当curRelIndex等于relList的长度时,
    		 * 说明当前节点的所有关系节点都遍历完了,已无节点可以前进,只能后退
    		 */
    		String nextNodeName = null ;
    		if(curRelIndex < relList.size()){
    			nextNodeName = relList.get(curRelIndex) ; 
    		}
    	
    	
    	
    		/**
    		 * 更新当前节点信息
    		 */
    		curNode.put("curRelIndex", curRelIndex);//不能调整顺序值调用getNextNodeIndex()方法后面
    		nodeCollections.put(curNodeName, curNode);
    		/**
    		 * 更新nodeName信息
    		 */
    		nodeName.put("nextNode", nextNodeName);
    		nodeName.put("curNode", curNodeName);
    		nodeName.put("beforeNode", beforeNodeName);
    	
    		return nodeName;
    	}
    
    	/**
    	* 
    	* 功能:在无向图中后退至之前的节点
    	* 作者:EugeneJao
    	* @param nodeCollections
    	* @param nodeName
    	* @return
    	 * @throws Exception 
    	*/
    	private Map<String,String> backInDigraphForSeek(Map<String,Map<String,Object>> nodeCollections , Map<String, String> nodeName) throws Exception{
    		
    		/**
    		 * 节点后退,说明遍历完当前节点的所有子孙节点后,依然没有闭环
    		 * 所以先更新当前节点信息的isFroze字段为true
    		 * 在多个父节点的情况下,通过isFrozen字段来区分之前通过另一父节点对改节点的遍历
    		 * 同时也通过这个属性介绍算法运算的复杂度
    		 */
    		String  curNodeName = nodeName.get("curNode");
    		Map<String,Object> curNode = nodeCollections.get(curNodeName);
    		curNode.put("isFrozen", true);
    		
    		/**
    		 * 更新完Frozen属性后,做后退操作
    		 */
    		curNodeName = nodeName.get("beforeNode") ; //传入参数的beforeNode在后退操作中即是当前节点		
    		curNode = nodeCollections.get(curNodeName);
    		List<String> relList = (List<String>) curNode.get("relList") ;
    		String beforeNodeName = (String) curNode.get("beforeNode");
    		/**
    		 * 先更新当前节点beforeNode信息,因为后面要用
    		 */
    		curNode.put("beforeNode", beforeNodeName);//不能调整顺序值调用getNextNodeIndex()方法后面
    		
    		int curRelIndex = getNextNodeIndexInDigraphForSeek(curNode);
    		/**
    		 * 获取下一个前进的目标节点名称,当curRelIndex等于relList的长度时,
    		 * 说明当前节点的所有关系节点都遍历完了,已无节点可以前进,只能后退
    		 */
    		String nextNodeName = null ;
    		if(curRelIndex < relList.size()){
    			nextNodeName = relList.get(curRelIndex) ; 
    		}
    		
    		/**
    		 * 更新当前节点信息
    		 */
    		curNode.put("curRelIndex", curRelIndex);//不能调整顺序值调用getNextNodeIndex()方法前面
    		
    		nodeCollections.put(curNodeName, curNode);
    		/**
    		 * 更新nodeName信息
    		 */
    		nodeName.put("nextNode", nextNodeName);
    		nodeName.put("curNode", curNodeName);
    		nodeName.put("beforeNode",beforeNodeName) ;
    		
    		
    		return nodeName;
    	}
    	
    	/**
    	 * 
    	 * 功能:将即将从inn中请出的node放入ret中
    	 * 作者:EugeneJao
    	 * @param inn
    	 * @param ret
    	 * @param curNodeName
    	 */
    	private void record(Map<String,Map<String,Object>> inn , Map<String,Map<String,Object>> ret , String curNodeName){
    		Map<String,Object> curNode = inn.get(curNodeName);
    		ret.put(curNodeName, curNode);
    	}
    	
    	/**
    	 * 
    	 * 功能:在有向图中获取下一节点名称在relList里的索引值
    	 * 作者:EugeneJao
    	 * @param curNode
    	 * @return
    	 * @throws Exception 
    	 */
    	@SuppressWarnings("unchecked")
    	private int getNextNodeIndexInDigraphForSeek(Map<String,Object> curNode) throws Exception{
    		if(!(curNode.get("isFrozen") instanceof Boolean)){
    			throw new Exception("节点"+ curNode.get("nodeName") +
    					"参数类型异常:isFrozen合法类型为布尔类型,isFrozen:"+ curNode.get("isFrozen"));
    		}
    		/**
    		 * 如果当前节点状态为冻结,怎么说明它与它的子节点之前都被遍历过了,
    		 * 为了让这次能够再次遍历,设置状态为非冻结状态,同时返回索引值0
    		 */
    		if((Boolean) curNode.get("isFrozen")){
    			
    			curNode.put("isFrozen", false);			
    			return 0 ;
    		}
    		
    		List<String> relList = (List<String>) curNode.get("relList") ;
    		int curRelIndex = (Integer) curNode.get("curRelIndex") ;
    		String beforeNodeName = (String) curNode.get("beforeNode");		
    		curRelIndex ++ ;
    		/**
    		 * 如果curRelIndex大于relList的大小
    		 * 则说明当前节点的关系节点全都遍历过了,curRelIndex赋值为relList的大小,
    		 * 即说明当前节点的关系节点全都遍历过了,不能前进了,只能后退
    		 */
    		if(curRelIndex > relList.size()){
    			curRelIndex = relList.size() ;
    		}
    		return curRelIndex ;
    	}

    测试代码如下:

    public static void main(String [] args) throws Exception{
    		
    		Map<String,Map<String,Object>> nodeCollections = new HashMap<String, Map<String,Object>>() ;
    		
    		Map<String,Object> node_1 = new HashMap<String, Object>() ;		
    		String nodeName_1 = "1" ; 		
    		List<String> relList_1 = new ArrayList<String>() ;	
    		relList_1.add("2");
    		relList_1.add("3");
    		int curRelIndex_1 = -1 ;		
    		String beforeNode_1 = null ;
    		node_1.put("nodeName", nodeName_1) ;
    		node_1.put("curRelIndex", curRelIndex_1) ;
    		node_1.put("beforeNode", beforeNode_1) ;
    		node_1.put("relList", relList_1) ;
    		node_1.put("isFrozen", false);
    		node_1.put("isRoot", false);
    		
    		Map<String,Object> node_2 = new HashMap<String, Object>() ;		
    		String nodeName_2 = "2" ; 		
    		List<String> relList_2 = new ArrayList<String>() ;	
    		relList_2.add("4");
    		int curRelIndex_2 = -1 ;		
    		String beforeNode_2 = null ;
    		node_2.put("nodeName", nodeName_2) ;
    		node_2.put("curRelIndex", curRelIndex_2) ;
    		node_2.put("beforeNode", beforeNode_2) ;
    		node_2.put("relList", relList_2) ;
    		node_2.put("isFrozen", false);
    		node_2.put("isRoot", false);
    		
    		Map<String,Object> node_3 = new HashMap<String, Object>() ;		
    		String nodeName_3 = "3" ; 		
    		List<String> relList_3 = new ArrayList<String>() ;	
    		relList_3.add("4");
    		
    		int curRelIndex_3 = -1 ;		
    		String beforeNode_3 = null ;
    		node_3.put("nodeName", nodeName_3) ;
    		node_3.put("curRelIndex", curRelIndex_3) ;
    		node_3.put("beforeNode", beforeNode_3) ;
    		node_3.put("relList", relList_3) ;
    		node_3.put("isFrozen", false);
    		node_3.put("isRoot", false);
    		
    		
    		Map<String,Object> node_4 = new HashMap<String, Object>() ;		
    		String nodeName_4 = "4" ; 		
    		List<String> relList_4 = new ArrayList<String>() ;	
    		relList_4.add("5");
    		relList_4.add("6");
    		int curRelIndex_4 = -1 ;		
    		String beforeNode_4 = null ;
    		node_4.put("nodeName", nodeName_4) ;
    		node_4.put("curRelIndex", curRelIndex_4) ;
    		node_4.put("beforeNode", beforeNode_4) ;
    		node_4.put("relList", relList_4) ;
    		node_4.put("isFrozen", false);
    		node_4.put("isRoot", false);
    		
    		
    		Map<String,Object> node_5 = new HashMap<String, Object>() ;		
    		String nodeName_5 = "5" ; 		
    		List<String> relList_5 = new ArrayList<String>() ;	
    		int curRelIndex_5 = -1 ;		
    		String beforeNode_5 = null ;
    		node_5.put("nodeName", nodeName_5) ;
    		node_5.put("curRelIndex", curRelIndex_5) ;
    		node_5.put("beforeNode", beforeNode_5) ;
    		node_5.put("relList", relList_5) ;
    		node_5.put("isFrozen", false);
    		node_5.put("isRoot", false);
    		
    		Map<String,Object> node_6 = new HashMap<String, Object>() ;		
    		String nodeName_6 = "6" ; 		
    		List<String> relList_6 = new ArrayList<String>() ;	
    		relList_6.add("7");
    		int curRelIndex_6 = -1 ;		
    		String beforeNode_6 = null ;
    		node_6.put("nodeName", nodeName_6) ;
    		node_6.put("curRelIndex", curRelIndex_6) ;
    		node_6.put("beforeNode", beforeNode_6) ;
    		node_6.put("relList", relList_6) ;
    		node_6.put("isFrozen", false);
    		node_6.put("isRoot", false);
    		
    		
    		
    		Map<String,Object> node_7 = new HashMap<String, Object>() ;		
    		String nodeName_7 = "7" ; 		
    		List<String> relList_7 = new ArrayList<String>() ;	
    		relList_7.add("5");
    		int curRelIndex_7 = -1 ;		
    		String beforeNode_7 = null ;
    		node_7.put("nodeName", nodeName_7) ;
    		node_7.put("curRelIndex", curRelIndex_7) ;
    		node_7.put("beforeNode", beforeNode_7) ;
    		node_7.put("relList", relList_7) ;
    		node_7.put("isFrozen", false);
    		node_7.put("isRoot", false);
    		
    		nodeCollections.put("1",node_1 );
    		nodeCollections.put("2",node_2 );
    		nodeCollections.put("3",node_3 );
    		nodeCollections.put("4",node_4 );
    		nodeCollections.put("5",node_5 );
    		nodeCollections.put("6",node_6 );
    		nodeCollections.put("7",node_7 );
    		
    		GraphAnalysis analysis = new GraphAnalysis() ;
    		long start = System.currentTimeMillis();
    			/*boolean result = analysis.isContainLoop(nodeCollections);*/
    		List<String> nodes = new ArrayList<String>();
    		nodes.add("1");
    		nodes.add("4");
    		nodes.add("7");
    		nodes.add("5");
    		Map<String,Map<String,Object>> ret = analysis.seekRelation(nodeCollections, nodes);
    		System.out.println(ret);
    		/*boolean result = analysis.isContainLoopInDigraph(nodeCollections);
    		System.out.println(result);*/
    		long end = System.currentTimeMillis();
    		
    		System.out.println("耗时:" + (end - start) );
    	}

    如有BUG,欢迎大家提出,谢谢!


    展开全文
  • 情人关系走向了,困境睡姿!   互相信任睡姿!   女人一切都要依赖男人睡姿!   你为什么找不到女朋友 你为什么交不到女朋友? 爱情安全型测试 好不容易有了恋情,本以为就是幸福...

    情人之间对未来有承诺的味道!

     

    情人关系走向了,困境的睡姿!

     

    互相信任的睡姿!

     

    女人的一切都要依赖男人的睡姿!
     

    你为什么交不到女朋友?
    好不容易有了恋情,本以为就是幸福的开始,...
    你会定期去做礼拜吗?你会坚持每天的祷告吗...
    一入豪门深似海?
    老情人的睡姿!
     

    新情人,热恋情人的睡姿!

     

    情侣双方工作很累,需要休息,正常的睡姿!

     

    男方想抛弃女方的睡姿!

     

    情人闹了点小别扭的睡姿!

     

    呵护的睡姿,多见于老男人对小情人的睡姿!

    展开全文
  • 如何判断两个现象存在因果关系/如何证明一个association是causal 本博客为转载个人觉得合理答案,不妥之处欢迎指正。 作者:程毅南 链接:https://www.zhihu.com/question/20532054/answer/15399462 来源:...
  • 那么,用叉乘判断p1,p2相对p3p4的关系,如果两次叉乘的结果都是0,那么重合,如果两次的结果都不为0,但是相等,由于叉乘可以用平行四边形的有向面积来定义,所以这个时候两条直线平行,如果以上条件都不满足,那么...
  • IPy模块包含IP类,使用它可以方便处理绝大部分格式为IPv6网络和地址 比如通过version方法来区分出IPv4和IPv6 >>> import IPy >>> IPy.IP('10.0.0.0/8').version() 4 >>> IPy.IP('::1').version() 6 通过指定...
  • python 判断两个列表是否具有包含关系以及获取子列表在父列表中索引 import operator def get_sub_list_index(parent_list, sub_list): length_sub_list = len(sub_list) index_list = [] counter = 0 ...
  • 1、instanceOf关键字,用来判断对象是否是类实例2、isAssignableFrom,用来判断类型是否存在派生关系3、isInstance方法,用来判断对象是否属于某个类型实例package jdk.reflect;/*** @author czy* @since 2010...
  • 1、instanceOf关键字,用来判断对象是否是类实例2、isAssignableFrom,用来判断类型是否存在派生关系3、isInstance方法,用来判断对象是否属于某个类型实例 //useinstanceOf,用来判断对象是否是类实例 ...
  • 该文依据关系判断任务特点将主动学习应用到本体概念关系的辅助判断中,对边缘采样、熵采样、最不确信采样等主动学习查询生成策略进行了比较研究。在此基础上,从实际应用角度出发,讨论了在三种不同样本初始情况下主动...
  • 2、isAssignableFrom,用来判断类型是否存在派生关系 3、isInstance方法,用来判断对象是否属于某个类型实例 package jdk.reflect; /** * @author <a href="mailto:czy88840616@gmail.com">czy...
  • 其次,提出一种尽可能减少元素共识补偿共识度度量方法,在此基础上建立基于信任关系的共识调整模型,并从理论上证明该模型有效性;最后通过信任关系矩阵特征向量中心度分别求出专家重要性权重,用以集结专家...
  • 判断类与实例的关系有以下三种方式 1、instanceof关键字,用来判断对象是否是类的实例(对象 => 类 ) 2、isAssignableFrom,用来判断类型是否存在派生关系(类 = > 类) 3、isInstance方法,用来判断对象是否...
  • 判断类与实例的关系有以下三种方式 1、instanceOf 关键字,用来判断对象是否是类的实例 2、isInstance方法,用来判断对象是否属于某个类型的实例 3、isAssignableFrom,用来判断类型是否存在派生关系 先贴一下他们...
  • 各位朋友们,这段时间没有经常更新我博客,抱歉!几何数据访问是编写Revit程序很重要内容。从今年开始我会编写录制一些专题讲座来介绍Revit编程。正如我之前一篇博客所说,我在准备一个讲座。由于要设计内容,...
  • unless onlyif:状态间的条件判断,主要用于cmd状态模块 常用方法:  onlyif:检查的命令,仅当'onlyif' 选项指向的命令返回true时才执行name 定义的命 unless:用于检查的命令,仅当'unless' 选项指向的命令...
  • 判断类与实例的关系有以下三种方式1、instanceOf关键字,用来判断对象是否是类的实例2、isAssignableFrom,用来判断类型是否存在派生关系3、isInstance方法,用来判断对象是否属于某个类型的实例 //use ...
  • 关于面对对象三要素逻辑关系与实例 #三要素 ##1.属性:现实世界存在任何事物都可以称之为对象。对象是具体存在,有着自己独特个性。 ##2.事件:事件是指对象能够识别并作出反应外部刺激。 ##3.方法...
  • 为什么要分开装而不用APMserv集成环境? 主要是让大家理解amp并且能自己在以后工作中会独自配置 ...其实apache是通过一个文件后缀来进行处理和判断是不是php文件,如果是.html后缀结尾,apache不会解析,
  • 大意:求出一道光能够从管道中通过到达的最远x值。思路:判断直线和线段间的关系。#include #include #include #include #include #include #include #include #define inf 0x3f3f3f3f #de
  • 在polyfillquerySelectorAll 和写弹出窗时都需要判断两个节点间的位置关系,通过jQuery我们可以轻松搞定,但原生JS呢?下面我将整理各种判断方法,以供日后查阅。 二、祖孙关系  html <div ...
  • 我们知道 NSOperationQueue 可以调度 NSOpertion 间的依赖, 虽然可以为 NSOperation 增加 Depends, 但是框架并没有提供方法, 让你可以直接判断依赖关系是否成立。 框架这么设计主要是考虑通用性, Operation...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 933
精华内容 373
关键字:

判断间的关系