leecode每日一练

已于 2024-05-24 23:43:01 修改
阅读量359 收藏
点赞数 5
分类专栏： 算法 文章标签： 算法 动态规划 leetcode
于 2024-05-05 07:49:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wniuniu_/article/details/138458716
版权

打家劫舍

在这里插入图片描述

我一开始的思路也是dp，但是转移方程想错了，这个题目转移方程应该是dp[i] = max(dp[i-2]+nums[i],dp[i-1])

class Solution {
public:
    int rob(vector<int>& nums) {
        int len = nums.size();
        vector<int> dp(len);
        int ans = 0;
        if(len>=1)
        dp[0] = nums[0],ans=max(ans,dp[0]);
        if(len>=2)
        dp[1] = max(nums[0],nums[1]),ans=max(ans,dp[1]);
        for(int i=2;i<len;i++){
            dp[i] = max(dp[i-2]+nums[i],dp[i-1]);
            ans = max(ans,dp[i]);
        }
        return ans;
    }
};

拆炸弹

在这里插入图片描述
纯模拟就是sb，我用了差分数组，但是转移方程写死我了
我写的代码

class Solution {
public:
    vector<int> decrypt(vector<int>& code, int k) {
        int len = code.size();
        vector<int> ans(len);
        vector<int> p(len+1);
        p[0] = code[0];
        for(int i=1;i<len;i++){
            p[i] = p[i-1]+code[i];
        }
        if(k==0){
            return ans;
        }
        else if(k>0){
            for(int i=0;i<len;i++){
                if(i+k<len){
                    ans[i] += p[i+k]-p[i];
                }else{
                    ans[i] += p[len-1]-p[i];
                    int cha = k-(len-1-i);
                    if(cha>0)
                    ans[i] += p[cha-1];
                }
            }
            
        }else{
            k = -k;
            for(int i=0;i<len;i++){
                if(i>k){
                    if(i-1-k>=0)
                    ans[i] += p[i-1]-p[i-1-k];
                    else{
                        ans[i] += p[i-1];
                    }
                }else{
                    if(i>0)
                    ans[i] += p[i-1];
                    int cha = k-i;
                    ans[i] += p[len-1]-p[len-1-cha];
                }
            }
        }
        return ans;
    }
};

但是其实只要开两倍的空间就可以简单完成,下面这个思路是滑动窗口，但是其实差分也是可以的

class Solution {
public:
    vector<int> decrypt(vector<int>& code, int k) {
        int n = code.size();
        vector<int> res(n);
        if (k == 0) {
            return res;
        }
        code.resize(n * 2);
        copy(code.begin(), code.begin() + n, code.begin() + n);
        int l = k > 0 ? 1 : n + k;
        int r = k > 0 ? k : n - 1;
        int w = 0;
        for (int i = l; i <= r; i++) {
            w += code[i];
        }
        for (int i = 0; i < n; i++) {
            res[i] = w;
            w -= code[l];
            w += code[r + 1];
            l++;
            r++;
        }
        return res;
    }
};

基站建设

题目地址
在这里插入图片描述

一开始我的思路是差分，但是只能过五分之一的数据集，这是因为如果这些重叠的区域过多的话就会出现问题

给你看一下差分的代码

#include<bits/stdc++.h>
using namespace std;

const int N = 1000005;
int s[N];
int p[N];
int n;


int main() {
	cin >> n;
	int a, b;
	int mm = 0;
	for (int i = 1; i <= n; i++) {
		cin >> a >> b;
		int l = (a - b) > 1 ? a - b : 1;
		int r = (a + b) < N ? a + b : N - 1; mm = max(mm, r);
		s[l] += 1;
		s[r + 1] -= 1;
	}
	for (int i = 1; i <= mm; i++) {
		p[i] += p[i - 1] + s[i];
	}
	int re = 0;
	int now;
	int flag = 0;
	for (int i = 1; i <= mm; i++) {
		//cout << p[i] << " ";
		if (flag == 0 && p[i] > 1) {
			flag = 1; // 进入区域
			now = p[i];
		}
		if (flag == 1 && p[i] <= 1) {
			flag = 0; //出去
			re += now - 1;
		}
		if (flag == 1 && p[i] > 1) {
			now = max(now, p[i]);
		}
	}
	cout << n - re;
	return 0;
}

应该用贪心来做，就是一个活动安排问题

#include<bits/stdc++.h>
using namespace std;

const int N = 1000005;
struct node
{
	int start, end;
	bool operator<(node b) {
		return this->end < b.end;
	}
}a[N];

int n;
int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		int x, b;
		cin >> x >> b;
		a[i].start = x - b;
		a[i].end = x + b;
	}
	sort(a + 1, a + 1 + n);
	if (n == 0) {
		cout << 0;
		return 0;
	}
	int ans = 1;
	int now = a[1].end;
	for (int i = 2; i <= n; i++) {
		if (a[i].start <= now) continue;
		now = a[i].end; ans++;
	}
	cout << ans;
	return 0;
}

leecode 每日温度

在这里插入图片描述

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int len = temperatures.size();
        deque<int> p;
        vector<int> ans(len);
        for (int i = 0; i < len; i++) {
            int temp = temperatures[i];
            while (p.size() && temp > temperatures[p.back()]) {
                int po = p.back();
                cout << "尾巴的 " << po << endl;
                p.pop_back();
                ans[po] = i - po;
            }
            p.push_back(i);
        }
        return ans;
    }
};

leecode 1475

在这里插入图片描述

class Solution {
public:
    vector<int> finalPrices(vector<int>& prices) {
        int len = prices.size();
        vector<int> ans(len);
        deque<int> q;
        for (int i = 0; i < len; i++) {
            int now = prices[i];
            while (q.size()&&now<=prices[q.back()])
            {
                int pos = q.back();
                q.pop_back();
                ans[pos] = prices[pos] - now;
            }
            q.push_back(i);
        }
        // 别忘记这一步
        while(q.size()){
            int pos = q.back();
            ans[pos] = prices[pos];
            q.pop_back();
        }
        return ans;
    }
};

落谷2422

在这里插入图片描述
我们还要注意退出for循环后的边界处理，这时候单调栈里面还有东西

#include<bits/stdc++.h>
using namespace std;

#define int long long

const int N = 1e5 + 5;
int a[N];
int n;
int ans = 0;
int p[N];
int l[N], r[N];


signed main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		p[i] = p[i - 1] + a[i];
		l[i] = r[i] = i;
	}
	deque<int> q;
	for (int i = 1; i <= n; i++) {
		int now = a[i];
		while (q.size()&& now<a[q.back()])
		{
			int  u = q.back();
			q.pop_back();
			r[u] = i;
		}
		q.push_back(i);
	}
	while (q.size()) {
		int u = q.back();
		q.pop_back();
		r[u] = n+1;
	}
	q.clear();
	for (int i = n; i >= 1; i--) {
		int now = a[i];
		while (q.size() && now < a[q.back()]) {
			int  u = q.back();
			q.pop_back();
			l[u] = i;
		}
		q.push_back(i);
	}
	while (q.size())
	{
		int u = q.back();
		q.pop_back();
		l[u] = 0;
	}
	for (int i = 1; i <= n; i++) {
		ans = max(ans, a[i] * (p[r[i]-1] - p[l[i]]));
	}
	//for (int i = 1; i <= n; i++) {
	//	cout << l[i] << " " << r[i] << endl;

	//}
	cout << ans;

	return 0;
}

leecode2244

在这里插入图片描述

class Solution {
public:
    int minimumRounds(vector<int>& tasks) {
        unordered_map<int, int> cnt;
        for (int t : tasks) {
            cnt[t]++;
        }
        int ans = 0;
        for (auto& [_, c] : cnt) {
            if (c == 1) {
                return -1;
            }
            ans += (c + 2) / 3;
        }
        return ans;
    }
};

leecode2589

在这里插入图片描述
这个题目和活动安排问题很相似，所以采用贪心的思路
我的代码

class Solution {
public:
    int findMinimumTime(vector<vector<int>>& tasks) {
        vector<int> d(20005,0);
        sort(tasks.begin(), tasks.end(), cmp);
        int len = tasks.size();
        int ans = 0;
        for (int i = 0; i < len; i++) {
            int du = tasks[i][2];
            int l = tasks[i][0], r = tasks[i][1];
                for (int j = l; j <= r; j++) {
                    if (d[j] == 1) du--;
                }
                    for (int j = r; du > 0; j--) {
                        if (d[j]) continue;
                        d[j] = 1; du--; ans++;
                    }
        }
        return ans;
    }
    static bool cmp(vector<int> a, vector<int> b) {
        return a[1] < b[1];
    }
};

leecode 1953

在这里插入图片描述
看到题目的数据范围就知道不能暴力算
稍微模拟一下就知道答案

class Solution {
public:
    long long numberOfWeeks(vector<int>& milestones) {
        int len = milestones.size();
        if(len==1) return 1;
        sort(milestones.begin(),milestones.end());
        long long qian = 0;
        for(int i=0;i<len-1;i++) qian+=milestones[i];
        long long ma = milestones[len-1];
        if(qian>=ma) return qian+ma;
        else return qian*2+1;
    }
};

leecode 2644

在这里插入图片描述

class Solution {
public:
    int maxDivScore(vector<int>& nums, vector<int>& divisors) {
        unordered_map<int, int> mp;
        for (int u : divisors) {
            int flag = 0;
            if (mp.contains(u)) continue;    // 避免重复
            if (!u) mp[u] = 0;
            else {
                for (int t : nums) {
                    if (t % u == 0) mp[u]++,flag = 1;
                }
            }
            if (flag == 0) mp[u] = 0;  // 避免没有初始化
        }
        int ans = -1, record = 10000;
        for (auto u : mp) {
            if (u.second > ans) {
                record = u.first;
                ans = u.second;
            }
            else if (u.second == ans) {
                record = min(record, u.first);
            }
        }
        return record;
    }
};

leecode 1535

在这里插入图片描述
我一开是想开两倍空间，然后用单调栈来记录每个值后面有多少个比它小的，但是没有考虑k的问题

class Solution {
public:
    int getWinner(vector<int>& arr, int k) {
        int mx = arr[0], win = 0;
        for (int i = 1; i < arr.size() && win < k; i++) {
            if (arr[i] > mx) { // 新的最大值
                mx = arr[i];
                win = 0;
            }
            win++; // 获胜回合 +1
        }
        return mx;
    }
};

class Solution:
    def getWinner(self, arr: List[int], k: int) -> int:
        mx = arr[0]
        win = -1  # 对于 arr[0] 来说，需要连续 k+1 个回合都是最大值
        for x in arr:
            if x > mx:  # 新的最大值
                mx = x
                win = 0
            win += 1  # 获胜回合 +1
            if win == k:
                break
        return mx

leecode 2225

在这里插入图片描述

以后和桶相关的都不必开数组，开个哈希表就行

class Solution {
public:
    vector<vector<int>> findWinners(vector<vector<int>>& matches) {
        int n = matches.size();
        unordered_map<int, int> mp;
        for (int i = 0; i < n; i++) {
            int win = matches[i][0], lose = matches[i][1];
            if (mp[win] % 2 == 0) {
                mp[win] += 2;
            }
            if (mp[lose]!=-1) {
                if(mp[lose] % 2)
                mp[lose] = -1;
                else {
                    mp[lose] += 1;
                }
            }
        }
        vector<vector<int>> ans(2);
        for (auto u : mp) {
            if (u.second %2==0 && u.second!=0) {
                ans[0].push_back(u.first);
            }
            if (u.second % 2 && u.second != -1) {
                ans[1].push_back(u.first);
            }
        }
        sort(ans[0].begin(), ans[0].end());
        sort(ans[1].begin(), ans[1].end());
        return ans;
    }
};

leecode1673

在这里插入图片描述

第一眼看的时候感觉要用贪心算法，每次找到一个最小的

class Solution {
public:
    vector<int> mostCompetitive(vector<int>& nums, int k) {
        int m = 0; // 栈的大小
        for (int i = 0; i < nums.size(); i++) {
            int x = nums[i];
            while (m && x < nums[m - 1] && m + nums.size() - i > k) {
                m--; // 出栈
            }
            if (m < k) {
                nums[m++] = x; // 入栈（把 nums 当作栈）
            }
        }
        nums.resize(m);
        return nums;
    }
};
wniuniu_
关注
专栏目录
LeeCode每日一题–合并两个有序数组
01-20
【前言】坚持日更LeeCode刷题系列    不积跬步,无以至千里;不积小流,无以成江海。愿与诸君共勉！   【题目】88.合并两个有序数组    题目描述：给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 ...
LeeCode每日一题–罗马数字转整数
12-22
【前言】坚持日更LeeCode刷题系列    不积跬步,无以至千里;不积小流,无以成江海。愿与诸君共勉！   【题目】13.罗马数字转整数   题目描述：罗马数字包含以下七种字符:I ,V , X , L, C , D 和 M 字符 数值 ...
Leecode每日一练
m0_72442777的博客
03-18 186
python 3,LEECODE每日一练---找不同
hqq1990的博客
03-04 467
a=chr(random.randint(97,122)) #随机生成小写英文字母，小写英文字母的ASCII码是97~122。print("ls={}\ns={}\nt={}".format(ls,s,t)) #输出各数据。print(findTheDifference(s,t)) ##调用函数并输出。ls.append(a) ##将生成的随机字母 append进列表中。#解题思路比较字母出现的次数，t字母出现的次数大于s出现的次数。t="".join(ls) ###将列表转换成字符串。
Leecode每日一练之400.第N位数字
weixin_44961626的博客
11-30 210
难倒不是很难，就是很麻烦，像是数学的有序数列，需要找规律，考虑全面一些，差点儿给我逼疯了。。。 /** * 给你一个整数 n ，请你在无限的整数序列[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...] 中找出并返回第 n 位数字。 * 示例 1： * 输入：n = 3 * 输出：3 * 示例 2： * 输入：n = 11 * 输出：0 * 解释：第 11 位数字在序列 1, 2, 3, 4, 5, 6
leecode每日一练-第48题-旋转图像
weixin_48820672的博客
07-02 155
【代码】leecode每日一练-第48题-旋转图像。
Leecode 每一练 Day 2
m0_47211450的博客
07-20 166
leecode每日一题 - day 02 - 两数相加
每日一练-LeeCode-加一
qq_33530585的博客
04-26 225
LeeCode-加一
每日一练-LeeCode-分糖果
qq_33530585的博客
04-28 299
LeeCode-分糖果
每日一练-LeeCode-爬楼梯
qq_33530585的博客
04-17 737
LeeCode-爬楼梯
每日一练-LeeCode-环形链表
qq_33530585的博客
04-19 443
LeeCode-环形链表
LeeCode每日一题–整数反转
12-22
【前言】坚持日更LeeCode刷题系列    不积跬步,无以至千里;不积小流,无以成江海。愿与诸君共勉！   【题目】7.整数反转    题目描述：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转...
LeeCode每日一题–最后一个单词的长度
01-20
【前言】坚持日更LeeCode刷题系列    不积跬步,无以至千里;不积小流,无以成江海。愿与诸君共勉！   【题目】58.最后一个单词的长度    题目描述：给定一个仅包含大小写字母和空格 ' ' 的字符串 s，返回其...
LeeCode每日一题–回文数
12-22
【前言】坚持日更LeeCode刷题系列    不积跬步,无以至千里;不积小流,无以成江海。愿与诸君共勉！   【题目】9.回文数    判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是...
二叉树最小深度
2301_80161204的博客
09-27 454
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1262
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
最新发布
YQ20210216的博客
09-27 354
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 1085
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
leecode 答案c++
02-04
leecode 答案c 意味着在 leetcode 上面有一个问题，而对应的答案是 c。通常来说，leetcode 是一个在线的编程练习平台，主要用来练习和提高编程能力。在 leetcode 上会有各种各样的编程问题，涵盖了算法、数据结构、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wniuniu_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值