LeetCode每日1题——2023.02

已于 2023-03-03 09:49:50 修改
阅读量295 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode 算法 职场和发展
于 2023-02-15 12:45:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43569892/article/details/129037812
版权
周日周一周二周三周四周五周六
1 √2 √34
567891011
121314 √1516 √17 ×18 √
19 √20 √21√22 ×23 ×24√25×
26√27√28√

统计每个月的每日1题做题情况。统计规则为：

  • 若正常解题且不为暴力做法，则日期后做标记 √
  • 若正常解题且为暴力做法，则日期后做标记 √
  • 若无法解题，则日期后做标记 ×

1 解密消息

链接
代码
class Solution {
public:
    string decodeMessage(string key, string message) {
        map<char, int> mp;
        for(int i = 0; i < 26; i++){
            mp[key[i]] = i;
        }
        string ans;
        for(int i = 0; i < message.length(); i++){
            char ch = char(mp[message[i]] + 'a');
            string s(1, ch);
            cout << "mp[message[i]] = " << mp[message[i]] << " message[i] = " << message[i] << endl;
            ans += s;
        }
        return ans;
    }
};

2 颜色交替的最短路径

链接
代码
class Solution {
public:
    struct point{
        int node;
        int last_color;
        int step;
        point(int n, int l, int s){node = n; last_color = l; step = s;}
    };
    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& redEdges, vector<vector<int>>& blueEdges) {
        int G[n][n][2];
        vector<int> answer(n);
        
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                for(int k = 0; k < 2; k++){
                    G[i][j][k] = 0;
                    answer[i] = 2*n;
                }
        
        for(int i = 0; i < redEdges.size(); i++)
            G[redEdges[i][0]][redEdges[i][1]][0] = 1;
        for(int i = 0; i < blueEdges.size(); i++)
            G[blueEdges[i][0]][blueEdges[i][1]][1] = 1;
        
        queue<point> Q;
        Q.push(point(0, 0, 0));
        Q.push(point(0, 1, 0));
        while(!Q.empty()){
            point tmp = Q.front();
            Q.pop();
            answer[tmp.node] = min(answer[tmp.node], tmp.step);
            for(int i = 0; i < n; i++){
                if(G[tmp.node][i][!tmp.last_color]){
                    Q.push(point(i, !tmp.last_color, tmp.step+1));
                    G[tmp.node][i][!tmp.last_color] = 0;
                }
            }
        }
        for(int i = 0; i < n; i++){
            if(answer[i] == 2*n) answer[i] = -1;
        }
        return answer;
    }
};

14 表现良好的最长时间段

链接
思路

在这里插入图片描述

代码
class Solution {
public:
    int longestWPI(vector<int>& hours) {
        vector<int> presum(hours.size()+1);
        stack<int> stk;
        stk.push(0);
        presum[0] = 0;
        int max_len = 0;
        for(int i = 1; i < presum.size(); i++) {
            if(hours[i-1] > 8)
                presum[i] = presum[i-1] + 1;
            else 
                presum[i] = presum[i-1] - 1; 
            if(presum[stk.top()] > presum[i]){
                stk.push(i);
            }
        }
        for(int j = hours.size(); j >= 0; j--){
            while(!stk.empty()){
                if(presum[j] - presum[stk.top()] > 0){
                    max_len = max(max_len, j - stk.top());
                    stk.pop();
                }
                else break;
            }
            if(stk.empty()) break;
        }
        return max_len;
    }
};

16 数组能形成多少数对

链接
代码
class Solution {
public:
    vector<int> numberOfPairs(vector<int>& nums) {
        vector<int> ans;
        map<int, queue<int> > mp;
        bool vis[nums.size()];
        for(int i = 0; i < nums.size(); i++){
            mp[nums[i]].push(i);
            vis[i] = false;
        }
        int cnt = 0;
        int num = nums.size();
        for(int i = 0; i < nums.size(); i++){
           if(vis[i]) continue;
           if(mp[nums[i]].size() >= 2){
              mp[nums[i]].pop();
              vis[mp[nums[i]].front()] = true;
              mp[nums[i]].pop();
              num -= 2;
              cnt++;
           }
        }
        ans.push_back(cnt);
        ans.push_back(num);
        return ans;
    }
};

17 最大的以 1 为边界的正方形

链接
思路

在这里插入图片描述

代码
class Solution {
public:
    int largest1BorderedSquare(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        int dp[m+1][n+1][2];
        for(int i = 0; i <= m; i++)
            for(int j = 0; j <= n; j++)
                dp[i][j][0] = dp[i][j][1] = 0;
        for(int i = 1; i <= m; i++)
            for(int j = 1; j <= n; j++){
                if(grid[i-1][j-1] == 0) continue;
                dp[i][j][0] = dp[i][j-1][0] + 1; // 行方向，从左到右
                dp[i][j][1] = dp[i-1][j][1] + 1; // 列方向，从上到下
            }
        int max_side = 0;
        for(int i = 1; i <= m; i++)
            for(int j = 1; j<= n; j++){
                int cur_side = min(dp[i][j][0], dp[i][j][1]);
                for(int k = cur_side; k > max_side; k--){
                    if(i-k+1 <= 0 || j-k+1 <= 0) continue;
                    if(dp[i-k+1][j][0] >= k && dp[i][j-k+1][1] >= k){
                        max_side = max(max_side, k);
                        break;
                    }
                }
            }
        return max_side*max_side;
    }
};

18 找出给定方程的正整数解

链接
代码
class Solution {
public:
    vector<vector<int>> findSolution(CustomFunction& customfunction, int z) {
        vector<vector<int>> ans;
        for(int i = 1; i <= 1000; i++)
            for(int j = 1; j <= 1000; j++){
                if(customfunction.f(i, j) == z){
                    vector<int> tmp;
                    tmp.push_back(i);
                    tmp.push_back(j);
                    ans.push_back(tmp);
                }
            }
        return ans;
    }
};

19 最大平均通过率

链接
代码
class Solution {
public:
    struct tmp1{
        int pass;
        int total;
        tmp1(int p, int t) {pass = p; total = t;}
        bool operator<(const tmp1& b) const
        {
            double inc1 = (pass+1.0)/(total+1) - pass*1.0/total;
            double inc2 = (b.pass+1.0)/(b.total+1) - b.pass*1.0/b.total;
            return inc1 < inc2; 
        }
    };
    double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {
            priority_queue<tmp1> q;
            for(int i = 0; i < classes.size(); i++){
                int pass = classes[i][0];
                int total = classes[i][1];
                q.push(tmp1(pass, total));
            }
            while(extraStudents--){
                tmp1 tmp = q.top();
                q.pop();
                tmp.pass +=1; tmp.total += 1;
                q.push(tmp);
            }
            double sum = 0;
            while(!q.empty()){
                tmp1 tmp = q.top();
                sum += tmp.pass*1.0/tmp.total;
                q.pop();
            }
            return sum/classes.size();
    }
};

20 最好的扑克手牌

链接
代码
class Solution {
public:
    string bestHand(vector<int>& ranks, vector<char>& suits) {
        if(suits[0] == suits[1] && suits[1] == suits[2] && suits[2] == suits[3] && suits[3] == suits[4])
            return "Flush";
        map<int, int> mp;
        int flag = 0;
        for(int i = 0; i < 5; i++) mp[ranks[i]] += 1;
        for(int i = 0; i < 5; i++){
            if(mp[ranks[i]] >= 3) return "Three of a Kind";
            if(mp[ranks[i]] == 2) flag = 1;
        }
        if(flag)
            return "Pair";
        return "High Card";
    }
};

21 灌溉花园的最少水龙头数目

链接
代码
class Solution {
public:
    struct Taps{
        int left;
        int right;
        Taps(){}
        Taps(int l, int r){left = l; right = r;}
    };
    static bool cmp(Taps p1, Taps p2){
        if(p1.left != p2.left)
            return p1.left < p2.left;
        else 
            return p1.right > p2.right;
    }
    int minTaps(int n, vector<int>& ranges) {
        struct Taps P[n+1];
        int cnt = 0;
        for(int i = 0; i < ranges.size(); i++){
            if(ranges[i]){
                int left = (i-ranges[i] >= 0)? i-ranges[i]: 0;
                int right = i + ranges[i];
                P[cnt++] = Taps(left, right);
            }
        }
        sort(P, P+cnt, cmp);
        if(P[0].left) return -1;
        int Taps_num = 1;
        int now_left = P[0].left;
        int now_right = P[0].right;
        int i = 1; 
        while(i < cnt){
            if(now_right >= n) break;
            int max_index = i;
            int max_right = now_right;
            while(P[i].left <= now_right && i < cnt){
                if(P[i].right > max_right){
                    max_index = i;
                    max_right = P[i].right;
                }
                i++;
            }
            if(max_right <= now_right) return -1;
            Taps_num++;
            now_left = P[max_index].left;
            now_right = P[max_index].right;
        }
        if(now_right < n) {
            return -1;
        }
            
        return Taps_num;
    }
};

22 石子游戏 II

链接
思路

在这里插入图片描述

代码
class Solution {
public:
    int stoneGameII(vector<int>& piles) {
        int n = piles.size();
        int dp[n+1][n+1];
        int sum = 0;
        for(int i = n-1; i >= 0; i--){
            sum += piles[i];
            for(int M = 1; M <= n; M++){
                if(i + 2*M >= n)
                    dp[i][M] = sum;
                else{
                    dp[i][M] = 0;
                    for(int x = 1; x <= 2*M; x++){
                        dp[i][M] = max(dp[i][M], sum - dp[i+x][max(M,x)]);
                    }
                }
            }
        }
        return dp[0][1];
    }
};

23 循环码排列

链接
思路

在这里插入图片描述

代码
class Solution {
public:
    vector<int> circularPermutation(int n, int start) {
        vector<int> p;
        for(int i = 0; i < 1<<n; i++){
            p.push_back(i^(i>>1)^start);   
        }
        return p;
    }
};

24 使数组中所有元素都等于零

链接
代码
class Solution {
public:
    int minimumOperations(vector<int>& nums) {
        int cnt = 0;
        set<int> st;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i]) 
                st.insert(nums[i]);
        }
        return st.size();
    }
};

25 交换字符使得字符串相同

链接
思路

在这里插入图片描述

代码
class Solution {
public:
    int minimumSwap(string s1, string s2) {
        int xy = 0;
        int yx = 0;
        for(int i = 0; i < s1.length(); i++){
            if(s1[i] != s2[i]){
                if(s1[i] == 'x') xy += 1;
                else yx += 1;
            }
        }
        int num = (xy + yx)/2;
        xy %= 2; yx %= 2;
        if(xy != yx) return -1;
        if(xy == 1) num += 1;
        return num;
    }
};

26 得分最高的单词集合

链接
代码
class Solution {
public:
    int maxScoreWords(vector<string>& words, vector<char>& letters, vector<int>& score) {
        vector<int> count(26); // 统计letters中的所有单词分布
        int n = words.size();
        int sum = 0;
        for(int i = 0; i < letters.size(); i++)
            count[letters[i] - 'a']++;
        for(int i = 0; i < (1 << n); i++){
            vector<int> tmp(26); // 统计当前子集中的所有单词分布
            for(int j = 0; j < n; j++){
                if(i & (1 << j)){
                    for(int k = 0; k < words[j].size(); k++) tmp[words[j][k]- 'a']++;
                }
            }
            int tmp_sum = 0;
            int ok = 1;
            for(int l = 0; l < 26; l++){
                tmp_sum += tmp[l] * score[l];
                ok = ok && (tmp[l] <= count[l]);
            }
            if(ok) sum = max(sum, tmp_sum);
        }
        return sum;
    }
};

27 递减元素使数组呈锯齿状

链接
代码
class Solution {
public:
    int sum_moves(vector<int> nums, int flag){
        int len = nums.size();
        int sum = 0;
        for(int i = len-2; i >= 1; i--){
            int min_value = min(nums[i-1], nums[i+1]);
            int max_value = max(nums[i-1], nums[i+1]);
            if(flag && nums[i] >= min_value) {// <
                sum += nums[i] - min_value + 1;
                nums[i] = min_value - 1;
            }
            else if(!flag && nums[i] <= max_value){
                if(nums[i] <= nums[i-1]){
                    sum += nums[i-1] - nums[i] + 1;
                    nums[i-1] =  nums[i] - 1;
                }
                if(nums[i] <= nums[i+1]){
                    sum += nums[i+1] - nums[i] + 1;
                    nums[i+1] =  nums[i] - 1;
                }
            }
            flag = !flag;
        }
        return sum;
    }
    int movesToMakeZigzag(vector<int>& nums) {
        return min(sum_moves(nums, 1), sum_moves(nums, 0));
    }
};

28 合并相似的物品

链接
代码
class Solution {
public:
    vector<vector<int>> mergeSimilarItems(vector<vector<int>>& items1, vector<vector<int>>& items2) {
        map<int, int> mp;
        for(int i = 0; i < items1.size(); i++){
            mp[items1[i][0]] += items1[i][1];
        }
        for(int i = 0; i < items2.size(); i++){
            mp[items2[i][0]] += items2[i][1];
        }
        vector<vector<int>> ans;
        for(auto p: mp){
            vector<int> tmp;
            tmp.push_back(p.first);
            tmp.push_back(p.second);
            ans.push_back(tmp);
        }
        return ans;
    }
};
innerheart
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【LeetCode每日一题合集】2023.11.27-2023.12.3
小威的博客
12-09 1714
就是找到长度为 n - k ，和最小的窗口，答案是 sum - mn。用差分 表示 from 到 to 的范围内增加了多少人，然后再还原。用一个变量维护上界，用一个有序集合维护新加的可用小数据。当新添加数字时，如果更小，则更新 mn 变量。参考官方题解的思想 和 0x3f的代码写的。维护最小变量mn，哈希表记录已经去除的数字。添加时 也只能添加 当前没有的，也是小的。去除时 是 去除最小的。
Leetcode(每日一题)——1234. 替换子串得到平衡字符串
庄小焱
02-13 310
因为我们在搜索过程中要时刻判断「不替换的内容」中四个字符的出现次数是否小于等于n/4，因此我们必须先遍历一遍整个字符串，得到字符的总共出现次数【初始化断「不替换的内容」中四个字符的出现次数，表示初始子串为空】，然后在滑动窗口的移动过程中，动态的增加或减少对应字符出现的次数，来维护「不替换的内容」中四个字符的出现次数。【子串不合法，就说明「不替换的内容」中存在至少一个字符的出现次数大于n/4，我们就要通过加长子串，从而缩短「不替换的内容」，期望多的字符被加入子串，使得「不替换的内容」可能满足】。
每日一题 -- LeetCode (二十一)
weixin_47771057的博客
07-07 123
JavaScript / TypeScript for LeetCode 当前进程： 开始时间：2020.6.27 结束时间：undefined GitHub仓库：https://github.com/Cundefined/JavaScript-or-TypeScript-for-LeetCode 参考视频：https://www.bilibili.com/video/BV1wA411b7qZ 1、题目要求 ( LeetCode-第152题 ) 乘积最大子数组 给你一个整数数组 nums ，请你找出数
LeetCode每日一题
WingPassager的博客
04-06 182
LeetCode每日一题 二维数组和字符串（旋转矩阵） 知识补充 **//给定一个数组** int[][] arr = new int[4][5]; //计算行的长度：4 int length1 = arr.length; //计算列的长度：5 int length2 = arr[0].length; 几种表示二维数组元素的方法： int arr1 [3] [4] ={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int arr2 [3] [4] = {1,2,3,4,5,6,
leetcode练习题——1. 两数之和（python实现）
01-20
leetcode练习题·简单组——1. 两数之和（python练习）题目+思路题目思路代码实现 以下解题思路，仅表示个人做题思路或引荐别人的方法——如有引用我会标注出来的 题目+思路 题目 给定一个整数数组 nums 和一个目标...
coolcao#ccsite#【LeetCode每日一题】33.搜索旋转排序数组1
07-25
3. nums 中的每个值都 独一无二 4. nums 肯定会在某个点上旋转 1. 先找到升序区间 2. 如果元素在升序区间内，直接在升序区间对其进行二分查找
LeetCode刷题笔记——56. 合并区间
01-20
1、解析   1）先对列表进行排序   2）判断两个相邻区间是否有交集 2、代码实现 class Solution: def merge(self, intervals: List[List[int]]) -> List[List[int]]: intervals = sorted(intervals) # 区间从小...
LeetCode刷题笔记——#14. 最长公共前缀
12-22
1、水平扫描 class Solution: def longestCommonPrefix(self, strs: List[str]) -> str: if len(strs) == 0: return '' s = strs[0] for i in range(1, len(strs)): while strs[i].find(s) != 0 : s = s[:-1] return...
LeetCode刷题笔记——#66. 加一
12-22
  这道题其实关注点只有一个，那就是进位的问题。设置一个进位位flag，先把最后一位加1，分离出十位和个位。之后依次对前面的数调整。判断最后依次进位位是否为1，如果是就在数组头插入1。 from typing import ...
力扣第233题“数字1的个数”
10年数据\经营分析经验，现任大厂数据分析负责人
07-15 701
本文详细解读了力扣第233题“数字1的个数”，通过使用逐位分析的方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
Leetcode - 周赛406
最新发布
m0_74859835的博客
07-19 331
Leetcode - 周赛406，主要知识点：dfs记忆化，贪心
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 180
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
leetcode简单题26 N.118 杨辉三角 rust描述
BECOMEviolet的博客
07-16 388
【代码】leetcode简单题26 N.118 杨辉三角 rust描述。
【java】力扣 H指数
qq_55846232的博客
07-17 267
java 力扣 H指数
LeetCode --- 2138. Divide a String Into Groups of Size k 解题报告
杨鑫newlife的专栏
07-16 3184
A string can be partitioned into groups of size using the following procedure:Note that the partition is done so that after removing the character from the last group (if it exists) and concatenating all the groups in order, the resultant string should
刷题记录：LeetCode 925.长按键入
m0_71124168的博客
07-16 259
如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回。你的朋友正在使用键盘输入他的名字。，而字符可能被输入 1 次或多次。你将会检查键盘输入的字符。
Leetcode 290. 单词规律
li_yizhixiaowukong的博客
07-19 229
指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。输入: pattern = “abba”, s = “dog cat cat dog”输入:pattern = “abba”, s = “dog cat cat fish”输入: pattern = “aaaa”, s = “dog cat cat dog”给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。类似做法，只不过需要在前面加上个长度的判断。
每日一题，力扣leetcode Hot100之283. 移动零
u013373155的博客
07-19 140
首先，两个指针都指向同一个位置，i=j=0，如果移动指针i的位置不为0则进行交换，固定指针+1，如果为0的话，固定指针不变，移动指针往后面移一直找。这样的话固定指针就会指在0的位置，相当于移动指针遇到非0就和0进行交换。对于当前数组进行调整，不使用额外空间，那么既用双指针。
"LeetCode每日一题高频面试算法题目1：队列实现栈
LeetCode每日一题高频面试算法题目1要求使用队列实现栈，实现push、pop、peek、isEmpty方法。这里使用两个队列queue和help进行实现。push操作向队列中添加元素，pop操作实现弹栈，并将队列中的元素迁移至help队列...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值