2019-08-04

Author: JiayangWu

1144.递减元素使数组呈锯齿状/1144-递减元素使数组呈锯齿状.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def movesToMakeZigzag(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        backup = nums[:]
+        cnt = 0
+        for i in range(1, len(nums), 2):
+            if i != len(nums) - 1:
+                if nums[i] >= nums[i - 1] or nums[i] >= nums[i + 1]:
+                    nums[i] = (min(nums[i - 1], nums[i + 1]) - 1)
+            else:
+                if nums[i] >= nums[i - 1]:
+                    nums[i] = (nums[i - 1] - 1)
+
+        cnt = sum(backup) - sum(nums)
+        nums = backup[:]
+        cnt1 = 0
+        for i in range(0, len(nums), 2):
+            if i != 0 and i != len(nums) - 1:
+                if nums[i] >= nums[i - 1] or nums[i] >= nums[i + 1]:
+                    nums[i] = (min(nums[i - 1], nums[i + 1]) - 1)
+            elif i == 0:
+                if nums[i] >= nums[i + 1]:
+                    nums[i] = (nums[i + 1] - 1)    
+            elif i == len(nums) - 1:
+                if nums[i] >= nums[i - 1]:
+                    nums[i] = (nums[i - 1] - 1)    
+        cnt1 = sum(backup) - sum(nums)
+        return min(cnt, cnt1)

1145.二叉树着色游戏/1145-二叉树着色游戏.py

@@ -0,0 +1,40 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def btreeGameWinningMove(self, root, n, x):
+        """
+        :type root: TreeNode
+        :type n: int
+        :type x: int
+        :rtype: bool
+        """
+        self.x_address = 0
+        
+        def dfs(node):
+            if not node:
+                return 
+            if node.val == x:
+                self.x_address = node
+                return
+            dfs(node.left)
+            dfs(node.right)
+        dfs(root)
+        
+        def cnt_node_in_subtree(node):
+            if not node:
+                return 0
+            return 1 + cnt_node_in_subtree(node.left) + cnt_node_in_subtree(node.right)
+        # print root.val
+        if root.val == x:     
+            return cnt_node_in_subtree(root.left) != cnt_node_in_subtree(root.right)
+        else:
+            x_cnt = cnt_node_in_subtree(self.x_address)
+            total_cnt = cnt_node_in_subtree(root) 
+            left_cnt = cnt_node_in_subtree(self.x_address.left)
+            right_cnt = cnt_node_in_subtree(self.x_address.right)
+            return x_cnt < total_cnt - x_cnt or left_cnt > total_cnt - left_cnt or right_cnt > total_cnt - right_cnt

1146.快照数组/1146-快照数组.py

@@ -0,0 +1,45 @@
+class SnapshotArray(object):
+    from collections import defaultdict
+    def __init__(self, length):
+        """
+        :type length: int
+        """
+        self.history = dict()
+        self.snap_id = -1
+        self.history[self.snap_id] = dict()
+    def set(self, index, val):
+        """
+        :type index: int
+        :type val: int
+        :rtype: None
+        """
+        self.history[self.snap_id][index] = val
+
+    def snap(self):
+        """
+        :rtype: int
+        """
+        import copy
+        
+        self.snap_id += 1
+        self.history[self.snap_id] = copy.deepcopy( self.history[self.snap_id - 1])
+        return self.snap_id
+
+    def get(self, index, snap_id):
+        """
+        :type index: int
+        :type snap_id: int
+        :rtype: int
+        """
+        snap_id -= 1
+        if index in self.history[snap_id]:
+            return self.history[snap_id][index]
+        else:
+            return 0
+
+
+# Your SnapshotArray object will be instantiated and called as such:
+# obj = SnapshotArray(length)
+# obj.set(index,val)
+# param_2 = obj.snap()
+# param_3 = obj.get(index,snap_id)

1147.段式回文/1147-段式回文.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def longestDecomposition(self, text):
+        """
+        :type text: str
+        :rtype: int
+        """
+        # print text
+        for i in range(1, len(text)):
+            if text[:i] == text[len(text) - i:]:
+                return 2 + self.longestDecomposition(text[i:len(text) - i])
+        return 1 if text else 0