<p>There is a safe protected by a password. The password is a sequence of <code>n</code> digits where each digit can be in the range <code>[0, k - 1]</code>.</p>

<p>The safe has a peculiar way of checking the password. When you enter in a sequence, it checks the <strong>most recent </strong><code>n</code><strong> digits</strong> that were entered each time you type a digit.</p>

<ul>
	<li>For example, the correct password is <code>&quot;345&quot;</code> and you enter in <code>&quot;012345&quot;</code>:

	<ul>
		<li>After typing <code>0</code>, the most recent <code>3</code> digits is <code>&quot;0&quot;</code>, which is incorrect.</li>
		<li>After typing <code>1</code>, the most recent <code>3</code> digits is <code>&quot;01&quot;</code>, which is incorrect.</li>
		<li>After typing <code>2</code>, the most recent <code>3</code> digits is <code>&quot;012&quot;</code>, which is incorrect.</li>
		<li>After typing <code>3</code>, the most recent <code>3</code> digits is <code>&quot;123&quot;</code>, which is incorrect.</li>
		<li>After typing <code>4</code>, the most recent <code>3</code> digits is <code>&quot;234&quot;</code>, which is incorrect.</li>
		<li>After typing <code>5</code>, the most recent <code>3</code> digits is <code>&quot;345&quot;</code>, which is correct and the safe unlocks.</li>
	</ul>
	</li>
</ul>

<p>Return <em>any string of <strong>minimum length</strong> that will unlock the safe <strong>at some point</strong> of entering it</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> n = 1, k = 2
<strong>Output:</strong> &quot;10&quot;
<strong>Explanation:</strong> The password is a single digit, so enter each digit. &quot;01&quot; would also unlock the safe.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> n = 2, k = 2
<strong>Output:</strong> &quot;01100&quot;
<strong>Explanation:</strong> For each possible password:
- &quot;00&quot; is typed in starting from the 4<sup>th</sup> digit.
- &quot;01&quot; is typed in starting from the 1<sup>st</sup> digit.
- &quot;10&quot; is typed in starting from the 3<sup>rd</sup> digit.
- &quot;11&quot; is typed in starting from the 2<sup>nd</sup> digit.
Thus &quot;01100&quot; will unlock the safe. &quot;10011&quot;, and &quot;11001&quot; would also unlock the safe.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= n &lt;= 4</code></li>
	<li><code>1 &lt;= k &lt;= 10</code></li>
	<li><code>1 &lt;= k<sup>n</sup> &lt;= 4096</code></li>
</ul>

class Solution {
    string dst;
    int nodes;
    unordered_set<string> s;

    bool dfs(string src, vector<string> adjL[], vector<string>& arr){
        arr.push_back(src);
        if(src == dst){
            if(arr.size() == nodes) return true;
            return false;
        }

        s.insert(src);
        string a = src.substr(1);
        int len = a.length();

        int d = src[1] - 48;
        for(int i = adjL[d].size() - 1; i >= 0; i--){
            string it = adjL[d][i];
            if(it.substr(0, len) == a && s.find(it) == s.end()){
                if(dfs(it, adjL, arr)) return true;
            }
        }

        s.erase(src);
        arr.pop_back();
        return false;
    }

    vector<string> f(int s, int n, int k){
        vector<string> ans;
        ans.push_back({to_string(s)});

        for(int i = 0; i < n - 1; i++){
            vector<string> temp = ans;
            ans.clear();

            for(int j = 0; j < temp.size(); j++){
                for(int t = 0; t < k; t++){
                    ans.push_back(temp[j] + to_string(t));
                }
            }
        }

        return ans;
    }
public:
    string crackSafe(int n, int k) {
        string ans = "";
        if(k == 1){
            for(int i = 0; i < n; i++)  ans += '0';
            return ans;
        }

        if(n == 1){
            for(int i = k - 1; i >= 0; i--) ans += to_string(i);
            return ans;
        }
        
        nodes = pow(k, n);
        vector<string> adjL[k];
        for(int i = 0; i < k; i++){
            adjL[i] = f(i, n, k);
        }

        string src = "";
        dst = "";
        for(int i = 0; i < n - 1; i++) src += '0', dst += '0';
        src += to_string(k - 1);
        dst += '0';

        vector<string> arr;
        bool call = dfs(src, adjL, arr);

        ans = arr[0];
        for(int i = 1; i < arr.size(); i++){
            ans += arr[i].back();
        }

        return ans;
    }
};
16500