Solutions to Assessment

Size: px

Start display at page:

Download "Solutions to Assessment"

Isaac Porter
5 years ago
Views:

1 Solutions to Assessment 1. Consider a directed weighted graph G containing 7 vertices, labelled from 1 to 7. Each edge in G is of the form e(i,j) where i<j(direction is from i to j). In addition, i is odd and j is even or i is even and j is odd. The Weight of e(i,j) is equal to i+j. Assume that we are computing the shortest path from 1 to all the remaining vertices using Dijkstra s algorithm. Which vertex will precede 7 in the shortest path from 1 to 7. Ans: 2 2.Suppose we run Dijkstra s single source shortest-path algorithm on the following edge weighted directed graph with vertex P as the source. What is the order of the vertices in which the shortest path is found by the algorithm? a) P, Q, R, S, T, U b) P, Q, R, U, S, T c) P, Q, R, U, T, S d) P, Q, T, R, U, S Answer: b 3. Dijkstra s single source shortest path algorithm when run from vertex a in the below graph, computes the correct shortest path distance to: a)only vertex a b)only vertices a,e,f,g,h c)only vertices a,b,c,d

2 d)all the vertices Ans: d 4. In an unweighted, undirected connected graph, the shortest path from a node S to every other node is computed most efficiently, in terms of time complexity by: a) Dijkstra's algorithm starting from A b) Warshall's algorithm c) Performing a dfs starting from S d) Performing a bfs starting from S Ans: d 5.Given a weighted graph where weights of all edges are unique (no two edge have same weights), there is always a unique shortest path from a source to destination in such a graph. a) Yes b) No Ans: b

3 Solutions to Programming Assignments Question 1: Implement Dijkstra s Algorithm in the method SSSP() given below. You are supposed to use two arrays dist[] and vertexincluded[] whose description is given in the comments in SSSP() method. The other required methods are given in the code and are explained in the comments. Input: The first line contains the number of vertices (V in number) and number of edges (E in number) separated by a space. E lines will follow, each containing 3 integers in the following format: v1 v2 d where, v1 and v2 are the two vertices having an undirected edge of length d between them. The vertex numbers will range from 0 to V-1. Output: A list of integers separated by spaces where the ith integer will denote the shortest distance of ith vertex from source. Note that indexing starts from 0 and 0 <= i < V. Constraints: 1<=V<=100 1<=E<=100 1<=d<=100 Test Cases: Public test cases: Input Output

4 Private test cases: Input Output

6 Solution: #include <stdio.h> #include <limits.h> #include<stdlib.h> /* This function returns the index of the vertex which is not included in the shortest path right now and has the smallest distance from the source. */ int minimumdist(int dist[], int vertexincluded[],int V) int min = INT_MAX, min_index; int v =0; for (v = 0; v < V; v++) if (vertexincluded[v] == 0 && dist[v] <= min) min = dist[v]; min_index = v; return min_index; /** This function prints the shortest distance of each vertex from the source separated by spaces */ int printsolution(int dist[], int V) int i=0; for ( i = 0; i < V-1; i++) printf("%d ",dist[i]); printf("%d",dist[v-1]); /** This function computes the shortest distance from the src.*/ void SSSP(int **graph, int src,int V) /** dist is the output array. dist[i] will hold the shortest distance from src to i. */ int dist[v]; /** vetexincluded[i] will be 1 if vertex i is included in shortest path tree or shortest distance from src to i is finalized */

7 int vertexincluded[v]; /** You are supposed to write your code from here **/ // Initialize all distances as INFINITE and vertexincluded[] as 0 int i; for (i = 0; i < V; i++) dist[i] = INT_MAX; vertexincluded[i] = 0; // Distance of source vertex from itself is always 0 dist[src] = 0; // Find shortest path for all vertices int count =0 ; for (count = 0; count < V-1; count++) // Pick the minimum distance vertex from the set of vertices not // yet processed. u is always equal to src in first iteration. int u = minimumdist(dist, vertexincluded,v); // Mark the picked vertex as processed vertexincluded[u] = 1; // Update dist value of the adjacent vertices of the picked vertex. int v; for (v = 0; v < V; v++) dist[v]) // Update dist[v] only if is not in vertexincluded, there is an edge from // u to v, and total weight of path from src to v through u is // smaller than current value of dist[v] if (!vertexincluded[v] && graph[u][v] && dist[u]!= INT_MAX && dist[u]+graph[u][v] < dist[v] = dist[u] + graph[u][v]; // print the constructed distance array printsolution(dist, V); // driver program to test above function int main() int V,E; int **graph;

8 // The vertices are numbered from 0 to V-1 scanf("%d %d",&v,&e); graph = (int **)malloc(sizeof(int *)*V); int i=0; for(i=0;i<v;i++) graph[i] = (int *)malloc(sizeof(int)*v); for(i=0;i<e;i++) int s,d,w; scanf("%d%d%d",&s,&d,&w); graph[s][d] = w; graph[d][s] = w; SSSP(graph, 0,V); return 0;

9 Question 2: In the kingdom of NPLand, there are a number of cities. One of them is the capital. Cities are connected to each other through straight roads. Every year a single person from each city gets a chance to work in the capital. The King organizes a competition every year. The rules are as follows: 1. The candidates will start running from their cities. (at the same times) 2. The entry into the capital will be permitted only for a fixed amount of time from when they all start running. 3. Whoever can enter the capital during that fixed time will surely be permitted to work there. Given the connections and the distances between the cities and the capital, the aim is to write a program to find out how many candidates can work in the capital. In designing the program you can assume that the candidates will find a route so that they can get to the capital before the entry closes, if there is one. Note that all the cities are numbered from 0 to V-1. Input: First line will contain the number of cities (V),number of roads (E) and time for which gate will be open (T). E lines will follow, each containing 3 integers in the format: city1 city2 t where, city1 and city2 are the two cities having a road between them and it takes time t to go from one city to another. Note that all the roads are bidirectional and the city numbered 0 is the capital city. Output: A single integer representing number of candidates that can work in the capital Constraints: 1<=V<=100 1<=E<=100 1<=t<=100 Test Cases: Public test cases: Input Output

10 Private test cases: Input Output

12 Solution: #include <stdio.h> #include <limits.h> #include<stdlib.h> /* This function returns the index of the vertex which is not included in the shortest path right now and has the smallest distance from the source. */ int minimumdist(int dist[], int vertexincluded[],int V) int min = INT_MAX, min_index; int v =0; for (v = 0; v < V; v++) if (vertexincluded[v] == 0 && dist[v] <= min) min = dist[v]; min_index = v; return min_index; /** This function computes the shortest distance from the src.*/ int SSSP(int **graph, int src,int V,int T) /** dist is the output array. dist[i] will hold the shortest distance from src to i. */ int dist[v];

13 /** vetexincluded[i] will be 1 if vertex i is included in shortest path tree or shortest distance from src to i is finalized */ int vertexincluded[v]; /** You are supposed to write your code from here **/ // Initialize all distances as INFINITE and stpset[] as 0 int i; for (i = 0; i < V; i++) dist[i] = INT_MAX; vertexincluded[i] = 0; // Distance of source vertex from itself is always 0 dist[src] = 0; // Find shortest path for all vertices int count =0 ; for (count = 0; count < V-1; count++) // Pick the minimum distance vertex from the set of vertices not // yet processed. u is always equal to src in first iteration. int u = minimumdist(dist, vertexincluded,v); // Mark the picked vertex as processed vertexincluded[u] = 1; // Update dist value of the adjacent vertices of the picked vertex. int v; for (v = 0; v < V; v++) // Update dist[v] only if is not in vertexincluded, there is an edge from // u to v, and total weight of path from src to v through u is // smaller than current value of dist[v] if (!vertexincluded[v] && graph[u][v] && dist[u]!= INT_MAX && dist[u]+graph[u][v] < dist[v]) dist[v] = dist[u] + graph[u][v]; // print the constructed distance array int entrycount=0; for(i=0;i<v;i++) if(dist[i] <= T) entrycount++; return entrycount;

14 // driver program to test above function int main() int V,E,T; int **graph; // The vertices are numbered from 0 to V-1 scanf("%d %d %d",&v,&e,&t); graph = (int **)malloc(sizeof(int*)*v); int i=0; for(i=0;i<v;i++) graph[i] = (int *)malloc(sizeof(int)*v); for(i=0;i<e;i++) int s,d,w; scanf("%d%d%d",&s,&d,&w); graph[s][d] = w; graph[d][s] = w; printf("%d",sssp(graph, 0,V,T)); return 0;

Description of The Algorithm

Description of The Algorithm Dijkstra s algorithm works by solving the sub-problem k, which computes the shortest path from the source to vertices among the k closest vertices to the source. For the dijkstra