- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# Check if a sequence of path visits any coordinate twice or not

In certain applications, we might be interested in checking whether a sequence of path visits any coordinate twice or not. This can be useful, for example, in GPS tracking systems to detect if a vehicle is going back and forth between two points. In this article, we will discuss how to check if a sequence of path visits any coordinate twice or not, along with its implementation in C++.

## Algorithm

To solve this problem, we can use a hash table to keep track of all the coordinates that we have visited so far. We start by visiting the first coordinate in the sequence, and add it to the hash table. Then, for each subsequent coordinate in the sequence, we check if it is already in the hash table. If it is, we know that we have visited this coordinate before and we can return true. If it is not, we add it to the hash table and continue to the next coordinate. If we have visited all coordinates without finding any duplicates, we can return false.

## Example

Here's the implementation of the above algorithm in C++−

#include<bits/stdc++.h> using namespace std; bool isVisitedTwice(int n, int path[][2]) { set<pair<int, int>> visited; for(int i=0;i<n;i++) { // Check if the current coordinate has already been visited if(visited.find(make_pair(path[i][0], path[i][1])) != visited.end()) { return true; } visited.insert(make_pair(path[i][0], path[i][1])); } return false; } int main() { // Test case 1 int path1[5][2] = {{0,0},{1,1},{2,2},{3,3},{4,4}}; if(isVisitedTwice(5, path1)) { cout << "Sequence visits a coordinate twice" << endl; } else { cout << "Sequence does not visit a coordinate twice" << endl; } // Test case 2 int path2[6][2] = {{0,0},{1,1},{2,2},{3,3},{4,4},{3,3}}; if(isVisitedTwice(6, path2)) { cout << "Sequence visits a coordinate twice" << endl; } else { cout << "Sequence does not visit a coordinate twice" << endl; } // Test case 3 int path3[3][2] = {{0,0},{1,1},{2,2}}; if(isVisitedTwice(3, path3)) { cout << "Sequence visits a coordinate twice" << endl; } else { cout << "Sequence does not visit a coordinate twice" << endl; } return 0; }

## Output

Sequence does not visit a coordinate twice Sequence visits a coordinate twice Sequence does not visit a coordinate twice

## Test Case Example

Consider the sequence "UDDLLRUUUDU" representing the path "Up, Down, Down, Left, Left, Right, Up, Up, Down, Up".

We start at the origin (0, 0) and traverse the path, updating our coordinates as we go along.

At each step, we check whether we have already visited the new coordinate before. If yes, we know that the sequence visits a coordinate twice and we return true. If not, we mark the coordinate as visited and continue.

Here is how the algorithm works for the given sequence −

Starting at the origin (0, 0)

**"U"**− Move up to (0, 1). Mark (0, 1) as visited.**"D"**− Move down to (0, 0). Mark (0, 0) as visited.**"D"**− Move down to (0, -1). Mark (0, -1) as visited.**"L"**− Move left to (-1, -1). Mark (-1, -1) as visited.**"L"**− Move left to (-2, -1). Mark (-2, -1) as visited.**"R"**− Move right to (-1, -1). This coordinate has been visited before, so we return true.

Since the sequence visits a coordinate twice, the function returns true.

Therefore, for the given sequence "UDDLLRUUUDU", the function correctly returns that the sequence visits a coordinate twice.

## Conclusion

In this article, we discussed how to check if a sequence of path visits any coordinate twice or not. We used a hash table to keep track of all the coordinates that we have visited so far, and checked for duplicates at each step. We also provided an implementation of this algorithm in C