题目描述:
1.一个系统的若干模块间存在相互依赖的关系,如果A模块调用了B模块的接口,那么成为A依赖B,记为A->B
如果A->B,B->A,那么称A和B模块都存在循环依赖。
如果A->B,B->C,C->D,D->B,那么BCD存在循环依赖,A不存在循环依赖,依次类推。
先输入若干模块之间的关系,判断某模块是存在循环依赖。
输入:
{0x00, 0x01},
{0x02, 0x03},
{0x03, 0x04}
输出:
{0x00, false},
{0x01, false},
{0x02, false},
{0x03, false},
{0x04, false}
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Set;
public class Main {
static ArrayList<LinkedList<String>> arrayList = new ArrayList<LinkedList<String>>();//存储模块间依赖关系的数据结构
static HashSet<String> hashSet = new HashSet<String>(); //存储具有循环依赖的点
static Set<String> set = new LinkedHashSet<String>();//用来保证按输入顺序输出
//static Set<String> set = new HashSet<String>(); //如果不需要保证输出顺序用HashSet
public static void main(String[] args){
Boolean isCrileNode = false;
Scanner s = new Scanner(System.in);
while(s.hasNext()){
//输入=====
String temp;
do{
String ss = s.nextLine();
temp = ss;
ss = ss.replace("{", "");
ss = ss.replaceAll("[^a-z^0-9]", " ");
String[] strings = ss.split("\\s+");
for(int i=0; i< strings.length; i++){
set.add(strings[i]);
}
AddDependency(strings[0], strings[1]);
}while(temp.charAt(temp.length()-1) == ',');
CricleNode();
//输出=====
int count = 0;
for(String str : set){
isCrileNode = MouduleIsCycularDependency(str);
count++;
if(count != set.size()){
System.out.println("{"+str+", "+isCrileNode+"},");
}else {
System.out.println("{"+str+", "+isCrileNode+"}");
}
}
clear();
}
}
//添加依赖关系
public static void AddDependency(String Modeled, String DependModuled){
LinkedList<String> linkedList = new LinkedList<String>();
linkedList.add(Modeled);
linkedList.add(DependModuled);
arrayList.add(linkedList);
Boolean change = true;
while(change){
change = ConnectList();
}
}
//判断其中的链表是否有可以相连的
public static Boolean ConnectList(){
if(arrayList.size() > 1){
for(int i = 0; i < arrayList.size()-1; i++){
for(int j= i+1; j < arrayList.size(); j++){
if(arrayList.get(i).getFirst().equals(arrayList.get(j).getLast())){
LinkedList<String> link1 = arrayList.get(j);
link1.removeLast();
link1.addAll(arrayList.get(i));
arrayList.remove(j);
arrayList.remove(i);
arrayList.add(link1);
return true;
}else if(arrayList.get(i).getLast().equals(arrayList.get(j).getFirst())){
LinkedList<String> link1 = arrayList.get(i);
link1.removeLast();
link1.addAll(arrayList.get(j));
arrayList.remove(j);
arrayList.remove(i);
arrayList.add(link1);
return true;
}
}
}
}
return false;
}
//获取依赖点集合
public static void CricleNode(){
for(int i = 0; i < arrayList.size(); i++){
int start = arrayList.get(i).indexOf(arrayList.get(i).getLast());
int end = arrayList.get(i).lastIndexOf(arrayList.get(i).getLast());
if(start != end){
for(int j = start; j < end; j++){
hashSet.add(arrayList.get(i).get(j));
}
}
int start1 = arrayList.get(i).indexOf(arrayList.get(i).getFirst());
int end1 = arrayList.get(i).lastIndexOf(arrayList.get(i).getFirst());
if(start1 != end1){
for(int j = start1; j < end1; j++){
hashSet.add(arrayList.get(i).get(j));
}
}
}
}
//判断模块是否存在依赖关系
public static boolean MouduleIsCycularDependency(String ModuleId){
if(hashSet.contains(ModuleId))
return true;
return false;
}
//清空模块数据
public static void clear(){
arrayList.clear();
hashSet.clear();
set.clear();
}
}