├── README.md
├── src
    ├── node_data.java
    ├── edge_data.java
    ├── Node.java
    ├── Edge.java
    ├── Revers_Kruskal.java
    ├── EulerCycle.java
    ├── TreeIsomorphism.java
    ├── Dfs.java
    ├── Graph.java
    ├── Haffman.java
    ├── dijkstra.java
    ├── Kruskal.java
    ├── BucketsProblem.java
    └── BFS.java
├── .idea
    ├── dictionaries
    │   └── amichaihadad.xml
    ├── codeStyles
    │   ├── codeStyleConfig.xml
    │   └── Project.xml
    ├── vcs.xml
    ├── modules.xml
    └── misc.xml
└── Algo 2.iml


/README.md:
--------------------------------------------------------------------------------
1 | # Algo-2
2 | 


--------------------------------------------------------------------------------
/src/node_data.java:
--------------------------------------------------------------------------------
1 | public interface node_data {
2 |     public int getId();
3 | 
4 | }
5 | 


--------------------------------------------------------------------------------
/src/edge_data.java:
--------------------------------------------------------------------------------
1 | public interface edge_data {
2 |     public int getSrc();
3 |     public int getDst();
4 | 
5 | }
6 | 


--------------------------------------------------------------------------------
/.idea/dictionaries/amichaihadad.xml:
--------------------------------------------------------------------------------
1 | <component name="ProjectDictionaryState">
2 |   <dictionary name="amichaihadad" />
3 | </component>


--------------------------------------------------------------------------------
/.idea/codeStyles/codeStyleConfig.xml:
--------------------------------------------------------------------------------
1 | <component name="ProjectCodeStyleConfiguration">
2 |   <state>
3 |     <option name="USE_PER_PROJECT_SETTINGS" value="true" />
4 |   </state>
5 | </component>


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="$PROJECT_DIR$" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/codeStyles/Project.xml:
--------------------------------------------------------------------------------
1 | <component name="ProjectCodeStyleConfiguration">
2 |   <code_scheme name="Project" version="173">
3 |     <option name="LINE_SEPARATOR" value="&#10;" />
4 |   </code_scheme>
5 | </component>


--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/Algo 2.iml" filepath="$PROJECT_DIR$/Algo 2.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK">
4 |     <output url="file://$PROJECT_DIR$/out" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/src/Node.java:
--------------------------------------------------------------------------------
 1 | public class Node implements node_data {
 2 |     int id;
 3 |     public Node(int id){
 4 |         this.id = id;
 5 |     }
 6 | 
 7 |     public Node(node_data v) {
 8 |         this.id = v.getId();
 9 |     }
10 | 
11 |     @Override
12 |     public int getId() {
13 |         return this.id;
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Edge.java:
--------------------------------------------------------------------------------
 1 | public class Edge implements edge_data {
 2 |     private int src;
 3 |     private int dst;
 4 |     public Edge(int src, int dst){
 5 |         this.dst = dst;
 6 |         this.src = src;
 7 |     }
 8 |     @Override
 9 |     public int getSrc() {
10 |         return src;
11 |     }
12 | 
13 |     @Override
14 |     public int getDst() {
15 |         return dst;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Algo 2.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="JAVA_MODULE" version="4">
 3 |   <component name="NewModuleRootManager" inherit-compiler-output="true">
 4 |     <exclude-output />
 5 |     <content url="file://$MODULE_DIR$">
 6 |       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
 7 |     </content>
 8 |     <orderEntry type="inheritedJdk" />
 9 |     <orderEntry type="sourceFolder" forTests="false" />
10 |   </component>
11 | </module>


--------------------------------------------------------------------------------
/src/Revers_Kruskal.java:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | import java.util.Comparator;
 3 | import java.util.Iterator;
 4 | import java.util.PriorityQueue;
 5 | 
 6 | public class Revers_Kruskal {
 7 |     public static ArrayList<edge_data> find_min_span_Tree(Graph g) {
 8 |         ArrayList<edge_data> arrayList = new ArrayList<>();
 9 |         ArrayList<edge_data> Tree = new ArrayList<>();
10 |         for (int i = 1; i < g.size(); i++) {
11 |             for (Iterator<edge_data> it = g.getEdges(i).iterator(); it.hasNext(); ) {
12 |                 edge_data e = it.next();
13 |                 arrayList.add(e);
14 |             }
15 |         }
16 |         arrayList.sort((edge_data d, edge_data x) -> x.getWeight() - d.getWeight());
17 |         int i = 0;
18 |         while (Tree.size() < g.size()-1){
19 |             edge_data t  =arrayList.get(i);
20 |             g.removeEdge(t.getSrc(),t.getDst());
21 |             BFS bfs = new BFS(g);
22 |             if (!bfs.connected()){
23 |                 Tree.add(t);
24 |             }
25 |             i++;
26 |         }
27 |         return Tree;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/EulerCycle.java:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | import java.util.Stack;
 3 | 
 4 | public class EulerCycle {
 5 |     private Graph graph;
 6 |     public EulerCycle(Graph g){
 7 |         this.graph = new Graph(g);
 8 |     }
 9 |     public ArrayList<Integer> findCycle(){
10 |         if (!isEuler()){
11 |             return null;
12 |         }
13 |         Stack<Integer> s = new Stack<>();
14 |         ArrayList<Integer> arrayList = new ArrayList();
15 |         s.push(1);
16 |         while (!s.isEmpty()){
17 |             int u = s.peek();
18 |             if (graph.deg(u) == 0){
19 |                 s.pop();
20 |                 arrayList.add(u);
21 |             }
22 |             else {
23 |                 int v = graph.getEdges(u).iterator().next().getDst();//
24 |                 s.push(v);
25 |                 graph.removeEdge(u,v);
26 |             }
27 |         }
28 |         return arrayList;
29 |     }
30 |     private boolean isEuler() {
31 |         return true;
32 |     }
33 |     public static void main(String[] args){
34 |         Graph g = new Graph();
35 |         for (int i = 0;i<6;i++){
36 |             g.addNode();
37 |         }
38 |         g.add2Edge(1,3);
39 |         g.add2Edge(1,6);
40 |         g.add2Edge(1,2);
41 |         g.add2Edge(6,2);
42 |         g.add2Edge(1,5);
43 |         g.add2Edge(2,3);
44 |         g.add2Edge(2,5);
45 |         g.add2Edge(3,5);
46 |         g.add2Edge(3,4);
47 |         g.add2Edge(5,4);
48 |         System.out.println("Euler Circle: " + new EulerCycle(g).findCycle().toString()); // Euler Circle: [1, 5, 4, 3, 5, 2, 6, 1, 2, 3, 1]
49 |     }
50 | }
51 | 
52 | 


--------------------------------------------------------------------------------
/src/TreeIsomorphism.java:
--------------------------------------------------------------------------------
 1 | import java.util.LinkedList;
 2 | import java.util.Queue;
 3 | import java.util.PriorityQueue;
 4 | public class TreeIsomorphism {
 5 |     class Node implements Comparable<Node>{
 6 |         Integer length;
 7 |         int index;
 8 |         Node(int index,int length){
 9 |             this.index = index;
10 |             this.length = length;
11 |         }
12 | 
13 |         public void setLength(Integer length) {
14 |             this.length = length;
15 |         }
16 | 
17 |         public int getIndex() {
18 |             return index;
19 |         }
20 | 
21 |         @Override
22 |         public int compareTo(Node o) {
23 |             return o.length-length;
24 |         }
25 |     }
26 | 
27 |     public String toCode(int[] tree, int root){
28 |         String[] ans = new String[tree.length];
29 |         AHU(ans,tree,root,null);
30 |         return ans[root];
31 |     }
32 |     public void AHU(String[] phi, int[] tree, int v,PriorityQueue<Node> insert_me){
33 |         if (isLeaf(tree,v)){
34 |             insert_me.add(new Node(v,2));
35 |             phi[v] =  "10";
36 |             return;
37 |         }
38 |         PriorityQueue<Node> queue1 = new PriorityQueue<>();
39 |         for (int i = 0; i<tree.length;i++){
40 |             if (tree[i] == v) {
41 |                 AHU(phi, tree, i,queue1);
42 |             }
43 |         }
44 |         phi[v] = "1";
45 |         while (!queue1.isEmpty()) {
46 |             int max = queue1.poll().getIndex();
47 |             phi[v] = phi[v] + phi[max];
48 |         }//best sort
49 |         phi[v] = phi[v] + "0";
50 |         if (insert_me!=null)
51 |             insert_me.add(new Node(v,phi[v].length()));
52 | 
53 |     }
54 | 
55 |     private static boolean isLeaf(int[] tree, int v) {
56 |         for (int i =0; i<tree.length;i++){
57 |             if (tree[i] == v)
58 |                 return false;
59 |         }
60 |         return true;
61 |     }
62 |     public boolean isomorphism(int[] tree1, int root1, int[] tree2, int root2){
63 |         return toCode(tree1,root1).equals(toCode(tree2,root2));
64 |     }
65 |     public static void main(String [] args){
66 |         int[] i = {2,2,3,4,-1,4,4,6,6};
67 |         int[] j = {1,8,1,5,5,6,-1,6,6};
68 |         System.out.println("111101000110100100".equals(new TreeIsomorphism().toCode(i,4)));
69 |         System.out.println("the code is: " + new TreeIsomorphism().toCode(i,4));
70 |         System.out.println(new TreeIsomorphism().isomorphism(i,4,j,6));
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Dfs.java:
--------------------------------------------------------------------------------
 1 | import java.util.Iterator;
 2 | import java.util.Stack;
 3 | 
 4 | public class Dfs {
 5 |     Graph graph;
 6 |     int n ;
 7 |     int[] pred;
 8 |     int[] start;
 9 |     int[] end ;
10 |     private enum Color
11 |     {
12 |         WHITE,
13 |         GRAY,
14 |         BLACK
15 |     }
16 | 
17 |     public Dfs(Graph g){
18 |         this.graph = new Graph(g);
19 |         this.n =  graph.size();
20 |         this.pred = new int[n];
21 |         this.start = new int[n];
22 |         this.end = new int[n];
23 |         dfsAt(1);
24 |     }
25 |     public void dfsAt(int u){
26 |         Stack<Integer> stack = new Stack<>();
27 |         Iterator<edge_data>[] iters = new Iterator[n];
28 |         for (int i=1; i<n;i++){
29 |             iters[i] = graph.getEdges(i).iterator();
30 |         }
31 |         boolean hasCycle = false;
32 |         int startCycle;
33 |         int endCycle;
34 |         Color[] visted = new Color[n];
35 |         for (int i = 1; i <n; i++){
36 |             visted[i] = Color.WHITE;
37 |         }
38 |         int time = 1;
39 |         stack.push(u);
40 |         while (!stack.isEmpty()){
41 |             u = stack.peek();
42 |             visted[u] = Color.GRAY;
43 |             start[u] = time++;
44 |             if (iters[u].hasNext()){
45 |                 int v = iters[u].next().getDst();
46 |                 if (visted[v]==Color.WHITE){
47 |                     visted[v] = Color.GRAY;
48 |                     pred[v] = u;
49 |                     start[v] = time++;
50 |                     stack.push(v);
51 |                 }
52 |                 else if(!hasCycle &&visted[v]==Color.GRAY && pred[u] != v) {
53 |                     hasCycle = true;
54 |                     startCycle = u;
55 |                     endCycle = v;
56 |                 }
57 |             }
58 |             else {
59 |                 end[u] = time++;
60 |                 visted[u] = Color.BLACK;
61 |                 stack.pop();
62 |                 System.out.print( "<-"+ u);
63 |             }
64 |         }
65 |         System.out.println(" cycle? "+hasCycle);
66 | 
67 |     }
68 |     public static void main(String [] args){
69 |         Graph g = new Graph();
70 |         for (int i=0; i<7 ; i++)
71 |             g.addNode();
72 |         g.add2Edge(1,2);
73 |         g.add2Edge(2,3);
74 |         g.add2Edge(3,4);
75 |         g.add2Edge(1,5);
76 |         g.add2Edge(1,6);
77 |         g.add2Edge(6,7);
78 |         g.add2Edge(7,4);
79 | //        System.out.println(g.getEdges(1).iterator().hasNext());
80 |         Dfs dfs = new Dfs(g);
81 | 
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/Graph.java:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | import java.util.Collection;
 3 | import java.util.HashMap;
 4 | import java.util.LinkedHashMap;
 5 | 
 6 | public class Graph {
 7 |     private int id = 1;
 8 |     private HashMap<Integer, node_data> NMap = new LinkedHashMap<>();
 9 |     private HashMap<Integer,HashMap<Integer, edge_data>> EMap = new LinkedHashMap<>();
10 |     private int sizeE = 0;
11 |     public Graph(){}
12 |     public Graph(Graph copy){
13 |         for (node_data v: copy.NMap.values()) {
14 |             this.NMap.put(v.getId(), new Node(v));
15 |         }
16 |         for (node_data v: copy.NMap.values()){
17 |             if (copy.getEdges(v.getId())!=null)
18 |                 for (edge_data e:copy.getEdges(v.getId()))
19 |                     add1Edge(e.getSrc(),e.getDst());
20 |         }
21 |         this.id = copy.id;
22 |         this.sizeE = copy.sizeE;
23 |     }
24 | 
25 |     public void addNode(){
26 |         NMap.put(id,new Node(id));
27 |         id++;
28 |     }
29 |     public void add2Edge(int src, int dst){
30 |         sizeE++;
31 |         add1Edge(src,dst);
32 |         add1Edge(dst,src);
33 |     }
34 |     private void add1Edge(int src, int dst){
35 |         if (NMap.get(src) == null || NMap.get(dst) == null){
36 |             System.out.println("dst or src dont exist");
37 |             return;
38 |         }
39 |         if (EMap.get(src) == null) {
40 |             HashMap<Integer, edge_data> temp = new LinkedHashMap<>();
41 |             temp.put(dst,new Edge(src,dst));
42 |             EMap.put(src, temp);
43 |         }
44 |         else EMap.get(src).put(dst,new Edge(src,dst));
45 |     }
46 |     public Collection<edge_data> getEdges(int id){
47 |         if (EMap.get(id) != null)
48 |             return EMap.get(id).values();
49 |         return null;
50 |     }
51 | 
52 |     public int size() {
53 |         return id;
54 |     }
55 | 
56 |     public int getSizeE() {
57 |         return sizeE;
58 |     }
59 |     public boolean isLeaf(int id){
60 |         Collection<edge_data> temp = getEdges(id);
61 |         return temp == null || temp.size() == 1;
62 |     }
63 |     public node_data removeNode(int id){
64 |         node_data temp = NMap.remove(id);
65 |         EMap.remove(id);
66 |         for (HashMap<Integer, edge_data> lists : EMap.values()){
67 |             lists.remove(id);
68 |         }
69 |         return temp;
70 |     }
71 | 
72 |     public int deg(int u) {
73 |         if(getEdges(u)==null) return 0;
74 |         return getEdges(u).size();
75 |     }
76 | 
77 |     public void removeEdge(int u, int v) {
78 |         if (EMap.get(u) != null)
79 |             EMap.get(u).remove(v);
80 |         if (EMap.get(v) != null)
81 |             EMap.get(v).remove(u);
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/Haffman.java:
--------------------------------------------------------------------------------
  1 | import java.util.Arrays;
  2 | import java.util.Comparator;
  3 | import java.util.PriorityQueue;
  4 | 
  5 | public class Haffman {
  6 |     PriorityQueue<Node> queue1 = new PriorityQueue<>();
  7 |     PriorityQueue<Node> queue2 = new PriorityQueue<>();
  8 |     class Node implements Comparable<Node> {
  9 |         int frec;
 10 |         char c;
 11 |         boolean leaf;
 12 |         Node right,left;
 13 |         int index;
 14 |         String chars;
 15 |         Node(int index,char c,int frec,boolean leaf){
 16 |             this.index = index;
 17 |             this.frec = frec;
 18 |             this.c = c;
 19 |             this.leaf = leaf;
 20 |         }Node(char c,int frec,boolean leaf,Node left,Node right){
 21 |             this.frec = frec;
 22 |             this.c = c;
 23 |             this.leaf = leaf;
 24 |             this.left = left;
 25 |             this.right = right;
 26 |         }
 27 | 
 28 |         public void setChars(String chars) {
 29 |             this.chars = chars;
 30 |         }
 31 | 
 32 |         @Override
 33 |         public int compareTo(Node o) {
 34 |             return this.frec-o.frec;
 35 |         }
 36 |     }
 37 |     public void init(int[] frec, char[] chars){
 38 |         for (int i = 0; i <chars.length;i++){
 39 |             queue1.add(new Node(i,chars[i],frec[i],true));
 40 |         }
 41 |         Node temp1;
 42 |         Node temp2;
 43 |         Node root = null;
 44 |         if (!queue1.isEmpty())
 45 |             temp1 = queue1.poll();
 46 |         else return;
 47 |         if (!queue1.isEmpty())
 48 |             temp2 = queue1.poll();
 49 |         else return;
 50 |         queue2.add(new Node('\n',temp1.frec+temp2.frec,false,temp1,temp2));
 51 | 
 52 |         while (!queue1.isEmpty()){
 53 |             if (queue1.peek().compareTo(queue2.peek())<=0){
 54 |                 temp1 = queue1.poll();
 55 |             }
 56 |             else temp1 = queue2.poll();
 57 |             if (queue2.isEmpty()&&!queue1.isEmpty()){
 58 |                 temp2 = queue1.poll();
 59 |             }
 60 |             else if (!queue1.isEmpty()&&queue1.peek().compareTo(queue2.peek())<=0){
 61 |                 temp2 = queue1.poll();
 62 |             }
 63 |             else temp2 = queue2.poll();
 64 |             root = new Node('\n',temp1.frec+temp2.frec,false,temp1,temp2);
 65 |             queue2.add(root);
 66 |         }
 67 |         String[][] mat = new String[chars.length][3];
 68 |         fillMat(root,mat);
 69 | 
 70 | 
 71 |     }
 72 | 
 73 |     private void fillMat(Node root, String[][] mat) {
 74 |         root.setChars("");
 75 |         fillRec(root,mat);
 76 |         printMat(mat);
 77 |     }
 78 | 
 79 |     private void fillRec(Node current,String[][] mat) {
 80 |         if( current == null) return;
 81 |         if (current.left!=null) {
 82 |             current.left.setChars(current.chars + "0");
 83 |         }
 84 |         if (current.right!=null) {
 85 |             current.right.setChars(current.chars + "1");
 86 |         }
 87 | 
 88 |         fillRec(current.right,mat);
 89 |         fillRec(current.left,mat);
 90 |         if(current.leaf){
 91 |             mat[current.index][0] = current.c+"";
 92 |             mat[current.index][1] = current.frec+"";
 93 |             mat[current.index][2] = current.chars+"";
 94 |         }
 95 |     }
 96 |     public static<T> void printMat(T mat[][]){
 97 |         for (int i = 0; i <mat.length;i++) {
 98 |             System.out.println(Arrays.toString(mat[i]));
 99 |         }
100 |     }
101 |     public static void main(String[] args){
102 |         int[] frec = {45,13,12,16,9,5};
103 |         char[] c = {'a','b','c','d','e','f'};
104 |         Haffman haffman = new Haffman();
105 |         haffman.init(frec,c);
106 |     }
107 | }
108 | 


--------------------------------------------------------------------------------
/src/dijkstra.java:
--------------------------------------------------------------------------------
  1 | import java.util.ArrayList;
  2 | import java.util.HashMap;
  3 | import java.util.LinkedHashMap;
  4 | import java.util.PriorityQueue;
  5 | 
  6 | 
  7 | class EdgeD implements Comparable<EdgeD>{
  8 |     int src;
  9 |     int dst;
 10 |     int weight;
 11 |     public EdgeD(int src,int dst, int weight){
 12 |         this.dst = dst;
 13 |         this.src = src;
 14 |         this.weight = weight;
 15 |     }
 16 | 
 17 |     @Override
 18 |     public int compareTo(EdgeD o) {
 19 |         return this.weight - o.weight;
 20 |     }
 21 | }
 22 | public class dijkstra {
 23 |     public static int inf = Integer.MAX_VALUE;
 24 |     private HashMap<Integer, HashMap<Integer, EdgeD>> G = new LinkedHashMap<>();
 25 | 
 26 |     public ArrayList<Integer> shortestPath(int src,int dst ,HashMap<Integer, HashMap<Integer, EdgeD>> g ){
 27 |         int[] cost = new int[g.size()];
 28 |         ArrayList<Integer>[] path = new ArrayList[g.size()];
 29 |         for (int i = 0; i<cost.length;i++){
 30 |             cost[i] = inf;
 31 |             path[i] = new ArrayList<>();
 32 |         }
 33 |         cost[src] =0;
 34 |         path[src].add(src);
 35 |         if (src==dst) return new ArrayList<>(src);
 36 |         if (g.get(src)==null||g.get(src).size()==0)return new ArrayList<>();
 37 |         PriorityQueue<EdgeD> minEq = new PriorityQueue<>();
 38 |         for (EdgeD edge:g.get(src).values()){
 39 |             minEq.add(edge);
 40 |         }
 41 |         boolean finish = false;
 42 |         while (!finish) {
 43 |             EdgeD  eTemp= minEq.poll();
 44 |             int tDst=eTemp.dst,tSrc = eTemp.src,wTemp = eTemp.weight;
 45 |             if (cost[tDst]==inf||cost[tDst] > cost[tSrc]+wTemp ){
 46 |                 cost[tDst] = cost[tSrc]+wTemp;
 47 |                 System.out.println(cost[tSrc]);
 48 |                 for (int i: path[tSrc]){
 49 |                     path[tDst].add(i);
 50 |                 }
 51 |                 path[tDst].add(tDst);
 52 |                 for (EdgeD edge:g.get(tDst).values()){
 53 |                     minEq.add(edge);
 54 |                 }
 55 |             }
 56 |             finish = minEq.isEmpty() || tDst == dst;
 57 |         }
 58 |         return path[dst];
 59 | 
 60 |     }
 61 |     public static void main(String[] args) {
 62 |         HashMap<Integer, HashMap<Integer, EdgeD>> g = new LinkedHashMap<>();
 63 |         EdgeD e01 = new EdgeD(0,1,3);
 64 |         EdgeD e02 = new EdgeD(0,2,1);
 65 | 
 66 |         EdgeD e10 = new EdgeD(1,0,3);
 67 |         EdgeD e13 = new EdgeD(1,3,2);
 68 |         EdgeD e12 = new EdgeD(1,2,1);
 69 | 
 70 |         EdgeD e20 = new EdgeD(2,0,1);
 71 |         EdgeD e21 = new EdgeD(2,1,1);
 72 |         EdgeD e24 = new EdgeD(2,4,5);
 73 | 
 74 |         EdgeD e34 = new EdgeD(3,4,1);
 75 |         EdgeD e31 = new EdgeD(3,1,2);
 76 |         EdgeD e35 = new EdgeD(3,5,9);
 77 |         EdgeD e36 = new EdgeD(3,6,5);
 78 | 
 79 |         EdgeD e42 = new EdgeD(4,2,5);
 80 |         EdgeD e43 = new EdgeD(4,3,1);
 81 |         EdgeD e46 = new EdgeD(4,6,5);
 82 | 
 83 |         EdgeD e53 = new EdgeD(5,3,9);
 84 |         EdgeD e56 = new EdgeD(5,6,8);
 85 |         EdgeD e57 = new EdgeD(5,7,2);
 86 | 
 87 |         EdgeD e65 = new EdgeD(6,5,8);
 88 |         EdgeD e63 = new EdgeD(6,3,5);
 89 |         EdgeD e64 = new EdgeD(6,4,5);
 90 |         EdgeD e67 = new EdgeD(6,7,1);
 91 | 
 92 |         EdgeD e76 = new EdgeD(7,6,1);
 93 |         EdgeD e75 = new EdgeD(7,5,2);
 94 | 
 95 | 
 96 |         for (int i = 0;i<8;i++){
 97 |             g.put(i,new HashMap<>());
 98 |         }
 99 |         g.get(0).put(1,e01);
100 |         g.get(0).put(2,e02);
101 | 
102 |         g.get(1).put(0,e10);
103 |         g.get(1).put(2,e12);
104 |         g.get(1).put(3,e13);
105 | 
106 |         g.get(2).put(0,e20);
107 |         g.get(2).put(1,e21);
108 |         g.get(2).put(4,e24);
109 | 
110 |         g.get(3).put(1,e31);
111 |         g.get(3).put(4,e34);
112 |         g.get(3).put(5,e35);
113 |         g.get(3).put(6,e36);
114 | 
115 |         g.get(4).put(2,e42);
116 |         g.get(4).put(3,e43);
117 |         g.get(4).put(6,e46);
118 | 
119 |         g.get(5).put(3,e53);
120 |         g.get(5).put(6,e56);
121 |         g.get(5).put(7,e57);
122 | 
123 |         g.get(6).put(3,e63);
124 |         g.get(6).put(4,e64);
125 |         g.get(6).put(5,e65);
126 |         g.get(6).put(7,e67);
127 | 
128 |         g.get(7).put(5,e75);
129 |         g.get(7).put(6,e76);
130 | 
131 |         dijkstra dijkstra = new dijkstra();
132 |         System.out.println(dijkstra.shortestPath(0,5,g));
133 |     }
134 | 
135 | }
136 | 


--------------------------------------------------------------------------------
/src/Kruskal.java:
--------------------------------------------------------------------------------
  1 | 
  2 | import javax.script.Compilable;
  3 | import java.util.*;
  4 | 
  5 | class EdgeW implements Comparable<EdgeW>  {
  6 |     private int src;
  7 |     private int dst;
  8 |     private int weight;
  9 |     public EdgeW(int src, int dst, int weight) {
 10 |         this.dst = dst;
 11 |         this.src = src;
 12 |         this.weight = weight;
 13 |     }
 14 | 
 15 |     public int getDst() {
 16 |         return dst;
 17 |     }
 18 | 
 19 |     public int getSrc() {
 20 |         return src;
 21 |     }
 22 | 
 23 |     public int getWeight() {
 24 |         return weight;
 25 |     }
 26 | 
 27 |     @Override
 28 |     public int compareTo(EdgeW o) {
 29 |         return weight-o.weight;
 30 |     }
 31 | 
 32 |     @Override
 33 |     public String toString() {
 34 |         return src+"->"+dst + " w:"+weight;
 35 |     }
 36 | }
 37 | 
 38 | public class Kruskal{
 39 |     private HashMap<Integer, HashMap<Integer, EdgeW>> G = new LinkedHashMap<>();
 40 |     public HashMap<Integer, HashMap<Integer, EdgeW>>
 41 |     kruskel(HashMap<Integer, HashMap<Integer, EdgeW>> g) throws Exception {
 42 |         HashMap<Integer, HashMap<Integer, EdgeW>> Tree = new LinkedHashMap<>();
 43 |         Union[] union = new Union[g.size()];
 44 |         for (int i = 0;i<g.size();i++) union[i] = new Union();
 45 |         PriorityQueue<EdgeW> listE_sorted = new PriorityQueue<>();
 46 |         for (int i = 0; i < g.size(); i++) {
 47 |             Collection<EdgeW> collection = g.get(i).values();
 48 |             for (EdgeW edgeW : collection) {
 49 |                 listE_sorted.add(edgeW);
 50 |                 g.get(edgeW.getDst()).remove(i);
 51 |             }
 52 |         }
 53 |         while (Tree.size()<g.size()){
 54 |             if (listE_sorted.isEmpty()) {
 55 |                 return Tree;
 56 |             }
 57 |             EdgeW edgeW = listE_sorted.poll();
 58 |             int src = edgeW.getSrc(),dst= edgeW.getDst();
 59 |             if (Union.find(union[src])!=Union.find(union[dst])){
 60 |                 if (Tree.get(src) == null)
 61 |                     Tree.put(src,new HashMap<Integer, EdgeW>());
 62 |                 Tree.get(src).put(dst,edgeW);
 63 |                 Union.Union(union[src],union[dst]);
 64 |             }
 65 |             else {
 66 |                 System.out.println(src+" "+ dst);
 67 |             }
 68 |         }
 69 | 
 70 |         return Tree;
 71 |     }
 72 | }
 73 | class Union {
 74 |         private Union parent;
 75 |         private int rank;
 76 |         public Union(){
 77 |             parent = this;
 78 |             rank = 0;
 79 |         }
 80 | 
 81 |     public static Union find(Union x) {
 82 |         if (x.parent != x) {
 83 |             x.parent = find(x.parent);
 84 |             x = x.parent;
 85 |         }
 86 |         return x.parent;
 87 |     }
 88 |     public static void Union(Union x, Union y) {
 89 |         Union xRoot = find(x);
 90 |         Union yRoot = find(y);
 91 |         if(xRoot== yRoot)
 92 |             return;
 93 |         if(xRoot.rank < yRoot.rank)
 94 |             xRoot.parent = yRoot;
 95 |         else if(xRoot.rank > yRoot.rank)
 96 |             yRoot.parent = xRoot;
 97 |         else{
 98 |             yRoot.parent = xRoot;
 99 |             xRoot.rank = xRoot.rank + 1;
100 |         }
101 | 
102 |     }
103 |     public static void main(String[] args) throws Exception {
104 |             EdgeW e0 = new EdgeW(0,1,2);
105 |             EdgeW e1 = new EdgeW(1,2,12);
106 |             EdgeW e2 = new EdgeW(2,3,2);
107 |             EdgeW e3 = new EdgeW(2,4,5);
108 |             EdgeW e4 = new EdgeW(3,4,1);
109 |             EdgeW e5 = new EdgeW(3,5,3);
110 |             EdgeW e6 = new EdgeW(3,1,11);
111 |             EdgeW e7 = new EdgeW(2,5,8);
112 |             HashMap<Integer, HashMap<Integer, EdgeW>> g = new LinkedHashMap<>();
113 |             for (int i = 0;i<6;i++){
114 |                 g.put(i,new HashMap<>());
115 |             }
116 |             g.get(0).put(1,e0);
117 |             g.get(1).put(2,e1);
118 |             g.get(2).put(3,e2);
119 |             g.get(2).put(4,e3);
120 |             g.get(3).put(4,e4);
121 |             g.get(3).put(5,e5);
122 |             g.get(3).put(1,e6);
123 |             g.get(2).put(5,e7);
124 |             Kruskal k = new Kruskal();
125 |         HashMap<Integer, HashMap<Integer, EdgeW>> ans = k.kruskel(g);
126 |         for (int i = 0; i<6;i++ ){
127 |             if (ans.get(i)!=null)
128 |                 for (EdgeW e:ans.get(i).values()){
129 |                     System.out.print(e+" ");
130 |                 }
131 |         }
132 |     }
133 | }
134 | 
135 | 


--------------------------------------------------------------------------------
/src/BucketsProblem.java:
--------------------------------------------------------------------------------
  1 | import java.util.Arrays;
  2 | 
  3 | public class BucketsProblem {
  4 |     private int sizeBucketA;
  5 |     private int sizeBucketB;
  6 |     private boolean[][] neighborMatrix;
  7 |     private boolean[][] trackMatrix;
  8 |     private String[][] theTrac;
  9 |     public BucketsProblem(int sizeBucketA,int sizeBucketB){
 10 |         this.sizeBucketA = sizeBucketA;
 11 |         this.sizeBucketB = sizeBucketB;
 12 |         int m = sizeBucketA+1;
 13 |         int n = sizeBucketB+1;
 14 |         neighborMatrix = new boolean[n*m][n*m];
 15 |         createTable();
 16 |         trackMatrix = new boolean[n*m][n*m];
 17 |         theTrac = new String[n*m][n*m];
 18 |         createTraks();
 19 |     }
 20 | 
 21 |     private void createTable() {
 22 |         int m = sizeBucketA;
 23 |         int n = sizeBucketB;
 24 |         for (int k = 0; k < neighborMatrix.length; k++){
 25 |             int capacityA = k / (n + 1);
 26 |             int capacityB = k % (n + 1);
 27 |             neighborMatrix[k][k]=true;
 28 |             int index = 0;
 29 | 
 30 |             index = emptyA(capacityA,capacityB);
 31 |             neighborMatrix[k][index] = true;
 32 | 
 33 |             index = emptyB(capacityA,capacityB);
 34 |             neighborMatrix[k][index] = true;
 35 | 
 36 |             index = fillA(capacityA,capacityB);
 37 |             neighborMatrix[k][index] = true;
 38 | 
 39 |             index = fillB(capacityA,capacityB);
 40 |             neighborMatrix[k][index] = true;
 41 | 
 42 |             index = AtoB(capacityA,capacityB);
 43 |             neighborMatrix[k][index] = true;
 44 | 
 45 |             index = BtoA(capacityA,capacityB);
 46 |             neighborMatrix[k][index] = true;
 47 |         }
 48 |     }
 49 |     int emptyA(int capacityA,int capacityB){
 50 |         return capacityB;
 51 |     }
 52 |     int emptyB(int capacityA,int capacityB){
 53 |         int n = (sizeBucketB+1);
 54 |         return capacityA * n;
 55 |     }
 56 |     int fillA(int capacityA,int capacityB){
 57 |         int n = (sizeBucketB+1);
 58 |         return n * sizeBucketA + capacityB;
 59 |     }
 60 |     int fillB(int capacityA,int capacityB){
 61 |         int n = (sizeBucketB+1);
 62 |         return n * capacityA + sizeBucketB;
 63 |     }
 64 |     int AtoB(int capacityA, int capacityB){
 65 |         int n = (sizeBucketB+1);
 66 |         int j = Math.min(capacityB+capacityA,sizeBucketB);
 67 |         int i = capacityB+capacityA - j;
 68 |         return n * i + j;
 69 |     }
 70 |     int BtoA(int capacityA, int capacityB){
 71 |         int n = (sizeBucketB+1);
 72 |         int i = Math.min(capacityB+capacityA,sizeBucketA);
 73 |         int j = capacityB+capacityA - i;
 74 |         return n * i + j;
 75 | 
 76 |     }
 77 | 
 78 |     private void createTraks() {
 79 |         for (int i = 0; i < neighborMatrix.length; i++) {
 80 |             int cA = i / (sizeBucketB + 1);
 81 |             int cB = i % (sizeBucketB + 1);
 82 |             String s2 = "(" + cA + " ," + cB + ")";
 83 |             for (int j = 0; j < neighborMatrix[i].length; j++) {
 84 |                 int capacityA = j / (sizeBucketB + 1);
 85 |                 int capacityB = j % (sizeBucketB + 1);
 86 |                 String s = s2 + " -> (" + capacityA + " ," + capacityB + ")";
 87 |                 if (cA == capacityA && cB == capacityB) {
 88 |                     theTrac[i][j] = s2;
 89 |                 } else if (neighborMatrix[i][j]) {
 90 |                     theTrac[i][j] = s + "";
 91 |                 }
 92 |             }
 93 |         }
 94 |         for (int k = 0; k < neighborMatrix.length; k++) {
 95 |             for (int i = 0; i < neighborMatrix.length; i++) {
 96 |                 for (int j = 0; j < neighborMatrix[i].length; j++) {
 97 |                         trackMatrix[i][j] = (neighborMatrix[i][j] || (neighborMatrix[i][k] && neighborMatrix[k][j])) || (trackMatrix[i][j] || (trackMatrix[i][k] && trackMatrix[k][j]));
 98 |                 }
 99 |             }
100 |         }
101 |         int go = 1;
102 |         boolean[][] fill = new boolean[neighborMatrix.length][neighborMatrix.length];
103 |         while (go>0) {
104 |             for (int k = 0; k < neighborMatrix.length; k++) {
105 |                 for (int i = 0; i < neighborMatrix.length; i++) {
106 |                     for (int j = 0; j < neighborMatrix[i].length; j++) {
107 |                         if (!neighborMatrix[i][j] && trackMatrix[i][j] && (theTrac[i][j] == null || i == j)) {
108 |                             if (theTrac[i][k] != null && theTrac[k][j] != null && !fill[i][j]) {
109 |                                 fill[i][j] = true;
110 |                                 theTrac[i][j] = theTrac[i][k] + " -> " + theTrac[k][j];
111 |                             }
112 |                             else go++;
113 |                         }
114 | 
115 | 
116 |                     }
117 |                 }
118 |             }
119 |             go--;
120 |         }
121 | 
122 |     }
123 | 
124 | 
125 | 
126 |     public  void printM(boolean[][] arr){
127 |         String[] arrayS = new String[arr.length];
128 |         for (int i = 0; i<arr.length;i++) {
129 |             int capacityA = i / (sizeBucketB + 1);
130 |             int capacityB = i % (sizeBucketB + 1);
131 |             String s = "("+ capacityA+ " ," + capacityB + ")";
132 |             arrayS[i] = s;
133 |         }
134 |         System.out.println("      " + Arrays.toString(arrayS));
135 |         for (int i = 0; i<arr.length;i++){
136 |             int capacityA = i / (sizeBucketB + 1);
137 |             int capacityB = i % (sizeBucketB + 1);
138 |             String s = "("+ capacityA+ " ," + capacityB + ")";
139 |             System.out.println(s + " " + Arrays.toString(arr[i]));
140 |         }
141 |     }
142 |     public  void printM(String[][] arr){
143 |         String[] arrayS = new String[arr.length];
144 |         for (int i = 0; i<arr.length;i++) {
145 |             int capacityA = i / (sizeBucketB + 1);
146 |             int capacityB = i % (sizeBucketB + 1);
147 |             String s = "("+ capacityA+ " ," + capacityB + ")";
148 |             arrayS[i] = s;
149 |         }
150 |         System.out.println("      " + Arrays.toString(arrayS));
151 |         for (int i = 0; i<arr.length;i++){
152 |             int capacityA = i / (sizeBucketB + 1);
153 |             int capacityB = i % (sizeBucketB + 1);
154 |             String s = "("+ capacityA+ " ," + capacityB + ")";
155 |             System.out.println(s + " " + Arrays.toString(arr[i]));
156 |         }
157 |     }
158 |     public static void main(String[] args){
159 |         BucketsProblem bucketsProblem = new BucketsProblem(3,5);
160 | //        bucketsProblem.printM(bucketsProblem.trackMatrix);
161 | //        bucketsProblem.printM(bucketsProblem.theTrac);
162 |         System.out.println(bucketsProblem.theTrac[0][4]);
163 |     }
164 | 
165 | 
166 | }
167 | 


--------------------------------------------------------------------------------
/src/BFS.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | 
  3 | public class BFS {
  4 |     private Graph graph;
  5 |     private int size;
  6 |     private enum Color
  7 |         {
  8 |             WHITE,
  9 |             GRAY,
 10 |             BLACK
 11 |         }
 12 |     private Color[] color;
 13 |     private int[] d;
 14 |     private int[] pi;
 15 |     private Tree tree;
 16 |     public BFS(Graph g){
 17 |         this.graph = g;
 18 |     }
 19 |     private void reInit() {
 20 |         this.size = graph.size();
 21 |         color = new Color[size];
 22 |         for (int i = 0 ; i<color.length;i++) {
 23 |             color[i] = Color.WHITE;
 24 |         }
 25 |         d = new int[size];
 26 |         for (int i = 0 ; i<d.length;i++){
 27 |             d[i] = Integer.MAX_VALUE;
 28 |         }
 29 |         pi = new int[size];
 30 |         for (int i = 0 ; i<pi.length;i++){
 31 |             pi[i] = -1;
 32 |         }
 33 |     }
 34 |     public void bfs(int id) {
 35 |         reInit();
 36 |         Queue<Integer> queue = new LinkedList<>();
 37 |         queue.add(id);
 38 |         color[id] = Color.GRAY;
 39 |         d[id] = 0;
 40 |         queue.add(id);
 41 |         while (!queue.isEmpty()){
 42 |             int v = queue.poll();
 43 |             Collection<edge_data> temp = graph.getEdges(v);
 44 |             if (temp != null)
 45 |                 for (edge_data e: temp){
 46 |                     int u = e.getDst();
 47 |                     if (color[u] == Color.WHITE){
 48 |                         color[u] = Color.GRAY;
 49 |                         d[u] = d[v] + 1;
 50 |                         pi[u] = v;
 51 |                         queue.add(u);
 52 |                     }
 53 |                 }
 54 |             color[v] = Color.BLACK;
 55 |         }
 56 | 
 57 |     }
 58 |     public boolean connected(){
 59 |         bfs(1);
 60 |         int sum = 0;
 61 |         for (int i:pi){
 62 |             if (i == -1)
 63 |                 sum++;
 64 |         }
 65 |         return sum == 2;//include in place 0
 66 |     }
 67 |     private void reBfsNoReinit(int id) {
 68 |         Queue<Integer> queue = new LinkedList<>();
 69 |         queue.add(id);
 70 |         color[id] = Color.GRAY;
 71 |         d[id] = 0;
 72 |         queue.add(id);
 73 |         while (!queue.isEmpty()) {
 74 |             int v = queue.poll();
 75 |             Collection<edge_data> temp = graph.getEdges(v);
 76 |             if (temp != null)
 77 |                 for (edge_data e : temp) {
 78 |                     int u = e.getDst();
 79 |                     if (color[u] == Color.WHITE) {
 80 |                         color[u] = Color.GRAY;
 81 |                         d[u] = d[v] + 1;
 82 |                         pi[u] = v;
 83 |                         queue.add(u);
 84 |                     }
 85 |                 }
 86 |             color[v] = Color.BLACK;
 87 |         }
 88 |     }
 89 |     private void fillTable(int[] what, int sine){
 90 |         for (int i = 1; i<what.length;i++){
 91 |             if (color[i]==Color.BLACK && what[i] == 0)
 92 |                 what[i] = sine;
 93 |         }
 94 |     }
 95 |     public int linksCounter(){
 96 |         bfs(1);
 97 |         if (connected()) return 1;
 98 |         //not connected --> more than one
 99 |         int sum = 1;
100 |         int[] what = new int[size];
101 |         fillTable(what,sum);
102 |         for (int i = 1; i < color.length; i++){
103 |             if (color[i] == Color.WHITE){
104 |                 sum ++;
105 |                 reBfsNoReinit(i);
106 |                 fillTable(what,sum);
107 |             }
108 |         }
109 |         System.out.println(Arrays.toString(what));
110 |         return sum;
111 |     }
112 |     private int getMaxD(boolean maxORindex){
113 |         int max = -1;
114 |         int index = -1;
115 |         for (int i = 1;i < d.length;i++){
116 |             if (d[i] > max) {
117 |                 max = d[i];
118 |                 index = i;
119 |             }
120 |         }
121 |         if (maxORindex)
122 |             return max;
123 |         else return index;
124 |     }
125 |     public int findDiam(){ //O(|V| * |V+E|)
126 |         int max = -1;
127 |         for (int i = 1; i <size;i++){
128 |             bfs(i);
129 |             int temp = getMaxD(true);
130 |             if (max < temp)
131 |                 max = temp;
132 |         }
133 |         return max;
134 |     }
135 |     public int findDiamEfficient(){// O(|V+E|)
136 |         bfs(1);
137 |         int indexMax = getMaxD(false);
138 |         bfs(indexMax);
139 |         return getMaxD(true);
140 |     }
141 |     public List<Integer> path(int src,int dst){
142 |         bfs(src);
143 |         if (d[dst] == -1) {
144 |             System.out.println("no path");
145 |             return null;
146 |         }
147 |         System.out.println("the distance between " + src+" to " + dst + " is  = "+d[dst]);
148 |         List<Integer> path = new LinkedList<>();
149 |         int current = dst;
150 |         while (current != -1){
151 |             path.add(current);
152 |             current = pi[current];
153 |         }
154 |         return path;
155 | 
156 | 
157 |     }
158 |     private int findHead() {
159 |         for (int i=1; i<size;i++){
160 |             if (graph.getEdges(i)!=null){
161 |                 if (graph.getEdges(i).size()==1)
162 |                     return i;
163 |             }
164 |         }
165 |         return -1;
166 |     }
167 |     public boolean isTree(){
168 |         if (linksCounter()!=1)
169 |             return false;
170 |         return graph.size()-1 == 2*graph.getSizeE();
171 |     }
172 |     class Tree{
173 |         int diameter;
174 |         int radius;
175 |         int[] center = new int[2];
176 |         boolean even;
177 |     }
178 |     public boolean fillTree(){
179 |         int[] handler = new int[size];
180 |         boolean leftOneOrTow = false;
181 |         handler[0] = -1;
182 |         if (!isTree())
183 |             return false;
184 |         tree = new Tree();
185 |         Graph g =new Graph(graph);
186 |         int sum = 0;
187 |         boolean even = true;
188 |         while (!leftOneOrTow){
189 |             sum++;
190 |             int left = 0;
191 |             for (int i=1; i<handler.length;i++){
192 |                 if (handler[i] != -1 && g.isLeaf(i)) {
193 |                     g.removeNode(i);
194 |                     handler[i] = -1;
195 |                 }
196 |                 else left++;
197 |             }
198 |             leftOneOrTow = left == 1 || left == 2;
199 |             even = left == 1;
200 |         }
201 |         tree.even = even;
202 |         if (even){
203 |             tree.radius = sum;
204 |             tree.diameter = 2*tree.radius;
205 |         }
206 |         else {
207 |             tree.radius = sum+1;
208 |             tree.diameter = tree.radius*2-1;
209 |         }
210 |         return true;
211 |     }
212 | 
213 | 
214 | 
215 |     public static void main(String [] args){
216 |         Graph g = new Graph();
217 |         for (int i=0; i<7 ; i++)
218 |             g.addNode();
219 |         g.add2Edge(1,2);
220 |         g.add2Edge(2,3);
221 |         g.add2Edge(3,4);
222 |         g.add2Edge(1,5);
223 |         g.add2Edge(1,6);
224 |         g.add2Edge(6,7);
225 |         //temp
226 | //        g.add2Edge(3,5);
227 | //        g.add2Edge(5,6);
228 | 
229 |         BFS bfs1 = new BFS(g);
230 |         System.out.println(bfs1.linksCounter());
231 |         System.out.println("diam = " + bfs1.findDiam()); // (diam = 5) 4--3--2--1--6--7
232 |         System.out.println("diam = " +bfs1.findDiamEfficient() +" but in O(|V+E|)");
233 |         //temp
234 | //        System.out.println(bfs1.path(6,3));
235 | 
236 | 
237 |     }
238 | 
239 | 
240 | }
241 | 


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