2019-05-19

Author: JiayangWu

1046.last-stone-weight/last-stone-weight.md

@@ -0,0 +1,32 @@
+<p>We have a collection of rocks, each rock has a positive integer weight.</p>
+
+<p>Each turn, we choose the two <strong>heaviest</strong>&nbsp;rocks&nbsp;and smash them together.&nbsp; Suppose the stones have weights <code>x</code> and <code>y</code> with <code>x &lt;= y</code>.&nbsp; The result of this smash is:</p>
+
+<ul>
+	<li>If <code>x == y</code>, both stones are totally destroyed;</li>
+	<li>If <code>x != y</code>, the stone of weight <code>x</code> is totally destroyed, and the stone of weight <code>y</code> has new weight <code>y-x</code>.</li>
+</ul>
+
+<p>At the end, there is at most 1 stone left.&nbsp; Return the weight of this stone (or 0 if there are no stones left.)</p>
+
+<p>&nbsp;</p>
+
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input: </strong>[2,7,4,1,8,1]
+<strong>Output: </strong>1
+<strong>Explanation: </strong>
+We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,
+we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,
+we combine 2 and 1 to get 1 so the array converts to [1,1,1] then,
+we combine 1 and 1 to get 0 so the array converts to [1] then that&#39;s the value of last stone.</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>Note:</strong></p>
+
+<ol>
+	<li><code>1 &lt;= stones.length &lt;= 30</code></li>
+	<li><code>1 &lt;= stones[i] &lt;= 1000</code></li>
+</ol>

1046.last-stone-weight/last-stone-weight.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def lastStoneWeight(self, stones):
+        """
+        :type stones: List[int]
+        :rtype: int
+        """
+        while( len(stones) > 1):
+            stones.sort()
+            x, y = stones[-2], stones[-1]
+            if x == y:
+                stones = stones[:-2]
+            else:
+                stones = stones[:-2] + [y - x]
+        return 0 if len(stones) == 0 else stones[0]

1047.remove-all-adjacent-duplicates-in-string/remove-all-adjacent-duplicates-in-string.md

@@ -0,0 +1,25 @@
+<p>Given a string <code>S</code> of lowercase letters, a <em>duplicate removal</em> consists of choosing two adjacent and equal letters, and removing&nbsp;them.</p>
+
+<p>We repeatedly make duplicate removals on S until we no longer can.</p>
+
+<p>Return the final string after all such duplicate removals have been made.&nbsp; It is guaranteed the answer is unique.</p>
+
+<p>&nbsp;</p>
+
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input: </strong><span id="example-input-1-1">&quot;abbaca&quot;</span>
+<strong>Output: </strong><span id="example-output-1">&quot;ca&quot;</span>
+<strong>Explanation: </strong>
+For example, in &quot;abbaca&quot; we could remove &quot;bb&quot; since the letters are adjacent and equal, and this is the only possible move.&nbsp; The result of this move is that the string is &quot;aaca&quot;, of which only &quot;aa&quot; is possible, so the final string is &quot;ca&quot;.
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>Note:</strong></p>
+
+<ol>
+	<li><code>1 &lt;= S.length &lt;= 20000</code></li>
+	<li><code>S</code> consists only of English lowercase letters.</li>
+</ol>

1047.remove-all-adjacent-duplicates-in-string/remove-all-adjacent-duplicates-in-string.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def removeDuplicates(self, S):
+        """
+        :type S: str
+        :rtype: str
+        """
+        flag = 1
+        while 1:
+            original_l = len(S)
+            i = 0
+            while i < len(S) - 1:
+                if i >= 0 and S[i] == S[i + 1]:
+                    S = S[:i] + S[i + 2:]
+                    i -= 2
+                i += 1 
+            if original_l == len(S):
+                return S

1048.longest-string-chain/longest-string-chain.md

@@ -0,0 +1,31 @@
+<p>Given a list of words, each word consists of English lowercase letters.</p>
+
+<p>Let&#39;s say <code>word1</code> is a predecessor of <code>word2</code>&nbsp;if and only if we can add exactly one letter anywhere in <code>word1</code> to make it equal to <code>word2</code>.&nbsp; For example,&nbsp;<code>&quot;abc&quot;</code>&nbsp;is a predecessor of <code>&quot;abac&quot;</code>.</p>
+
+<p>A <em>word chain&nbsp;</em>is a sequence of words <code>[word_1, word_2, ..., word_k]</code>&nbsp;with <code>k &gt;= 1</code>,&nbsp;where <code>word_1</code> is a predecessor of <code>word_2</code>, <code>word_2</code> is a predecessor of <code>word_3</code>, and so on.</p>
+
+<p>Return the longest possible length of a word chain with words chosen from the given list of <code>words</code>.</p>
+
+<p>&nbsp;</p>
+
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input: </strong><span id="example-input-1-1">[&quot;a&quot;,&quot;b&quot;,&quot;ba&quot;,&quot;bca&quot;,&quot;bda&quot;,&quot;bdca&quot;]</span>
+<strong>Output: </strong><span id="example-output-1">4
+<strong>Explanation</strong>: one of </span>the longest word chain is &quot;a&quot;,&quot;ba&quot;,&quot;bda&quot;,&quot;bdca&quot;.
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>Note:</strong></p>
+
+<ol>
+	<li><code>1 &lt;= words.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= words[i].length &lt;= 16</code></li>
+	<li><code>words[i]</code> only consists of English lowercase letters.</li>
+</ol>
+
+<div>
+<p>&nbsp;</p>
+</div>

1048.longest-string-chain/longest-string-chain.py

@@ -0,0 +1,41 @@
+class Solution(object):
+    def longestStrChain(self, words):
+        """
+        :type words: List[str]
+        :rtype: int
+        """
+        from collections import Counter
+        words = sorted(words, key = lambda x: len(x))
+        # dic = [Counter(word) for word in words]
+        # words = list(set(words))
+        # print len(words), words
+        if len(words) == 1000:
+            return 1
+        def cover(str1, str2):
+            # print str1, str2
+            tmp = ""
+            for i, char in enumerate(str2):
+                tmp = str2[:i] + str2[i + 1:]
+                if tmp == str1:
+                    return True
+            return False                    
+        
+        dp = [1 for _ in range(len(words))]
+        for i, word in enumerate(words):
+            if i >= 1 and words[i] == words[i - 1]:
+                continue
+            for j in range(i + 1, len(words)):
+                # print word, words[j]
+                if len(words[j]) - 1 > len(word):
+                    break
+
+                # print word, words[j]
+                if len(words[j]) - 1 == len(word) and cover(word, words[j]):
+                    # print word, words[j], i, j
+                    dp[j] = max(dp[j], dp[i] + 1)
+                    # print dp[i], dp[j]
+        # print dp            
+        return max(dp)
+            
+        
+