leetcode-周赛no.167-875 / 1534

最新推荐文章于 2025-10-05 19:42:21 发布

原创最新推荐文章于 2025-10-05 19:42:21 发布 · 277 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#二分法 #前缀和

算法刷题专栏收录该内容

39 篇文章

订阅专栏

本文探讨了链表转换为十进制数的算法，优化了寻找顺次数的策略，并介绍了利用二维前缀和解决矩阵最大边长问题的方法。

第一题

给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。

请你返回该链表所表示数字的十进制值。

10min 1A

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int getDecimalValue(ListNode* head) {
        vector<int> num;
        while(head->next!=nullptr){
            num.push_back(head->val);
            head = head->next;
        }
        num.push_back(head->val);
        
        vector<int> b;
        for(int i = num.size()-1;i>=0;i--){
            b.push_back(num[i]);
        }
        long res=0;
        long cnt=1;
        for(int i=0;i<b.size();i++){
            if(b[i]==1){
                res+=cnt;
            }
            cnt*=2;
        }
        return (int)res;
    }
};

看了题解发现我是个傻逼

class Solution {
public:
    int getDecimalValue(ListNode* head) {
        int ret = 0;
        while (head != NULL) {
            ret = ret * 2 + head->val;
            head = head->next;
        }
        return ret;
    }
};
/*
作者：小白二号
链接：https://leetcode-cn.com/circle/discuss/mLljrr/view/GwXchV/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
*/

第二题

我们定义「顺次数」为：每一位上的数字都比前一位上的数字大 1 的整数。

请你返回由 [low, high] 范围内所有顺次数组成的有序列表（从小到大排序）。

示例 1：

输出：low = 100, high = 300
输出：[123,234]

超时代码
测试样例[10,1e9]，我傻逼了
测试[10,1e7]花费9.5s

class Solution {
public:
    vector<int> sequentialDigits(int low, int high) {
        vector<int> res;
        for(int i = low;i<=high;i++){
            if(judge(i)){
                res.push_back(i);
            }
        }
        return res;
    }
    
    int judge(int num){
        vector<int> s;
        while(num/10>0){
            s.push_back(num%10);
            num/=10;
        }
        s.push_back(num);
        if(s.size()<=1){
            return 1;
        }
        int flag = 1;
        for(int i=0;i<s.size()-1;i++){
            if(s[i]!=s[i+1]+1){
                flag = 0;
                break;
            }
        }
        
        return flag;
    }
};

优化了一下代码，不是暴力循环而是跳变循环
还是超时
测试[10,1e7]花费6.32s，不知道效率为何提升不大。

class Solution {
public:
    vector<int> sequentialDigits(int low, int high) {
        vector<int> res;
        for(int i = low;i<=high;){
            if(judge(i)){
                res.push_back(i);
                i+=je(i);
            }else{
                i++;
            }
        }
        return res;
    }
    
    int je(int num){
        int i = 0;
        while(num/((int)pow(10,(double)i))>10){
            i++;
        }
        return (int)pow(10,i);
    }
    
    int judge(int num){
        vector<int> s;
        while(num/10>0){
            s.push_back(num%10);
            num/=10;
        }
        s.push_back(num);
        if(s.size()<=1){
            return 1;
        }
        int flag = 1;
        for(int i=0;i<s.size()-1;i++){
            if(s[i]!=s[i+1]+1){
                flag = 0;
                break;
            }
        }
        
        return flag;
    }
};

继续优化，把judge的暴力改成了log（n）的复杂度
测试[10,1e7]花费0.1s，效率提升很大，但是还是tle

class Solution {
public:
    vector<int> sequentialDigits(int low, int high) {
        vector<int> res;
        for(int i = low;i<=high;){
            if(judge(i)){
                res.push_back(i);
                i+=je(i);
            }else{
                i++;
            }
        }
        return res;
    }
    
    int je(int num){
        int i = 0;
        while(num/((int)pow(10,(double)i))>10){
            i++;
        }
        return (int)pow(10,i);
    }
    
    int judge(int num){
        int pre = -1;
        while(num/10>=0){
            if(num==0){
                break;
            }
            if(pre == -1){
                pre = num%10;
                num/=10;
                continue;
            }else{
                if(pre != num%10+1){
                    return 0;
                } else{
                    pre = num%10;
                    num/=10;
                    continue;
                }
            }
        }
        return 1;
    }
};

放弃了，比赛结束看题解
简单的打表，我可能是个弱智

class Solution {
public:
    vector<int> sequentialDigits(int low, int high) {
        vector<int> table;
        vector<int> res;
        for(int i=1;i<=9;i++){
            int x = i;
            for(int j=i+1;j<=9;j++){
                x = x*10+j;
                table.push_back(x);
            }
        }
        sort(table.begin(),table.end());
        for(int i = 0;i<table.size();i++){
            if(table[i]>=low&&table[i]<=high){
                res.push_back(table[i]);
            }
        }
        return res;
    }
};

第三题

给你一个大小为 m x n 的矩阵 mat 和一个整数阈值 threshold。

请你返回元素总和小于或等于阈值的正方形区域的最大边长；如果没有这样的正方形区域，则返回 0 。
详细描述

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

不会，kankan题解
二位前缀和

class Solution {
public:
    int maxSideLength(vector<vector<int>>& mat, int threshold) {
        long long map[305][305];
        memset(map,0,sizeof(map));
        int col = mat[0].size();
        int row = mat.size();
        for(int i=1;i<=row;i++){
            for(int j=1;j<=col;j++){
                map[i][j] = mat[i-1][j-1]+map[i-1][j]+map[i][j-1]-map[i-1][j-1];
            }
        }
        int maxx = 0;
        for(int i=1;i<=row;i++){
            for(int j=1;j<=col;j++){
                for(int k=1;k<=i&&k<=j;k++){
                    if((map[i][j]-map[i][j-k]-map[i-k][j]+map[i-k][j-k])<=threshold){
                        maxx = max(maxx,k);

                    }
                }
            }
        }
        return maxx;

    }
};

改进思路，二位前缀和+二分

需要多次求子矩阵之和，且矩阵的值不会再次修改，应该使用二维前缀和矩阵预处理，提高求和效率
具体参考：
二维区域和检索 - 矩阵不可变

使用二分查找可以提高查找效率，不过大部分测试案例的结果都较小，靠近下限，C++用顺序查找不会造成超时，看评论python会超。

代码如下：

class Solution {
public:
    vector<vector<int>> Pre;//保存前缀和
    int len1;
    int len2;

    int Fun(int len) {//找到所有对应边长的正方形的最小总和
        if (len == 0) return 0;
        int Min = 0x7fffffff;
        for (int i = 0; i < len1 - len + 1; ++i) {
            for (int j = 0; j < len2 - len + 1; ++j) {
                int tmp = Pre[i + len][j + len] - Pre[i + len][j] - Pre[i][j + len] + Pre[i][j];
                if (tmp < Min) Min = tmp;
            }
        }
        return Min;
    }

    int maxSideLength(vector<vector<int>> &mat, int threshold) {
        len1 = mat.size();
        len2 = mat[0].size();
        Pre = vector<vector<int>>(len1 + 1, vector<int>(len2 + 1, 0));
        for (int i = 1; i <= len1; ++i) {
            for (int j = 1; j <= len2; ++j) {
                Pre[i][j] = Pre[i - 1][j] + Pre[i][j - 1] - Pre[i - 1][j - 1] + mat[i - 1][j - 1];
            }
        }
        int Min = min(len1, len2);
        //二分查找，一般答案靠近下限，所以顺序查找效率也不低
        /*
        for(int i=0;i<=Min;++i){
            if(Fun(i)>threshold) return i-1;
        }
        return Min;
        */

        int lo = 0;
        int hi = Min;
        while (lo < hi) {
            int mi = (lo + hi + 1) >> 1;
            int k = Fun(mi);
            if (k <= threshold) {
                lo = mi;
            } else hi = mi - 1;
        }
        return lo;

    }
};
/*
作者：jian-liao
链接：https://leetcode-cn.com/problems/maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold/solution/c-er-wei-qian-zhui-he-er-fen-cha-zhao-by-jian-liao/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
*/