Dungeon Game

Author: ishpreet-singh

19.cpp

@@ -0,0 +1,59 @@
+/*
+
+Longest Duplicate Substring
+---------------------------
+
+Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times.  (The occurrences may overlap.)
+
+Return any duplicated substring that has the longest possible length.  (If S does not have a duplicated substring, the answer is "".)
+
+Example 1:
+
+Input: "banana"
+Output: "ana"
+Example 2:
+
+Input: "abcd"
+Output: ""
+ 
+
+Note:
+
+2 <= S.length <= 10^5
+S consists of lowercase English letters.
+
+*/
+
+class Solution {
+public:
+    string longestDupSubstring(string S) {
+        std::string_view longest;
+        std::unordered_set<std::string_view> set;
+        int start = 1;
+        int end = S.size() - 1;
+        while (start <= end)
+        {
+            int len = start + (end - start) / 2;
+            bool found = false;
+            for (int i = 0; i != S.size() - len + 1; ++i)
+            {
+                const auto [it, inserted] = set.emplace(S.data() + i, len);
+                if (!inserted)
+                {
+                    found = true;
+                    longest = *it;
+                    break;   
+                }
+            }
+            
+            if (found)
+                start = len + 1;
+            else
+                end = len - 1;
+            
+            set.clear();      
+        }
+            
+        return {longest.begin(), longest.end()};
+    }
+};

20.cpp

@@ -0,0 +1,54 @@
+/*
+
+Permutation Sequence
+--------------------
+
+The set [1,2,3,...,n] contains a total of n! unique permutations.
+
+By listing and labeling all of the permutations in order, we get the following sequence for n = 3:
+
+"123"
+"132"
+"213"
+"231"
+"312"
+"321"
+Given n and k, return the kth permutation sequence.
+
+Note:
+
+Given n will be between 1 and 9 inclusive.
+Given k will be between 1 and n! inclusive.
+Example 1:
+
+Input: n = 3, k = 3
+Output: "213"
+Example 2:
+
+Input: n = 4, k = 9
+Output: "2314"
+
+*/
+
+class Solution {
+public:
+    string getPermutation(int n, int k) {
+          string ans = "";
+          vector <char> candidates(n);
+          for(long long i = 0; i < n; i++)
+             candidates[i] = ((i + 1) + '0');
+          vector <long long> fact(n + 1);
+          fact[0] = 1;
+          for(long long i = 1; i <= n; i++)
+             fact[i] = fact[i - 1] * i;
+          k--;
+          for(long long i = n - 1; i >= 0; i--){
+             long long idx = k / fact[i];
+             ans += candidates[idx];
+             for(long long j = idx; j + 1< candidates.size(); j++)
+                candidates[j] = candidates[j + 1];
+             k = k % fact[i];
+          }
+          return ans;
+    }
+};

21.cpp

@@ -0,0 +1,53 @@
+/*
+
+Dungeon Game
+------------
+
+The demons had captured the princess (P) and imprisoned her in the bottom-right corner of a dungeon. The dungeon consists of M x N rooms laid out in a 2D grid. Our valiant knight (K) was initially positioned in the top-left room and must fight his way through the dungeon to rescue the princess.
+
+The knight has an initial health point represented by a positive integer. If at any point his health point drops to 0 or below, he dies immediately.
+
+Some of the rooms are guarded by demons, so the knight loses health (negative integers) upon entering these rooms; other rooms are either empty (0's) or contain magic orbs that increase the knight's health (positive integers).
+
+In order to reach the princess as quickly as possible, the knight decides to move only rightward or downward in each step.
+
+ 
+
+Write a function to determine the knight's minimum initial health so that he is able to rescue the princess.
+
+For example, given the dungeon below, the initial health of the knight must be at least 7 if he follows the optimal path RIGHT-> RIGHT -> DOWN -> DOWN.
+
+-2 (K)	-3	3
+-5	-10	1
+10	30	-5 (P)
+ 
+
+Note:
+
+The knight's health has no upper bound.
+Any room can contain threats or power-ups, even the first room the knight enters and the bottom-right room where the princess is imprisoned.
+
+*/
+
+class Solution {
+public:
+    int calculateMinimumHP(vector<vector<int>>& dungeon) {
+         if(dungeon.size()==0) return 0;
+    
+        int row=dungeon.size();
+        int col=dungeon[0].size();
+
+        for(int i=row-1; i>=0; i--) {
+
+            for(int j=col-1; j>=0; j--) {
+
+                if(i==row-1 && j==col-1) dungeon[i][j]=max(1, 1-dungeon[i][j]);
+                else if(i==row-1) dungeon[i][j]=max(1, dungeon[i][j+1]-dungeon[i][j]);
+                else if(j==col-1) dungeon[i][j]=max(1, dungeon[i+1][j]-dungeon[i][j]);
+                else dungeon[i][j]=max(1, min(dungeon[i+1][j], dungeon[i][j+1])-dungeon[i][j]);
+            }
+        }
+
+        return dungeon[0][0];
+    }
+};

README.md

@@ -19,4 +19,7 @@
 |  15  |  Search in a Binary Search Tree | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/15.cpp) |
 |  16  |       Validate IP Address       | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/16.cpp) |
 |  17  |        Surrounded Regions       | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/17.cpp) |
-|  18  |            H-Index II           | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/18.cpp) |
+|  18  |            H-Index II           | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/18.cpp) |
+|  19  |   Longest Duplicate Substring   | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/19.cpp) |
+|  20  |       Permutation Sequence      | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/20.cpp) |
+|  21  |           Dungeon Game          | [Link](https://github.com/ishpreet-singh/leetcode-june-challenge/blob/master/21.cpp) |