LeetCode 212. Word Search II

Given a 2D board and a list of words from the dictionary, find all words in the board.

Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.

For example,
Given words = ["oath","pea","eat","rain"] and board =

[
  ['o','a','a','n'],
  ['e','t','a','e'],
  ['i','h','k','r'],
  ['i','f','l','v']
]

Return ["eat","oath"].

Solved it using the most stupid method..... time complexity(k(words.size()) * board.size() * board[0].size()).... The time complexity is really high....

It can be reduced by using Trie structure.

#include <vector>
#include <string>
#include <set>
#include <iostream>
using namespace std;

void checkValid(vector< vector<char> >& board, int i, int j, string word, int k, vector< vector<bool> >& visited, bool& found) {
    if(found) return;
    if(k == word.size()) {found = true; return;}
    vector< vector<int> > dir {
        {0, -1},
        {0, 1},
        {1, 0},
        {-1, 0}};
    for(int x = 0; x < 4; ++x) {
        int tx = i + dir[x][0];
        int ty = j + dir[x][1];
        if(tx >= 0 && tx <= board.size() && ty >= 0 && ty <= board[i].size() && board[tx][ty] == word[k] && !visited[tx][ty]) {
            visited[tx][ty] = true;
            checkValid(board, tx, ty, word, k + 1, visited, found);
            visited[tx][ty] = false;
        }
    }
}

bool exist(vector< vector<char> >& board, string word) {
    vector< vector<bool> > visited(board.size(), vector<bool>(board[0].size(), false));
    for(int i = 0; i < board.size(); ++i) {
        for(int j = 0; j < board[0].size(); ++j) {
            if(board[i][j] == word[0]) {
                visited[i][j] = true;
                bool found = false;
                checkValid(board, i, j, word, 1, visited, found);
                if(found) return true;
                visited[i][j] = false;
            }
        }
    }
    return false;
}

// this time, instead of giving one string, we have a map of strings to find.
vector<string> findWords(vector< vector<char> >& board, vector<string>& words) {
    if(board.size() == 0 || board[0].size() == 0 || words.size() == 0) return {};
    set<string> allWords;
    vector<string> res;
    for(auto iter = words.begin(); iter != words.end(); ++iter) {
        if(exist(board, *iter)) res.push_back(*iter);
    }
    return res;
}


int main(void) {
  vector< vector<char> > board {
    {'o','a','a','n'},
    {'e','t','a','e'},
    {'i','h','k','r'},
    {'i','f','l','v'}};
    vector<string> words{"eat", "oath", "pea", "rain"};
    vector<string> res = findWords(board, words);
    for(auto iter : res) {
        cout << iter << endl;
    }
    cout << endl;
}