Trapping Rain Water Problem

#include <stdio.h>

int maxWater(int arr[], int n) {
    int res = 0;

    // For every element of the array
    for (int i = 1; i < n - 1; i++) {

        // Find the maximum element on its left
        int left = arr[i];
        for (int j = 0; j < i; j++)
            if (arr[j] > left)
                left = arr[j];

        // Find the maximum element on its right
        int right = arr[i];
        for (int j = i + 1; j < n; j++)
            if (arr[j] > right)
                right = arr[j];

        // Update the maximum water
        res += (left < right ? left : right) - arr[i];
    }

    return res;
}

// Driver code
int main() {
    int arr[] = { 2, 1, 5, 3, 1, 0, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d", maxWater(arr, n));
    return 0;
}

#include <stdio.h>

int maxWater(int arr[], int n) {

    // left[i] contains height of tallest bar to the
    // left of i'th bar including itself
    int left[n];

    // right[i] contains height of tallest bar to
    // the right of i'th bar including itself
    int right[n];

    int res = 0;

    // fill left array
    left[0] = arr[0];
    for (int i = 1; i < n; i++)
        left[i] = left[i - 1] > arr[i] ? left[i - 1] : arr[i];

    // fill right array
    right[n - 1] = arr[n - 1];
    for (int i = n - 2; i >= 0; i--)
        right[i] = right[i + 1] > arr[i] ? right[i + 1] : arr[i];

    // calcualte the accumulated water element by element
    for (int i = 1; i < n - 1; i++) {
        int minOf2 = left[i] < right[i] ? left[i] : right[i];
            res += minOf2 - arr[i];
    }

    return res;
}

int main() {
    int arr[] = { 2, 1, 5, 3, 1, 0, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d", maxWater(arr, n));
    return 0;
}

#include <stdio.h>

int maxWater(int arr[], int n) {
    int left = 1;
    int right = n - 2;

    // lMax : Maximum in subarray arr[0..left-1]
    // rMax : Maximum in subarray arr[right+1..n-1]
    int lMax = arr[left - 1];
    int rMax = arr[right + 1];

    int res = 0;
    while (left <= right) {
      
        // If rMax is smaller, then we can
        // decide the amount of water for arr[right]
        if (rMax <= lMax) {
          
            // Add the water for arr[right]
            res += (rMax - arr[right]) > 0 ? (rMax - arr[right]) : 0;

            // Update right max
            rMax = rMax > arr[right] ? rMax : arr[right];

            // Update right pointer as we have 
            // decided the amount of water for this
            right -= 1;
        } else { 
            // Add the water for arr[left]
            res += (lMax - arr[left]) > 0 ? (lMax - arr[left]) : 0;

            // Update left max
            lMax = lMax > arr[left] ? lMax : arr[left];

            // Update left pointer as we have decided water for this
            left += 1;
        }
    }
    return res;
}

int main() {
    int arr[] = {2, 1, 5, 3, 1, 0, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", maxWater(arr, n));
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

struct Stack {
    int *array;
    int top;
    int capacity;
};

struct Stack* createStack(int capacity) {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (int*)malloc(capacity * sizeof(int));
    return stack;
}

// Stack is full when top is equal to the last index
int isFull(struct Stack* stack) {
    return stack->top == stack->capacity - 1;
}

// Stack is empty when top is -1
int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

// Function to add an item to stack
void push(struct Stack* stack, int item) {
    if (isFull(stack))
        return;
    stack->array[++stack->top] = item;
}

// Function to remove an item from stack
int pop(struct Stack* stack) {
    if (isEmpty(stack))
        return -1;
    return stack->array[stack->top--];
}

// Function to return the top from the stack without popping
int top(struct Stack* stack) {
    return stack->array[stack->top];
}

int maxWater(int* arr, int n) {

    struct Stack* st = createStack(n);
    int res = 0;

    for (int i = 0; i < n; i++) {
       
        // Pop all items smaller than arr[i]
        while (!isEmpty(st) && arr[top(st)] < arr[i]) {          
            
            int pop_height = arr[pop(st)];

            if (isEmpty(st))
                break;

            // arr[i] is the next greater for the removed item
            // and new stack top is the previous greater 
            int distance = i - top(st) - 1;

            // Take the minimum of two heights (next and prev greater)
            int water = (arr[top(st)] < arr[i]) ? arr[top(st)] : arr[i];

            // Find the amount of water
            water -= pop_height;
            
            res += distance * water;
        }
        push(st, i);
    }
    free(st->array);
    free(st);
    return res;
}

int main() {
    int arr[] = {2, 1, 5, 3, 1, 0, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", maxWater(arr, n));
    return 0;
}