leetcode刷题：回溯算法14（重新安排行程）

已于 2022-07-12 15:44:14 修改
阅读量1.5k 收藏 1
点赞数 1
分类专栏： 二叉树 算法 回溯 文章标签： 算法 leetcode 职场和发展
于 2022-07-12 15:16:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niTaoTaoa/article/details/125743663
版权
算法 同时被 3 个专栏收录
120 篇文章 1 订阅
订阅专栏
二叉树
46 篇文章 0 订阅
订阅专栏
回溯
11 篇文章 0 订阅
订阅专栏

332.重新安排行程

力扣题目链接

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

提示：

  • 如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前
  • 所有的机场都用三个大写字母表示（机场代码）。
  • 假定所有机票至少存在一种合理的行程。
  • 所有的机票必须都用一次 且 只能用一次。

示例 1：

  • 输入：[[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]]
  • 输出：[“JFK”, “MUC”, “LHR”, “SFO”, “SJC”]

示例 2：

  • 输入：[[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
  • 输出：[“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
  • 解释：另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”]。但是它自然排序更大更靠后。

有一说一，这题还是蛮难的，我做了得有七八个小时，思路是正确的，但最终超时。
先放一个我的思路：找到所有的路径，然后筛选。

package com.programmercarl.backtracking;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName FindItinerary
 * @Descriotion TODO
 * @Author nitaotao
 * @Date 2022/7/11 21:14
 * @Version 1.0
 * https://leetcode.cn/problems/reconstruct-itinerary/
 * 332. 重新安排行程
 *
 * 找到所有结果
 * 筛选最小路径
 *
 **/
public class FindItinerary1 {
    //结果集
    List<List<String>> result = new ArrayList<>();
    List<String> path = new ArrayList<>();


    public List<String> findItinerary(List<List<String>> tickets) {
        boolean[] used = new boolean[tickets.size()];
        // false 表示该车票没有用
        // true 表示该车票已经用了
        Arrays.fill(used, false);
        path.add("JFK");
        //获取所有机票
        backtracking(tickets, used, "JFK");
//        System.out.println(result);
        //删除多于的机票。得到最小路径机票
        getMinPath(0);
        System.out.println("最终结果：" + result);
        return result.get(0);
    }

    /**
     * @param tickets 所有车票
     * @param from    上一个出发的地方
     */
    public void backtracking(List<List<String>> tickets, boolean[] used, String from) {
        //如果规划好一个行程，则添加
        if (path.size() == tickets.size() + 1) {
            result.add(new ArrayList(path));
            return;
        }
        for (int i = 0; i < tickets.size(); i++) {
            //如果该机票已经被使用，则跳过
            if (used[i]) {
                continue;
            }
            //如果该机票的出发地不是之前的降落地，则返回
            if (!tickets.get(i).get(0).equals(from)) {
                continue;
            }
            used[i] = true;
            path.add(tickets.get(i).get(1));
            // 降落地点要更新
            backtracking(tickets, used, tickets.get(i).get(1));
            //回溯
            used[i] = false;
            path.remove(path.size() - 1);
        }
    }


    //删除多于的机票
    public void getMinPath(int curIndex) {
        if (result.size() == 1) {
            return;
        }
        char[] chars = new char[result.size()];
        char min = 'Z';
        //获取当前curIndex城市的字典第一位最小值
        for (int i = 0; i < result.size(); i++) {
            chars[i] = result.get(i).get(curIndex).charAt(0);
            if (chars[i] < min) {
                min = chars[i];
            }
        }
        //凡是比这个值不一样的都删除
        List<List<String>> temp = new ArrayList<>();
        for (int i = 0; i < result.size(); i++) {
            if (result.get(i).get(curIndex).charAt(0) == min) {
                temp.add(new ArrayList<>(result.get(i)));
            }
        }
        result = temp;



        min = 'Z';
        //获取当前curIndex城市的字典第二位最小值
        for (int i = 0; i < result.size(); i++) {
            chars[i] = result.get(i).get(curIndex).charAt(1);
            if (chars[i] < min) {
                min = chars[i];
            }
        }


        temp = new ArrayList<>();
        //凡是比这个值不一样的都删除
        for (int i = 0; i < result.size(); i++) {
            if (result.get(i).get(curIndex).charAt(1) == min) {
                temp.add(new ArrayList<>(result.get(i)));
            }
        }
        result = temp;

        min = 'Z';
        //获取当前curIndex城市的字典第三位最小值
        for (int i = 0; i < result.size(); i++) {
            chars[i] = result.get(i).get(curIndex).charAt(2);
            System.out.println(chars[i]);
            if (chars[i] < min) {
                min = chars[i];
            }
        }
        temp = new ArrayList<>();
        //凡是比这个值不一样的都删除

        for (int i = 0; i < result.size(); i++) {
            if (result.get(i).get(curIndex).charAt(2) == min) {
                temp.add(new ArrayList<>(result.get(i)));
            }
        }
        result = temp;

        curIndex++;
        if (curIndex == result.get(0).size()) {
            return;
        }
        getMinPath(curIndex);
    }


}

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

然后开始求助群好友们。在他们的引导下，改变思路，贪心思想：只要找到一条路就可以了，步步最优。
在这里插入图片描述

package com.programmercarl.backtracking;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName FindItinerary
 * @Descriotion TODO
 * @Author nitaotao
 * @Date 2022/7/11 21:14
 * @Version 2.0
 * https://leetcode.cn/problems/reconstruct-itinerary/
 * 332. 重新安排行程
 * 贪心算法思想
 *
 * 每步找到最优解
 *
 **/
public class FindItinerary2 {
    //结果集
    List<List<String>> result = new ArrayList<>();
    List<String> path = new ArrayList<>();
    List<String> to = new ArrayList<>();

    /**
     * 使用贪心算法思想，每次寻找最优解
     *
     * @param tickets
     * @return
     */

    public List<String> findItinerary(List<List<String>> tickets) {
        boolean[] used = new boolean[tickets.size()];
        // false 表示该车票没有用
        // true 表示该车票已经用了
        Arrays.fill(used, false);
        path.add("JFK");
        //获取所有机票
        backtracking(tickets, used, "JFK");
//        System.out.println(result);
        return result.get(0);
    }

    /**
     * @param tickets 所有车票
     * @param from    上一个出发的地方
     */
    public void backtracking(List<List<String>> tickets, boolean[] used, String from) {
        //找到最优解
        if (result.size() == 1) {
            return;
        }
        //如果规划好一个行程，则添加
        if (path.size() == tickets.size() + 1) {
            result.add(new ArrayList(path));
            return;
        }
        //找到当前机场的所有下一个机场
        for (int i = 0; i < tickets.size(); i++) {
            //如果该机票已经被使用，则跳过
            if (used[i]) {
                continue;
            }
            //如果该机票的出发地不是之前的降落地，则跳过
            if (!tickets.get(i).get(0).equals(from)) {
                continue;
            }
            //没有使用的，下一个机场
            //下一个机场的集合
            to.add(tickets.get(i).get(1));
        }
        if (to.size() == 0 && path.size() < tickets.size() + 1) {
            //此路不通
            return;
        }
        String minTo = getMinPath();
        to.clear();

        for (int i = 0; i < tickets.size(); i++) {
            if (used[i]) {
                continue;
            }
            //如果 to 不是 最优机场
            if (!tickets.get(i).get(1).equals(minTo)) {
                continue;
            }
            used[i] = true;
            path.add(minTo);
            // 降落地点要更新
            backtracking(tickets, used, minTo);
            //回溯
            used[i] = false;
            path.remove(path.size() - 1);
        }
    }


    //获取最近的机票
    public String getMinPath() {
        if (to.size() == 1) {
            return to.get(0);
        }
        char[] chars = new char[to.size()];
        char min = 'Z';
        //获取当前curIndex城市的字典第一位最小值
        for (int i = 0; i < to.size(); i++) {
            chars[i] = to.get(i).charAt(0);
            if (chars[i] < min) {
                min = chars[i];
            }
        }
        //凡是比这个值不一样的都删除
        List<String> temp = new ArrayList<>();
        for (int i = 0; i < to.size(); i++) {
            if (to.get(i).charAt(0) == min) {
                temp.add(to.get(i));
            }
        }
        to = temp;
        if (to.size() == 1) {
            return to.get(0);
        }
        min = 'Z';
        chars = new char[to.size()];
        //获取当前curIndex城市的字典第二位最小值
        for (int i = 0; i < to.size(); i++) {
            chars[i] = to.get(i).charAt(1);
            if (chars[i] < min) {
                min = chars[i];
            }
        }

        temp = new ArrayList<>();
        //凡是比这个值不一样的都删除
        for (int i = 0; i < to.size(); i++) {
            if (to.get(i).charAt(1) == min) {
                temp.add(to.get(i));
            }
        }
        to = temp;
        if (to.size() == 1) {
            return to.get(0);
        }
        min = 'Z';
        chars = new char[to.size()];
        //获取当前curIndex城市的字典第三位最小值
        for (int i = 0; i < to.size(); i++) {
            chars[i] = to.get(i).charAt(2);
            if (chars[i] < min) {
                min = chars[i];
            }
        }
        //凡是和这个值不一样的都删除
        temp = new ArrayList<>();
        for (int i = 0; i < to.size(); i++) {
            if (to.get(i).charAt(2) == min) {
                temp.add(to.get(i));
            }
        }
        to = temp;
        return to.get(0);
    }

    public static void main(String[] args) {
        List<List<String>> tickets = new ArrayList<List<String>>();
        ArrayList ticket1 = new ArrayList<ArrayList>();
        ArrayList ticket2 = new ArrayList<ArrayList>();
        ArrayList ticket3 = new ArrayList<ArrayList>();
        ArrayList ticket4 = new ArrayList<ArrayList>();
        ArrayList ticket5 = new ArrayList<ArrayList>();
        ticket1.add("JFK");
        ticket1.add("SFO");
        ticket2.add("JFK");
        ticket2.add("ATL");
        ticket3.add("SFO");
        ticket3.add("ATL");
        ticket4.add("ATL");
        ticket4.add("JFK");
        ticket5.add("ATL");
        ticket5.add("SFO");
        tickets.add(ticket1);
        tickets.add(ticket2);
        tickets.add(ticket3);
        tickets.add(ticket4);
        tickets.add(ticket5);
        System.out.println(tickets);
        System.out.println(new FindItinerary2().findItinerary(tickets));
    }
}

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

总之思路是对的。最后看答案，使用map解法。

package com.programmercarl.backtracking;

import java.util.*;

/**
 * @ClassName FindItinerary
 * @Descriotion TODO
 * @Author nitaotao
 * @Date 2022/7/11 21:14
 * @Version 3.0
 * https://leetcode.cn/problems/reconstruct-itinerary/
 * 332. 重新安排行程
 **/
public class FindItinerary3 {
    Stack<String> stack;
    // 出发机场   到达机场  航班次数
    //通过航班次数来判断当前到达机场是否使用过了
    Map<String, Map<String, Integer>> map;

    public List<String> findItinerary(List<List<String>> tickets) {
        // 出发机场   到达机场  航班次数
        map = new HashMap<String, Map<String, Integer>>();
        stack = new Stack<>();
        for (List<String> ticket : tickets) {
            // 目的机场，班次数量
            Map<String, Integer> temp;
            if (map.containsKey(ticket.get(0))) {
                //如果map包含当前出发机场
                temp = map.get(ticket.get(0));
                //则当前出发机场的目的机场的班次+1
                //如果没有这个 ticket.get(1) 的目的机场，就添加一个，默认是0+1
                // 如果有，就获取其值，然后+1，再更新
                temp.put(ticket.get(1), temp.getOrDefault(ticket.get(1), 0) + 1);
            } else {
                //如果没有这个出发机场
                temp = new TreeMap<>();
                //就添加这个map，把目的机场信息加上
                temp.put(ticket.get(1), 1);
            }
            // map 键：出发机场  值 ：目标机场集
            //   如  key   JFK     值   TreeMap    值以 treemap存储，自动升序
            //                          ATL      1
            //                          SFO      1
            //更新出发机场的map
            map.put(ticket.get(0), temp);
        }
        //初始机场
        stack.push("JFK");
        backtracking(tickets.size());
        return new ArrayList(stack);
    }


    /**
     * @param ticketNum 机票数量
     * @return
     */
    public boolean backtracking(int ticketNum) {
        // stack有六个元素时，说明用了五个机票
        if (stack.size() == ticketNum + 1) {
            //如果已使用票数和一共需要用的票数相等，则返回
            return true;
        }
        //获取队尾元素
        String last = stack.peek();
        //防止出现null
        if (map.containsKey(last)) {
            for (Map.Entry<String, Integer> target : map.get(last).entrySet()) {
                //获取 出发地为 last 的 所有 目的地 机票及数量
                //机票数量
                int count = target.getValue();
                //如果机票还有
                if (count > 0) {
                    //如果还有航班次数
                    //使用当前机票
                    stack.push(target.getKey());
                    //可使用航班次数 - 1
                    target.setValue(count - 1);
                    //递归
                    //如果找到一条路径，因为 treemap 默认最优解，直接返回
                    boolean isEnd = backtracking(ticketNum);
                    if (isEnd) {
                        return true;
                    }
                    //回溯
                    stack.pop();
                    target.setValue(count);
                }
            }
        }
        return false;
    }
    public static void main(String[] args) {
        List<List<String>> tickets = new ArrayList<List<String>>();
        ArrayList ticket1 = new ArrayList<ArrayList>();
        ArrayList ticket2 = new ArrayList<ArrayList>();
        ArrayList ticket3 = new ArrayList<ArrayList>();
        ArrayList ticket4 = new ArrayList<ArrayList>();
        ArrayList ticket5 = new ArrayList<ArrayList>();
        ticket1.add("JFK");
        ticket1.add("SFO");
        ticket2.add("JFK");
        ticket2.add("ATL");
        ticket3.add("SFO");
        ticket3.add("ATL");
        ticket4.add("ATL");
        ticket4.add("JFK");
        ticket5.add("ATL");
        ticket5.add("SFO");
        tickets.add(ticket1);
        tickets.add(ticket2);
        tickets.add(ticket3);
        tickets.add(ticket4);
        tickets.add(ticket5);
        System.out.println(tickets);
        System.out.println(new FindItinerary3().findItinerary(tickets));
    }
}

在这里插入图片描述

经过我的潜心研究，终于懂了，代码删了自己根据思路复现了一遍。

package com.programmercarl.backtracking;

import java.util.*;

/**
 * @ClassName FindItinerary4
 * @Descriotion TODO
 * @Author nitaotao
 * @Date 2022/7/12 15:19
 * @Version 4.0
 * https://leetcode.cn/problems/reconstruct-itinerary/
 * 332. 重新安排行程
 **/
public class FindItinerary4 {
    //当前使用的票
    Stack<String> stack;
    //出发机场  目的机场集合{[目的机场1，机票数量1],[目的机场2，机票数量1]}
    Map<String, Map<String, Integer>> map;

    public List<String> findItinerary(List<List<String>> tickets) {
        stack = new Stack<>();
        map = new HashMap<String, Map<String, Integer>>();
        //遍历每一张机票
        for (List<String> ticket : tickets) {
            Map<String, Integer> curStart;
            //如果当前map中包含该 起始地 为键的 集合
            if (map.containsKey(ticket.get(0))) {
                curStart = map.get(ticket.get(0));
                //更新 当前 起始地 的 目标地 的机票数量，有则+1，无则为1
                curStart.put(ticket.get(1), curStart.getOrDefault(ticket.get(1), 0) + 1);
            } else {
                //保证其中元素按键升序存储
                curStart = new TreeMap<String, Integer>();
                curStart.put(ticket.get(1), 1);
            }
            //更新当前map中 当前 起始地 的 目标地 集合的数据
            map.put(ticket.get(0), curStart);
        }
        //以 JFK 为起始地
        stack.push("JFK");
        //获取机票结果集
        backtracking(tickets.size());
        return new ArrayList(stack);
    }

    /**
     * @param ticketsNum 需要用到的机票的数量
     * @return
     */
    public boolean backtracking(int ticketsNum) {
        // 五个城市 需要 四 个机票连接在一起
        if (stack.size() == ticketsNum + 1) {
            return true;
        }
        //起始地
        String startArea = stack.peek();
        //防止空指针
        if (map.containsKey(startArea)) {
            //获取 当前 出发地 的 所有 目的地 的机票 和 相关 剩余票数
            for (Map.Entry<String, Integer> ticket : map.get(startArea).entrySet()) {
                //当前目的地 的 剩余机票数量
                int remainSum = ticket.getValue();
                if (remainSum > 0) {
                    //当 本目的地 的 机票数量 > 0
                    //机票数量 - 1
                    ticket.setValue(remainSum - 1);
                    stack.push(ticket.getKey());
                    boolean isFind = backtracking(ticketsNum);
                    if (isFind) {
                        //如果找到一条路，就返回，因为treemap自动排序，是最优解
                        return true;
                    }
                    //回溯
                    stack.pop();
                    ticket.setValue(remainSum);
                }
            }
        }
        //此路不通，重新找最优路线
        return false;
    }


    public static void main(String[] args) {
        List<List<String>> tickets = new ArrayList<List<String>>();
        ArrayList ticket1 = new ArrayList<ArrayList>();
        ArrayList ticket2 = new ArrayList<ArrayList>();
        ArrayList ticket3 = new ArrayList<ArrayList>();
        ArrayList ticket4 = new ArrayList<ArrayList>();
        ArrayList ticket5 = new ArrayList<ArrayList>();
        ticket1.add("JFK");
        ticket1.add("SFO");
        ticket2.add("JFK");
        ticket2.add("ATL");
        ticket3.add("SFO");
        ticket3.add("ATL");
        ticket4.add("ATL");
        ticket4.add("JFK");
        ticket5.add("ATL");
        ticket5.add("SFO");
        tickets.add(ticket1);
        tickets.add(ticket2);
        tickets.add(ticket3);
        tickets.add(ticket4);
        tickets.add(ticket5);
        System.out.println(tickets);
        System.out.println(new FindItinerary4().findItinerary(tickets));
    }
}

在这里插入图片描述

Ctrl + C Ctrl + V AC !!! over … next !!!
在这里插入图片描述

涛涛英语学不进去
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
每日一题算法：2020年8月27日 [重新安排行程] findItinerary
I12XXXXXLbull的博客
08-27 142
2020年8月27日 重新安排行程 findItinerary class Solution { public List<String> findItinerary(List<List<String>> tickets) { } } 解题思路: 首先这个自然排序，实际上有一个非常简单的方法我学到过，就是直接使用hashcode，比如下面三个字符串的hashcode就可以直接看出排序。 知道这一点之后就是使用搜索算法了，使用有选择性的搜索算法，既不
Leetcode1466. 重新规划路线(medium,BFS)
chenxy_bwave的专栏
04-17 563
Leetcode1466. 重新规划路线(medium,BFS),Python题解
LeetCode 332. 重新安排行程
XY_xyz_xyz的博客
12-06 452
给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。 所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。 例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。 假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。 示例 1
Reconstruct Itinerary 重新安排行程
qq_26410101的博客
09-18 608
给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 出发。 说明: 如果存在多种有效的行程，你可以按字符自然排序返回最小的行程组合。例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前 ...
leetcode——第332题——重新安排行程
linping_的博客
05-08 199
题目： 给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。 class Solution { // 先回忆一下：首先要把给定的的 二维字符串数组，一一映射 private: // <出发机场， <到达机场， 航班次数>> unordered_map<string, map<string
LeetCode-5426、重新规划路线-中等
clover_my的博客
05-31 453
LeetCode-5426、重新规划路线-中等 n 座城市，从 0 到 n-1 编号，其间共有 n-1 条路线。因此，要想在两座不同城市之间旅行只有唯一一条路线可供选择（路线网形成一颗树）。去年，交通运输部决定重新规划路线，以改变交通拥堵的状况。路线用 connections 表示，其中 connections[i] = [a, b] 表示从城市 a 到 b 的一条有向路线。今年，城市 0 将会举办一场大型比赛，很多游客都想前往城市 0 。请你帮助重新规划路线方向，使每个城市都可以访问城市 0 。返回需要
leetcode:leetcode刷题:pencil:
05-02
LeetCode Leetcode solutions in C++ 11 NO. Title Solution Note Difficulty Tag 1 Easy 数组 | 哈希表 2 Medium 链表 | 数学 3 Medium 字符串 4 Hard 数组 | 二分查找 5 Medium 字符串 | 动态规划 7 反转整数 C++ ...
leetcode分类-leetcode:算法分类刷题leetcode刷题
06-30
《LeetCode刷题攻略：系统化解题与算法分类探讨》 在编程学习与技能提升的过程中，LeetCode作为一款备受推崇的在线平台，为开发者提供了海量的编程挑战题目，涵盖了算法、数据结构以及实际问题解决等多个领域。本...
Leetcode刷题：剑指offer【面试题07】
01-20
Leetcode题目对应位置： 面试题07：重建二叉树 复习： 二叉树的三种遍历方式： 前序遍历：根 左 右 中序遍历：左 根 右 后序遍历：左 右 根 要恢复一颗二叉树，必须知道它的中序序列（因为中序序列可以知道根节点...
Leetcode刷题手册 labuladong的算法小抄官方完整版（共 560 页）
06-19
算法 Leetcode刷题手册 labuladong的算法小抄官方完整版
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
力扣网---贪心算法（JAVA实现）---中等（一）
小jinx的博客
11-26 401
目录55，跳跃游戏134，加油站376，摆动序列 55，跳跃游戏 问题描述： 给定一个非负整数数组，你最初位于数组的第一个位置。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个位置。 示例 1: 输入: [2,3,1,1,4] 输出: true 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。 示例 2: 输入: [3,2,1,0,4] 输出: false 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最
332. Reconstruct Itinerary
wilzxu的博客
03-03 559
332. Reconstruct Itinerary方法1:方法2: Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a...
力扣112 路径总和
小吕的博客
05-24 156
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: bool hasPathSum(TreeNode* ro...
算法014：找到字符串中所有字母异位词
最新发布
m0_62319039的博客
07-14 282
算法014：找到字符串中所有字母异位词
函数模板与类模板
程序员_小兵
07-12 1535
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
36. Adam 算法详解
qq_41238579的博客
07-10 947
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
【排序 - 堆排序】
2302_80393814的博客
07-10 502
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 165
【代码】代码随想录算法训练营第33天。
LeetCode刷题手册. by halfrost（中文名：霜神） (z-lib.org)1
08-03
总之，通过阅读《LeetCode刷题手册》，读者能够更好地了解LeetCode和Cookbook的概念，并学习到各种算法的解题方法和实例代码。笔者建议读者阅读在线版，以获取最新的修订和错误更正。如果读者对本书有所帮助，可以给...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值