Python solution using backtracking with explanation
\n######################################################\n\n#   Runtime: 1412ms   -   94.74%\n#   Memory: 14.2MB  -   71.98%\n\n################################
```\n######################################################\n\n#   Runtime: 1412ms   -   94.74%\n#   Memory: 14.2MB  -   71.98%\n\n######################################################\n\nclass Solution:\n    def exist(self, board: List[List[str]], word: str) -> bool:\n        \n        # Below code will help in reducing time complexity significantly.\n        # What below code does is, it creates a set with all chars present in board\n        # and then it will check whether all chars in word are present in board\n        # If a char in word is not present in the board, we can\'t find the word in \n        # board. So we return False\n        # Without these lines of code, I got a Time Complexity of 8000+ ms\n        # After adding these lines of code, my TC reduced to just 1400+ ms\n        # Why this drastic change is, since we are checking all possible strings\n        # using a backtracking paradigm, there will be some cases where we go to so\n        # much deep just to find the required char is not even present in the board\n        # So we are eliminating it before hand.\n        characters = set()\n        for i in range(len(board)):\n            for j in range(len(board[0])):\n                if board[i][j] not in characters: characters.add(board[i][j])\n        \n        for s in word: \n            if s not in characters: return False\n        \n        def dfs(row, col, index, visited):\n            # index represents current index of word string\n            # Checking for out of bounds indices and returning False\n            if row < 0 or row > len(board) - 1 or col < 0 or col > len(board[0]) - 1: return False\n            # If we already visited current cell, return False\n            if (row, col) in visited: return False\n            # If char at cell (row, col) matches with word[index] we go next char\n            # in all the 4 directions\n            if board[row][col] == word[index]:\n                visited.add((row, col))\n                # If we reach end of word return Trur\n                if index == len(word) - 1: return True\n                isExist = (\n                            dfs(row, col - 1, index + 1, visited) or \n                            dfs(row, col + 1, index + 1, visited) or\n                            dfs(row - 1, col, index + 1, visited) or \n                            dfs(row + 1, col, index + 1, visited)\n                       )   \n                # Why we are removing at the end is, we might encounter this cell\n                # again in some other path if this path didn\'t give us required \n                # word. In that path, we haven\'t yet visited the cell right. So, we\n                # are removing it.\n                visited.remove((row, col))\n                return isExist\n            \n            return False\n        \n        # Running DFS when the char in the cell (i,j) matches with word[0] i.e; \n        # starting of the word\n        for i in range(len(board)):\n            for j in range(len(board[0])):\n                if board[i][j] == word[0]:\n                    visited = set()\n                    if dfs(i, j, 0, visited): return True\n        \n        return False\n```
['Backtracking', 'Depth-First Search', 'Python']