update

Author: sindwerra

.DS_Store

@@ -1,15 +1,35 @@
-def findLCS(A, n, B, m):
-        # write code here
-        c = [([0] * (m + 1)) for _ in xrange(n + 1)]
-        for i in xrange(n):
-            for j in xrange(m):
-                if A[i] == B[j]:
-                    c[i + 1][j + 1] = c[i][j] + 1
-                elif c[i][j + 1] > c[i + 1][j]:
-                    c[i + 1][j + 1] = c[i][j + 1]
-                else:
-                    c[i + 1][j + 1] = c[i + 1][j]
-        return c[n][m]
-
-
-print findLCS("1A2C3D4B56",10,"B1D23CA45B6A",12)
+# coding=utf-8
+
+# 最大公共子串，CLRS思路
+
+# def findLCS(A, n, B, m):
+#         # write code here
+#         c = [([0] * (m + 1)) for _ in xrange(n + 1)]
+#         for i in xrange(n):
+#             for j in xrange(m):
+#                 if A[i] == B[j]:
+#                     c[i + 1][j + 1] = c[i][j] + 1
+#                 elif c[i][j + 1] > c[i + 1][j]:
+#                     c[i + 1][j + 1] = c[i][j + 1]
+#                 else:
+#                     c[i + 1][j + 1] = c[i + 1][j]
+#         return c[n][m]
+#
+#
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# print findLCS("1A2C3D4B56",10,"B1D23CA45B6A",12)
+print findLCS("1A2C3D4B56","B1D23CA45B6A")

CLRS/.DS_Store

@@ -0,0 +1,14 @@
+def LIS(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        n = len(nums)
+        res = [0] * n
+        for s in xrange(n):
+            q = 0
+            for k in xrange(s):
+                if nums[k] < nums[s]:
+                    q = max(q, res[k])
+            res[s] += (q + 1)
+        return max(res) if n <> 0 else 0

CLRS/LCS.py

@@ -1,113 +0,0 @@
-LF-RT(T, x)
-  y = x.right
-  x.right = y.left
-  if y.left != T.nil
-    y.left.parent = x
-  y.parent = x.parent
-  if x.parent == T.nil
-    T.root = y
-  elif x.parent.right = x
-    x.parent.right = y
-  else
-    x.parent.left = y
-  y.left = x
-  x.parent = y
-
-RB-TRANSPLANT(T, u, v)
-  if u.parent == T.nil
-    T.root = v
-  elif u.parent.right == u
-    u.parent.right = v
-  else
-    u.parent.left = v
-  v.parent = u.parent
-
-RB-INSERT(T, z)
-  x = T.root
-  y = T.nil
-  while x != T.nil
-    y = x
-    if x.val < z.val
-      x = x.right
-    else
-      x = x.left
-  z.parent = y.parent
-  if y == T.nil
-    T.root = z
-  elif y.parent.right == y
-    y.parent.right = z
-  else
-    y.parent.left = z
-  z.left = T.nil
-  z.right = T.nil
-  z.color = RED
-  RB-INSERT-FIX(T, z)
-
-RB-INSERT-FIX(T, z)
-  while z.parent.color == RED
-    if z.parent = z.parent.parent.left
-      y = z.parent.parent.right
-      if y.color == RED
-        y.color = BLACK
-        z.parent.color = BLACK
-        z.parent.parent.color = RED
-        z = z.parent.parent
-      elif z = z.parent.right
-          z = z.parent
-          LF-RT(T, z)
-        z.parent.color = BLACK
-        z.parent.parent.color = RED
-        RT-RT(T, z.parent.parent)
-    else (change left and right)
-  T.root.color = BLACK
-
-RB-DELETE(T, z)
-  y = z
-  y-ori-color = z.color
-  if z.right == T.nil
-    x = z.right
-    TRANSPLANT(T, z, z.right)
-  elif z.left == T.nil
-    x = z.left
-    TRANSPLANT(T, z, z.left)
-  else
-    y = TREE-MIN(T, z.right)
-    y-ori-color = y.color
-    x = y.right
-    if y.parent == z
-      x.parent = y
-    else
-        TRANSPLANT(T, y, y.right)
-        y.right = z.right
-        y.right.parent = y
-      TRANSPLANT(T, z, y)
-      y.left = z.left
-      y.left.parent = y
-      y.color = z.color
-  if y-ori-color == BLACK
-    RB-DELETE-FIX(T, x)
-
-RB-DELETE-FIX(T, x)
-  while T.root != x and x.color == BLACK
-    if x == x.parent.left
-      w = x.parent.right
-      if w.color == RED
-        w.color = BLACK
-        x.parent.color = RED
-        LF.RT(x.parent)
-        w = x.parent.right
-      if w.left.color == BLACK and w.right.color == BLACK
-        w.color = RED
-        x = x.parent
-      elif w.right.color == BLACK
-          w.color = RED
-          w.left.color = BLACK
-          RT-RT(T, w)
-          w = x.parent.right
-        w.color = x.parent.color
-        w.right.color = BLACK
-        x.parent.color = BLACK
-        LF-RT(T, x.parent)
-        T.root = x
-    else(change left and right)
-  x.color = BLACK

CLRS/LIS.py

@@ -0,0 +1,151 @@
+// Java Program to show segment tree operations like construction,
+// query and update
+class SegmentTree
+{
+    int st[]; // The array that stores segment tree nodes
+
+    /* Constructor to construct segment tree from given array. This
+       constructor  allocates memory for segment tree and calls
+       constructSTUtil() to  fill the allocated memory */
+    SegmentTree(int arr[], int n)
+    {
+        // Allocate memory for segment tree
+        //Height of segment tree
+        int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
+
+        //Maximum size of segment tree
+        int max_size = 2 * (int) Math.pow(2, x) - 1;
+
+        st = new int[max_size]; // Memory allocation
+
+        constructSTUtil(arr, 0, n - 1, 0);
+    }
+
+    // A utility function to get the middle index from corner indexes.
+    int getMid(int s, int e) {
+        return s + (e - s) / 2;
+    }
+
+    /*  A recursive function to get the sum of values in given range
+        of the array.  The following are parameters for this function.
+
+      st    --> Pointer to segment tree
+      si    --> Index of current node in the segment tree. Initially
+                0 is passed as root is always at index 0
+      ss & se  --> Starting and ending indexes of the segment represented
+                    by current node, i.e., st[si]
+      qs & qe  --> Starting and ending indexes of query range */
+    int getSumUtil(int ss, int se, int qs, int qe, int si)
+    {
+        // If segment of this node is a part of given range, then return
+        // the sum of the segment
+        if (qs <= ss && qe >= se)
+            return st[si];
+
+        // If segment of this node is outside the given range
+        if (se < qs || ss > qe)
+            return 0;
+
+        // If a part of this segment overlaps with the given range
+        int mid = getMid(ss, se);
+        return getSumUtil(ss, mid, qs, qe, 2 * si + 1) +
+                getSumUtil(mid + 1, se, qs, qe, 2 * si + 2);
+    }
+
+    /* A recursive function to update the nodes which have the given
+       index in their range. The following are parameters
+        st, si, ss and se are same as getSumUtil()
+        i    --> index of the element to be updated. This index is in
+                 input array.
+       diff --> Value to be added to all nodes which have i in range */
+    void updateValueUtil(int ss, int se, int i, int diff, int si)
+    {
+        // Base Case: If the input index lies outside the range of
+        // this segment
+        if (i < ss || i > se)
+            return;
+
+        // If the input index is in range of this node, then update the
+        // value of the node and its children
+        st[si] = st[si] + diff;
+        if (se != ss) {
+            int mid = getMid(ss, se);
+            updateValueUtil(ss, mid, i, diff, 2 * si + 1);
+            updateValueUtil(mid + 1, se, i, diff, 2 * si + 2);
+        }
+    }
+
+    // The function to update a value in input array and segment tree.
+   // It uses updateValueUtil() to update the value in segment tree
+    void updateValue(int arr[], int n, int i, int new_val)
+    {
+        // Check for erroneous input index
+        if (i < 0 || i > n - 1) {
+            System.out.println("Invalid Input");
+            return;
+        }
+
+        // Get the difference between new value and old value
+        int diff = new_val - arr[i];
+
+        // Update the value in array
+        arr[i] = new_val;
+
+        // Update the values of nodes in segment tree
+        updateValueUtil(0, n - 1, i, diff, 0);
+    }
+
+    // Return sum of elements in range from index qs (quey start) to
+   // qe (query end).  It mainly uses getSumUtil()
+    int getSum(int n, int qs, int qe)
+    {
+        // Check for erroneous input values
+        if (qs < 0 || qe > n - 1 || qs > qe) {
+            System.out.println("Invalid Input");
+            return -1;
+        }
+        return getSumUtil(0, n - 1, qs, qe, 0);
+    }
+
+    // A recursive function that constructs Segment Tree for array[ss..se].
+    // si is index of current node in segment tree st
+    int constructSTUtil(int arr[], int ss, int se, int si)
+    {
+        // If there is one element in array, store it in current node of
+        // segment tree and return
+        if (ss == se) {
+            st[si] = arr[ss];
+            return arr[ss];
+        }
+
+        // If there are more than one elements, then recur for left and
+        // right subtrees and store the sum of values in this node
+        int mid = getMid(ss, se);
+        st[si] = constructSTUtil(arr, ss, mid, si * 2 + 1) +
+                 constructSTUtil(arr, mid + 1, se, si * 2 + 2);
+        return st[si];
+    }
+
+    // Driver program to test above functions
+    public static void main(String args[])
+    {
+        int arr[] = {1, 3, 5, 7, 9, 11};
+        int n = arr.length;
+        SegmentTree  tree = new SegmentTree(arr, n);
+
+        // Build segment tree from given array
+
+        // Print sum of values in array from index 1 to 3
+        System.out.println("Sum of values in given range = " +
+                           tree.getSum(n, 1, 3));
+
+        // Update: set arr[1] = 10 and update corresponding segment
+        // tree nodes
+        tree.updateValue(arr, n, 1, 10);
+
+        // Find sum after the value is updated
+        System.out.println("Updated sum of values in given range = " +
+                tree.getSum(n, 1, 3));
+    }
+}
+//This code is contributed by Ankur Narain Verma