6 problems solved.

lintcoder · lintcoder · commit 7f5ef72fe725 · 2021-04-29T18:44:49.000+08:00
diff --git a/src/1266.cpp b/src/1266.cpp
@@ -0,0 +1,25 @@
+int minTimeToVisitAllPoints(vector<vector<int>>& points) {
+        int len = points.size();
+        if (len == 1)
+            return 0;
+        int a = points[0][0], b = points[0][1];
+        int sum = 0;
+        for (int i = 1; i < len; ++i)
+        {
+            int c = points[i][0], d = points[i][1];
+            if (a == c && b != d)
+                sum += abs(b-d);
+            else if (a != c && b == d)
+                sum += abs(a-c);
+            else if (a != c && b != d)
+            {
+                int mindiff = abs(a-c) < abs(b-d) ? abs(a-c) : abs(b-d);
+                int delta = abs(abs(a-c)-abs(b-d));
+                sum += mindiff + delta;
+            }
+            a = c;
+            b = d;
+        }
+        
+        return sum;
+    }
diff --git a/src/1827.cpp b/src/1827.cpp
@@ -0,0 +1,14 @@
+int minOperations(vector<int>& nums) {
+        int len = nums.size();
+        int sum = 0;
+        for (int i = 1; i < len; ++i)
+        {
+            if (nums[i] <= nums[i-1])
+            {
+                sum += nums[i-1]-nums[i]+1;
+                nums[i] = nums[i-1]+1;
+            }
+        }
+        
+        return sum;
+    }
diff --git a/src/1833.cpp b/src/1833.cpp
@@ -0,0 +1,20 @@
+int maxIceCream(vector<int>& costs, int coins) {
+        int len = costs.size();
+        sort(costs.begin(), costs.end());
+        
+        int n = 0;
+        int i = 0;
+        while (i < len && coins > 0)
+        {
+            if (coins >= costs[i])
+            {
+                coins -= costs[i];
+                ++i;
+                ++n;
+            }
+            else
+                break;
+        }
+        
+        return n;
+    }
diff --git a/src/1837.cpp b/src/1837.cpp
@@ -0,0 +1,10 @@
+int sumBase(int n, int k) {
+        int sum = 0;
+        while (n >= k)
+        {
+            sum += n%k;
+            n /= k;
+        }
+        
+        return sum+n;
+    }
diff --git a/src/746.cpp b/src/746.cpp
@@ -0,0 +1,15 @@
+int minCostClimbingStairs(vector<int>& cost) {
+        int len = cost.size();
+        vector<int> dp(len+1, 0);
+        
+        dp[0] = 0;
+        dp[1] = 0;
+        int i = 2;
+        while (i <= len)
+        {
+            dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]);
+            ++i;
+        }
+        
+        return dp[len];
+    }
diff --git a/src/82.cpp b/src/82.cpp
@@ -0,0 +1,92 @@
+ListNode* deleteDuplicates(ListNode* head) {
+       if (head == nullptr || head->next == nullptr)
+           return head;
+        
+        ListNode* node = head;
+        int refval = head->val;
+        ListNode* tmp = node->next;
+        bool flag = false;
+        while (tmp != nullptr)
+        {
+            if (tmp->val == refval)
+            {
+                ListNode* p = tmp->next;
+                delete tmp;
+                tmp = p;
+                flag = true;
+            }
+            else
+            {
+                if (!flag)
+                {
+                    head = node;
+                    break;
+                }
+                else
+                {
+                    delete node;
+                    node = tmp;
+                    tmp = tmp->next;
+                    refval = node->val;
+                    flag = false;
+                }
+            }
+        }
+        
+        if (tmp == nullptr)
+        {
+            if (flag)
+            {
+                delete node;
+                return nullptr;
+            }
+            else
+            {
+                head = node;
+                return head;
+            }
+        }
+        
+        flag = false;
+        refval = tmp->val;
+        ListNode* tmp2 = tmp->next;
+        ListNode* lastnode = node;
+        while (tmp2 != nullptr)
+        {
+            if (tmp2->val == refval)
+            {
+                ListNode* p = tmp2->next;
+                tmp->next = p;
+                delete tmp2;
+                tmp2 = p;
+                flag = true;
+            }
+            else
+            {
+                if (!flag)
+                {
+                    refval = tmp2->val;
+                    lastnode = tmp;
+                    tmp = tmp2;
+                    tmp2 = tmp2->next;
+                }
+                else
+                {
+                    lastnode->next = tmp2;
+                    delete tmp;
+                    refval = tmp2->val;
+                    tmp = tmp2;
+                    tmp2 = tmp2->next;
+                    flag = false;
+                }
+            }
+        }
+        
+        if (flag)
+        {
+            lastnode->next = nullptr;
+            delete tmp;
+        }
+        
+        return head;
+    }
