2 problems

Author: hitzzc

Diff for: README.md

@@ -234,6 +234,8 @@ Golang solution for leetcode. For each problem, there is a simple *_test.go to t
 #### [319. Bulb Switcher](https://github.com/hitzzc/go-leetcode/tree/master/bulb_switcher)
 #### [322. Coin Change](https://github.com/hitzzc/go-leetcode/tree/master/coin_change)
 #### [326. Power of Three](https://github.com/hitzzc/go-leetcode/tree/master/power_of_three)
+#### [327. Count of Range Sum](https://github.com/hitzzc/go-leetcode/tree/master/count_of_range_sum)
+#### [329. Longest Increasing Path in a Matrix](https://github.com/hitzzc/go-leetcode/tree/master/longest_increasing_path_in_a_matrix)
 
 
 

Diff for: count_of_range_sum/count_of_range_sum.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    int countRangeSum(vector<int>& nums, int lower, int upper) {
+        vector<long> sums(nums.size()+1, 0);
+        for (int i = 0; i < nums.size(); ++i) {
+        	sums[i+1] = sums[i] + nums[i];
+        }
+        return count_when_merging_sort(sums, 0, sums.size(), lower, upper);
+    }
+    int count_when_merging_sort(vector<long>& array, int start, int end, int lower, int upper) {
+    	if (end-start <= 1) return 0;
+    	int mid = start + (end-start)/2;
+    	int j = mid, k = mid, t = mid;
+    	int count = count_when_merging_sort(array, start, mid, lower, upper) + count_when_merging_sort(array, mid, end, lower, upper);
+    	vector<long> cache(end-start);
+    	for (int i = start, r = 0; i < mid; ++i, ++r) {
+    		while (k < end && array[k]-array[i] <= upper) ++k;
+    		while (j < end && array[j]-array[i] < lower) ++j;
+    		while (t < end && array[t] < array[i]) cache[r++] = array[t++];
+    		cache[r] = array[i];
+    		count += k - j; 
+    	}
+    	for (int i = start; i < t; ++i) {
+    		array[i] = cache[i-start];
+    	}
+    	return count;
+    }
+};

Diff for: longest_increasing_path_in_a_matrix/longest_increasing_path_in_a_matrix.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    int longestIncreasingPath(vector<vector<int>>& matrix) {
+        int row = matrix.size();
+        int col = row ? matrix[0].size() : 0;
+        vector<vector<int>> path(row, vector<int>(col, 0));
+        vector<vector<bool>> visited(row, vector<bool>(col, 0));
+        int ret = 0;
+        for (int i = 0; i < row; ++i) {
+            for (int j = 0; j < col; ++j) {
+                ret = max(ret, helper(matrix, path, row, col, i , j, visited));
+            }
+        }
+        return ret;
+    }
+    
+    int helper(vector<vector<int>>& matrix, vector<vector<int>>& path, const int row, const int col, int r, int c, vector<vector<bool>>& visited) {
+        if (path[r][c] > 0) return path[r][c];
+        visited[r][c] = true;
+        int ret = 0;
+        if (r > 0 && !visited[r-1][c] && matrix[r][c] < matrix[r-1][c]) {
+            ret = max(ret, helper(matrix, path, row, col, r-1, c, visited));
+        }
+        if (r < row-1 && !visited[r+1][c] && matrix[r][c] < matrix[r+1][c]) {
+            ret = max(ret, helper(matrix, path, row, col, r+1, c, visited));
+        }
+        if (c > 0 && !visited[r][c-1] && matrix[r][c] < matrix[r][c-1]) {
+            ret = max(ret, helper(matrix, path, row, col, r, c-1, visited));
+        }
+        if (c < col-1 && !visited[r][c+1] && matrix[r][c] < matrix[r][c+1]) {
+            ret = max(ret, helper(matrix, path, row, col, r, c+1, visited));
+        }
+        visited[r][c] = false;
+        path[r][c] = ret+1;
+        return path[r][c];
+    }
+};