├── g5
├── bin
    ├── apps
    │   └── Friends.class
    ├── Structures
    │   ├── Graph.class
    │   ├── Graph$Edge.class
    │   ├── Graph$Friend.class
    │   └── Graph$Person.class
    └── structures
    │   ├── Graph.class
    │   ├── Graph$Friend.class
    │   └── Graph$Person.class
├── g4
├── g3
├── todo.txt
├── .classpath
├── g2
├── README.md
├── .project
├── g1
├── .settings
    └── org.eclipse.jdt.core.prefs
├── src
    ├── apps
    │   └── Friends.java
    ├── Structures
    │   └── Graph.java
    └── structures
    │   └── Graph.java
└── prog4.html


/g5:
--------------------------------------------------------------------------------
1 | 3
2 | a|n
3 | b|n
4 | c|n
5 | a|b
6 | b|c


--------------------------------------------------------------------------------
/bin/apps/Friends.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/apps/Friends.class


--------------------------------------------------------------------------------
/bin/Structures/Graph.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/Structures/Graph.class


--------------------------------------------------------------------------------
/bin/structures/Graph.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/structures/Graph.class


--------------------------------------------------------------------------------
/bin/Structures/Graph$Edge.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/Structures/Graph$Edge.class


--------------------------------------------------------------------------------
/bin/Structures/Graph$Friend.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/Structures/Graph$Friend.class


--------------------------------------------------------------------------------
/bin/Structures/Graph$Person.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/Structures/Graph$Person.class


--------------------------------------------------------------------------------
/bin/structures/Graph$Friend.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/structures/Graph$Friend.class


--------------------------------------------------------------------------------
/bin/structures/Graph$Person.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/i/friendship/master/bin/structures/Graph$Person.class


--------------------------------------------------------------------------------
/g4:
--------------------------------------------------------------------------------
 1 | 6
 2 | D|n
 3 | B|n
 4 | C|n
 5 | A|n
 6 | E|n
 7 | F|n
 8 | A|b
 9 | B|c
10 | B|e
11 | C|d
12 | E|d
13 | D|f
14 | 


--------------------------------------------------------------------------------
/g3:
--------------------------------------------------------------------------------
 1 | 14
 2 | a|n
 3 | b|n
 4 | c|n
 5 | d|n
 6 | e|n
 7 | f|n
 8 | g|n
 9 | h|n
10 | i|n
11 | j|n
12 | k|n
13 | l|n
14 | m|n
15 | q|n
16 | a|b
17 | b|c
18 | c|d
19 | d|e
20 | a|g
21 | 


--------------------------------------------------------------------------------
/todo.txt:
--------------------------------------------------------------------------------
 1 | todo:
 2 | shortest path (liz)
 3 | connected islands (cliques) started?
 4 | connectors 70% done
 5 | fix atschool
 6 | 
 7 | completed:
 8 | interface
 9 | build
10 | subgraph
11 | 
12 | **efficiency**
13 | 


--------------------------------------------------------------------------------
/.classpath:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <classpath>
3 | 	<classpathentry kind="src" path="src"/>
4 | 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
5 | 	<classpathentry kind="output" path="bin"/>
6 | </classpath>
7 | 


--------------------------------------------------------------------------------
/g2:
--------------------------------------------------------------------------------
 1 | 23
 2 | q|n
 3 | w|n
 4 | e|n
 5 | r|n
 6 | t|n
 7 | y|n
 8 | u|n
 9 | i|n
10 | o|n
11 | p|y|la
12 | a|y|la
13 | s|y|la
14 | d|y|la
15 | f|y|la
16 | g|y|la
17 | h|y|la
18 | j|y|la
19 | k|y|la
20 | l|y|la
21 | z|y|la
22 | x|y|la
23 | c|y|la
24 | b|y|la
25 | q|w
26 | w|e
27 | e|r
28 | r|t
29 | t|y
30 | y|h
31 | h|g
32 | g|b
33 | g|f
34 | f|d
35 | d|e


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | CS112 Data Structures Project
 2 | Fall 2012
 3 | Ian Lozinski / Elizabeth Gao
 4 | ==================================
 5 | Creates a graph from a given input file of friends and schools and performs the following operations:
 6 | shortest path of friends between two people
 7 | calculates cliques
 8 | determines who the connectors are
 9 | creates new graph of all people at a particular school
10 | prints graph
11 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>Friendship</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.eclipse.jdt.core.javabuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 	</buildSpec>
14 | 	<natures>
15 | 		<nature>org.eclipse.jdt.core.javanature</nature>
16 | 	</natures>
17 | </projectDescription>
18 | 


--------------------------------------------------------------------------------
/g1:
--------------------------------------------------------------------------------
 1 |  15
 2 |  jane|y|rutgers
 3 |  sam|y|rutgers
 4 |  michele|y|cornell
 5 |  sergei|y|rutgers
 6 |  ricardo|y|penn state
 7 |  kaitlin|y|rutgers
 8 |  samir|n
 9 |  aparna|y|rutgers
10 |  ming|y|penn state
11 |  nick|y|penn state
12 |  bob|y|rutgers
13 |  heather|y|penn state
14 |  rachel|n
15 |  rich|y|ucla
16 |  tom|y|ucla
17 |  sam|jane
18 |  jane|bob
19 |  jane|kaitlin
20 |  kaitlin|nick
21 |  bob|samir
22 |  sergei|aparna
23 |  samir|aparna
24 |  aparna|ricardo
25 |  nick|ricardo
26 |  ming|nick
27 |  heather|nick
28 |  michele|rachel
29 |  michele|tom
30 |  tom|rich


--------------------------------------------------------------------------------
/.settings/org.eclipse.jdt.core.prefs:
--------------------------------------------------------------------------------
 1 | eclipse.preferences.version=1
 2 | org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 3 | org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
 4 | org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
 5 | org.eclipse.jdt.core.compiler.compliance=1.6
 6 | org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 7 | org.eclipse.jdt.core.compiler.debug.localVariable=generate
 8 | org.eclipse.jdt.core.compiler.debug.sourceFile=generate
 9 | org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
10 | org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
11 | org.eclipse.jdt.core.compiler.source=1.6
12 | 


--------------------------------------------------------------------------------
/src/apps/Friends.java:
--------------------------------------------------------------------------------
 1 | //Ian Lozinski
 2 | //Elizabeth Gao
 3 | 
 4 | package apps;
 5 | import java.io.File;
 6 | import java.io.FileNotFoundException;
 7 | import java.util.ArrayList;
 8 | import java.util.Scanner;
 9 | 
10 | import structures.Graph;
11 | 
12 | 
13 | 
14 | public class Friends {
15 | 	
16 | 	
17 | static Scanner userin = new Scanner(System.in);
18 | 	
19 | 	static char getOption() {
20 | 		System.out.print("Choose action: \n");
21 | 		System.out.print("\t1) Students at school\n");
22 | 		System.out.print("\t2) Shortest intro chain\n");
23 | 		System.out.print("\t3) Cliques at school\n");
24 | 		System.out.print("\t4) Connectors\n");
25 | 		System.out.print("\tq) Quit\n");
26 | 		char response = userin.nextLine().toLowerCase().charAt(0);
27 | 		while (response != '1' && response != '2' && response != '3' && response != '4' && response != 'q') {
28 | 			System.out.print("\tYou must enter one of 1, 2, 3, 4, 5, or q! ");
29 | 			response = userin.nextLine().toLowerCase().charAt(0);
30 | 		}
31 | 		return response;
32 | 	}
33 | 
34 | 	/**
35 | 	 * @param args
36 | 	 * @throws FileNotFoundException 
37 | 	 */
38 | 	public static void main(String[] args) throws FileNotFoundException {
39 | 		// TODO Auto-generated method stub
40 | 		System.out.println("Enter graph file name: ");
41 | 		String graphFile = userin.nextLine();
42 | 		Graph graph;
43 | 		try{
44 | 			graph = new Graph(new Scanner(new File(graphFile)));
45 | 
46 | 			char option;
47 | 			while((option = getOption()) != 'q'){
48 | 				if(option == '1'){
49 | 					System.out.println("Enter school name: ");
50 | 					Graph school = graph.atSchool(userin.nextLine().toLowerCase());
51 | 					school.printGraph();
52 | 				}
53 | 				else if(option == '2'){
54 | 					System.out.println("Enter name of person:");
55 | 					String sName = userin.nextLine().toLowerCase();
56 | 					System.out.println("Enter name of person they want to meet:");
57 | 					String eName = userin.nextLine().toLowerCase();
58 | 					graph.shortestChain(sName, eName);					
59 | 				}
60 | 				else if(option == '3'){
61 | 					System.out.println("Enter school name: ");
62 | 					Graph subgraph = graph.atSchool(userin.nextLine().toLowerCase());
63 | 					ArrayList<Graph> cliques = subgraph.cliques();
64 | 					for(int k = 1; k < cliques.size()+1; k++){
65 | 						System.out.println("Clique " + k + ":");
66 | 						cliques.get(k-1).printGraph();
67 | 					}					
68 | 				}
69 | 				else if(option == '4'){
70 | 					graph.connectors();
71 | //					do connectors
72 | 				}
73 | 			}
74 | 		}catch(Exception FileNotFoundException){
75 | 			System.err.println("Not valid file! Closing program!");
76 | 			
77 | 		}
78 | 	}
79 | }
80 | 


--------------------------------------------------------------------------------
/src/Structures/Graph.java:
--------------------------------------------------------------------------------
  1 | //Ian Lozinski
  2 | //Elizabeth Gao
  3 | 
  4 | package Structures;
  5 | 
  6 | import java.util.ArrayList;
  7 | import java.util.Hashtable;
  8 | import java.util.Scanner; 
  9 | import java.util.Stack;
 10 | 
 11 | import Structures.Graph.Friend;
 12 | 
 13 | public class Graph {
 14 | 
 15 | 	int size;  //number of vertices
 16 | 	ArrayList<Person> people;
 17 | 	Hashtable<String , Integer>  hash;
 18 | 	int dfscount;
 19 | 	int sccount;
 20 | 	String schoolname;
 21 | 	
 22 | 
 23 | 	public Graph(Scanner sc) {
 24 | 		this.size = Integer.parseInt(sc.nextLine().trim());
 25 | 		this.people = new ArrayList<Person>(this.size);
 26 | 		this.hash = new Hashtable<String, Integer>(this.size);
 27 | 		this.dfscount = 1;
 28 | 		this.sccount = 1;
 29 | 		this.schoolname = null;
 30 | 		
 31 | 		//Creates vertex for each student and fills 'people' array
 32 | 		for(int i=0; i<this.size; i++){
 33 | 			String t = sc.nextLine().trim().toLowerCase();
 34 | 			if (t.charAt(t.indexOf('|')+1) == 'y'){
 35 | 				people.add(new Person(t.substring(0, t.indexOf('|')),  
 36 | 						t.substring((t.indexOf('|'))+3, t.length()), null));
 37 | 			}
 38 | 			else{
 39 | 				people.add(new Person(t.substring(0, t.indexOf('|')), null, null));
 40 | 			}
 41 | 			hash.put(t.substring(0, t.indexOf('|')), i);
 42 | 		}
 43 | 		//reads edges
 44 | 		while(sc.hasNextLine()){
 45 | 			String t = sc.nextLine().trim().toLowerCase();
 46 | 			int pipe = t.indexOf('|');
 47 | 			int v1 = indexForName(t.substring(0,pipe));
 48 | 			int v2 = indexForName(t.substring(pipe+1));
 49 | 			
 50 | 			people.get(v1).friends = new Friend(v2, people.get(v1).friends);
 51 | 			people.get(v2).friends = new Friend(v1, people.get(v2).friends);
 52 | 
 53 | //			System.out.println(nameForIndex(v1) + " is now friends with " + nameForIndex(v2)+'.');
 54 | 		}
 55 | 
 56 | 	}
 57 | 	
 58 | 	//alternate graph constructor -- takes in arrayList instead of scanner
 59 | 	public Graph (ArrayList<Person> people){
 60 | 		this.dfscount = 1;
 61 | 		this.sccount = 1;
 62 | 		this.size = people.size();
 63 | 		this.people = people;
 64 | 		try{
 65 | 			this.schoolname = people.get(0).school;
 66 | 		}catch (Exception indexOutOfBoundsException){
 67 | 			System.out.println("Invalid school name!");
 68 | 			return;
 69 | 		}
 70 | 		this.hash = new Hashtable<String, Integer>(this.size);
 71 | 		for(int i = 0; i < people.size(); i++) {
 72 | 			this.hash.put(people.get(i).name, i);
 73 | 		}
 74 | 		this.dfscount = 1;
 75 | 		for(int i = 0; i<this.people.size(); i++){
 76 | 			this.hash.put(this.people.get(i).name, i);
 77 | 			Friend newfriends = null;
 78 | 			Friend ptr = this.people.get(i).friends;
 79 | 			while(ptr != null){
 80 | 				ptr.index = this.indexForName(ptr.name);System.out.println(ptr.index + ptr.name);
 81 | 				if(ptr.index != -1){
 82 | 					newfriends = new Friend(ptr.index, newfriends);
 83 | 				}
 84 | 				ptr = ptr.next;
 85 | 			}
 86 | 			this.people.get(i).friends = newfriends;
 87 | 		}
 88 | 	}
 89 | 	
 90 | 	String nameForIndex(int index){
 91 | 		return people.get(index).name;
 92 | 	}
 93 | 	
 94 | 	int indexForName(String name){
 95 | 		try{
 96 | 			return hash.get(name);
 97 | 		}catch(Exception NullPointerException){
 98 | 			return -1;
 99 | 		}
100 | 	}
101 | 	
102 | 	public class Person {
103 | 		String name;	
104 | 		String school;
105 | 		Friend friends;
106 | 		int dfsnum;
107 | 		int back;
108 | 		int scnum;
109 | 		
110 | 		public Person(String name, String school, Friend friends ) {
111 | 			this.scnum = -1;
112 | 			this.name = name;
113 | 			this.school = school;
114 | 			this.friends = friends;
115 | 			this.dfsnum = 0;
116 | 			this.back = 0;
117 | 		}
118 | 	}
119 | 	
120 | 	class Friend{
121 | 		public int index; 
122 | 		public Friend next;
123 | 		public String name;
124 | 		public String school;
125 | 	
126 | 		public Friend(String name, Friend next){
127 | 			this.index = indexForName(name);
128 | 			this.name = name;
129 | 			this.school = people.get(index).school;
130 | 			this.next = next;
131 | 		}
132 | 		
133 | 		public Friend(int index, Friend next){
134 | 			this.index = index;
135 | 			this.next = next;
136 | 			this.school = people.get(index).school;
137 | 			this.name = people.get(index).name;
138 | 		}		
139 | 	}	
140 | 
141 | 	/**
142 | 	 * Makes a graph consisting only of the students at a certain school.
143 | 	 * Prints the graph in the same format as input file.
144 | 	 * 
145 | 	 */	
146 | 	public Graph atSchool(String schoolName){
147 | 		ArrayList<Person> students = new ArrayList<Person>();
148 | 
149 | 		for (int i = 0; i < people.size(); i++){			
150 | 			Person p = people.get(i);
151 | 			if(p.school != null && p.school.equals(schoolName)){
152 | 				students.add(new Person(p.name, schoolName, p.friends));
153 | 			}
154 | 		}
155 | 		Graph subgraph = new Graph(students);
156 | 		return subgraph;
157 | 	}
158 | 
159 | 	/**
160 | 	 *  Finds the shortest path between two people.
161 | 	 *  Prints the sequence of names.
162 | 	 *  Greedy Algorithm maybe?
163 | 	 */	
164 | 	public void shortestChain(String sname, String ename){
165 | 		if(indexForName(sname) == -1 || indexForName(ename) == -1){
166 | 			System.out.println("invalid name!");
167 | 			return;
168 | 		}
169 | 		Stack<String> chain = new Stack<String>();
170 | 		int snum = indexForName(sname);
171 | 		Person start = people.get(snum);
172 | 		Person end = people.get(indexForName(ename));
173 | 		boolean[] visited = new boolean[size];
174 | 		
175 | 		people.get(indexForName(sname)).scnum = 0;
176 | 		scdfs(indexForName(sname), visited);
177 | 		if(end.scnum == -1){
178 | 			System.out.println("They can NEVER be friends!!!");
179 | 			return;
180 | 		}
181 | 		Person ptr = end;
182 | 		while(ptr.scnum != 0){
183 | 			chain.push(ptr.name);
184 | 			Friend t = ptr.friends;
185 | 			int min = ptr.scnum;
186 | 			while(t != null){
187 | 				if(people.get(t.index).scnum < min){
188 | 					ptr = people.get(t.index);
189 | 					break;
190 | 				}
191 | 				t = t.next;
192 | 			}
193 | 		}
194 | 		chain.push(start.name);
195 | 		String ret = "";
196 | 		while(chain.size() > 1){
197 | 			ret = ret + chain.pop() + ", ";
198 | 		}
199 | 		ret = "Shortest path: " + ret + chain.pop() + ".";
200 | 		System.out.println(ret);
201 | 		
202 | 		//resets scnumbers
203 | 		for(int i = 0; i < people.size(); i++){
204 | 			people.get(i).scnum = -1;
205 | 		}
206 | 	}
207 | 	private void scdfs(int v, boolean[] visited){
208 | 		visited[v] = true;
209 | 		for (Friend e = people.get(v).friends; e != null; e=e.next){
210 | 			if(!visited[e.index]){
211 | 				people.get(e.index).scnum = sccount;
212 | 				sccount++;	
213 | 				scdfs(e.index, visited);
214 | 				sccount--;
215 | 				people.get(v).scnum = Math.min(people.get(v).scnum, people.get(e.index).scnum + 1);	
216 | 			}
217 | 			else{//already visited
218 | 				people.get(v).scnum = Math.min(people.get(e.index).scnum + 1, people.get(v).scnum);
219 | 			}
220 | 		}
221 | 	}
222 | 	
223 | 	/**
224 | 	 * Prints a textual representation of the graph
225 | 	 */
226 | 	public void printGraph(){
227 | 		System.out.println(people.size());
228 | 		for(int v = 0; v < people.size(); v++){
229 | 			if(people.get(v).school != null){
230 | 				System.out.println(people.get(v).name + "|y|" + people.get(v).school);
231 | 			}
232 | 			else{
233 | 				System.out.println(people.get(v).name + "|n");
234 | 			}
235 | 		}
236 | 		for(int v = 0; v < people.size(); v++){
237 | 			Friend ptr = people.get(v).friends;
238 | 			while(ptr != null){
239 | 				if(v < ptr.index){
240 | 					System.out.println(people.get(v).name + "|" + nameForIndex(ptr.index));
241 | 				}
242 | 				ptr = ptr.next;
243 | 			}
244 | 			
245 | 		}
246 | 	}
247 | 	
248 | 	/**
249 | 	 * finds cliques (separate groups) at a particular school.
250 | 	 * prints the subgraphs in format of input file.
251 | 	 */
252 | 	public ArrayList<Graph> cliques(){
253 | 		ArrayList<Graph> cliqueslist = new ArrayList<Graph>();
254 | 		boolean[] visited = new boolean[size];
255 | 		boolean[] vtemp = new boolean[size];
256 | 		
257 | 		for(int i=0; i<size; i++){
258 | 			ArrayList<Person> clique = new ArrayList<Person>();
259 | 			if (!visited[i]){		
260 | 				System.out.println("Starting on new clique");
261 | 				cliquedfs(vtemp, i, visited);
262 | 				for(int j=0; j<visited.length; j++){
263 | 					if(vtemp[j])
264 | 						clique.add(new Person(nameForIndex(j), schoolname, people.get(j).friends));
265 | 						vtemp[j] = false;
266 | 				}
267 | 				Graph tempgraph = new Graph(clique);
268 | 				cliqueslist.add(tempgraph);
269 | 			}
270 | 		}
271 | 		return cliqueslist;
272 | 	}
273 | 	
274 | 	private void cliquedfs(boolean[] newlyVisited, int v, boolean[] visited) {
275 | 		visited[v] = true;
276 | 		newlyVisited[v] = true;
277 | 		for (Friend e=people.get(v).friends; e != null; e=e.next) {
278 | 			if (!visited[e.index]) {
279 | 				cliquedfs(newlyVisited, e.index, visited);
280 | 			}
281 | 		}
282 | 	}
283 | 	
284 | 
285 | 	/**
286 | 	 * finds and prints the names of all people who are connectors
287 | 	 * separated by commas, in any order.
288 | 	 */
289 | 	
290 | 	public void connectors(){
291 | 		boolean[] knex = new boolean[size];
292 | 		boolean[] visited = new boolean[size];
293 | 		
294 | 		for (int v = 0; v < visited.length; v++) {
295 | 			if (!visited[v]) {
296 | 				dfscon(v, visited, knex);
297 | 			}
298 | 		}
299 | 		int min = 0;
300 | 		for(int n = people.size()-1; n >= 0; n--){
301 | 			if(people.get(n).back == 1 && n != 0){
302 | 				min++;
303 | 				if(min >= 2){knex[0] = true;}
304 | 			}
305 | 		}
306 | 		System.out.print("Connectors:");
307 | 		String s = "";
308 | 		for(int i=0; i<knex.length; i++){
309 | 			if(knex[i]){
310 | 				s = people.get(i).name + ", "+ s;
311 | 			}
312 | 		}
313 | 		System.out.println(s);
314 | 		dfscount = 1;
315 | 		for(Person p: people){
316 | 			p.dfsnum = 0;
317 | 			p.back = 0;
318 | 		}
319 | 	}
320 | 	private void  dfscon(int v, boolean[] visited, boolean[] knex) {
321 | 		visited[v] = true;
322 | 		people.get(v).dfsnum = dfscount;
323 | 		people.get(v).back = dfscount;
324 | 		dfscount++;
325 | //		System.out.println("Visiting " + people.get(v).name + " num: " + people.get(v).dfsnum);
326 | 
327 | 		for (Friend w = people.get(v).friends; w != null; w = w.next) {
328 | 			if (!visited[w.index]) {
329 | 				dfscon(w.index, visited, knex);
330 | 				if(people.get(v).dfsnum > people.get(w.index).back) {
331 | 					people.get(v).back = Math.min(people.get(v).back , people.get(w.index).back);
332 | 				}
333 | 				if(people.get(v).dfsnum <= people.get(w.index).back && v != 0){
334 | 					knex[v]=true;
335 | 				}
336 | 			}
337 | 			else{//w is already visited
338 | 				people.get(v).back = Math.min(people.get(v).back, people.get(w.index).dfsnum);
339 | 				//System.out.println(people.get(w.index).name + " " + people.get(w.index).dfsnum + "/" + people.get(w.index).back);
340 | 			}	
341 | 		}
342 | 		
343 | 	}
344 | 	
345 | }
346 | 


--------------------------------------------------------------------------------
/src/structures/Graph.java:
--------------------------------------------------------------------------------
  1 | //Ian Lozinski
  2 | //Elizabeth Gao
  3 | 
  4 | package structures;
  5 | 
  6 | import java.util.ArrayList;
  7 | import java.util.Hashtable;
  8 | import java.util.Scanner; 
  9 | import java.util.Stack;
 10 | 
 11 | import structures.Graph.Friend;
 12 | 
 13 | 
 14 | public class Graph {
 15 | 
 16 | 	int size;  //number of vertices
 17 | 	ArrayList<Person> people;
 18 | 	Hashtable<String , Integer>  hash;
 19 | 	int dfscount;
 20 | 	int sccount;
 21 | 	String schoolname;
 22 | 	
 23 | 
 24 | 	public Graph(Scanner sc) {
 25 | 		this.size = Integer.parseInt(sc.nextLine().trim());
 26 | 		this.people = new ArrayList<Person>(this.size);
 27 | 		this.hash = new Hashtable<String, Integer>(this.size);
 28 | 		this.dfscount = 1;
 29 | 		this.sccount = 1;
 30 | 		this.schoolname = null;
 31 | 		
 32 | 		//Creates vertex for each student and fills 'people' array
 33 | 		for(int i=0; i<this.size; i++){
 34 | 			String t = sc.nextLine().trim().toLowerCase();
 35 | 			if (t.charAt(t.indexOf('|')+1) == 'y'){
 36 | 				people.add(new Person(t.substring(0, t.indexOf('|')),  
 37 | 						t.substring((t.indexOf('|'))+3, t.length()), null));
 38 | 			}
 39 | 			else{
 40 | 				people.add(new Person(t.substring(0, t.indexOf('|')), null, null));
 41 | 			}
 42 | 			hash.put(t.substring(0, t.indexOf('|')), i);
 43 | 		}
 44 | 		//reads edges
 45 | 		while(sc.hasNextLine()){
 46 | 			String t = sc.nextLine().trim().toLowerCase();
 47 | 			int pipe = t.indexOf('|');
 48 | 			int v1 = indexForName(t.substring(0,pipe));
 49 | 			int v2 = indexForName(t.substring(pipe+1));
 50 | 			
 51 | 			people.get(v1).friends = new Friend(v2, people.get(v1).friends);
 52 | 			people.get(v2).friends = new Friend(v1, people.get(v2).friends);
 53 | 
 54 | //			System.out.println(nameForIndex(v1) + " is now friends with " + nameForIndex(v2)+'.');
 55 | 		}
 56 | 
 57 | 	}
 58 | 	
 59 | 	//alternate graph constructor -- takes in arrayList instead of scanner
 60 | 	public Graph (ArrayList<Person> people){
 61 | 		this.dfscount = 1;
 62 | 		this.sccount = 1;
 63 | 		this.size = people.size();
 64 | 		this.hash = new Hashtable<String, Integer>(this.size);
 65 | 		this.people = people;
 66 | 		try{
 67 | 			this.schoolname = people.get(0).school;
 68 | 		}catch (Exception indexOutOfBoundsException){
 69 | 			System.out.println("Invalid school name!");
 70 | 			return;
 71 | 		}
 72 | 
 73 | 		for(int i = 0; i < people.size(); i++) {
 74 | 			this.hash.put(people.get(i).name, i);
 75 | 		}
 76 | 		for(int i = 0; i<this.people.size(); i++){
 77 | 			this.hash.put(this.people.get(i).name, i);
 78 | 			Friend newfriends = null;
 79 | 			Friend ptr = (this.people.get(i).friends);
 80 | 			while(ptr != null){
 81 | 				
 82 | 				ptr.index = this.indexForName(ptr.name);
 83 | 				if(ptr.index != -1){
 84 | 					newfriends = new Friend(ptr.index, newfriends);
 85 | 				}
 86 | 				ptr = ptr.next;
 87 | 			}
 88 | 			this.people.get(i).friends = newfriends;
 89 | 		}
 90 | 	}
 91 | 	
 92 | 	String nameForIndex(int index){
 93 | 		return people.get(index).name;
 94 | 	}
 95 | 	
 96 | 	int indexForName(String name){
 97 | 		try{
 98 | 			return hash.get(name);
 99 | 		}catch(Exception NullPointerException){
100 | 			return -1;
101 | 		}
102 | 	}
103 | 	
104 | 	public class Person {
105 | 		String name;	
106 | 		String school;
107 | 		Friend friends;
108 | 		int dfsnum;
109 | 		int back;
110 | 		int scnum;
111 | 		
112 | 		public Person(String name, String school, Friend friends ) {
113 | 			this.scnum = -1;
114 | 			this.name = name;
115 | 			this.school = school;
116 | 			this.friends = friends;
117 | 			this.dfsnum = 0;
118 | 			this.back = 0;
119 | 		}
120 | 	}
121 | 	
122 | 	class Friend{
123 | 		public int index; 
124 | 		public Friend next;
125 | 		public String name;
126 | 		public String school;
127 | 	
128 | 		public Friend(String name, Friend next){
129 | 			this.index = indexForName(name);
130 | 			this.name = name;
131 | 			this.school = people.get(index).school;
132 | 			this.next = next;
133 | 		}
134 | 		
135 | 		public Friend(int index, Friend next){
136 | 			this.index = index;
137 | 			this.next = next;
138 | 			this.school = people.get(index).school;
139 | 			this.name = people.get(index).name;
140 | 		}		
141 | 	}	
142 | 
143 | 	/**
144 | 	 * Makes a graph consisting only of the students at a certain school.
145 | 	 * Prints the graph in the same format as input file.
146 | 	 * 
147 | 	 */	
148 | 	public Graph atSchool(String schoolName){
149 | 		ArrayList<Person> students = new ArrayList<Person>();
150 | 
151 | 		for (int i = 0; i < people.size(); i++){			
152 | 			Person p = people.get(i);
153 | 			if(p.school != null && p.school.equals(schoolName)){
154 | 				Friend newfriends = null;
155 | 				Friend temp = p.friends;
156 | 				while(temp != null){
157 | 					if(temp.school != null && temp.school.equals(schoolName)){
158 | 						newfriends = new Friend(temp.index, newfriends);
159 | 					}
160 | 					temp = temp.next;
161 | 				}
162 | 				students.add(new Person(p.name, schoolName, newfriends));
163 | 			}
164 | 		}
165 | 		Graph subgraph = new Graph(students);
166 | 		return subgraph;
167 | 	}
168 | 
169 | 	/**
170 | 	 *  Finds the shortest path between two people.
171 | 	 *  Prints the sequence of names.
172 | 	 *  Greedy Algorithm maybe?
173 | 	 */	
174 | 	public void shortestChain(String sname, String ename){
175 | 		if(indexForName(sname) == -1 || indexForName(ename) == -1){
176 | 			System.out.println("invalid name!");
177 | 			return;
178 | 		}
179 | 		Stack<String> chain = new Stack<String>();
180 | 		int snum = indexForName(sname);
181 | 		Person start = people.get(snum);
182 | 		Person end = people.get(indexForName(ename));
183 | 		boolean[] visited = new boolean[size];
184 | 		
185 | 		people.get(indexForName(sname)).scnum = 0;
186 | 		scdfs(indexForName(sname), visited);
187 | 		if(end.scnum == -1){
188 | 			System.out.println("They can NEVER be friends!!!");
189 | 			return;
190 | 		}
191 | 		Person ptr = end;
192 | 		while(ptr.scnum != 0){
193 | 			chain.push(ptr.name);
194 | 			Friend t = ptr.friends;
195 | 			int min = ptr.scnum;
196 | 			while(t != null){
197 | 				if(people.get(t.index).scnum < min){
198 | 					ptr = people.get(t.index);
199 | 					break;
200 | 				}
201 | 				t = t.next;
202 | 			}
203 | 		}
204 | 		chain.push(start.name);
205 | 		String ret = "";
206 | 		while(chain.size() > 1){
207 | 			ret = ret + chain.pop() + ", ";
208 | 		}
209 | 		ret = "Shortest path: " + ret + chain.pop() + ".";
210 | 		System.out.println(ret);
211 | 		
212 | 		//resets scnumbers
213 | 		for(int i = 0; i < people.size(); i++){
214 | 			people.get(i).scnum = -1;
215 | 		}
216 | 	}
217 | 	private void scdfs(int v, boolean[] visited){
218 | 		visited[v] = true;
219 | 		for (Friend e = people.get(v).friends; e != null; e=e.next){
220 | 			if(!visited[e.index]){
221 | 				people.get(e.index).scnum = sccount;
222 | 				sccount++;	
223 | 				scdfs(e.index, visited);
224 | 				sccount--;
225 | 				people.get(v).scnum = Math.min(people.get(v).scnum, people.get(e.index).scnum + 1);	
226 | 			}
227 | 			else{//already visited
228 | 				people.get(v).scnum = Math.min(people.get(e.index).scnum + 1, people.get(v).scnum);
229 | 			}
230 | 		}
231 | 	}
232 | 	
233 | 	/**
234 | 	 * Prints a textual representation of the graph
235 | 	 */
236 | 	public void printGraph(){
237 | 		if(size == 0){
238 | 			System.out.println("Empty graph.");
239 | 			return;
240 | 		}
241 | 		System.out.println(size);
242 | 		for(int v = 0; v < size; v++){
243 | 			if(people.get(v).school != null){
244 | 				System.out.println(people.get(v).name + "|y|" + people.get(v).school);
245 | 			}
246 | 			else{
247 | 				System.out.println(people.get(v).name + "|n");
248 | 			}
249 | 		}
250 | 		for(int v = 0; v < size; v++){
251 | 			Friend ptr = people.get(v).friends;
252 | 			while(ptr != null){
253 | 				if(v < ptr.index){
254 | 					System.out.println(people.get(v).name + "|" + nameForIndex(ptr.index));
255 | 				}
256 | 				ptr = ptr.next;
257 | 			}
258 | 		}
259 | 	}
260 | 	
261 | 	/**
262 | 	 * finds cliques (separate groups) at a particular school.
263 | 	 * prints the subgraphs in format of input file.
264 | 	 */
265 | 	public ArrayList<Graph> cliques(){
266 | 		ArrayList<Graph> cliqueslist = new ArrayList<Graph>();
267 | 		boolean[] visited = new boolean[size];
268 | 		boolean[] vtemp = new boolean[size];
269 | 		
270 | 		for(int i=0; i<size; i++){
271 | 			ArrayList<Person> clique = new ArrayList<Person>();
272 | 			if (!visited[i]){		
273 | 				System.out.println("Starting on new clique");
274 | 				cliquedfs(vtemp, i, visited);
275 | 				for(int j=0; j<visited.length; j++){
276 | 					if(vtemp[j])
277 | 						clique.add(new Person(nameForIndex(j), schoolname, people.get(j).friends));
278 | 						vtemp[j] = false;
279 | 				}
280 | 				Graph tempgraph = new Graph(clique);
281 | 				cliqueslist.add(tempgraph);
282 | 			}
283 | 		}
284 | 		return cliqueslist;
285 | 	}
286 | 	
287 | 	private void cliquedfs(boolean[] newlyVisited, int v, boolean[] visited) {
288 | 		visited[v] = true;
289 | 		newlyVisited[v] = true;
290 | 		for (Friend e=people.get(v).friends; e != null; e=e.next) {
291 | 			if (!visited[e.index]) {
292 | 				cliquedfs(newlyVisited, e.index, visited);
293 | 			}
294 | 		}
295 | 	}
296 | 	
297 | 
298 | 	/**
299 | 	 * finds and prints the names of all people who are connectors
300 | 	 * separated by commas, in any order.
301 | 	 */
302 | 	
303 | 	public void connectors(){
304 | 		boolean[] knex = new boolean[size];
305 | 		boolean[] visited = new boolean[size];
306 | 		
307 | 		for (int v = 0; v < visited.length; v++) {
308 | 			if (!visited[v]) {
309 | 				dfscon(v, visited, knex);
310 | 			}
311 | 		}
312 | 		int min = 0;
313 | 		for(int n = people.size()-1; n >= 0; n--){
314 | 			if(people.get(n).back == 1 && n != 0){
315 | 				min++;
316 | 				if(min >= 2){knex[0] = true;}
317 | 			}
318 | 		}
319 | 		System.out.print("Connectors:");
320 | 		String s = "";
321 | 		for(int i=0; i<knex.length; i++){
322 | 			if(knex[i]){
323 | 				s = people.get(i).name + ", "+ s;
324 | 			}
325 | 		}
326 | 		System.out.println(s);
327 | 		dfscount = 1;
328 | 		for(Person p: people){
329 | 			p.dfsnum = 0;
330 | 			p.back = 0;
331 | 		}
332 | 	}
333 | 	private void  dfscon(int v, boolean[] visited, boolean[] knex) {
334 | 		visited[v] = true;
335 | 		people.get(v).dfsnum = dfscount;
336 | 		people.get(v).back = dfscount;
337 | 		dfscount++;
338 | //		System.out.println("Visiting " + people.get(v).name + " num: " + people.get(v).dfsnum);
339 | 
340 | 		for (Friend w = people.get(v).friends; w != null; w = w.next) {
341 | 			if (!visited[w.index]) {
342 | 				dfscon(w.index, visited, knex);
343 | 				if(people.get(v).dfsnum > people.get(w.index).back) {
344 | 					people.get(v).back = Math.min(people.get(v).back , people.get(w.index).back);
345 | 				}
346 | 				if(people.get(v).dfsnum <= people.get(w.index).back && v != 0){
347 | 					knex[v]=true;
348 | 				}
349 | 			}
350 | 			else{//w is already visited
351 | 				people.get(v).back = Math.min(people.get(v).back, people.get(w.index).dfsnum);
352 | 				//System.out.println(people.get(w.index).name + " " + people.get(w.index).dfsnum + "/" + people.get(w.index).back);
353 | 			}	
354 | 		}
355 | 		
356 | 	}
357 | 	
358 | }
359 | 


--------------------------------------------------------------------------------
/prog4.html:
--------------------------------------------------------------------------------
  1 | <html><head>
  2 | <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
  3 | 
  4 | <title>CS112 Fall 2012 - Friendship Graph Algorithms</title>
  5 | <style>
  6 | body { font: 14px Trebuchet MS, Verdana, Arial, Helvetica, sans-serif; }
  7 | div.code { background: lightgrey; }
  8 | table { border-collapse: collapse; cellspacing: 0px; margin-left: 10%;}
  9 | th { font: bold 14px Trebuchet MS; border-bottom: 1px solid black; padding: 10px;}
 10 | td { padding-right: 20px; padding-top: 5px; font: 13px Trebuchet MS; }
 11 | td.pts { text-align: center; }
 12 | a, a:visited { color: blue; }
 13 | pre { color: blue; }
 14 | span.new { color: red; font-size: 16px;}
 15 | tt, code { color: blue; }
 16 | strong { color: red; }
 17 | </style>
 18 | </head><body>
 19 | <center>
 20 | <h2>CS112 Fall 2012: Programming Assignment 4</h2>
 21 | <h2>Friendship Graph Algorithms</h2>
 22 | <h3>Posted Tue, Nov 27. Due Fri, Dec 7, 11:00 PM 
 23 | </h3><h3>Worth 100 points = 10% of your course grade</h3> 
 24 | </center>
 25 | <hr>
 26 | <p>In this assignment, you will implement some useful algorithms that apply
 27 | to friendship graphs of the Facebook kind.
 28 | 
 29 | </p><p>You will work on this assignment in PAIRS.
 30 | INDIVIDUAL SUBMISSIONS WILL NOT BE ACCEPTED.
 31 | 
 32 | </p><p>Read <a href="http://www.cs.rutgers.edu/policies/academicintegrity/index.php?page=3">
 33 | DCS Academic Integrity Policy for Programming Assignments</a> - you are responsible for abiding 
 34 | by the policy. In particular, note that "<b>All Violations of the Academic Integrity Policy will 
 35 | be reported by the instructor to the appropriate Dean</b>". (For this assignment, each
 36 | <em>pair</em> of partners must write its own code.)
 37 | 
 38 | </p><p>There will NOT be an extension pass option for this assignment.
 39 | 
 40 | </p><hr>
 41 | 
 42 | <ul>
 43 | <li><a href="#bg">Background</a>
 44 | </li><li><a href="#algo">Algorithms</a>
 45 | </li><li><a href="#impl">Implementation</a>
 46 | </li><li><a href="#submit">Submission</a>
 47 | </li></ul>
 48 | 
 49 | <p></p><hr>
 50 | <p><a name="bg"></a></p><h3><a name="bg">Background</a></h3>
 51 | 
 52 | <p>In this program, you will implement some useful algorithms for
 53 | graphs that represent friendships, such as Facebook. A friendship graph
 54 | is an undirected graph without any weights on the edges. It is a simple
 55 | graph because there are no self loops (a self loop is an edge from a vertex to
 56 | itself), or multiple edges (a multiple edge means more than edge between a
 57 | pair of vertices).
 58 | 
 59 | </p><p>The vertices in the graphs for this assignment represent two kinds of people:
 60 | students and non-students. Each vertex will store the name of the person.
 61 | If the person is a student, the name of the school will also be stored.
 62 | 
 63 | </p><p>Here's a sample friendship graph:
 64 | </p><pre>     (sam,rutgers)---(jane,rutgers)-----(bob,rutgers)   (sergei,rutgers)
 65 |                           |                 |             |
 66 |                           |                 |             |
 67 |                      (kaitlin,rutgers)   (samir)----(aparna,rutgers)
 68 |                           |                            |
 69 |                           |                            |
 70 |   (ming,penn state)----(nick,penn state)----(ricardo,penn state)
 71 |                           |
 72 |                           |
 73 |                      (heather,penn state)
 74 | 
 75 | 
 76 |                    (michele,cornell)----(rachel)     
 77 |                           | 
 78 |                           | 
 79 |      (rich,ucla)---(tom,ucla)
 80 | </pre>
 81 | Note that the graph may not be connected, as seen in this example in which there
 82 | are two "islands" or cliques that are not connected to each other by any edge.
 83 | Also see that all the vertices represent students with names of schools, except for
 84 | <tt>rachel</tt> and <tt>samir</tt>, who are not students.
 85 | 
 86 | <p></p><hr>
 87 | <p><a name="algo"></a></p><h3><a name="algo">Algorithms</a></h3>
 88 | 
 89 | <ol>
 90 | <li>
 91 | <p><a name=""></a></p><h4><a name="">Subgraph: Students at a school</a></h4>
 92 | 
 93 | <p>You want to be able to focus exclusively on students in a particular school, and
 94 | all the friendships between them. To do this, you will have to extract an
 95 | appropriate subgraph out of the full graph. Here is the subgraph of students at
 96 | rutgers, extracted from the original sample graph:
 97 | 
 98 | </p><pre>     (sam,rutgers)---(jane,rutgers)-----(bob,rutgers)    (sergei,rutgers)
 99 |                           |                                |
100 |                           |                                |
101 |                      (kaitlin,rutgers)             (aparna,rutgers)
102 | </pre>
103 | 
104 | </li><li><p><a name=""></a></p><h4><a name="">Shortest path: Intro Chain </a></h4>
105 | 
106 | <p><tt>sam</tt> wants an intro to <tt>aparna</tt> through friends and friends
107 | of friends. There are two possible chains of intros:
108 | </p><pre>  sam--jane--kaitlin--nick--ricardo--aparna
109 |             or
110 |   sam--jane-bob--samir--aparna
111 | </pre>
112 | The second chain is preferable since it is shorter. 
113 | 
114 | <p>If <tt>sam</tt> wants to be introduced to <tt>michele</tt> through a chain of
115 | friends, he is out of luck since there is no chain that leads from <tt>sam</tt> to
116 | <tt>michele</tt> in the graph.
117 | 
118 | </p><p>Note that this algorithm does NOT have any restriction on the composition of the
119 | vertices: a vertex along the shortest chain need NOT be a student at a particular
120 | school, or even a student. So, for instance, you may have to find the shortest intro
121 | chain from <tt>nick</tt> to <tt>samir</tt>, which has the following solution:
122 | </p><pre>   nick--ricardo--aparana--samir
123 | </pre>
124 | which consists of two penn state students, one rutgers student, and one non-student.
125 | 
126 | </li><li><p><a name=""></a></p><h4><a name="">Connected Islands: Cliques</a></h4>
127 | 
128 | <p>Students tend to form cliques with their friends, which creates
129 | islands that do not connect with each other. If these cliques could be identified,
130 | particularly in the student population at a particular school,
131 | introductions could be made between people in different cliques to build larger
132 | networks of friendships at that school. 
133 | 
134 | </p><p>In the sample graph, there are two island cliques for students at rutgers:
135 | </p><pre>     (sam,rutgers)---(jane,rutgers)-----(bob,rutgers)    (sergei,rutgers)
136 |                           |                                |
137 |                           |                                |
138 |                      (kaitlin,rutgers)             (aparna,rutgers)
139 | </pre>
140 | 
141 | <p>If we were to look at students at penn state, instead, there is a single clique:
142 | </p><pre>   (ming,penn state)----(nick,penn state)----(ricardo,penn state)
143 |                           |
144 |                           |
145 |                      (heather,penn state)
146 | </pre>
147 | <p>And again, a single clique for students at ucla:
148 | </p><pre>     (rich,ucla)---(tom,ucla)
149 | </pre>
150 | <p>And one for students at cornell:
151 | </p><pre>             (michele,cornell)
152 | </pre>
153 | <p>From these examples, it should be clear that if there is at least one student
154 | in the graph that goes to a particular school, then there must be at least one
155 | island clique in the graph for students at that school.
156 | 
157 | </p></li><li><p><a name=""></a></p><h4><a name="">Connectors: Friends who keep friends together </a></h4>
158 | 
159 | <p>If <tt>jane</tt> were to leave rutgers, <tt>sam</tt> would no longer be able to
160 | connect with anyone else--<tt>jane</tt> was the "connector" who could pull
161 | <tt>sam</tt> in to hang out with her other friends. Similarly, <tt>aparna</tt>
162 | is a connector, since without her, <tt>sergei</tt> would not be able to 
163 | "reach" anyone else. (And there are more connectors in the graph...)
164 | 
165 | </p><p>On the other hand <tt>samir</tt> is not a connector. Even if he were to leave,
166 | everyone else could still "reach" whoever they could when <tt>samir</tt> was there,
167 | even though they may have to go through a longer chain.
168 | 
169 | </p><p>A precise definition of a connector in any undirected graph is a vertex, v,
170 | such that there are at least two other vertices x and w for which <em>every</em> path
171 | between x and w goes through v. For example, <tt>v=jane</tt>,
172 | <tt>x=sam</tt>, and <tt>w=bob</tt>.
173 | 
174 | </p><p>Finding all connectors in an undirected graph can be done using DFS (depth-first search),
175 | but keeping track of a couple more numbers for every vertex <tt>v</tt>. These are:
176 | </p><ul>
177 | <li><tt>dfsnum(v)</tt>: This is the dfs number, assigned when a vertex is visited, dealt out
178 | in increasing order.
179 | </li><li><tt>back(v)</tt>: This is a number that is initially assigned when a vertex is
180 | visited, and is equal to <tt>dfsnum</tt>, but can be changed later based on three conditions:
181 | <ul>
182 | <li>When the DFS backs up from a neighbor, <tt>w</tt>, to <tt>v</tt>,
183 | if <tt>dfsnum(v)</tt> &gt; 
184 | <tt>back(w)</tt>, then <tt>back(v)</tt> is set to min(<tt>back(v)</tt>,<tt>back(w)</tt>)
185 | </li><li>If a neighbor, <tt>w</tt>, is already visited then
186 | <tt>back(v)</tt> is set to min(<tt>back(v)</tt>,<tt>dfsnum(w)</tt>)
187 | </li></ul>
188 | </li></ul>
189 | <p>When the DFS backs up from a neighbor, <tt>w</tt>, to <tt>v</tt>,
190 | if <tt>dfsnum(v)</tt> &#8804; <tt>back(w)</tt>, then <tt>v</tt> is identified as
191 | a connector, IF <tt>v</tt> is NOT the starting point
192 | for the DFS.
193 | (If <tt>v</tt> is a starting point for DFS, it can be a connector, but
194 | another check must be made - see the examples below. The examples don't tell
195 | you how to identify such cases, that's up to you.)
196 | 
197 | </p><p>Here are some examples that show how this works. 
198 | 
199 | </p><ul>
200 | <li>Example 1: (B is a connector)
201 | <pre>    A--B--C
202 | </pre>
203 | The DFS starts at A. Neighbors for a vertex are stored in REVERSE alphabetical order:
204 | <pre>  
205 |   A: B
206 |   B: C,A
207 |   C: B
208 | 
209 |   dfs @ A  1/1  (dfsnum/back)
210 |       dfs @ B 2/2
211 |           dfs @ C 3/3
212 |               neighbor B is already visited =&gt; C 3/2
213 |           dfsnum(B) &lt;= back(C) B is a CONNECTOR
214 |           nbr A is already visited =&gt; B 2/1
215 |       dfsnum(A) &lt;= back(B) A is starting point of DFS, NOT connector
216 | </pre>
217 | 
218 | <p></p></li><li>Example 2: (B is a connector)
219 | <pre>   A--B--C
220 | </pre>
221 | The same example as the first, except DFS starts at B. This shows how even thought B is
222 | the starting point, it is still identified (correctly) as a connector. The code is
223 | not complete because it does not show HOW B is determined to be a connector
224 | in the last line - that's for you to figure out. Neighbors are
225 | stored in reverse alphabetical order as before.
226 | <pre>  dfs @ B  1/1 
227 |       dfs @ C 2/2
228 |           nbr B is already visited =&gt; C 2/1
229 |       dfsnum(B) &lt;= back(C) B is starting point, NOT connector
230 |       dfs @ A 3/3
231 |           nbr B is already visited =&gt; A 3/1
232 |       dfsnum(B) &lt;= back(A) B is starting point, but is a CONNECTOR
233 | </pre>
234 | 
235 | <p></p></li><li>Example 3: (B and D are connectors)
236 | <pre>    A---B---C
237 |         |   |
238 |         E---D---F
239 | </pre>
240 | <p>DFS starts at A. Neighbors stored in reverse alphabetical order again:
241 | </p><pre>  A: B
242 |   B: E,C,A
243 |   C: D,B
244 |   D: F,E,C
245 |   E: D,B
246 |   F: D
247 | 
248 |   dfs @ A 1/1
249 |       dfs @ B 2/2
250 |           dfs @ E 3/3
251 |               dfs @ D 4/4
252 |                   dfs @ F 5/5
253 |                       nbr D is already visited =&gt; F 5/4
254 |                   dfsnum(D) &lt;= back(F) =&gt; D is a CONNECTOR
255 |                   nbr E already visited =&gt; D 4/3
256 |                   dfs @ C 6/6
257 |                       nbr D already visited =&gt; C 6/4
258 |                       nbr B already visited =&gt; C 6/2
259 |                   dfsnum(D) &gt; back(C) =&gt; D 4/2
260 |               dfsnum(E) &gt; back(D) =&gt; E 3/2
261 |               nbr B is already visited =&gt; E 3/2
262 |           dfsnum(B) &lt;= back(E) =&gt; B is a CONNECTOR
263 |           nbr C is already visited =&gt; B 2/2
264 |           nbr A is already visited =&gt; B 2/1
265 |       dfsnum(A) &lt;= back(B) A is starting point, NOT connector
266 | </pre>
267 | 
268 | <p></p></li><li>Example 4: (B and D are connectors)
269 | <pre>    A---B---C
270 |         |   |
271 |         E---D---F
272 | </pre>
273 | <p>Same example as the previous, except DFS starts at D, and neighbors stored
274 | in alphabetical order. Connectors are still correctly identified as B and D.
275 | </p><pre>  A: B
276 |   B: A,C,E
277 |   C: B,D
278 |   D: C,E,F
279 |   E: B,D
280 |   F: D
281 | 
282 |   dfs @ D 1/1
283 |       dfs @ C 2/2
284 |           dfs @ B 3/3
285 |               dfs @ A 4/4
286 |                   nbr B is already visited =&gt; A 4/3
287 |               dfsnum(B) &lt;= back(A) =&gt; B is a CONNECTOR
288 |               nbr C is already visited =&gt; B 3/2
289 |               dfs @ E 5/5
290 |                   nbr B is already visited =&gt; E 5/3
291 |                   nbr D is already visited =&gt; E 5/1
292 |               dfsnum(B) &gt; back(E) =&gt; B 3/1
293 |           dfsnum(C) &gt; back(B) =&gt; C 2/1
294 |           nbr D is already visited =&gt; C 2/1
295 |       dfsnum(D) &lt;= back(C) D is starting point, NOT connector
296 |       dfs @ F 6/6
297 |           nbr D is already visited =&gt; F 6/1
298 |       dfsnum(D) &lt;= back(F) D is starting point, is a CONNECTOR
299 | </pre></li></ul>
300 | 
301 | </li></ol>
302 | 
303 | <p></p><hr>
304 | <a name="impl"><h3>Implementation</h3></a>
305 | 
306 | <p>You will write a program called <tt>Friends</tt> that will read a graph file,
307 | build a graph (using the adjacency linked lists representation), and implement the
308 | four algorithms described above. The following describes the inputs and outputs
309 | for all the functionality you need to implement, as well as point assignment.
310 | 
311 | </p><ol>
312 | <li><a name=""><h4>(5 pts) User interface</h4></a>
313 | <ul>
314 | <li>Your user interface should ask for the input graph file, build the graph,
315 | then spin on five choices--students at a school, shortest intro chain, cliques at
316 | school, connectors, and quit--until the user quits.
317 | </li></ul>
318 | 
319 | <p></p></li><li><a name=""><h4>(10 pts) Graph build</h4></a>
320 | <ul>
321 | <li>Input: file that lists names of all people and edges between them. Here is 
322 | the format of the input file for the sample friendship graph given in the
323 | <tt>Background</tt> section.
324 | <pre>   15
325 |    sam|y|rutgers
326 |    jane|y|rutgers
327 |    michele|y|cornell
328 |    sergei|y|rutgers
329 |    ricardo|y|penn state
330 |    kaitlin|y|rutgers
331 |    samir|n
332 |    aparna|y|rutgers
333 |    ming|y|penn state
334 |    nick|y|penn state
335 |    bob|y|rutgers
336 |    heather|y|penn state
337 |    rachel|n
338 |    rich|y|ucla
339 |    tom|y|ucla
340 |    sam|jane
341 |    jane|bob
342 |    jane|kaitlin
343 |    kaitlin|nick
344 |    bob|samir
345 |    sergei|aparna
346 |    samir|aparna
347 |    aparna|ricardo
348 |    nick|ricardo
349 |    ming|nick
350 |    heather|nick
351 |    michele|rachel
352 |    michele|tom
353 |    tom|rich
354 | </pre>
355 | <p>The first line has the number of people in the graph (15 in this case). 
356 | 
357 | </p><p>The next set of lines has information about the people in the graph, one line per
358 | person (15 lines in this example), with the '|' used to separate the fields. 
359 | In each line, the first field is the name of
360 | the person. Names of people can have any character except '|', and are case
361 | <em>insensitive</em>. The second field is 'y' if
362 | the person is a student, and 'n' if not. The third field is 
363 | only present for students, and is the name of the school the student attends.
364 | The name of a school can have any character except '|', and is
365 | case <em>insensitive</em>.
366 | 
367 | </p><p>The last set of lines, following the people information, lists the friendships
368 | between people, one friendship per line. Since friendship works both ways, any
369 | friendship is only listed once, and the order in which the names of the friends
370 | is listed does not matter.
371 | 
372 | </p></li><p></p><li>Result: The ajacency linked list representation, along with a data structure
373 | to be able to quickly translate from a person's name to vertex number. There should
374 | also be a quick way to translate from vertex number to the person's
375 | name. 
376 | <p></p></li><li>Output: <font color="red">You don't have to print the representation, we
377 | will check your code to see if you are storing the graph in this representation.</font>
378 | </li></ul>
379 | <p></p></li><li><a name=""><h4>(15 pts) Subgraph (students at a school)</h4></a>
380 | <ul>
381 | <li>Input: Name of school (case insensitive), e.g. "penn state"
382 | </li><p></p><li>Result: Subgraph of original graph, vertices are all students at the given school,
383 | edges are a subset of the edges of the original graph such that both endpoints are
384 | students at the school. The subgraph must be in stored in the adjacency linked
385 | lists form, just as for the original graph.
386 | <p></p></li><li>Output: Print the subgraph in the same format as the
387 | input in the <b>Graph build</b> section above.
388 | </li></ul>
389 | <p></p></li><li><a name=""><h4>(20 pts) Shortest path (Intro chain)</h4></a>
390 | <ul>
391 | <li>Input: Name of person who wants the intro, and the name of the other person,
392 | e.g. "sam" and "aparna" for the graph in the Background section. 
393 | (Neither of these, nor any of the intermediate people are
394 | required to be students, in the same school or otherwise.)
395 | </li><p></p><li>Result: The shortest chain of people in the graph
396 | starting at the first and ending at the second. 
397 | <p></p></li><li>Output: Print the chain of people in the shortest path, for example:
398 | <pre>sam--jane-bob--samir--aparna
399 | </pre>
400 | If there is no way to get from the first person to the second person, then the 
401 | output should be a message to this effect.
402 | </li></ul>
403 | <p></p></li><li><a name=""><h4>(15 pts) Connected Islands (cliques)</h4></a>
404 | <ul>
405 | <li>Input: Name of school for which cliques are to be found, e.g. "rutgers"
406 | </li><p></p><li>Result: The subgraphs for each of the cliques. 
407 | <p></p></li><li>Output: Print the subgraph for each clique, in the same format as
408 | the input described in the <tt>Graph build</tt> section. For example:
409 | <pre>Clique 1:
410 | 
411 | &lt;subgraph output&gt;
412 | 
413 | Clique 2:
414 | 
415 | &lt;subgraph output&gt;
416 | 
417 | etc...
418 | </pre>
419 | 
420 | Note: If there is even one student at the named school in the graph, then
421 | there must be at least
422 | one clique in the output. If the graph has no students at all at that school,
423 | then the output will be empty. 
424 | </li></ul>
425 | <p></p></li><li><a name=""><h4>(25 pts) Connectors (Friends who keep friends together)</h4></a>
426 | <ul>
427 | <li>Input: Nothing
428 | </li><p></p><li>Result: Names of all people who are connectors in the graph
429 | <p></p></li><li>Output: Print names of all people who are connectors in the graph, comma
430 | separated, in any order.
431 | </li></ul>
432 | <p></p></li><li><a name=""><h4>(10 pts) Efficiency</h4></a>
433 | <ul>
434 | <li>Your program will be assessed for efficiency in space usage and running time.
435 | Assume that the input graph in general can have several tens of thousands
436 | of vertices (people), and that each person will have, on average, about 100 friends.
437 | Think carefully through the algorithms to make sure you implement them as efficiently
438 | as you can.
439 | 
440 | <p>Remember, translating between a person's name and vertex number, as well as the other
441 | way around, should done efficiently. When implementing the algorithms, you will
442 | need to maintain additional data structures--pay particular attention to the space
443 | you use for the data structures. 
444 | 
445 | </p></li></ul>
446 | </li></ol>
447 | 
448 | <p>Your program MUST be called <tt>Friends</tt> - in other words, you must have a filed
449 | named <tt>Friends.java</tt> with a <tt>main</tt> method.
450 | 
451 | </p><p>You may implement as many classes as you want, and separate them into packages as needed.
452 | 
453 | </p><p>You may import any of the classes from <tt>java.lang</tt>, 
454 | <tt>java.io</tt> and <tt>java.util</tt>, but you may NOT 
455 | import classes from any of the other packages in the standard Java API, and you may NOT 
456 | import classes from any external java APIs. (Of course, if you have more than one package in your 
457 | application, you can cross-import classes among them.) Note: The <tt>java.util.TreeMap</tt> 
458 | class may be useful--it implements a red-black
459 | tree, which, like the AVL tree, is a balanced binary search tree with O(log n) worst case
460 | insert/delete/search times.
461 | 
462 | </p><h3><a name="submit">Submission</a></h3>
463 | 
464 | In the <tt>Friends.java</tt> file, <font color="red">make sure you write the names of
465 | both members of your team in comment lines at the top. </font>
466 | <p>Export your entire Eclipse project as a zip archive into a file called
467 | <tt>friends.zip</tt>, 
468 | and upload this file to Sakai. (See the Eclipse page for how to do this.)
469 | 
470 | </p><p>If you submit an 
471 | incorrect/incomplete project, you will lose credit. So before you submit,
472 | you should check that all is well by importing your friends.zip file as a project
473 | into Eclipse (in a different workspace, so it doesn't conflict with your
474 | existing project), and running it.
475 | 
476 | </p><p>ONLY ONE PERSON per team should submit the assignment.
477 | 
478 | 
479 | </p></body></html>


--------------------------------------------------------------------------------