Added tasks 56-114

Author: javadev

Diff for: README.md

@@ -0,0 +1,84 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 56\. Merge Intervals
+
+Medium
+
+Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, merge all overlapping intervals, and return _an array of the non-overlapping intervals that cover all the intervals in the input_.
+
+**Example 1:**
+
+**Input:** intervals = \[\[1,3],[2,6],[8,10],[15,18]]
+
+**Output:** [[1,6],[8,10],[15,18]]
+
+**Explanation:** Since intervals [1,3] and [2,6] overlap, merge them into [1,6].
+
+**Example 2:**
+
+**Input:** intervals = \[\[1,4],[4,5]]
+
+**Output:** [[1,5]]
+
+**Explanation:** Intervals [1,4] and [4,5] are considered overlapping.
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Return an array of arrays of size *returnSize.
+ * The sizes of the arrays are returned as *returnColumnSizes array.
+ * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ */
+int compare(const void* a, const void* b) {
+    return (*(int**)a)[0] - (*(int**)b)[0];
+}
+
+int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes) {
+    // Step 1: Sort the intervals based on the starting times
+    qsort(intervals, intervalsSize, sizeof(int*), compare);
+
+    // Step 2: Create a dynamic array to hold merged intervals
+    int** merged = (int**)malloc(intervalsSize * sizeof(int*));
+    *returnColumnSizes = (int*)malloc(intervalsSize * sizeof(int));
+    *returnSize = 0;
+
+    // Initialize the current interval as the first one
+    int* current = intervals[0];
+    merged[(*returnSize)++] = (int*)malloc(2 * sizeof(int));
+    merged[0][0] = current[0];
+    merged[0][1] = current[1];
+
+    // Step 3: Iterate through the intervals
+    for (int i = 1; i < intervalsSize; i++) {
+        int* next = intervals[i];
+        // Check if there is an overlap
+        if (current[1] >= next[0]) {
+            current[1] = (current[1] > next[1]) ? current[1] : next[1]; // Merge
+            merged[*returnSize - 1][1] = current[1]; // Update the last merged interval
+        } else {
+            current = next; // Move to the next interval
+            merged[(*returnSize)++] = (int*)malloc(2 * sizeof(int));
+            merged[*returnSize - 1][0] = current[0];
+            merged[*returnSize - 1][1] = current[1];
+        }
+    }
+
+    // Step 4: Allocate return column sizes
+    for (int i = 0; i < *returnSize; i++) {
+        (*returnColumnSizes)[i] = 2; // Each merged interval has size 2
+    }
+
+    return merged;
+}
+```

Diff for: src/main/c/g0001_0100/s0056_merge_intervals/readme.md

@@ -0,0 +1,81 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 62\. Unique Paths
+
+Medium
+
+There is a robot on an `m x n` grid. The robot is initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m - 1][n - 1]`). The robot can only move either down or right at any point in time.
+
+Given the two integers `m` and `n`, return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
+
+The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png)
+
+**Input:** m = 3, n = 7
+
+**Output:** 28
+
+**Example 2:**
+
+**Input:** m = 3, n = 2
+
+**Output:** 3
+
+**Explanation:** From the top-left corner, there are a total of 3 ways to reach the bottom-right corner: 
+
+1. Right -> Down -> Down 
+
+2. Down -> Down -> Right 
+
+3. Down -> Right -> Down
+
+**Constraints:**
+
+*   `1 <= m, n <= 100`
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+int uniquePaths(int m, int n) {
+    // Step 1: Allocate a 2D array for dynamic programming
+    int** dp = (int**)malloc(m * sizeof(int*));
+    for (int i = 0; i < m; i++) {
+        dp[i] = (int*)malloc(n * sizeof(int));
+    }
+
+    // Step 2: Initialize the first column
+    for (int i = 0; i < m; i++) {
+        dp[i][0] = 1;
+    }
+
+    // Step 3: Initialize the first row
+    for (int j = 0; j < n; j++) {
+        dp[0][j] = 1;
+    }
+
+    // Step 4: Fill the rest of the dp array
+    for (int i = 1; i < m; i++) {
+        for (int j = 1; j < n; j++) {
+            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+        }
+    }
+
+    // Step 5: Store the result
+    int result = dp[m - 1][n - 1];
+
+    // Step 6: Free allocated memory
+    for (int i = 0; i < m; i++) {
+        free(dp[i]);
+    }
+    free(dp);
+
+    return result;
+}
+```

Diff for: src/main/c/g0001_0100/s0062_unique_paths/readme.md

@@ -0,0 +1,88 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 64\. Minimum Path Sum
+
+Medium
+
+Given a `m x n` `grid` filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg)
+
+**Input:** grid = \[\[1,3,1],[1,5,1],[4,2,1]]
+
+**Output:** 7
+
+**Explanation:** Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum.
+
+**Example 2:**
+
+**Input:** grid = \[\[1,2,3],[4,5,6]]
+
+**Output:** 12
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= grid[i][j] <= 100`
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+int recur(int** grid, int** dm, int r, int c, int rows, int cols) {
+    if (dm[r][c] == 0 && r != rows - 1 && c != cols - 1) {
+        dm[r][c] = grid[r][c] + (recur(grid, dm, r + 1, c, rows, cols) < recur(grid, dm, r, c + 1, rows, cols) 
+                                 ? recur(grid, dm, r + 1, c, rows, cols) 
+                                 : recur(grid, dm, r, c + 1, rows, cols));
+    }
+    return dm[r][c];
+}
+
+int minPathSum(int** grid, int gridSize, int* gridColSize) {
+    if (gridSize == 1 && gridColSize[0] == 1) {
+        return grid[0][0];
+    }
+
+    int rows = gridSize;
+    int cols = gridColSize[0];
+    int** dm = (int**)malloc(rows * sizeof(int*));
+    for (int i = 0; i < rows; i++) {
+        dm[i] = (int*)malloc(cols * sizeof(int));
+        for (int j = 0; j < cols; j++) {
+            dm[i][j] = 0; // Initialize to 0
+        }
+    }
+
+    int s = 0;
+    for (int r = rows - 1; r >= 0; r--) {
+        dm[r][cols - 1] = grid[r][cols - 1] + s;
+        s += grid[r][cols - 1];
+    }
+
+    s = 0;
+    for (int c = cols - 1; c >= 0; c--) {
+        dm[rows - 1][c] = grid[rows - 1][c] + s;
+        s += grid[rows - 1][c];
+    }
+
+    int result = recur(grid, dm, 0, 0, rows, cols);
+
+    // Free allocated memory
+    for (int i = 0; i < rows; i++) {
+        free(dm[i]);
+    }
+    free(dm);
+
+    return result;
+}
+```

Diff for: src/main/c/g0001_0100/s0064_minimum_path_sum/readme.md

@@ -0,0 +1,73 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-C/LeetCode-in-C?label=Stars&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C)
+[![](https://img.shields.io/github/forks/LeetCode-in-C/LeetCode-in-C?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-C/LeetCode-in-C/fork)
+
+## 70\. Climbing Stairs
+
+Easy
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 
+
+1. 1 step + 1 step 
+
+2. 2 steps
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 
+
+1. 1 step + 1 step + 1 step 
+
+2. 1 step + 2 steps 
+
+3. 2 steps + 1 step
+
+**Constraints:**
+
+*   `1 <= n <= 45`
+
+## Solution
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+int climbStairs(int n) {
+    if (n < 2) {
+        return n;
+    }
+
+    // Create an array to store the number of ways to climb to each step
+    int* cache = (int*)malloc(n * sizeof(int));
+    
+    // Base cases
+    cache[0] = 1; // 1 way to climb to the 1st step
+    cache[1] = 2; // 2 ways to climb to the 2nd step
+
+    // Fill the cache using dynamic programming
+    for (int i = 2; i < n; i++) {
+        cache[i] = cache[i - 1] + cache[i - 2];
+    }
+
+    // Store the result
+    int result = cache[n - 1];
+
+    // Free allocated memory
+    free(cache);
+
+    return result;
+}
+```