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.这道题我最先想到的就是贪心算法,我先试试看。成了,淦。