From 1275d5150f3c637d6a1ce20e865a6fade8c8cbfa Mon Sep 17 00:00:00 2001
From: Abhishek Nalla <nalla.abhishek2@gmail.com>
Date: Sat, 16 Dec 2017 21:47:47 +0530
Subject: [PATCH] added greedy algos

---
 .../Greedy/KruskalMst/Kruskal.cpp             |  72 +++++++++++
 .../Greedy/KruskalMst/Readme.md               |  23 ++++
 Competitive Coding/Greedy/PrimMst/Prim.cpp    | 121 ++++++++++++++++++
 Competitive Coding/Greedy/PrimMst/Readme.md   |  34 +++++
 .../Greedy/activitySelection/Readme.md        |  16 +++
 .../activitySelection/activitySelection.cpp   |  38 ++++++
 .../Greedy/huffmanCoding/Readme.md            |  43 +++++++
 .../Greedy/huffmanCoding/huffmanCoding.py     | 118 +++++++++++++++++
 .../Greedy/jobSequencing/Readme.md            |  23 ++++
 .../Greedy/jobSequencing/jobSequencing.cpp    |  51 ++++++++
 .../Greedy/travellingSalesman/Readme.md       |  38 ++++++
 .../travellingSalesman/travellingSalesman.c   |  55 ++++++++
 12 files changed, 632 insertions(+)
 create mode 100644 Competitive Coding/Greedy/KruskalMst/Kruskal.cpp
 create mode 100644 Competitive Coding/Greedy/KruskalMst/Readme.md
 create mode 100644 Competitive Coding/Greedy/PrimMst/Prim.cpp
 create mode 100644 Competitive Coding/Greedy/PrimMst/Readme.md
 create mode 100644 Competitive Coding/Greedy/activitySelection/Readme.md
 create mode 100644 Competitive Coding/Greedy/activitySelection/activitySelection.cpp
 create mode 100644 Competitive Coding/Greedy/huffmanCoding/Readme.md
 create mode 100644 Competitive Coding/Greedy/huffmanCoding/huffmanCoding.py
 create mode 100644 Competitive Coding/Greedy/jobSequencing/Readme.md
 create mode 100644 Competitive Coding/Greedy/jobSequencing/jobSequencing.cpp
 create mode 100644 Competitive Coding/Greedy/travellingSalesman/Readme.md
 create mode 100644 Competitive Coding/Greedy/travellingSalesman/travellingSalesman.c

diff --git a/Competitive Coding/Greedy/KruskalMst/Kruskal.cpp b/Competitive Coding/Greedy/KruskalMst/Kruskal.cpp
new file mode 100644
index 000000000..cacd8de00
--- /dev/null
+++ b/Competitive Coding/Greedy/KruskalMst/Kruskal.cpp	
@@ -0,0 +1,72 @@
+#include<bits/stdc++.h>
+using namespace std;
+bool vis[100];
+int arr[100],size[100];
+#define piii pair<int,pair<int,int> >
+class mycmp{
+	public:
+		bool operator()(piii p1,piii p2)
+		{
+			return p1.first>p2.first;
+		}
+};
+int root(int x)
+{
+	while(arr[x]!=x)
+	{
+		arr[x]=arr[arr[x]];
+		x=arr[x];
+	}
+	return x;
+}
+bool find(int x,int y)
+{
+	int rootx=root(x),rooty=root(y);
+	return rootx==rooty;
+}
+void union1(int x,int y)
+{
+	int rootx=root(x);
+	int rooty=root(y);
+	if(size[rootx]<size[rooty])
+	{
+		arr[rootx]=rooty;
+		size[rooty]+=size[rootx];
+	}
+	else
+	{
+		arr[rooty]=rootx;
+		size[rootx]+=size[rooty];
+	}
+}
+int main()
+{
+	printf("Enter no of vertices and no of edges\n");
+	int n,m,i;cin>>n>>m;
+	for(i=1;i<=n;i++)
+	{
+		arr[i]=i;
+		size[i]=1;
+	}
+	printf("Enter\nsrc dest weight\n");
+	priority_queue<piii,vector<piii>,mycmp>pq;
+	for(i=1;i<=m;i++)
+	{
+		int u,v,w;cin>>u>>v>>w;
+		pq.push({w,{u,v}});
+	}
+	int sum=0;
+	while(!pq.empty())
+	{
+		piii p=pq.top();
+		pq.pop();
+		int w=p.first,fir=p.second.first,sec=p.second.second;
+		if(find(fir,sec)==false)
+		{
+			sum+=w;
+			union1(fir,sec);
+		}
+	}
+	printf("weight of MST\n");
+	cout<<sum<<endl;
+}
diff --git a/Competitive Coding/Greedy/KruskalMst/Readme.md b/Competitive Coding/Greedy/KruskalMst/Readme.md
new file mode 100644
index 000000000..c6d57f3b7
--- /dev/null
+++ b/Competitive Coding/Greedy/KruskalMst/Readme.md	
@@ -0,0 +1,23 @@
+Given a connected and undirected graph, a spanning tree of that graph is a subgraph that is a tree and connects all the vertices together. A single graph can have many different spanning trees. A minimum spanning tree (MST) or minimum weight spanning tree for a weighted, connected and undirected graph is a spanning tree with weight less than or equal to the weight of every other spanning tree. The weight of a spanning tree is the sum of weights given to each edge of the spanning tree.
+
+
+Below are the steps for finding MST using Kruskal’s algorithm
+
+1. Sort all the edges in non-decreasing order of their weight.
+2. Pick the smallest edge. Check if it forms a cycle with the spanning tree formed so far. If cycle is not formed, include this edge. Else, discard it.
+3. Repeat step#2 until there are (V-1) edges in the spanning tree.
+
+The step#2 uses Union-Find algorithm to detect cycle.
+
+The algorithm is a Greedy Algorithm. The Greedy Choice is to pick the smallest weight edge that does not cause a cycle in the MST constructed so far.
+
+
+Example:
+4 5
+0 1 10
+0 2 6
+0 3 5
+1 3 15
+2 3 4
+
+Output: 19
diff --git a/Competitive Coding/Greedy/PrimMst/Prim.cpp b/Competitive Coding/Greedy/PrimMst/Prim.cpp
new file mode 100644
index 000000000..be41cee1c
--- /dev/null
+++ b/Competitive Coding/Greedy/PrimMst/Prim.cpp	
@@ -0,0 +1,121 @@
+#include<iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+// declare a class for graph
+
+struct Edge{
+	int src,dest,weight;
+};
+
+class Graph{
+	int V,E;
+	vector<Edge> edge;  // an array of all the edges
+	public:
+	Graph(int v, int e);
+	void addEdge(int src, int dest, int weight);
+	void mst();
+};
+
+Graph::Graph(int v, int e){
+	V=v;
+	E=e;
+}
+
+void Graph::addEdge(int src, int dest, int weight){
+	Edge *e= new Edge;
+	e->src= src;
+	e->dest= dest;
+	e->weight= weight;
+	edge.push_back(*e);
+}
+bool comp(Edge e1, Edge e2){
+	return e1.weight<e2.weight ;
+}
+
+struct subset{
+	int parent;
+	int rank;
+};
+// A utility function to find set of an element i
+// (uses path compression technique)
+int find(struct subset subsets[], int i){
+	// find root and make root as parent of i (path compression)
+	if (subsets[i].parent != i)
+		subsets[i].parent = find(subsets, subsets[i].parent);
+	return subsets[i].parent;
+}
+
+// A function that does union of two sets of x and y
+// (uses union by rank)
+void Union(struct subset subsets[], int x, int y)
+{
+	int xroot = find(subsets, x);
+	int yroot = find(subsets, y);
+
+	// Attach smaller rank tree under root of high rank tree
+	// (Union by Rank)
+	if (subsets[xroot].rank < subsets[yroot].rank)
+		subsets[xroot].parent = yroot;
+	else if (subsets[xroot].rank > subsets[yroot].rank)
+		subsets[yroot].parent = xroot;
+	else
+	{
+		subsets[yroot].parent = xroot;
+		subsets[xroot].rank++;
+	}
+}
+
+void Graph::mst(){
+	sort(edge.begin(), edge.end(), comp);
+	//create disjoint set for all vertices
+	struct subset *subsets = new subset[V];
+
+	// Create V subsets with single elements
+	for(int i=0;i<V;i++){
+		subsets[i].parent = i;
+		subsets[i].rank = 0;
+	}
+	vector<Edge> result;
+
+	// Number of edges to be taken is equal to V-1
+	for(auto i=edge.begin(); i!=edge.end();i++){
+		int src= i->src;
+		int dest=i->dest;
+		//if not same root
+		if(find(subsets, src)!= find(subsets, dest)){
+			result.push_back(*i);
+			Union(subsets, src, dest);
+		}
+	}
+	printf("The edges of the MST are\n");
+	for(auto i=result.begin(); i!=result.end(); i++)
+		cout<<i->src<<"--"<<i->dest<<"="<<i->weight<<endl;
+	return;
+}
+
+int main(){
+	int V;  // Number of vertices in graph
+	int E;
+	printf("Enter no of vertices and edges\n");
+	scanf("%d%d",&V,&E); // Number of edges in graph
+	Graph g(V,E);
+	int i,u,v,x;
+	printf("Enter\nsrc dest weight\n");
+	for(i=0;i<E;i++)
+	{
+		scanf("%d%d%d",&u,&v,&x);
+		g.addEdge(u,v,x);
+	}
+	// add edge 0-1
+	/*g.addEdge(0,3,1);
+	g.addEdge(4,5,2);
+	g.addEdge(2,4,5);
+	g.addEdge(3,4,6);
+	g.addEdge(0,1,3);
+	g.addEdge(1,2,1);
+	g.addEdge(2,3,1);
+	g.addEdge(1,3,3);
+	g.addEdge(2,5,4);*/
+	g.mst();
+}
diff --git a/Competitive Coding/Greedy/PrimMst/Readme.md b/Competitive Coding/Greedy/PrimMst/Readme.md
new file mode 100644
index 000000000..e73766da0
--- /dev/null
+++ b/Competitive Coding/Greedy/PrimMst/Readme.md	
@@ -0,0 +1,34 @@
+The idea behind Prim’s algorithm is simple, a spanning tree means all vertices must be connected. So the two disjoint subsets (discussed above) of vertices must be connected to make a Spanning Tree. And they must be connected with the minimum weight edge to make it a Minimum Spanning Tree.
+
+
+Algorithm
+
+1) Create a set mstSet that keeps track of vertices already included in MST.
+2) Assign a key value to all vertices in the input graph. Initialize all key values as INFINITE. Assign key value as 0 for the first vertex so that it is picked first.
+3) While mstSet doesn’t include all vertices
+….a) Pick a vertex u which is not there in mstSet and has minimum key value.
+….b) Include u to mstSet.
+….c) Update key value of all adjacent vertices of u. To update the key values, iterate through all adjacent vertices. For every adjacent vertex v, if weight of edge u-v is less than the previous key value of v, update the key value as weight of u-v.
+
+
+The idea of using key values is to pick the minimum weight edge from cut. The key values are used only for vertices which are not yet included in MST, the key value for these vertices indicate the minimum weight edges connecting them to the set of vertices included in MST.
+
+Example:
+6 9
+0 3 1
+4 5 2
+2 4 5
+3 4 6
+0 1 3
+1 2 1
+2 3 1
+1 3 3
+2 5 4
+
+
+Output :
+0--3=1
+1--2=1
+2--3=1
+4--5=2
+2--5=4
diff --git a/Competitive Coding/Greedy/activitySelection/Readme.md b/Competitive Coding/Greedy/activitySelection/Readme.md
new file mode 100644
index 000000000..f7d580c50
--- /dev/null
+++ b/Competitive Coding/Greedy/activitySelection/Readme.md	
@@ -0,0 +1,16 @@
+You are given n activities with their start and finish times. Select the maximum number of activities that can be performed by a single person, assuming that a person can only work on a single activity at a time.
+
+The greedy choice is to always pick the next activity whose finish time is least among the remaining activities and the start time is more than or equal to the finish time of previously selected activity. We can sort the activities according to their finishing time so that we always consider the next activity as minimum finishing time activity.
+
+1) Sort the activities according to their finishing time
+2) Select the first activity from the sorted array and print it.
+3) Do following for remaining activities in the sorted array.
+…….a) If the start time of this activity is greater than or equal to the finish time of previously selected activity then select this activity and print it.
+
+Example:
+6
+1 3 0 5 8 5
+2 4 6 7 9 9
+
+Output:
+selected activities are 0 1 3 4
diff --git a/Competitive Coding/Greedy/activitySelection/activitySelection.cpp b/Competitive Coding/Greedy/activitySelection/activitySelection.cpp
new file mode 100644
index 000000000..17680db8f
--- /dev/null
+++ b/Competitive Coding/Greedy/activitySelection/activitySelection.cpp	
@@ -0,0 +1,38 @@
+#include<stdio.h>
+
+void selection(int s[], int f[], int n)
+{
+    int i, j;
+    i = 0;
+    printf("%d ", i);
+
+    for (j = 1; j < n; j++)
+    {
+      if (s[j] >= f[i])
+      {
+          printf ("%d ", j);
+          i = j;
+      }
+    }
+}
+
+int main()
+{
+    int n;
+    printf("Enter no of activities\n");
+    scanf("%d",&n);
+    int s[n],f[n],i;
+    printf("Enter the start times of the activities\n");
+    for(i=0;i<n;i++)
+    {
+      scanf("%d",&s[i]);
+    }
+    printf("Enter the finish times of the actvities\n");
+    for(i=0;i<n;i++)
+    {
+      scanf("%d",&f[i]);
+    }
+    printf("Following activities are selected\n");
+    selection(s, f, n);
+    return 0;
+}
diff --git a/Competitive Coding/Greedy/huffmanCoding/Readme.md b/Competitive Coding/Greedy/huffmanCoding/Readme.md
new file mode 100644
index 000000000..9426c0e98
--- /dev/null
+++ b/Competitive Coding/Greedy/huffmanCoding/Readme.md	
@@ -0,0 +1,43 @@
+Huffman coding is a lossless data compression algorithm. The idea is to assign variable-length codes to input characters, lengths of the assigned codes are based on the frequencies of corresponding characters. The most frequent character gets the smallest code and the least frequent character gets the largest code.
+The variable-length codes assigned to input characters are Prefix Codes, means the codes (bit sequences) are assigned in such a way that the code assigned to one character is not prefix of code assigned to any other character. This is how Huffman Coding makes sure that there is no ambiguity when decoding the generated bit stream.
+
+There are mainly two major parts in Huffman Coding
+1) Build a Huffman Tree from input characters.
+2) Traverse the Huffman Tree and assign codes to characters.
+
+
+Steps to build Huffman Tree:
+
+a) Input is array of unique characters along with their frequency of occurrences and output is Huffman Tree.
+
+1. Create a leaf node for each unique character and build a min heap of all leaf nodes (Min Heap is used as a priority queue. The value of frequency field is used to compare two nodes in min heap. Initially, the least frequent character is at root)
+
+2. Extract two nodes with the minimum frequency from the min heap.
+
+3. Create a new internal node with frequency equal to the sum of the two nodes frequencies. Make the first extracted node as its left child and the other extracted node as its right child. Add this node to the min heap.
+
+4. Repeat steps #2 and #3 until the heap contains only one node. The remaining node is the root node and the tree is complete.
+
+b) Steps to print codes from Huffman Tree:
+
+Traverse the tree formed starting from the root. Maintain an auxiliary array. While moving to the left child, write 0 to the array. While moving to the right child, write 1 to the array. Print the array when a leaf node is encountered.
+
+
+
+Example:
+ 6
+ a 5
+ b 9
+ c 12
+ d 13
+ e 16
+ f 45
+
+ Output:
+ character code-word
+ f         0
+ c         100
+ d         101
+ a         1100  
+ b         1101
+ e         111
diff --git a/Competitive Coding/Greedy/huffmanCoding/huffmanCoding.py b/Competitive Coding/Greedy/huffmanCoding/huffmanCoding.py
new file mode 100644
index 000000000..28e7efad5
--- /dev/null
+++ b/Competitive Coding/Greedy/huffmanCoding/huffmanCoding.py	
@@ -0,0 +1,118 @@
+import random
+
+dic = {}
+class MinHeapNode:
+    def setNode(self, left, right, freq, char):
+        self.left = left
+        self.right = right
+        self.freq = freq
+        self.char = char
+        return self
+def huffmanCoding(arr, freq):
+    heapArr = []
+
+    for i in range(len(arr)):
+        heapArr.append(MinHeapNode().setNode(None, None , freq[i], arr[i]))
+        print(heapArr[i].freq, heapArr[i].char)
+
+    while(len(heapArr)>1):
+       left = heapArr.pop(0)
+       right = heapArr.pop(0)
+       insertionSort(heapArr, MinHeapNode().setNode(left, right, left.freq+right.freq, left.char + right.char))
+
+    rootheap= heapArr.pop()
+
+    return rootheap
+
+def printHeap(heap, str):
+    if heap.left != None:
+        printHeap(heap.left, str + '0')
+
+    if heap.right !=None:
+        printHeap(heap.right, str + '1' )
+
+    if heap.left == None:
+        print("character code-word")
+        print(heap.char, str)
+        dic[heap.char] = str
+
+def insertionSort(heapArr, heap):
+    index = len(heapArr)
+    for i in range(len(heapArr)):
+        if heap.freq < heapArr[i].freq:
+           index  = i
+           break
+    heapArr.insert(index, heap)
+
+def makeNewString(arr, freq):
+
+    freqcopy = freq[:]
+    arrcopy = arr[:]
+    strval = ''
+    while len(freqcopy) >0:
+        number = random.randrange(0,len(freqcopy))
+        freqcopy[number] = freqcopy[number]-1
+        strval = strval + arrcopy[number]
+        if freqcopy[number] == 0:
+            freqcopy.pop(number)
+            arrcopy.pop(number)
+
+    return strval
+
+def endcoding(str):
+    strval = ''
+    for i in range(len(str)):
+        strval = strval + dic[str[i]]
+
+    return strval
+
+def huffmandecode(rootheap, strvalencoded):
+
+    index = 0;
+    orgstr = '';
+
+    while index < len(strvalencoded):
+        str = getchar(rootheap, index, strvalencoded)
+        index = index + len(dic[str])
+        orgstr = orgstr + str
+    return orgstr
+
+def getchar(rootheap, index, strvalencoded):
+    if rootheap.left == None:
+        return rootheap.char
+
+    number = int(strvalencoded[index])
+    if number ==0:
+        return getchar(rootheap.left, index+1, strvalencoded)
+
+    if number ==1:
+        return getchar(rootheap.right, index+1, strvalencoded)
+
+
+print("Example input:")
+print("6\na\n5\nb\n9\nc\n12\nd\n13\ne\n16\nf\n45\n")
+text = raw_input("Enter no of characters ")
+text = int(text)
+arr = []
+freq = []
+for i in range(text):
+    arr.append((raw_input("Character ")))
+    freq.append(int(raw_input("Frequency ")))
+
+#    arr[i] = raw_input("character")
+#    freq[i] = raw_input("frequency")
+
+#arr = ['a', 'b', 'c', 'd', 'e', 'f']
+#freq = [5, 9, 12, 13, 16, 45]
+rootheap = huffmanCoding(arr, freq)
+
+printHeap(rootheap, '')
+
+strval  = makeNewString(arr, freq)
+print("org     ", strval)
+
+strvalencoded = endcoding(strval)
+print("encoded ",strvalencoded)
+
+orgencoded = huffmandecode(rootheap, strvalencoded)
+print("decoded ", orgencoded)
diff --git a/Competitive Coding/Greedy/jobSequencing/Readme.md b/Competitive Coding/Greedy/jobSequencing/Readme.md
new file mode 100644
index 000000000..3ba51bc5b
--- /dev/null
+++ b/Competitive Coding/Greedy/jobSequencing/Readme.md	
@@ -0,0 +1,23 @@
+Given an array of jobs where every job has a deadline and associated profit if the job is finished before the deadline. It is also given that every job takes single unit of time, so the minimum possible deadline for any job is 1. How to maximize total profit if only one job can be scheduled at a time.
+
+
+A Simple Solution is to generate all subsets of given set of jobs and check individual subset for feasibility of jobs in that subset. Keep track of maximum profit among all feasible subsets. The time complexity of this solution is exponential.
+
+This is a standard Greedy Algorithm problem. Following is algorithm.
+
+1) Sort all jobs in decreasing order of profit.
+2) Initialize the result sequence as first job in sorted jobs.
+3) Do following for remaining n-1 jobs
+.......a) If the current job can fit in the current result sequence
+          without missing the deadline, add current job to the result.
+	        Else ignore the current job.
+
+Example:
+4
+a 4 20
+b 1 10
+c 1 40
+d 1 30
+
+Output:
+c a
diff --git a/Competitive Coding/Greedy/jobSequencing/jobSequencing.cpp b/Competitive Coding/Greedy/jobSequencing/jobSequencing.cpp
new file mode 100644
index 000000000..a12760ba9
--- /dev/null
+++ b/Competitive Coding/Greedy/jobSequencing/jobSequencing.cpp	
@@ -0,0 +1,51 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+struct job
+{
+	char title;
+	int dead;
+	int profit;
+};
+
+bool compare(job a,job b)
+{
+	return (a.profit > b.profit);
+}
+
+int main()
+{
+	int n;
+	printf("Example Input:\n");
+	printf("4\n");
+	printf("a 4 20\n");
+	printf("b 1 10\n");
+	printf("c 1 40\n");
+	printf("d 1 30\n");
+	printf("Enter no of activities\n");
+	cin>>n;
+	job j[n];
+	printf("Enter\n");
+	printf("JobID  Deadline  Profit\n");
+	for(int i=0;i<n;i++)			//user input
+	{
+		cin>>j[i].title;
+		cin>>j[i].dead;
+		cin>>j[i].profit;
+	}
+	sort(j,j+n,compare);
+	printf("Max sequence of jobs is\n");
+
+	cout<<j[0].title<<" ";			//selecting the first job with highest profit
+	int count=1;					//count of number of jobs completed
+	for(int i=1;i<n;i++)			//look for other jobs within the timeline
+	{
+		if(j[i].dead > count)		//If current job can be accocmodated take it
+		{
+			cout<<j[i].title<<" ";
+			count++;
+		}
+	}
+	return 0;
+}
diff --git a/Competitive Coding/Greedy/travellingSalesman/Readme.md b/Competitive Coding/Greedy/travellingSalesman/Readme.md
new file mode 100644
index 000000000..52d35adc1
--- /dev/null
+++ b/Competitive Coding/Greedy/travellingSalesman/Readme.md	
@@ -0,0 +1,38 @@
+Travelling Salesman Problem (TSP): Given a set of cities and distance between every pair of cities, the problem is to find the shortest possible route that visits every city exactly once and returns to the starting point.
+The problem is a famous NP hard problem. There is no polynomial time know solution for this problem.
+
+
+Following are different solutions for the traveling salesman problem.
+
+a) Naive Solution:
+
+1) Consider city 1 as the starting and ending point.
+2) Generate all (n-1)! Permutations of cities.
+3) Calculate cost of every permutation and keep track of minimum cost permutation.
+4) Return the permutation with minimum cost.
+
+
+b) Dynamic Programming:
+
+Let the given set of vertices be {1, 2, 3, 4,….n}. Let us consider 1 as starting and ending point of output. For every other vertex i (other than 1), we find the minimum cost path with 1 as the starting point, i as the ending point and all vertices appearing exactly once. Let the cost of this path be cost(i), the cost of corresponding Cycle would be cost(i) + dist(i, 1) where dist(i, 1) is the distance from i to 1. Finally, we return the minimum of all [cost(i) + dist(i, 1)] values. This looks simple so far. Now the question is how to get cost(i)?
+To calculate cost(i) using Dynamic Programming, we need to have some recursive relation in terms of sub-problems. Let us define a term C(S, i) be the cost of the minimum cost path visiting each vertex in set S exactly once, starting at 1 and ending at i.
+We start with all subsets of size 2 and calculate C(S, i) for all subsets where S is the subset, then we calculate C(S, i) for all subsets S of size 3 and so on. Note that 1 must be present in every subset.
+
+If size of S is 2, then S must be {1, i},
+ C(S, i) = dist(1, i)
+Else if size of S is greater than 2.
+ C(S, i) = min { C(S-{i}, j) + dis(j, i)} where j belongs to S, j != i and j != 1.
+
+For a set of size n, we consider n-2 subsets each of size n-1 such that all subsets don’t have nth in them.
+Using the above recurrence relation, we can write dynamic programming based solution. There are at most O(n*2n) subproblems, and each one takes linear time to solve. The total running time is therefore O(n2*2n). The time complexity is much less than O(n!), but still exponential. Space required is also exponential. So this approach is also infeasible even for slightly higher number of vertices.
+
+
+Example:
+3
+1 0 1
+0 1 0
+1 0 1
+
+Output:
+ Tour Cost: 1
+ Tour Path: 0 1 2 0
diff --git a/Competitive Coding/Greedy/travellingSalesman/travellingSalesman.c b/Competitive Coding/Greedy/travellingSalesman/travellingSalesman.c
new file mode 100644
index 000000000..aeabbc8d0
--- /dev/null
+++ b/Competitive Coding/Greedy/travellingSalesman/travellingSalesman.c	
@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include<limits.h>
+#include<math.h>
+#define size 10 //maximum 10 cities
+#define min(a,b) a>b?b:a
+#define sizePOW 1024 // 2^10
+int n,npow,g[size][sizePOW],p[size][sizePOW],adj[size][size];
+int compute(int start,int set)
+{	int masked,mask,result=INT_MAX,temp,i;
+	if(g[start][set]!=-1)
+		return g[start][set];
+	for(i=0;i<n;i++)
+	{
+		mask=(npow-1)-(1<<i);
+		masked=set&mask;
+		if(masked!=set)
+		{
+			temp=adj[start][i]+compute(i,masked);
+			if(temp<result)
+				result=temp,p[start][set]=i;
+		}
+	}
+	return g[start][set]=result;
+}
+void getpath(int start,int set)
+{
+	if(p[start][set]==-1) return;
+	int x=p[start][set];
+	int mask=(npow-1)-(1<<x);
+	int masked=set&mask;
+	printf("%d ",x);
+	getpath(x,masked);
+}
+void TSP()
+{	int i,j;
+	for(i=0;i<n;i++)
+		for(j=0;j<npow;j++)
+			g[i][j]=p[i][j]=-1;
+	for(i=0;i<n;i++)g[i][0]=adj[i][0];
+	int result=compute(0,npow-2);
+	printf("Tour cost:%d\n",result);
+	printf("Tour path:\n0 ");
+	getpath(0,npow-2);
+	printf("0\n");
+}
+int main(void) {
+	int i,j;
+	printf("Enter number of cities\n");
+	scanf("%d",&n);
+	npow=(int)pow(2,n);
+	printf("Enter the adjacency matrix\n");
+	for(i=0;i<n;i++)for(j=0;j<n;j++)scanf("%d",&adj[i][j]);
+	TSP();
+	return 0;
+}