6 problems solved.

lintcoder · lintcoder · commit 2e0f1876bf18 · 2022-12-17T20:41:58.000+08:00
diff --git a/src/2407.cpp b/src/2407.cpp
@@ -0,0 +1,18 @@
+int countDistinctIntegers(vector<int>& nums) {
+        set<int> st;
+        int len = nums.size();
+        for (int i = 0; i < len; ++i)
+        {
+            st.insert(nums[i]);
+            int val = 0;
+            int tmp = nums[i];
+            while (tmp != 0)
+            {
+                val = val*10 + tmp%10;
+                tmp /= 10;
+            }
+            st.insert(val);
+        }
+
+        return st.size();
+    }
diff --git a/src/2491.cpp b/src/2491.cpp
@@ -0,0 +1,21 @@
+bool isCircularSentence(string sentence) {
+        int len = sentence.size();
+        char first = sentence[0], last = sentence[0];
+        int i = 1;
+
+        while (i < len)
+        {
+            if (sentence[i] == ' ')
+            {
+                last = sentence[i-1];
+                if (sentence[i+1] != last)
+                    return false;
+                else
+                    ++i;
+            }
+            else
+                ++i;
+        }
+
+        return sentence[i-1] == first;
+    }
diff --git a/src/2492.cpp b/src/2492.cpp
@@ -0,0 +1,17 @@
+long long dividePlayers(vector<int>& skill) {
+        int len = skill.size();
+        sort(skill.begin(), skill.end());
+
+        int n = len/2;
+        int v = skill[0] + skill[len-1];
+        long long sum = skill[0] * skill[len-1];
+        for (int i = 1; i < n; ++i)
+        {
+            if (skill[i] + skill[len-1-i] != v)
+                return -1;
+            else
+                sum += skill[i] * skill[len-1-i];
+        }
+
+        return sum;
+    }
diff --git a/src/2497.cpp b/src/2497.cpp
@@ -0,0 +1,36 @@
+int maximumValue(vector<string>& strs) {
+        int len = strs.size();
+        int maxval = 0;
+        for (int i = 0; i < len; ++i)
+        {
+            int n = strs[i].size();
+            bool flag = false;
+            int j = 0;
+            int val = 0;
+            while (j < n)
+            {
+                if (isdigit(strs[i][j]))
+                    val = val*10 + (strs[i][j]-'0');
+                else
+                {
+                    flag = true;
+                    break;
+                }
+                ++j;
+            }
+
+            if (flag)
+            {
+                if (n > maxval)
+                    maxval = n;
+            }
+            else
+            {
+                if (val > maxval)
+                    maxval = val;
+            }
+            cout << val << endl;
+        }
+
+        return maxval;
+    }
diff --git a/src/2501.cpp b/src/2501.cpp
@@ -0,0 +1,22 @@
+int deleteGreatestValue(vector<vector<int>>& grid) {
+        int m = grid.size();
+        int n = grid[0].size();
+
+        for (int i = 0; i < m; ++i)
+            sort(grid[i].begin(), grid[i].end());
+        
+        int sum = 0;
+        for (int i = n-1; i >= 0; --i)
+        {
+            int maxval = 0;
+            for (int j = 0; j < m; ++j)
+            {
+                if (grid[j][i] > maxval)
+                    maxval = grid[j][i];
+            }
+
+            sum += maxval;
+        }
+
+        return sum;
+    }
diff --git a/src/63.cpp b/src/63.cpp
@@ -0,0 +1,72 @@
+int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int row = obstacleGrid.size();
+        int col = obstacleGrid[0].size();
+
+        if (row == 1 && col == 1)
+        {
+            return obstacleGrid[0][0] == 0 ? 1 : 0;
+        }
+
+        vector<vector<int>> dp(row, vector<int>(col, 0));
+        int r = 0, c = 0;
+        while (r < row)
+        {
+            if (obstacleGrid[r][0] == 0)
+            {
+                dp[r][0] = 1;
+                ++r;
+            }    
+            else
+            {
+                while (r < row)
+                {
+                    dp[r][0] = -1;
+                    ++r;
+                }
+            }
+        }
+
+        while (c < col)
+        {
+            if (obstacleGrid[0][c] == 0)
+            {
+                dp[0][c] = 1;
+                ++c;
+            }    
+            else
+            {
+                while (c < col)
+                {
+                    dp[0][c] = -1;
+                    ++c;
+                }
+            }
+        }
+
+        r = 1;
+        while (r < row)
+        {
+            c = 1;
+            while (c < col)
+            {
+                if (obstacleGrid[r][c] == 0)
+                {
+                    if (dp[r-1][c] == -1 && dp[r][c-1] == -1)
+                        dp[r][c] = -1;
+                    else
+                    {
+                        if (dp[r-1][c] != -1)
+                            dp[r][c] += dp[r-1][c];
+                        if (dp[r][c-1] != -1)
+                            dp[r][c] += dp[r][c-1];
+                    }
+                }
+                else
+                    dp[r][c] = -1;
+                ++c;
+            }
+            ++r;
+        }
+        
+        return dp[row-1][col-1] > 0 ? dp[row-1][col-1] : 0;
+    }
