第 358 场周赛 - 力扣（LeetCode）

2815. 数组中的最大数对和 - 力扣（LeetCode）

双for遍历即可

class Solution {
public:
    int maxSum(vector<int>& nums) {
        
        auto re = [](int x){
            int ma = 0;
            while(x){
                if(x % 10 > ma) ma = x % 10;
                x /= 10;
            }
            return ma;
        };
        
        int n = nums.size();
        int ans = -1;
        for(int i = 0;i < n;i ++){
            for(int j = i + 1;j < n;j ++){
                if(re(nums[i]) == re(nums[j]) && nums[i] + nums[j] > ans)
                    ans = nums[i] + nums[j];
            }
        }

        return ans;
    }
};

2816. 翻倍以链表形式表示的数字 - 力扣（LeetCode）

不太常用链表,还是现查了一下怎么用qwq,还写了个字符串乘\(2\)的函数orz

原版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    string multiplyByTwo(const std::string& numberString) {
        std::string num1(numberString.rbegin(), numberString.rend());
        string num2 = num1;
        string result = "";
        int carry = 0;
        for (int i = 0; i < num1.length(); i++) {
            int digit1 = num1[i] - '0';
            int digit2 = num2[i] - '0';
            int sum = digit1 + digit2 + carry;
            int currentDigit = sum % 10;
            result.insert(0, 1, currentDigit + '0');
            carry = sum / 10;
        }
        if (carry != 0) {
            result.insert(0, 1, carry + '0');
        }
        return result;
    }
    ListNode* doubleIt(ListNode* head) {
        string s = "";
        while(head != nullptr){
                s += head->val + '0';
            head = head->next;
        }
        s = multiplyByTwo(s);
        ListNode *ans = nullptr;
        ListNode *num = nullptr;
        for(int i = 0;i < s.size();i ++){
            ListNode* t = new ListNode;
            t->val = s[i] - '0';
            t->next = nullptr;
            if(ans == nullptr){
                ans = t;
                num = t;
            }else{
                num->next = t;
                num = t;
            }
        }
        return ans;
    }
};

后来看了灵神的代码,发现很妙,一个数乘\(2\)最多就只会进一位,所以在最开始判断首位数是不是大于4,是的话就在前面新加一个节点,其余的就是跟着模拟,如果下一个数大于4,那么它前一个数就应该进1,它自己就等于二倍后的个位数了

class Solution {
public:
    ListNode* doubleIt(ListNode* head) {
        if(head->val > 4)
            head = new ListNode(0, head);
            for(auto i = head; i; i = i->next){
                i->val = i->val * 2 % 10;
                if(i->next && i->next->val > 4)
                i->val ++;
            }
        return head;
    }
};

2817. 限制条件下元素之间的最小绝对差 - 力扣（LeetCode）(平衡树+双指针)

用双指针把每隔\(x\)个元素都加进去,但是不用弹出,因为题目说了是至少大于等于\(x\)个数,指针往下一个数扫描时,它的前\(x+1\)个数也能被存进去,然后就是二分去找一个最小值,因为二分查找的是第一个大于等于当前的数,但是也可能它的前一个差值更小,这里也要比较它二分查找出的前一个,因为要做自减操作,防止空指针我们要提前在set里存一个最小值和一个最大值,\(INT\_MIN / 2\)是防止数据溢出int范围,如果你set存的是long long类型那就不用担心这个问题了

class Solution {
public:
    int minAbsoluteDifference(vector<int>& nums, int x) {
        int ans = INT_MAX, n = nums.size();
        set<int> s = {INT_MIN / 2, INT_MAX};
        for(int i = x;i < n;i ++){
            s.insert(nums[i - x]);
            auto t = s.lower_bound(nums[i]);
            ans = min({ans, *t - nums[i], nums[i] - *--t});
        }
        return ans ;
    }
};

2818. 操作使得分最大 - 力扣（LeetCode）(质因数分解+单调栈+快速幂)

看了很多佬说这道题不错,不过有点难,先留着,后面其他题补了再来补