Leetcode dfs bfs相关题目(二)

已于 2023-03-10 14:30:07 修改
阅读量75 收藏
点赞数
分类专栏： 算法 文章标签： 深度优先 leetcode 宽度优先
于 2023-03-04 18:35:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44972129/article/details/129337410
版权
文章介绍了如何解决LeetCode上的几个问题，包括以最小成本雇佣工人、香蕉分配、包裹送达和完成工作的时间优化，涉及到工资比例、二分查找、拓扑排序等算法。通过对工人性价比排序和动态调整，以及对图的拓扑结构分析，实现问题的高效解法。
摘要由CSDN通过智能技术生成

Leetcode857雇佣k名工人的最低成本

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这个题说工资支付是按照工作量成比例的，设Wa，Wb为实际支付的工资，设qa,qb为每个人的工作量，那么因该有 Wa:Wb = qa : qb
也就是这个组中的所有人的实际支付的工资:个人工作量是一个定值，并且题目中描述说，每个人至少会拿到自己的期望工资，也就是说
Wa/qa = x 而 Wa = x * qa >= Ea, 即 x >= Ea / qa 也就是说这个工资系数，至少是Ea/qa 也就是每个人的期望工资/每个人的工作量， 也就是这个k个工人组成的集合中，工资系数是最大的那个期望工资/工作量

然后，我们对每个人的 Ea/qa 进行从小到大排序，枚举这个工人的这个性价比作为k个工人组的工资系数x， 然后我们需要选择k-1个工资系数小于这个值的工人，满足实发工资最小即可，而实发工资 = 工资系数 * 劳动值， 也就是说求劳动值和最小即可

然后我们每次枚举一个新的工资系数的时候，把这个工人加进去，得把劳动量最多的那个工人给弹出来，这样用一个优先队列来维护即可

struct Person{
    int wage; //期望工资
    int work;  //工作量
    double ratio; //工资系数
}nodes[10010],heap[10010];
int cnt; //堆的大小

int cmp(const void* a,const void* b)
{
    struct Person* aa = (struct Person*)a;
    struct Person* bb = (struct Person*)b;
    if(aa->ratio > bb->ratio) return 1;
    return -1;
}

void down(int x)
{
    int tt = x;
    if(2*x <= cnt && heap[tt].work < heap[2*x].work) tt = 2 * x;
    if(2*x+1 <= cnt && heap[tt].work < heap[2*x+1].work) tt = 2*x+1;
    if(tt != x)
    {
        int temp_wage = heap[x].wage,temp_work = heap[x].work;
        double temp_ratio = heap[x].ratio;
        heap[x].work = heap[tt].work;
        heap[x].wage = heap[tt].wage;
        heap[x].ratio = heap[tt].ratio;
        heap[tt].wage = temp_wage;
        heap[tt].work = temp_work;
        heap[tt].ratio = temp_ratio;
        down(tt);
    }
}

double mincostToHireWorkers(int* quality, int qualitySize, int* wage, int wageSize, int k){
    int n = qualitySize;
    for(int i = 0; i < n; i++){
        nodes[i].wage = wage[i];
        nodes[i].work = quality[i];
        nodes[i].ratio = (double)wage[i] / (double)quality[i]; //整数转浮点除法一定要先把整数转浮点数后再运算
    }
    qsort(nodes,n,sizeof(nodes[0]),cmp);
    cnt = 0; //记录堆中元素个数
    for(int i = 0; i < k; i++){
        heap[++cnt] = nodes[i];
    }
    for(int i = cnt / 2; i; i--) down(i);
    double res  = 0;
    double work_sum = 0; //记录k个工人的总工作量
    double ratio = nodes[k-1].ratio; //这组中的工资系数
    for(int i = 1; i<= cnt; i++){
        printf("%d %d %lf\n",heap[i].wage,heap[i].work,heap[i].ratio);
        work_sum += heap[i].work;
    }
    res = work_sum * ratio;
    for(int i = k; i < n; i++){
        ratio = nodes[i].ratio; //枚举工资系数
        work_sum = work_sum - heap[1].work + nodes[i].work;
        res = fmin(res,work_sum*ratio);
        heap[1].wage = nodes[i].wage;
        heap[1].work = nodes[i].work;
        heap[1].ratio = nodes[i].ratio;
        for(int j = cnt / 2; j; j--) down(j);
    } 
    return res;
}

Leetcode爱吃香蕉的珂珂(二分)

在这里插入图片描述

int cmp(const void *a, const void* b)
{
    int* aa = (int*)a;
    int* bb = (int*)b;
    if(*aa < *bb) return 1;
    return -1;
}

bool check(int* nums,int n,int h,int k)
{
    long long hour = 0;
    for(int i = 0; i < n; i++){
        if(k == 0) return false;
        if(nums[i] % k == 0) hour = hour + nums[i] / k;  //如果正好整除就不用再加1了
        else hour = hour + nums[i] / k + 1;             //如果不是整除，得上取整
    }
    if(hour > h) return false;
    return true;
}

int minEatingSpeed(int* piles, int pilesSize, int h){
    int n = pilesSize;
    int l = 0, r = piles[0];
    for(int i = 0; i < n; i++) r = fmax(r,piles[i]);
    while(l < r){
        int mid = (l + r)/2;
        if(check(piles,n,h,mid)) r = mid;
        else l = mid + 1;
    }
    return l;
}

Leetcode1011在D天内送达包裹的能力

在这里插入图片描述

bool check(int* weights,int n,int D,int x) //检查船的承重为x的时候，能不能让货物在D天内全部装完
{
    int sum = 0; //每天装载的总重量
    int len = 1; //全部装载完毕需要的天数
    for(int i = 0; i < n; i++){
        if(weights[i] > x) return false;
        if(sum + weights[i] > x){
            len++;
            sum = 0;
        }
        sum += weights[i];
    }
    if(len <= D) return true;
    return false;
}

int shipWithinDays(int* weights, int n, int days){
    int sum = 0;
    for(int i = 0; i < n; i++) sum += weights[i];
    int l = 0, r = sum;
    while(l < r){
        int mid = (l + r)/2;
        if(check(weights,n,days,mid)) r = mid;
        else l = mid + 1;
    }
    return l;
}

Leetcode1723完成所有工作的最短时间

在这里插入图片描述

int cmp(const void* a,const void* b)
{
    int* aa = (int*)a;
    int* bb = (int*)b;
    if(*aa < *bb) return 1;
    return -1;
}

//k是工人分配时长数组的长度，u是当前已经分配到哪一个任务了,h是需要判断的时长
bool check(int* jobs,int n,int* worker,int k,int u,int h)
{
    if(u >= n) return true; //如果所有任务都能够被分配出去，那么h是合法的时间
    for(int i = 0; i < k; i++){
        if(worker[i] + jobs[u] <= h){
            worker[i] = worker[i] + jobs[u];
            if(check(jobs,n,worker,k,u+1,h)) return true;
            worker[i] -= jobs[u];
        }
    }
    return false;
}

int minimumTimeRequired(int* jobs, int n, int k){
    qsort(jobs,n,sizeof(jobs[0]),cmp);
    int sum = 0;
    for(int i = 0; i < n; i++) sum += jobs[i];
    int l = 0 ,r = sum;
    while(l < r)
    {
        int mid = (l + r)/2;
        int worker[k+1];
        memset(worker,0,sizeof(worker));
        if(check(jobs,n,worker,k,0,mid)) r = mid;
        else l = mid + 1;
    }
    return l;
}

Leetcode437 路径总和III

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
long long res;

long long dfs(struct TreeNode* root,int target) //dfs表示以root为根节点，值为target的路径条数
{
    if(!root) return 0;
    long long ans = 0;
    if(root->val == target) ans++;
    ans += dfs(root->left,target-root->val);
    ans += dfs(root->right,target-root->val);
    return ans; 
}

void dfs2(struct TreeNode* root,int target){ //枚举每个点作为根节点的情况
    if(!root) return;
    res += dfs(root,target);
    dfs2(root->left,target);
    dfs2(root->right,target);
}

int pathSum(struct TreeNode* root, int target){
    if(!root) return 0;
    res = 0;
    dfs2(root,target);
    return res;
}

Leetcode543 二叉树的直径

二叉树的直径仅仅看叶子节点到另一个叶子节点的最长的那条路径
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int res; 
int dfs(struct TreeNode* root){//返回从root走到叶子节点的最长的那条路径的节点数
    if(!root) return 0;
    int ans = 1;
    int left = dfs(root->left);
    int right = dfs(root->right);
    res = fmax(res,1+left+right);  //最大结果肯定是以某个点为根的一个路径，所以计算/\这种形式的路径长度即可
    return 1+fmax(left,right);
}

int diameterOfBinaryTree(struct TreeNode* root){
    res = 1;
    dfs(root);
    return res-1; //注意最终结果是路径数，比节点数小1
}

Leetcode124 二叉树最大路径和

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int res;
int dfs(struct TreeNode* root){
    if(!root) return 0;
    int left = fmax(0,dfs(root->left));
    int right = fmax(0,dfs(root->right));
    res = fmax(res,left+root->val+right);
    return root->val + fmax(left,right);
}

int maxPathSum(struct TreeNode* root){
    res = -0x3f3f3f3f;
    dfs(root);
    return res;
}

Leetcode 207课程表(拓扑排序)

在这里插入图片描述

#define N (int)(1e5+10)
int visit[N];  
int cnt; //判断已经拓扑排序访问了多少个点了
int degree[N]; //每个点的入度
int queue[N];
int front,tail;

int e[N],ne[N],h[N],idx;  //这题数据是1e5没法用g[N][N]，只能用邻接表来存储
void add(int a,int b){ //在图中已有的值a后面添加一个到b的边
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx;
    idx++;
}

bool canFinish(int n, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize){
    memset(visit,0,sizeof(visit));
    memset(h,-1,sizeof(h));
    memset(degree,0,sizeof(degree));
    idx = 0, cnt = 0;
    front = 0, tail = -1;
    for(int i = 0; i < prerequisitesSize; i++){
        int a = prerequisites[i][1];
        int b = prerequisites[i][0];
        add(a,b);
        degree[b]++;
    }
    //拓扑排序
    for(int i = 0; i < n; i++){
        if(degree[i] == 0) queue[++tail] = i; //入度为0的点入队
    }
    if(tail == -1) return false; //如果没有入度为0的点，肯定是错误的
    while(front <= tail){
        int node = queue[front++];
        cnt++;
        for(int i = h[node]; i != -1; i = ne[i]){
            int j = e[i];
            degree[j]--;
            if(degree[j] == 0) queue[++tail] = j;
        }
    }
    if(cnt != n) return false;
    return true;

}

模板题：Acwing848 有向图的拓扑序列

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N (int)(1e5+10)
int e[N],ne[N],h[N],idx = 0;
int visit[N],degree[N]; //visit记录这个点是否被访问过，degree记录每个点的入度
int queue[N]; 
int front = 0, tail = -1;
int res[N],cnt = 0; //记录拓扑排序的结果
int n,m;

void add(int a,int b) //把b这个值添加到图中a这个节点的后面
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx;
    idx++;
}

int main()
{
    scanf("%d%d",&n,&m);
    memset(degree,0,sizeof(degree));
    memset(visit,0,sizeof(visit));
    memset(h,-1,sizeof(h));
    while(m--){
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        degree[b]++;
    }
    //拓扑排序
    for(int i = 1; i <= n; i++){
        if(degree[i] == 0) queue[++tail] = i; //把入度为0的点加入队列之中
    }
    if(tail < front){
        printf("-1\n");
        return 0;
    }
    while(front <= tail){
        int node = queue[front++];
        res[cnt++] = node;
        for(int i = h[node]; i != -1; i = ne[i]){
            int j = e[i];
            degree[j]--;
            if(degree[j] == 0) queue[++tail] = j;
        }
    }
    if(cnt != n){
        printf("-1\n");
        return 0;
    }
    for(int i  =0; i < cnt; i++) printf("%d ",res[i]);
    return 0;
}
新城里的旧少年^_^
关注
专栏目录
LeetCode | 一文帮你搞定BFS、DFS算法（python版）
qq_34296398的博客
05-19 1047
模板方法 使用BFS，DFS的题目，在leetcode上一般标记为medium或者hard。但从思维逻辑上看，其难度定义偏高。可能从代码量来看，写一道BFS或者DFS的篇幅比其他类型的题目要多。 BFS，DFS既然思维固定，必然有其套路。套用模板方法，让我们的解题更加流畅。有如庖丁解牛，游刃有余。 BFS模板 BFS思路是先将邻居加进来，如果只是口述的话难免枯燥。 下面将以图上的搜索（找start_node到end_node之间的最短距离长度）为例，阐述怎样将思维变成代码。 得到图 正如链表其实质为节点和指
算法：BFS和DFS相关题目
hefrankeleyn的博客
10-24 253
BFS和DFS相关题目 文章目录BFS和DFS相关题目一、[102. 二叉树的层序遍历](https://leetcode-cn.com/problems/binary-tree-level-order-traversal/)1.1 解法一：BFS二、[433. 最小基因变化](https://leetcode-cn.com/problems/minimum-genetic-mutation/)2.1 解法一：BFS三、[22. 括号生成](https://leetcode-cn.com/problems/
Leetcode dfs bfs 递归回溯题目
最新发布
weixin_44972129的博客
02-11 370
算法
【leetcode】BFS DFS （图论）
myaijarvis notebook
12-21 400
总结 套路：图论算法基础（修订版）_ labuladong DFS 应用：二叉树搜索，图搜索 回溯法=DFS+剪枝 DFS：每一条路径走完再回溯 BFS … //938.二叉搜索树的范围和 public int rangeSumBST(TreeNode root, int low, int high) { if(root==null) return 0; int result=0; Queue<TreeNode> queue=new Lin
leetcode DFS和BFS题目
yechiyu167的博客
12-23 161
BFS和DFS专题LeetCode 77 组合（DFS）LeetCode 104 树的最大深度（DFS）LeetCode 111 二叉树的最小深度（DFS）LeetCode 127 单词接龙（BFS）LeetCode 207 课程表（拓扑排序BFS）LeetCode 257 二叉树的所有路径LeetCode 279 完全平方数（BFS）LeetCode 130 被围绕的区域（DFS）LeetCod...
leetcode上面的一些bfs和dfs的题目
jiang199912的博客
04-20 518
dfs和bfs的相关题目，dfs可以使用递归实现，bfs使用quene实现。 题目描述： 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入...
LeetCode DFS&BFS 题库
qq_52138199的博客
01-13 189
lc.226 lc.46 lc.47 lc.51 lc.52
leetcode刷题之BFS专题
Daisy_Wang777的博客
11-17 1906
参考资料： 广度优先算法 BFS（即广度优先搜索）是图论中一种常见的算法，常用于二叉树数据结构，能够实现对树或图中每个节点的遍历。本文将从leetcode的一些例题中详尽介绍这种算法的实现原理和在实际问题中的应用方式。 一、概念 原理：如其名字，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法终止。 结束条件：树或图中的所有节点都已被遍历。 如果还存在未被遍历的节点，则选择其中一个作为源节点并重复以上过程，整个过程反复进行知道所有节点都被遍历为止。 二、实现方法（利用栈） B
LeetCode刷题 -- BFS
qq_43325216的博客
11-02 645
如果我们只是为了遍历一棵树、一张图上的所有结点的话，那么 DFS 和 BFS 的能力没什么差别，我们当然更倾向于更方便写、空间复杂度更低的 DFS 遍历。不过，某些使用场景是 DFS 做不到的，只能使用 BFS 遍历。这就是本文要介绍的两个场景：「层序遍历」、「最短路径」。
【LeetCode】树与图的dfs和bfs
flora
06-22 385
参考： lzh的笔记 树与图的存储结构：邻接表 由于树是特殊的图，所以我们存储树也是用的邻接表或邻接图。 邻接表是指对于图上的每个结点来说，用一个单链表存储它的临接点。 我们需要h[],e[],ne[],idx来表示这个邻接点： h[v] : 指向节点v形成的链表的头节点注意初始化为-1 e[i] : 第i个点的值v（表示下标和值的映射） ne[i] : 表示邻接表链表中 i 节点的下一个节点 idx : 当前遍历到的节点的索引,等边都插入完idx就是节点个数 在节点a的后面插入b： idx为当前遍历
Leetcode【树 DFS BFS】| 199. 二叉树的右视图
Cherils的博客
04-22 273
Leetcode | 199. 二叉树的右视图题目解题DFS解法BFS解法 题目 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 示例: 　输入: [1,2,3,null,5,null,4] 　输出: [1, 3, 4] 　解释: 　　 1 <— 　　 / 　　2 3 <— 　　 \ ...
leetcode 经典宽搜BFS深搜DFS题目(思路、方法、code)
Ding 的博客
05-14 1787
leetcode 经典宽搜BFS深搜DFS题目(思路、方法、code) BFS和DFS的经典应用就是在树和图中的遍历。 地图的搜索问题通常都可以用BFS和DFS解决，下面题目非常典型，并且很多题目类似，自己如果能够独立完成基本就掌握了BFS和DFS以及地图的遍历问题。 文章目录leetcode 经典宽搜BFS深搜DFS题目(思路、方法、code)[200. 岛屿数量](https://leetcode-cn.com/problems/number-of-islands/)[127. 单词接龙](https:
Leetcode错题记录
weixin_44972129的博客
02-10 6983
15三数之和 class Solution { public: vector<vector<int>> threeSum(vector<int>& nums) { sort(nums.begin(),nums.end()); vector<vector<int>> res; for(int i=0;i<nums.size();i++){ if(i&gt
408知识复试前摘要复习
weixin_44972129的博客
03-26 1058
SPFA算法
排序算法总结(二)------堆排序
weixin_44972129的博客
08-17 651
堆排序
贪心法学习笔记
weixin_44972129的博客
12-27 644
区间选点 意思就是从比如上图这是有四个区间，这些区间可能有重合的部分，从这些区间中选出最少数目的点，存在于所有区间之中
排序算法分析
weixin_44972129的博客
03-03 608
插入排序 就是相当于打扑克，不断把一个数插入到之前已经已经有序的序列中去 #include <iostream> #include <algorithm> using namespace std; const int N = 100010; int n; int a[N]; void insert_sort() { for(int i=1;i<n;i++){ int t = a[i]; int j = i; while(j
Leetcode动态规划题目
weixin_44972129的博客
02-10 598
Leetcode10 正则表达式匹配 class Solution { public: bool isMatch(string s, string p) { int n = s.size(), m = p.size(); s = ' ' + s, p = ' ' + p; vector<vector<bool>> f(n+1,vector<bool>(m+1)); //vector<int> vec(
C++ BFS与DFS解决N叉树最大深度：深度优先遍历挑战
本文档主要讨论了如何使用C++编程语言解决LeetCode上关于N叉树最大深度的问题，题目编号为105——最大深度的N叉树。N叉树是一种每个节点最多有N个子节点的树形数据结构，这里的最大深度是指从根节点到最远叶子节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

新城里的旧少年^_^

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

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

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

打赏作者

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

抵扣说明：

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

余额充值