GATE-CS-2004 problem 1

This is a classic problem in computer science and it tests the knowledge and understanding of data structures, algorithms and problem-solving skills. It is a good challenge for programmers who are preparing for interviews or competitive exams.

Problem Statement

Given an undirected graph represented as an adjacency matrix and two vertices s and t, find the number of distinct paths from s to t that do not contain any vertex more than once.

Solution

This problem can be solved using Dynamic Programming. Let dp[i][j] be the number of distinct paths from vertex i to vertex j that do not contain any vertex more than once. The base case is when i=j, in which case dp[i][j]=1.

The recurrence relation is as follows:

dp[i][j] = sum(dp[i][k] * dp[k][j]) if A[i][j] == 1 and i != k != j
dp[i][j] = 0 otherwise

where A is the adjacency matrix of the graph.

The final answer is dp[s][t].

The time complexity of this solution is O(n^3) where n is the number of vertices in the graph.

Implementation

Here is the python code for the solution:

def count_paths(A, s, t):
    n = len(A)
    dp = [[0 for j in range(n)] for i in range(n)]
    for i in range(n):
        dp[i][i] = 1
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if A[i][j] == 1 and i != k and j != k:
                    dp[i][j] += dp[i][k] * dp[k][j]
    return dp[s][t]

Conclusion

This problem is a good exercise for programmers to improve their understanding of Dynamic Programming and Graph algorithms. It is a classic problem that has practical applications in network routing, recommendation systems and social network analysis.