leetcode刷题记录-day14

369

1.本来我还想和他折腾一下，计划着先将这个链表翻转，然后再加1，最后再翻转回来，现在看来完全不必。
2.直接读取这个链表的数据，然后转成整数计算，最后给这个链表重新赋值即可。
3.当然，不可直接转为int计算，而应该在字符串上计算。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* plusOne(ListNode* head) {
        string s;
        for(ListNode* curNode = head; curNode != nullptr; curNode = curNode->next) {
            s += to_string(curNode->val);
        }
        reverse(s.begin(), s.end());
        int fullup = 1;
        for(int i = 0; i < s.size(); ++ i) {
            int part = (atoi(s.substr(i, 1).c_str()) + fullup) % 10;
            fullup = (atoi(s.substr(i, 1).c_str()) + fullup) / 10;
            s[i] = '0'+part;
            if(fullup == 0)
                break;
        }
        if(fullup == 1)
            s += "1";
        reverse(s.begin(), s.end());
        ListNode* curNode = head;
        for(int i = 0; i < s.size(); ++ i) {
            if(i != s.size()-1) {
                if(curNode->next == nullptr) {
                    ListNode* newNode = new ListNode(0);
                    curNode->next = newNode;
                }
                curNode->val = atoi(s.substr(i,1).c_str());
                curNode = curNode->next;
            } else {
                curNode->val = atoi(s.substr(i,1).c_str());
            }
        }
        return head;
    }
};

370

1.这道题之前应该是做过才对，直接维护一个差值数组即可，时间复杂度非常低。

372

1.这道题应该就是计算一下a的b次方对1337取模，可以直接dfs解决这个计算过程。
2.快速幂的计算应该是没啥问题的，不过这里b的数组长度可能会非常大，那也没办法了。

373

1.这道题真的很棒，就是264丑数一样的解决思路，太棒啊。

class Solution {
public:
    vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
        if(nums1.size() + nums2.size() < k)
            return vector<vector<int>>();
        vector<vector<int>> ans(k,vector<int>(2, 0));
        ans[0][0] = nums1[0];
        ans[0][1] = nums2[0];
        int leftIndex = 1, rightIndex = 1;
        for(int i = 1; i < k; ++ i) {
            int leftSum = (leftIndex == nums1.size()) ? INT_MAX : (ans[leftIndex-1][1] + nums1[leftIndex]);
            int rightSum = (rightIndex == nums2.size()) ? INT_MAX : (ans[rightIndex-1][0] + nums2[rightIndex]);
            if(leftSum <= rightSum) {
                ans[i][0] = nums1[leftIndex];
                ans[i][1] = ans[leftIndex-1][1];
                leftIndex++;
            } else {
                ans[i][1] = nums2[rightIndex];
                ans[i][0] = ans[rightIndex-1][0];
                rightIndex++;
            }
        }
        return ans;
    }
};

375

1.这道题很有趣，我最开始的想法是不正确的。（二分法强行向上）
2.这道题的正确解法是dp，维护一个从i到j的最小代价，然后任取其中一个元素将整个区间一分为二，最后将两区间的最小值的max（注意啊，这里是max），加上划分区间的代价，作为i到j的值。

class Solution {
public:
    int getMoneyAmount(int n) {
        vector<vector<int>> details(n, vector<int>(n, 0));
        for(int i = 1; i < n; ++ i) {
            for(int j = 0; j < n-i; ++ j) {
                int tempMax = INT_MAX;
                for(int p = 0; p < i+1; ++ p) {
                    if(p == 0) {
                        tempMax = min(tempMax, details[j+1][j+i] + j+1);
                    } else if(p == i) {
                        tempMax = min(tempMax, details[j][j+i-1] + j+i+1);
                    } else {
                        tempMax = min(tempMax, max(details[j][j+p-1], details[j+p+1][j+i]) + j+p+1);
                    }
                }
                details[j][j+i] = tempMax;
            }
        }
        return details[0][n-1];
    }
};

376

1.这道题我最先想到的就是贪心算法，我先试试看。成了，淦。