├── Dijkstra(single source shortest path).cpp
├── Kruskal's Algo for MST.cpp
├── Prim's Algo for MST.cpp
├── README.md
├── dijkstra.py
├── floyd.py
├── kruskal.py
├── prim.py
└── priodict.py


/Dijkstra(single source shortest path).cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | #define ll long long
  4 | #define ld long double
  5 | #define pb push_back
  6 | #define pf push_front
  7 | #define mp make_pair
  8 | #define F first
  9 | #define S second
 10 | #define mod 1000000007
 11 | #define md 998244353 
 12 | #define INF INT_MAX
 13 | #define vl vector<ll>
 14 | #define vi vector<int>
 15 | #define pi pair<int,int>
 16 | #define pl pair<ll,ll>
 17 | #define vpl vector<pl>
 18 | #define vpi vector<pi>
 19 | #define ml map<ll,ll>
 20 | #define mi map<int,int>
 21 | #define m(a,b) map<a,b>
 22 | #define rep(i,n) for(int i=1;i<=n;i++)
 23 | #define mxn 100005
 24 | #define printfloat(y) cout<<fixed<<setprecision(9)<<y<<endl;
 25 | #define YesNo(f) if(f){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;continue;}
 26 | #define setval(a,val) memset(a,val,sizeof(a)) 
 27 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
 28 | 
 29 | //WORKS IF THERE IS NO NEGATIVE EDGE    WORKING TIME O(nlogn+m)
 30 | 
 31 | vpi adj[mxn];
 32 | ll dist[mxn],parent[mxn];
 33 | void dijkstra(int source){
 34 |     priority_queue<pi> q;
 35 |     bool processed[mxn];
 36 |     setval(processed,false);
 37 |     dist[source]=0;
 38 |     q.push({0,source});
 39 |     while (!q.empty()) {
 40 |         int a=q.top().second; 
 41 |         q.pop();
 42 |         if(processed[a]){
 43 |             continue;
 44 |         }
 45 |         processed[a]=true;
 46 |         for(auto u :adj[a]){
 47 |             int b=u.first;
 48 |             ll w=u.second;
 49 |             if(dist[a]+w<dist[b]){
 50 |                 dist[b]=dist[a]+w;
 51 |                 parent[b]=a;
 52 |                 q.push({-dist[b],b});
 53 |             }
 54 |         }
 55 |     }
 56 | }
 57 | void printPath(int source,int destination){
 58 |     vi path;
 59 |     path.pb(destination);
 60 |     while(destination!=source){
 61 |         path.pb(parent[destination]);
 62 |         destination=parent[destination];
 63 |     }
 64 |     reverse(path.begin(), path.end());
 65 |     for(auto i: path){
 66 |         cout<<i<<" ";
 67 |     }
 68 |     cout<<endl;
 69 | }
 70 | int main()
 71 | {
 72 |     fastIO;
 73 | //    freopen("input.txt","r",stdin);
 74 | //    freopen("output.txt","w",stdout);
 75 |     int t=1;
 76 |     // cin>>t;
 77 |     while(t--){
 78 |         int n,m,source=1,destination;
 79 |         cin>>n>>m;
 80 |         destination=n;
 81 |         for(int j=0;j<m;j++){
 82 |             int a,b;
 83 |             ll w;
 84 |             cin>>a>>b>>w;
 85 |             adj[a].pb(mp(b,w));
 86 |             adj[b].pb(mp(a,w));
 87 |         }
 88 |         for(int i=1;i<=n;i++){
 89 |             dist[i]=1e12;
 90 |         }
 91 |         // cin>>source;  //if source is given
 92 |         // cin>>destination; // if destination is given
 93 |         dijkstra(source);
 94 |         // cout<<dist[n];
 95 |         if(dist[n]==1e12){
 96 |             cout<<-1<<endl;
 97 |         }else{
 98 |             // cout<<dist[n]<<endl;
 99 |             printPath(source,destination);
100 |         }
101 | 
102 |     }
103 | 
104 | return 0;
105 | }


--------------------------------------------------------------------------------
/Kruskal's Algo for MST.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | #define ll long long
  4 | #define ld long double
  5 | #define pb push_back
  6 | #define pf push_front
  7 | #define mp make_pair
  8 | #define F first
  9 | #define S second
 10 | #define mod 1000000007
 11 | #define INF INT_MAX
 12 | #define vl vector<ll>
 13 | #define vi vector<int>
 14 | #define pi pair<int,int>
 15 | #define pl pair<ll,ll>
 16 | #define vpl vector<pl>
 17 | #define vpi vector<pi>
 18 | #define ml map<ll,ll>
 19 | #define mi map<int,int>
 20 | #define m(a,b) map<a,b>
 21 | #define YesNo(f) if(f){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;continue;}
 22 | #define setval(a,val) memset(a,val,sizeof(a)) 
 23 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
 24 | 
 25 | //WORKS BETTER IN SPARSE GRAPH USE PRIM'S ALGO FOR DENSE GRAPH
 26 | // TIME COMPLEXITY ElogE
 27 | 
 28 | struct edge{
 29 | 	int a,b,w;
 30 | };
 31 | bool comp(edge p,edge q){
 32 | 	return p.w<q.w;
 33 | }
 34 | const int mxN=20005;    //1 based node system
 35 | int reprs[mxN];
 36 | int size[mxN];
 37 | int findrep(int n){     //finds representative of a set
 38 | 	return n==reprs[n]?n:reprs[n]=findrep(reprs[n]);//uses path compression
 39 | }
 40 | void unionsets(int x,int y){   //connects two set
 41 | 	int p=findrep(x);		   //joins smaller one to the larger one
 42 | 	int q=findrep(y);
 43 | 	if(size[p]<size[q]){
 44 | 		swap(p,q);
 45 | 	}
 46 | 	size[p]+=size[q];
 47 | 	reprs[q]=p;
 48 | }
 49 | bool ifMakingCycle(int x,int y){  //checks if two nodes are in same set
 50 | 	if(findrep(x)==findrep(y)){   //here used to check formation of cycle
 51 | 		return true;
 52 | 	}
 53 | 	return false;
 54 | }
 55 | 
 56 | int KruskalsMST(vector<edge> edgeList,vector<edge> &mstEdges){
 57 | 	int weight=0;
 58 | 	for(edge i: edgeList){
 59 | 		if(ifMakingCycle(i.a,i.b)){
 60 | 			continue;
 61 | 		}
 62 | 		unionsets(i.a,i.b);
 63 | 		weight+=i.w;
 64 | 		mstEdges.pb(i);
 65 | 	}
 66 | 	return weight;
 67 | }
 68 | 
 69 | int main()
 70 | {
 71 | 	fastIO;
 72 | //	freopen("input.txt","r",stdin);
 73 | //	freopen("output.txt","w",stdout);
 74 | 	int t=1;
 75 | 	// cin>>t;
 76 | 	while(t--){
 77 | 		int n,m,x,y;
 78 | 		cin>>n>>m;
 79 | 		vector<edge> edgeList(m);
 80 | 		for(int j=0;j<m;j++){
 81 | 			cin>>edgeList[j].a>>edgeList[j].b>>edgeList[j].w;
 82 | 		}
 83 | 		sort(edgeList.begin(), edgeList.end(),comp);
 84 | 
 85 | 		for(int i=1;i<=n;i++){
 86 | 			size[i]=1;
 87 | 			reprs[i]=i;
 88 | 		}
 89 | 		vector<edge> mstEdges; //stores edges in the mst
 90 | 		int weight=KruskalsMST(edgeList, mstEdges);  //stores weight of the MST
 91 | 
 92 | 		cout<<weight<<endl;
 93 | 
 94 | 		for(auto i: mstEdges){  //Printing edges in the MST
 95 | 			cout<<i.a<<" "<<i.b<<" "<<i.w<<endl;
 96 | 		}
 97 | 	}
 98 | 
 99 | return 0;
100 | }
101 | /* Testing Graph: 1 
102 | 6 8
103 | 5 6 2
104 | 1 2 3
105 | 3 4 9
106 | 4 6 7
107 | 2 5 6
108 | 2 3 5
109 | 3 6 3
110 | 1 5 5
111 |   Testing Graph: 2 
112 | 6 8
113 | 2 4 2
114 | 4 6 2
115 | 5 3 8
116 | 5 1 7
117 | 1 2 6
118 | 1 3 3
119 | 3 4 3
120 | 3 2 4
121 |  Testing Graph: 3 
122 | 6 9
123 | 5 4 9
124 | 4 3 5
125 | 3 6 8
126 | 6 2 7
127 | 2 1 2
128 | 1 5 4
129 | 1 4 1
130 | 2 4 3
131 | 3 2 3
132 | */


--------------------------------------------------------------------------------
/Prim's Algo for MST.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | #define ll long long
  4 | #define ld long double
  5 | #define pb push_back
  6 | #define pf push_front
  7 | #define mp make_pair
  8 | #define F first
  9 | #define S second
 10 | #define mod 1000000007
 11 | #define INF INT_MAX
 12 | #define vl vector<ll>
 13 | #define vi vector<int>
 14 | #define pi pair<int,int>
 15 | #define pl pair<ll,ll>
 16 | #define vpl vector<pl>
 17 | #define vpi vector<pi>
 18 | #define ml map<ll,ll>
 19 | #define mi map<int,int>
 20 | #define m(a,b) map<a,b>
 21 | #define YesNo(f) if(f){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;continue;}
 22 | #define setval(a,val) memset(a,val,sizeof(a)) 
 23 | #define fastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
 24 | 
 25 | int PrimsMST(int n,vpi adj[],vpi &mstedges){ // 1 based node system
 26 | 
 27 | 	priority_queue< pi,vector<pi>,greater<pi> >q;
 28 | 
 29 | 	int start=1;  //Taking any node to start building the MST
 30 | 	vi weight(n+1,INF);  //ith position stores min value edge ending at i
 31 | 	vpi parent(n+1,mp(-1,INF));	//stores parent of a node in the mst
 32 | 	vi inMST(n+1,false); //stores if node i is included in MST
 33 | 
 34 | 	q.push(mp(0,start)); //starting the MST
 35 | 	weight[start]=0;
 36 | 
 37 | 	while(!q.empty()){
 38 | 		int u=q.top().S;
 39 | 		q.pop();
 40 | 		inMST[u]=true; //includes node u in MST
 41 | 
 42 | 		for(auto i: adj[u]){
 43 | 			int v=i.F;
 44 | 			int w=i.S;
 45 | 			if(!inMST[v] && w<weight[v]){ //makes the weight minimum to
 46 | 				weight[v]=w;				//include node v in MST using 
 47 | 				q.push(mp(w,v));			//included nodes in MST
 48 | 				parent[v]=mp(u,w);
 49 | 			}
 50 | 		}
 51 | 	}
 52 | 	int mstWeight=0;
 53 | 	for(int i=1;i<=n;i++){
 54 | 		if(parent[i].F==-1){
 55 | 			continue;
 56 | 		}
 57 | 		mstWeight+=parent[i].S;
 58 | 		mstedges.pb(mp(i,parent[i].F));
 59 | 	}
 60 | 	return mstWeight;
 61 | }	
 62 | 
 63 | int main()
 64 | {
 65 | 	fastIO;
 66 | //	freopen("input.txt","r",stdin);
 67 | //	freopen("output.txt","w",stdout);
 68 | 	int t=1;
 69 | 	// cin>>t;
 70 | 	while(t--){
 71 | 		int n,m,x,y,w;
 72 | 		cin>>n>>m;
 73 | 		vpi adj[n+1];
 74 | 		for(int i=0;i<m;i++){
 75 | 			cin>>x>>y>>w;
 76 | 			adj[x].pb(mp(y,w));
 77 | 			adj[y].pb(mp(x,w));
 78 | 		}
 79 | 		vpi mstEdges; // stores the edges in MST
 80 | 		int weight=PrimsMST(n,adj,mstEdges); //stores weight of the MST
 81 | 
 82 | 		cout<<weight<<endl;
 83 | 
 84 | 		for(auto i: mstEdges){  //Printing edges in the MST
 85 | 			cout<<i.F<<" "<<i.S<<endl;
 86 | 		}
 87 | 	}
 88 | 
 89 | return 0;
 90 | }
 91 | /* Testing Graph: 1 
 92 | 9 13
 93 | 1 2 4
 94 | 1 8 8
 95 | 2 3 8
 96 | 2 9 11
 97 | 3 4 7
 98 | 3 9 2
 99 | 3 6 4
100 | 4 5 9
101 | 4 6 14
102 | 5 6 10
103 | 6 7 2
104 | 7 9 6
105 | 8 9 7
106 | */


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | #Graph algorithm
 2 | 
 3 | This repository contain some classical graph algorithms like Dijkstra,Floyd.
 4 | 
 5 | 
 6 | ##Usage
 7 | 
 8 | 	git clone https://muzixing/graph_algorithm.git
 9 | 	cd graph_algorithm
10 | 	python dijkstra.py
11 | 
12 | 
13 | 
14 | 


--------------------------------------------------------------------------------
/dijkstra.py:
--------------------------------------------------------------------------------
 1 | def dijkstra(graph,src):
 2 |     length = len(graph)
 3 |     type_ = type(graph)
 4 |     if type_ == list:
 5 |         nodes = [i for i in xrange(length)]
 6 |     elif type_ == dict:
 7 |         nodes = graph.keys()
 8 | 
 9 |     visited = [src]
10 |     path = {src:{src:[]}}
11 |     nodes.remove(src)
12 |     distance_graph = {src:0}
13 |     pre = next = src
14 | 
15 |     while nodes:
16 |         distance = float('inf')
17 |         for v in visited:
18 |              for d in nodes:
19 |                 new_dist = graph[src][v] + graph[v][d]
20 |                 if new_dist <= distance:
21 |                     distance = new_dist
22 |                     next = d
23 |                     pre = v
24 |                     graph[src][d] = new_dist
25 | 
26 | 
27 |         path[src][next] = [i for i in path[src][pre]]
28 |         path[src][next].append(next)
29 | 
30 |         distance_graph[next] = distance
31 | 
32 |         visited.append(next)
33 |         nodes.remove(next)
34 | 
35 |     return distance_graph, path
36 | 
37 | 
38 | if __name__ == '__main__':
39 |     graph_list = [   [0, 2, 1, 4, 5, 1],
40 |             [1, 0, 4, 2, 3, 4],
41 |             [2, 1, 0, 1, 2, 4],
42 |             [3, 5, 2, 0, 3, 3],
43 |             [2, 4, 3, 4, 0, 1],
44 |             [3, 4, 7, 3, 1, 0]]
45 | 
46 |     graph_dict = {  "s1":{"s1": 0, "s2": 2, "s10": 1, "s12": 4, "s5":3},
47 |                     "s2":{"s1": 1, "s2": 0, "s10": 4, "s12": 2, "s5":2},
48 |                     "s10":{"s1": 2, "s2": 1, "s10": 0, "s12":1, "s5":4},
49 |                     "s12":{"s1": 3, "s2": 5, "s10": 2, "s12":0,"s5":1},
50 |                     "s5":{"s1": 3, "s2": 5, "s10": 2, "s12":4,"s5":0},
51 |     }
52 | 
53 |     distance, path = dijkstra(graph_list, 2)
54 |     #print distance, '\n', path
55 |     distance, path = dijkstra(graph_dict, 's1')
56 |     print distance, '\n', path
57 | 


--------------------------------------------------------------------------------
/floyd.py:
--------------------------------------------------------------------------------
 1 | def floyd(graph):
 2 |     length = len(graph)
 3 |     path = {}
 4 | 
 5 |     for i in xrange(length):
 6 |         path.setdefault(i, {})
 7 |         for j in xrange(length):
 8 |             if i == j:
 9 |                 continue
10 | 
11 |             path[i].setdefault(j, [i,j])
12 |             new_node = None
13 | 
14 |             for k in xrange(length):
15 |                 if k == j:
16 |                     continue
17 | 
18 |                 new_len = graph[i][k] + graph[k][j]
19 |                 if graph[i][j] > new_len:
20 |                     graph[i][j] = new_len
21 |                     new_node = k
22 |             if new_node:
23 |                 path[i][j].insert(-1, new_node)
24 | 
25 |     return graph, path
26 | 
27 | def floyd_dict(graph):
28 |     length = len(graph)
29 |     path = {}
30 | 
31 |     for src in graph:
32 |         path.setdefault(src, {})
33 |         for dst in graph[src]:
34 |             if src == dst:
35 |                 continue
36 |             path[src].setdefault(dst, [src,dst])
37 |             new_node = None
38 | 
39 |             for mid in graph:
40 |                 if mid == dst:
41 |                     continue
42 | 
43 |                 new_len = graph[src][mid] + graph[mid][dst]
44 |                 if graph[src][dst] > new_len:
45 |                     graph[src][dst] = new_len
46 |                     new_node = mid
47 |             if new_node:
48 |                 path[src][dst].insert(-1, new_node)
49 | 
50 |     return graph, path
51 | 
52 | 
53 | if __name__ == '__main__':
54 |     ini = float('inf')
55 |     graph_list = [   [0, 2, 1, 4, 5, 1],
56 |             [1, 0, 4, 2, 3, 4],
57 |             [2, 1, 0, 1, 2, 4],
58 |             [3, 5, 2, 0, 3, 3],
59 |             [2, 4, 3, 4, 0, 1],
60 |             [3, 4, 7, 3, 1, 0]]
61 | 
62 |     graph_dict = {  "s1":{"s1": 0, "s2": 2, "s10": 1, "s12": 4},
63 |                     "s2":{"s1": 1, "s2": 0, "s10": 4, "s12": 2},
64 |                     "s10":{"s1": 2, "s2": 1, "s10": 0, "s12":1},
65 |                     "s12":{"s1": 3, "s2": 5, "s10": 2, "s12":0},
66 |     }
67 | 
68 |     #new_graph, path= floyd_dict(graph_dict)    
69 |     new_graph, path = floyd(graph_list)
70 |     print new_graph, '\n\n\n', path
71 | 


--------------------------------------------------------------------------------
/kruskal.py:
--------------------------------------------------------------------------------
 1 | def kruskal(graph):
 2 |     assert type(graph)==dict
 3 | 
 4 |     nodes = graph.keys()   
 5 |     visited = set()
 6 |     path = []
 7 |     next = None
 8 | 
 9 |     while len(visited) < len(nodes):
10 |         distance = float('inf') 
11 |         for s in nodes:
12 |             for d in nodes:
13 |                 if s in visited and d in visited or s == d:
14 |                     continue
15 |                 if graph[s][d] < distance:
16 |                     distance = graph[s][d]
17 |                     pre = s
18 |                     next = d
19 | 
20 |         path.append((pre, next))
21 |         visited.add(pre)
22 |         visited.add(next)
23 | 
24 |     return path
25 | 
26 | 
27 | if __name__ == '__main__':
28 |     graph_dict = {  "s1":{"s1": 0, "s2": 6, "s10": 3, "s12": 4, "s5":3},
29 |                     "s2":{"s1": 1, "s2": 0, "s10": 4, "s12": 3, "s5":4},
30 |                     "s10":{"s1": 2, "s2": 6, "s10": 0, "s12":3, "s5":4},
31 |                     "s12":{"s1": 1, "s2": 5, "s10": 2, "s12":0,"s5":2},
32 |                     "s5":{"s1": 3, "s2": 5, "s10": 7, "s12":4,"s5":0},
33 |     }
34 | 
35 |     path = kruskal(graph_dict)
36 |     print path
37 | 
38 | 


--------------------------------------------------------------------------------
/prim.py:
--------------------------------------------------------------------------------
 1 | def prim(graph, root):
 2 |     assert type(graph)==dict
 3 | 
 4 |     nodes = graph.keys()
 5 |     nodes.remove(root)
 6 |     
 7 |     visited = [root]
 8 |     path = []
 9 |     next = None
10 | 
11 |     while nodes:
12 |         distance = float('inf') 
13 |         for s in visited:
14 |             for d in graph[s]:
15 |                 if d in visited or s == d:
16 |                     continue
17 |                 if graph[s][d] < distance:
18 |                     distance = graph[s][d]
19 |                     pre = s
20 |                     next = d
21 |         path.append((pre, next))
22 |         visited.append(next)
23 |         nodes.remove(next)
24 | 
25 |     return path
26 | 
27 | 
28 | if __name__ == '__main__':
29 |     graph_dict = {  "s1":{"s1": 0, "s2": 2, "s10": 3, "s12": 4, "s5":3},
30 |                     "s2":{"s1": 1, "s2": 0, "s10": 4, "s12": 2, "s5":2},
31 |                     "s10":{"s1": 2, "s2": 6, "s10": 0, "s12":3, "s5":4},
32 |                     "s12":{"s1": 3, "s2": 5, "s10": 2, "s12":0,"s5":2},
33 |                     "s5":{"s1": 3, "s2": 5, "s10": 2, "s12":4,"s5":0},
34 |     }
35 | 
36 |     path = prim(graph_dict, 's12')
37 |     print path
38 | 


--------------------------------------------------------------------------------
/priodict.py:
--------------------------------------------------------------------------------
 1 | # Priority dictionary using binary heaps
 2 | # David Eppstein, UC Irvine, 8 Mar 2002
 3 | 
 4 | from __future__ import generators
 5 | 
 6 | class priorityDictionary(dict):
 7 |     def __init__(self):
 8 |         '''Initialize priorityDictionary by creating binary heap
 9 | of pairs (value,key).  Note that changing or removing a dict entry will
10 | not remove the old pair from the heap until it is found by smallest() or
11 | until the heap is rebuilt.'''
12 |         self.__heap = []
13 |         dict.__init__(self)
14 | 
15 |     def smallest(self):
16 |         '''Find smallest item after removing deleted items from heap.'''
17 |         if len(self) == 0:
18 |             raise IndexError, "smallest of empty priorityDictionary"
19 |         heap = self.__heap
20 |         while heap[0][1] not in self or self[heap[0][1]] != heap[0][0]:
21 |             lastItem = heap.pop()
22 |             insertionPoint = 0
23 |             while 1:
24 |                 smallChild = 2*insertionPoint+1
25 |                 if smallChild+1 < len(heap) and \
26 |                         heap[smallChild] > heap[smallChild+1]:
27 |                     smallChild += 1
28 |                 if smallChild >= len(heap) or lastItem <= heap[smallChild]:
29 |                     heap[insertionPoint] = lastItem
30 |                     break
31 |                 heap[insertionPoint] = heap[smallChild]
32 |                 insertionPoint = smallChild
33 |         return heap[0][1]
34 |     
35 |     def __iter__(self):
36 |         '''Create destructive sorted iterator of priorityDictionary.'''
37 |         def iterfn():
38 |             while len(self) > 0:
39 |                 x = self.smallest()
40 |                 yield x
41 |                 del self[x]
42 |         return iterfn()
43 |     
44 |     def __setitem__(self,key,val):
45 |         '''Change value stored in dictionary and add corresponding
46 | pair to heap.  Rebuilds the heap if the number of deleted items grows
47 | too large, to avoid memory leakage.'''
48 |         dict.__setitem__(self,key,val)
49 |         heap = self.__heap
50 |         if len(heap) > 2 * len(self):
51 |             self.__heap = [(v,k) for k,v in self.iteritems()]
52 |             self.__heap.sort()  # builtin sort likely faster than O(n) heapify
53 |         else:
54 |             newPair = (val,key)
55 |             insertionPoint = len(heap)
56 |             heap.append(None)
57 |             while insertionPoint > 0 and \
58 |                     newPair < heap[(insertionPoint-1)//2]:
59 |                 heap[insertionPoint] = heap[(insertionPoint-1)//2]
60 |                 insertionPoint = (insertionPoint-1)//2
61 |             heap[insertionPoint] = newPair
62 |     
63 |     def setdefault(self,key,val):
64 |         '''Reimplement setdefault to call our customized __setitem__.'''
65 |         if key not in self:
66 |             self[key] = val
67 |         return self[key]


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