dp

Author: vegetabledogg

152-Maximum-Product-Subarray.c

@@ -0,0 +1,50 @@
+int maxProduct(int* nums, int numsSize) {
+    int *pos = (int*)malloc(sizeof(int) * numsSize);
+    int *neg = (int*)malloc(sizeof(int) * numsSize);
+    int i;
+    for(i = 0; i < numsSize; i++){
+        if(0 == i){
+            if(nums[0] > 0){
+                pos[0] = nums[0];
+                neg[0] = 0;
+            }
+            else if(nums[0] < 0){
+                pos[0] = 0;
+                neg[0] = nums[0];
+            }
+            else{
+                pos[0] = neg[0] = 0;
+            }
+        }
+        else{
+            if(nums[i] > 0){
+                if(pos[i - 1] > 0){
+                    pos[i] = pos[i - 1] * nums[i];
+                }
+                else{
+                    pos[i] = nums[i];
+                }
+                neg[i] = neg[i - 1] * nums[i];
+            }
+            else if(nums[i] < 0){
+                pos[i] = neg[i - 1] * nums[i];
+                if(pos[i - 1] > 0){
+                    neg[i] = pos[i - 1] * nums[i];
+                }
+                else{
+                    neg[i] = nums[i];
+                }
+            }
+            else{
+                pos[i] = neg[i] = 0;
+            }
+        }
+    }
+    int max = nums[0];
+    for(i = 1; i < numsSize; i++){
+        if(max < pos[i]){
+            max = pos[i];
+        }
+    }
+    return max;
+}

221-Maximal-Square.c

@@ -0,0 +1,40 @@
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+int maximalSquare(char** matrix, int matrixRowSize, int matrixColSize) {
+    int **l = (int**)malloc(sizeof(int*) * matrixRowSize);
+    int i, j, max = 0;
+    for(i = 0; i < matrixRowSize; i++){
+        l[i] = (int*)malloc(sizeof(int) * matrixColSize);
+    }
+    for(i = 0; i < matrixRowSize; i++){
+        if(matrix[i][0] == '0'){
+            l[i][0] = 0;
+        }
+        else{
+            l[i][0] = 1;
+            max = 1;
+        }
+    }
+    for(i = 0; i < matrixColSize; i++){
+        if(matrix[0][i] == '0'){
+            l[0][i] = 0;
+        }
+        else{
+            l[0][i] = 1;
+            max = 1;
+        }
+    }
+    for(i = 1; i < matrixRowSize; i++){
+        for(j = 1; j < matrixColSize; j++){
+            if('0' != matrix[i][j]){
+                l[i][j] = MIN(MIN(l[i - 1][j], l[i - 1][j - 1]), l[i][j - 1]) + 1;
+            }
+            else{
+                l[i][j] = 0;
+            }
+            if(l[i][j] > max){
+                max = l[i][j];
+            }
+        }
+    }
+    return max * max;
+}

264-Ugly-Number-II.c

@@ -0,0 +1,41 @@
+int nthUglyNumber(int n) {
+    int *dp = (int*)malloc(sizeof(int) * n);
+    int min, i, j;
+    if(n < 7){
+        return n;
+    }
+    for(i = 0; i < 6; i++){
+        dp[i] = i + 1;
+    }
+    for(i = 6; i < n; i++){
+        min = 2147483647;
+        for(j = i - 2; j >= 0; j--){
+            if(dp[j] * 2 > 0){
+                if(dp[j] * 2 > dp[i - 1]){
+                    if(dp[j] * 2 < min){
+                        min = dp[j] * 2;
+                    }
+                }
+                else if(dp[j] * 3 > 0){
+                    if(dp[j] * 3 > dp[i - 1]){
+                        if(dp[j] * 3 < min){
+                            min = dp[j] * 3;
+                        }
+                    }
+                    else if(dp[j] * 5 > 0){
+                        if(dp[j] * 5 > dp[i - 1]){
+                            if(dp[j] * 5 < min){
+                                min = dp[j] * 5;
+                            }
+                        }
+                        else{
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        dp[i] = min;
+    }
+    return dp[i - 1];
+}

279-Perfect-Squares.c

@@ -0,0 +1,22 @@
+int numSquares(int n) {
+    int *dp = (int*)malloc(sizeof(int) * (n + 1));
+    int i, j, min;
+    for(i = 1; i <= n; i++){
+        dp[i] = 0;
+    }
+    for(i = 1; i * i <= n; i++){
+        dp[i * i] = 1;
+    }
+    for(i = 1; i <= n; i++){
+        if(0 == dp[i]){
+            min = 2147483647;
+            for(j = 1; j * j <= i; j++){
+                if(dp[i - j * j] + 1 < min){
+                    min = dp[i - j * j] + 1;
+                }
+            }
+            dp[i] = min;
+        }
+    }
+    return dp[i - 1];
+}

300-Longest-Increasing-Subsequence.c

@@ -0,0 +1,20 @@
+int lengthOfLIS(int* nums, int numsSize) {
+    int *dp = (int*)malloc(sizeof(int) * numsSize);
+    int i, j, max;
+    for(i = 0; i < numsSize; i++){
+        max = 1;
+        for(j = 0; j < i; j++){
+            if(nums[j] < nums[i] && dp[j] + 1 > max){
+                max = dp[j] + 1;
+            }
+        }
+        dp[i] = max;
+    }
+    max = dp[0];
+    for(i = 0; i < numsSize; i++){
+        if(max < dp[i]){
+            max = dp[i];
+        }
+    }
+    return max;
+}

91-Decode-Ways.c

@@ -0,0 +1,50 @@
+int numDecodings(char* s) {
+    int i;
+    int length = strlen(s);
+    int *dp = (int*)malloc(sizeof(int) * length);
+    if(length == 0 || s[0] == '0'){
+        return 0;
+    }
+    for(i = 0; i < length; i++){
+        if(0 == i){
+            dp[i] = 1;
+        }
+        else if(1 == i){
+            if(s[1] != '0'){
+                if(s[0] == '1' || s[0] == '2' && s[1] < '7'){
+                    dp[i] = 2;
+                }
+                else{
+                    dp[i] = 1;
+                }
+            }
+            else{
+                if(s[0] < '3' && s[0] > '0'){
+                    dp[i] = 1;
+                }
+                else{
+                    return 0;
+                }
+            }
+        }
+        else{
+            if(s[i] != '0'){
+                if(s[i - 1] == '1' || s[i - 1] == '2' && s[i] < '7'){
+                    dp[i] = dp[i - 1] + dp[i - 2];
+                }
+                else{
+                    dp[i] = dp[i - 1];
+                }
+            }
+            else{
+                if(s[i - 1] < '3' && s[i - 1] > '0'){
+                    dp[i] = dp[i - 2];
+                }
+                else{
+                    return 0;
+                }
+            }
+        }
+    }
+    return dp[length - 1];
+}