SMWAK Algorithm

Recursion/SmwakAlgorithm/Readme.md

@@ -0,0 +1,143 @@
+# Smwak Algorithm Via Recursion
+
+## Description of Smwak Algorithm
+
+In various computational fields, including data analysis and optimization, the need to efficiently find minimum values in large matrices is critical. The **SMAWK algorithm** addresses this challenge by providing an efficient method for identifying row minima in **totally monotone matrices** , where the values decrease or remain constant along each row and column.
+
+Given an m×n matrix that meets the total monotonicity property, the objective is to implement the SMAWK algorithm to compute the index of the minimum value for each row. This algorithm is particularly useful in scenarios such as:
+
+1. **Data Processing** : Streamlining operations in machine learning pipelines that require quick access to row minima.
+2. **Resource Allocation** : Optimizing tasks in operations research where minimizing costs or distances is crucial.
+3. **Graph Algorithms** : Enhancing performance in dynamic programming solutions reliant on matrix representations.
+
+The SMAWK algorithm's efficient approach, with a time complexity of **O(m + n)** , makes it a powerful tool for developers and researchers needing to perform minimum value searches in structured datasets. The solution will provide a comprehensive implementation that adheres to best practices in computational efficiency and usability.
+
+#### Explanation:
+
+The **SMAWK algorithm** is a powerful and efficient technique for locating row minima in **totally monotone matrices** . A matrix is defined as totally monotone if the entries in each row and column are non-increasing or non-decreasing. This special property allows the SMAWK algorithm to significantly reduce the computational complexity involved in finding minimum values across large datasets.
+
+### Use Cases
+
+The SMAWK algorithm has several practical applications, particularly in fields that involve optimization and matrix operations with monotonic properties. Here are some notable use cases:
+
+**Resource Allocation in Operations Research** :
+
+- In scenarios where resources need to be allocated optimally (e.g., scheduling tasks or assigning resources), the SMAWK algorithm efficiently finds minimum costs in cost matrices, especially when the data exhibits monotonic properties.
+
+**Dynamic Programming Optimization** :
+
+- The SMAWK algorithm can be used to speed up certain dynamic programming problems by efficiently finding minimum values in recurrence relations, especially in cases where these relations form totally monotone matrices. Examples include problems in bioinformatics (e.g., sequence alignment) and computer vision.
+
+**Cost and Supply Chain Optimization** :
+
+- In logistics, matrices are used to model costs between suppliers, locations, or transit points. The SMAWK algorithm helps identify the optimal paths or minimize costs across locations, which is crucial for reducing expenses in supply chain management.
+
+**Matrix Sparsification in Machine Learning** :
+
+- For large datasets with matrix-like structures that are also sparse and monotonic, the SMAWK algorithm can find the minimum values quickly, supporting efficient feature extraction, clustering, and pattern recognition.
+
+**Image and Signal Processing** :
+
+- In image processing, matrices often represent pixel intensities, where minimum-finding algorithms are used to enhance image quality or detect edges. SMAWK can be applied to process specific monotone regions efficiently.
+
+**Optimal Pathfinding in Graphs** :
+
+- When finding optimal paths in certain types of graph structures that can be represented as monotone matrices, the SMAWK algorithm offers a faster approach for identifying paths with minimum weights or costs, which can be useful in network routing and navigation systems.
+
+**Scheduling in Manufacturing and Job Assignments** :
+
+- For scheduling tasks with dependencies, the SMAWK algorithm aids in minimizing time or cost for job assignments when the scheduling matrix satisfies monotonicity, thus optimizing production and labor allocation in manufacturing.
+
+**Data Science and Statistics** :
+
+- In large datasets with hierarchical or ranked data, the SMAWK algorithm can find minima efficiently, useful for statistical analysis and identifying key trends in data with monotonic relationships.
+
+## Problem Definition
+
+The SMAWK algorithm is an efficient method for finding row minima in totally monotone matrices, a specific type of matrix where entries decrease or stay constant along each row and column. Developed for optimizing complex search operations, this algorithm leverages a unique recursive approach, reducing computation time to O(m+n) for an m×n matrix, making it ideal for applications in computational geometry, dynamic programming, and machine learning. With SMAWK, developers gain a powerful tool for solving matrix-based problems more effectively, significantly improving the performance of algorithms that depend on finding minimum values in large, structured datasets
+
+### **Limitations:**
+
+The SMAWK algorithm, while efficient for certain types of problems, comes with its own set of limitations and considerations:
+
+**Matrix Requirements** :
+
+- The SMAWK algorithm requires the input matrix to be **totally monotone** , meaning that the minimum of each row must occur in a strictly increasing sequence down the columns. If the matrix does not satisfy this condition, the algorithm may produce incorrect results or fail to execute properly.
+
+**Handling Non-Monotone Matrices** :
+
+- If the input matrix is not totally monotone, the SMAWK algorithm cannot be applied directly. Alternative algorithms or preprocessing steps may be necessary to transform the matrix into a suitable form.
+
+**Implementation Complexity** :
+
+- While the theoretical performance is excellent, implementing the SMAWK algorithm correctly can be complex due to the intricate handling of indices and maintaining the monotonicity condition. Careful attention is needed to avoid errors such as segmentation faults or index out-of-bounds exceptions.
+
+**Practical Use Cases** :
+
+- The algorithm is particularly useful in specific scenarios like linear programming and optimization problems where matrices exhibit monotonic properties. However, it may not be the best choice for general-purpose matrix operations or for matrices where such properties are not guaranteed.
+
+**Memory Usage** :
+
+- The space complexity of **O(m+n)** , while efficient compared to other algorithms, can still be a concern with very large matrices. In situations where memory is limited, other strategies may need to be considered.
+
+**Scalability** :
+
+- While SMAWK is efficient for large matrices, it may not scale well if the problem constraints change, such as when the matrix becomes sparse or if different types of constraints are introduced. Alternative algorithms may perform better under those conditions.
+
+**Algorithm Assumptions** :
+
+- The algorithm assumes that the entire matrix fits into memory, which might not be feasible for extremely large datasets. In such cases, adaptations or different approaches, such as streaming algorithms, may be required.
+
+#### Constraints:
+
+The SMAWK algorithm is a powerful tool, but it does come with several constraints and requirements that limit its applicability in certain scenarios:
+
+**Totally Monotone Matrix Requirement** :
+
+- The SMAWK algorithm requires the matrix to be _totally monotone_ , meaning the position of the minimum value in each row must increase monotonically as you move down the rows. This property isn’t present in all matrices, limiting SMAWK's use to specific structured matrices.
+
+**Non-Adaptive to Arbitrary Matrices** :
+
+- SMAWK cannot be directly applied to arbitrary matrices without monotonic properties. If used on non-monotonic matrices, the algorithm may fail to provide correct results, making it essential to verify matrix properties before applying SMAWK.
+
+**Static Matrix Structure** :
+
+- The SMAWK algorithm is designed for matrices with fixed values. If the matrix values change frequently, SMAWK may not be efficient since it would need to reprocess the matrix after each change, reducing its time-saving advantages.
+
+**Memory Constraints with Large Matrices** :
+
+- Although SMAWK is efficient, it still requires memory proportional to the number of rows and columns. For extremely large matrices, especially in memory-constrained environments, this memory requirement could be a limitation.
+
+**Specialized Implementation** :
+
+- Implementing the SMAWK algorithm can be complex, requiring careful handling of indices and conditions to ensure the totally monotone property is maintained. Incorrect implementation can lead to incorrect results or increased time complexity, demanding experienced developers for reliable application.
+
+**Dependency on Monotonicity of Functions** :
+
+- In cases where SMAWK is applied to dynamic programming problems or cost matrices, the underlying functions need to exhibit monotonic behavior. If the functions are not monotonic, SMAWK may not be applicable or may require modifications that reduce its efficiency.
+
+#### Objective:
+
+The objective of the SMAWK algorithm is to efficiently find the minimum value in each row of a totally monotone matrix with a time complexity of O(n+m), where n is the number of rows and m is the number of columns. By leveraging the matrix’s monotonic structure, SMAWK reduces the need for exhaustive searches, making it suitable for large-scale optimization problems where row minima are required.
+
+This objective aligns with the algorithm's purpose in applications like resource allocation, dynamic programming, and other optimization scenarios, where it enables faster, more scalable solutions compared to traditional approaches. Through careful exploitation of monotonic properties, the SMAWK algorithm achieves a balance between performance and accuracy, especially in domains that demand efficient handling of large datasets.
+
+#### Complexity Analysis
+
+### Time Complexity
+
+The SMAWK algorithm has a time complexity of **O(m+n)**, where m is the number of rows and n is the number of columns in the matrix. This efficiency is achieved because the algorithm processes each row and column in a single pass, effectively discarding columns that do not contribute to the minima.
+
+### Space Complexity
+
+Regarding space complexity, SMAWK also requires **O(m+n)** additional space. This space is used for storing row and column indices, the reduced set of columns during processing, and result vectors that hold the minima for each row.
+
+Overall, the efficient time and space complexities make the SMAWK algorithm particularly well-suited for working with large matrices that have a totally monotonic property, enabling quick and effective results while minimizing computational overhead.
+
+### Summary
+
+The SMAWK algorithm is a specialized optimization technique designed to find row minima in totally monotone matrices with high efficiency, operating in O(n+m) time complexity. Leveraging the matrix's monotonic properties, it reduces the computational overhead compared to conventional methods, making it especially useful in large-scale optimization problems, such as resource allocation, scheduling, and dynamic programming. While it offers significant performance benefits, the algorithm’s applicability is limited to matrices that meet specific structural requirements, particularly total monotonicity. SMAWK exemplifies how mathematical properties can optimize complex operations and remains a valuable tool in fields requiring fast, scalable solutions for structured data.
+
+Time complexity of **O(m+n)**
+
+Space complexity **O(m+n)**

Recursion/SmwakAlgorithm/smwak.c

@@ -0,0 +1,126 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+bool is_totally_monotone(int **matrix, int rows, int cols)
+{
+  for (int c = 1; c < cols; ++c)
+  {
+    for (int r = 1; r < rows; ++r)
+    {
+      if (matrix[r][c] < matrix[r - 1][c] && matrix[r][c - 1] > matrix[r - 1][c - 1])
+      {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+int *smawk_recursive(int *rows, int rowsSize, int *cols, int colsSize, int **matrix)
+{
+  if (rowsSize == 0)
+    return NULL;
+
+  int *result = (int *)malloc(rowsSize * sizeof(int));
+  for (int i = 0; i < rowsSize; ++i)
+    result[i] = -1;
+
+  int *reduced_cols = (int *)malloc(colsSize * sizeof(int));
+  int reduced_cols_size = 0;
+
+  for (int i = 0; i < colsSize; ++i)
+  {
+    int j = cols[i];
+    while (reduced_cols_size > 0 && matrix[rows[reduced_cols_size - 1]][j] <= matrix[rows[reduced_cols_size - 1]][reduced_cols[reduced_cols_size - 1]])
+    {
+      reduced_cols_size--;
+    }
+    reduced_cols[reduced_cols_size++] = j;
+  }
+
+  for (int i = 0; i < rowsSize; ++i)
+  {
+    if (i % 2 == 0)
+    {
+      result[i] = reduced_cols_size > 0 ? reduced_cols[0] : -1;
+      continue;
+    }
+    int min_col = -1;
+    for (int j = 0; j < reduced_cols_size; ++j)
+    {
+      if (min_col == -1 || matrix[rows[i]][reduced_cols[j]] < matrix[rows[i]][min_col])
+      {
+        min_col = reduced_cols[j];
+      }
+    }
+    result[i] = min_col;
+  }
+
+  free(reduced_cols);
+  return result;
+}
+
+int *smawk(int **matrix, int rows, int cols)
+{
+  int *row_indices = (int *)malloc(rows * sizeof(int));
+  int *col_indices = (int *)malloc(cols * sizeof(int));
+  for (int i = 0; i < rows; ++i)
+    row_indices[i] = i;
+  for (int i = 0; i < cols; ++i)
+    col_indices[i] = i;
+
+  int *result = smawk_recursive(row_indices, rows, col_indices, cols, matrix);
+  free(row_indices);
+  free(col_indices);
+  return result;
+}
+
+int main()
+{
+  int rows, cols;
+  printf("Enter number of rows and columns: ");
+  scanf("%d %d", &rows, &cols);
+
+  int **matrix = (int **)malloc(rows * sizeof(int *));
+  for (int i = 0; i < rows; ++i)
+  {
+    matrix[i] = (int *)malloc(cols * sizeof(int));
+  }
+
+  printf("Enter matrix elements (row by row):\n");
+  for (int i = 0; i < rows; ++i)
+  {
+    for (int j = 0; j < cols; ++j)
+    {
+      scanf("%d", &matrix[i][j]);
+    }
+  }
+
+  if (!is_totally_monotone(matrix, rows, cols))
+  {
+    printf("The matrix is not totally monotone. SMAWK algorithm requires a totally monotone matrix.\n");
+    for (int i = 0; i < rows; ++i)
+    {
+      free(matrix[i]);
+    }
+    free(matrix);
+    return 1;
+  }
+
+  int *minima_indices = smawk(matrix, rows, cols);
+
+  printf("Row-wise minimum indices is :\n");
+  for (int i = 0; i < rows; ++i)
+  {
+    printf("Row %d: Column %d\n", i, minima_indices[i]);
+  }
+
+  free(minima_indices);
+  for (int i = 0; i < rows; ++i)
+  {
+    free(matrix[i]);
+  }
+  free(matrix);
+  return 0;
+}