Day 23 (30 Days of Code)

26 July 2023

I am still working on the project I have started recently. I am facing some issues but I am doing some progress. Apart from that I solved some DSA problems.

• Minimum Path Sum

My approach:

As usual, my very first approach was a brute force method using recursion. Then I used memoization and eventually solved it using Dynamic Programming.

My solution:

• Recursion with Memoization

class Solution {
public:

    int helper(vector<vector<int>>& grid, int m, int n, int i, int j, int** arr){

        if(i>=m || j>=n){
            return INT_MAX;
        }

        if(i==m-1 && j==n-1){
            return grid[i][j];
        }

        if(arr[i][j]!=-1){
            return arr[i][j];
        }

        int a = helper(grid, m,n,i,j+1,arr);
        int b = helper(grid, m,n,i+1,j,arr);

        arr[i][j] = min(a,b)+grid[i][j];
        return min(a,b)+grid[i][j];
    }

    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();

        int** arr = new int*[m];

        for(int i=0;i<m;i++){
            arr[i] = new int[n];
        }

        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                arr[i][j] = -1;
            }
        }
        return helper(grid,m,n,0,0,arr);
    }
};

• Dynamic Programming

class Solution {
public:

    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();

        int** arr = new int*[m];

        for(int i=0;i<m;i++){
            arr[i] = new int[n];
        }

        arr[0][0] = grid[0][0];
        for(int i=1;i<m;i++){
            arr[i][0] = grid[i][0]+arr[i-1][0];
        }

        for(int i=1;i<n;i++){
            arr[0][i] = grid[0][i]+arr[0][i-1];
        }

        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                arr[i][j] = grid[i][j]+min(arr[i-1][j], arr[i][j-1]);
            }
        }

        return arr[m-1][n-1];
    }
};

---

• Longest Palindrome

My approach:

I solved it by using a hashmap and a vector.

My solution:

class Solution {
public:
    int longestPalindrome(string s) {
        unordered_map<char,int> m;
        vector<char> v;

        for(int i=0;i<s.size();i++){
            if(m.count(s[i])>0){
                m[s[i]]++;
                continue;
            }
            m[s[i]] = 1;
            v.push_back(s[i]);
        }

        int maxLength = 0;

        for(int i=0;i<v.size();i++){
            if(m[v[i]]%2==0){
                maxLength+=m[v[i]];
            }else{
                maxLength+=(m[v[i]]-1);
            }
        }

        if(maxLength%2==0 && maxLength<s.size()){
            return maxLength+1;
        }

        return maxLength;
    }
};