Leetcode算法训练日记 | day30

已于 2024-04-20 17:07:52 修改
阅读量674 收藏 12
点赞数 28
文章标签： 算法 leetcode
于 2024-04-19 20:56:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74882777/article/details/137976565
版权

专题九  贪心算法

一、重新安排行程

1.题目

Leetcode：第 332 题

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

  • 例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

示例 1：

输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]
输出：["JFK","MUC","LHR","SFO","SJC"]

示例 2：

输入：tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
输出：["JFK","ATL","JFK","SFO","ATL","SFO"]
解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"] ，但是它字典排序更大更靠后。

2.解题思路

使用回溯算法来解决路径问题。findItinerary 函数负责初始化并开始回溯过程。backtracking 函数是回溯算法的核心，它尝试在每个位置添加一个城市，并递归地继续处理后续的城市。通过这种方式，backtracking 函数能够找到一条有效的旅行路径。targets 映射用于存储每个出发城市到到达城市的机票数量，这个映射在 findItinerary 函数中被构建，并在 backtracking 函数中被用来检查是否存在可用的机票。通过递归和回溯来搜索所有可能的解决方案。当找到一个满足条件的解时，递归返回 true，否则尝试其他可能的路径。

3.实现代码

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
using namespace std;

class Solution {
public:
    // 使用 unordered_map 存储目标城市，其中 key 为出发城市，value 为一个 map，其 key 为到达城市，value 为机票数量
    unordered_map<string, map<string, int>> targets;

    // backtracking 函数实现回溯算法，尝试找出一条有效的旅行路径
    bool backtracking(int ticketNum, vector<string>& result) {
        // 如果当前路径长度等于机票数量加一（包括起点城市），说明找到了一条完整的路径
        if (result.size() == ticketNum + 1) {
            return true;
        }

        // 遍历当前结果路径最后一个城市的所有可到达城市
        for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
            // 如果从当前城市到 target.first 的机票数量大于 0
            if (target.second > 0) { 
                result.push_back(target.first);// 将 target.first 添加到结果路径中
                target.second--;// 减少 target.first 的机票数量
                if (backtracking(ticketNum, result)) return true; // 递归调用 backtracking 函数，尝试继续添加路径  
                result.pop_back();// 如果当前路径不可行，回溯：移除最后一个添加的城市
                target.second++;// 恢复机票数量
            }
        }
        return false;// 如果所有可能的路径都已经尝试过，但没有找到可行的路径，则返回 false
    }

    // findItinerary 函数用于找出一条最短的旅行路径
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear(); // 清空 targets，为新的机票数据做准备
        vector<string> result;
        // 统计每个出发城市到到达城市的机票数量
        for (const vector<string>& vec : tickets) {
            targets[vec[0]][vec[1]]++;
        }
        result.push_back("JFK");// 将起点城市 "JFK" 添加到结果路径中 
        backtracking(tickets.size(), result);// 从起点城市开始，使用 backtracking 函数尝试找出一条旅行路径
        return result; // 返回找到的旅行路径
    }
};

//测试
int main()
{
    Solution p;
    vector<vector<string>>tickets = { {"MUC", "LHR"} ,{"JFK", "MUC"},{"SFO", "SJC"},{"LHR", "SFO"} };
   vector<string> result;
    vector<int>nums = { 1,2,2 };
    result = p.findItinerary(tickets);
    cout << "行程：" << endl;
    for (auto& ans : result) {
        cout << "[";
        for (auto& i : ans) {
            cout << i << " ";
        }
        cout << "] ," ;
    }
    printf("\b \n");
    return 0;
}

二、N皇后

1.题目

Leetcode：第 51 题

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

示例 1：

输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。

示例 2：

输入：n = 1
输出：[["Q"]]
2.解题思路

使用回溯算法来解决棋盘问题。solveNQueens 函数负责初始化棋盘并开始回溯过程。backtracking 函数是回溯算法的核心，它尝试在每个位置放置皇后，并递归地继续处理后续的行。isValid 函数用于检查当前位置是否安全，即没有受到其他皇后的攻击。backtracking 函数通过递归尝试每一行的每一个位置来放置皇后。如果找到一个安全的位置，它将继续递归到下一行。如果这一行的所有位置都尝试过了，它将回溯到上一行，改变上一行皇后的位置。isValid 函数通过检查当前行的列、左上到右下的对角线、右上到左下的对角线是否有皇后来确定当前位置是否安全。这种方法可以找到所有可能的解决方案，即所有安全的皇后放置方式。

3.实现代码
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    vector<vector<string>> result;// 定义一个二维字符串数组用于存储所有可能的棋盘布局结果

    // backtracking 函数实现回溯算法，尝试放置每一行的皇后
    void backtracking(int n, int row, vector<string>& chessboard) {
        // 如果当前行数等于 n，说明已经放置完所有行的皇后，找到了一个解决方案
        if (row == n) {
            result.push_back(chessboard);
            return;
        }
        // 遍历当前行的每一个列
        for (int col = 0; col < n; col++) {
            // 检查当前位置是否有效，即该位置没有受到其他皇后的攻击
            if (isValid(row, col, chessboard, n)) {    
                chessboard[row][col] = 'Q'; // 在当前位置放置一个皇后
                backtracking(n, row + 1, chessboard);// 递归调用 backtracking 函数，尝试放置下一行的皇后
                chessboard[row][col] = '.';// 移除当前位置的皇后，回溯以便尝试其他位置
            }
        }
    }

    // isValid 函数用于检查当前行和列是否是安全的，即该位置没有受到其他皇后的攻击
    bool isValid(int row, int col, vector<string>& chessboard, int n) {
        // 检查列是否有其他皇后
        for (int i = 0; i < row; i++) {
            if (chessboard[i][col] == 'Q') {
                return false; // 如果同一列有皇后，则返回 false
            }
        }
        // 检查左上到右下的对角线是否有其他皇后
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (chessboard[i][j] == 'Q') {
                return false; // 如果对角线有皇后，则返回 false
            }
        }
        // 检查右上到左下的对角线是否有其他皇后
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (chessboard[i][j] == 'Q') {
                return false; // 如果对角线有皇后，则返回 false
            }
        }
        return true;// 如果当前位置安全，则返回 true
    }

    // solveNQueens 函数用于开始解决 N 皇后问题
    vector<vector<string>> solveNQueens(int n) {      
        result.clear();// 清空结果集，为新的棋盘布局做准备
        vector<string> chessboard(n, string(n, '.')); // 初始化棋盘，所有位置先设为 '.'
        backtracking(n, 0, chessboard);// 从第一行开始放置皇后
        return result;// 返回所有可能的棋盘布局结果
    }
};

//测试
int main()
{
    Solution s;
    int n;
    vector<vector<string>>result;
    cout << "请输入 n ： ";
    cin >> n;
    result = s.solveNQueens(n);
    cout << "所有的解法有：" << endl;
    for (int i = 0; i < result.size(); i++) {
        cout << "第"<<i+1<<"种解法" << endl;
        for (int j = 0; j < n; j++) {
            cout << result[i][j] << "  " << endl;
        }
        cout << endl;
    }
    cout <<endl;
    return 0;
}

三、解数独

1.题目

Leetcode：第 37 题

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

2.解题思路

使用回溯算法来解决数独问题。solveSudoku 函数负责开始回溯过程。backtracking 函数是回溯算法的核心，它尝试在每个空格填入数字，并递归地继续处理后续的空格。isValid 函数用于检查当前位置填入某个数字后数独板是否仍然有效。backtracking 函数通过递归尝试每个空格的每个可能的数字来解决数独问题。如果找到一个数字使得数独板有效，它将继续递归到下一个空格。如果当前空格的所有尝试都失败了，它将回溯到上一个空格，改变上一个空格的数字。isValid 函数通过检查当前行、当前列以及当前单元格所在的 3x3 子网格是否有重复的数字来确定当前位置是否有效。这种方法可以找到数独问题的解决方案，即使在复杂的数独谜题中也能有效地找到答案。

3.实现代码
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    // backtracking 函数实现回溯算法，尝试填入数独板的每个空格
    bool backtracking(vector<vector<char>>& board) {
        // 遍历数独板的每个单元格
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                // 如果当前单元格为空（'.'）
                if (board[i][j] == '.') {
                    // 尝试填入数字 1 到 9
                    for (char k = '1'; k <= '9'; k++) {
                        // 如果填入当前数字 k 后数独板仍然有效
                        if (isValid(i, j, k, board)) {
                            // 在当前单元格填入数字 k
                            board[i][j] = k;
                            // 递归调用 backtracking 函数，尝试填入下一个空格
                            if (backtracking(board)) {
                                return true; // 如果找到一个解决方案，则返回 true
                            }
                            // 如果当前数字 k 不适用，回溯：将当前单元格重置为空
                            board[i][j] = '.';
                        }
                    }
                    return false;// 如果没有数字可以填入当前单元格，则返回 false
                }
            }
        }
        return true;// 如果所有单元格都已经填入数字并且数独板有效，则返回 true
    }

    // isValid 函数检查在给定的行和列填入某个值后数独板是否仍然有效
    bool isValid(int row, int col, char val, vector<vector<char>>& board) {
        // 检查当前行是否已包含要填入的值 val
        for (int i = 0; i < 9; i++) {
            if (board[row][i] == val) {
                return false; // 如果已包含，则返回 false
            }
        }
        // 检查当前列是否已包含要填入的值 val
        for (int j = 0; j < 9; j++) {
            // 数独规则中，即使单元格为空（'.'），列中也不能有重复的数字
            if (board[j][col] == val) {
                return false; // 如果已包含，则返回 false
            }
        }

        // 计算当前单元格所在的 3x3 子网格的起始行和列
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        // 检查当前 3x3 子网格是否已包含要填入的值 val
        for (int i = startRow; i < startRow + 3; i++) {
            for (int j = startCol; j < startCol + 3; j++) {
                if (board[i][j] == val) {
                    return false; // 如果已包含，则返回 false
                }
            }
        }
        // 如果当前单元格填入 val 后不违反数独规则，则返回 true
        return true;
    }

    // solveSudoku 函数用于解决数独问题
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);// 调用 backtracking 函数尝试填入数独板
    }
};

//测试
int main()
{
    Solution s;
    vector<vector<char>> board = { {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
        {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
        {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
        {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
        {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
        {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
        {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
        {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
        {'.', '.', '.', '.', '8', '.', '.', '7', '9'} };
    s.solveSudoku(board);
    cout << "数独的其中一种解法：" << endl;
    for (int i = 0; i < board.size(); i++) {
        for (int j = 0; j < board[0].size(); j++) {
            cout << board[i][j] << "  ";
        }
        cout << endl;
    }
    cout << endl;
    cout << endl;
    return 0;
}

 ps：以上皆是本人在探索算法旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。

山川人海
关注
  • 28
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
arith:LeetCode算法训练
03-10
arith:LeetCode算法训练
leetcode2sumc-LeetCode:Leetcodealgorithms|Leetcode算法题
06-30
leetcode 2 和 c 力扣算法 # 标题 解决方案 困难 680 , 简单的 678 , 中等的 666 , 中等的 663 中等的 662 中等的 661 简单的 660 难的 657 简单的 653 , 简单的 650 中等的 647 中等的 605 , 简单的 599 , 简单的 ...
Leetcode算法训练日记 | day34
m0_74882777的博客
04-23 1267
Leetcode：第 1005 题 给你一个整数数组nums和一个整数k，按以下方法修改该数组：选择某个下标i并将nums[i]替换为-nums[i]。重复这个过程恰好k次。可以多次选择同一个下标i。以这种方式修改数组后，返回数组可能的最大和。 Leetcode：第 134 题 在一条环路上有n个加油站，其中第i个加油站有汽油gas[i]升。 Leetcode：第 135 题 n个孩子站成一排。给你一个整数数组ratings表示每个孩子的评分。
Leetcode算法训练日记 | day31
m0_74882777的博客
04-20 990
Leetcode：第 455 题 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 Leetcode：第 376 题 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
Leetcode算法训练日记 | day36
m0_74882777的博客
04-25 660
Leetcode：第 435 题 给定一个区间的集合intervals，其中intervals[i] = [starti, endi]。返回需要移除区间的最小数量，使剩余区间互不重叠。 Leetcode：第 763 题 给你一个字符串s。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。 Leetcode：第 56 题 以数组intervals表示若干个区间的集合，其中单个区间为intervals[i] = [starti, endi]。
Leetcode算法训练日记 | day29
m0_74882777的博客
04-18 964
Leetcode：第 491 题 给你一个整数数组nums，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。 Leetcode：第 46题 给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。 Leetcode：第 47题 给定一个可包含重复数字的序列nums，按任意顺序返回所有不重复的全排列。
Leetcode算法训练日记 | day18
m0_74882777的博客
04-06 766
Leetcode：第 513 题 给定一个二叉树的根节点root，请找出该二叉树的最底层最左边节点的值。假设二叉树中至少有一个节点。 Leetcode：第 112题 给你二叉树的根节点root和一个表示目标和的整数targetSum。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和targetSum。如果存在，返回true；否则，返回false。叶子节点是指没有子节点的节点。
Leetcode算法训练日记 | day32
m0_74882777的博客
04-20 947
Leetcode：第 53题 给你一个整数数组nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。 Leetcode：第 122 题 给你一个整数数组prices，其中prices[i]表示某支股票第i天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。 返回你能获得的最大利润。
Leetcode算法训练日记 | day10
m0_74882777的博客
03-29 994
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）。 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
Leetcode算法训练日记 | day35
m0_74882777的博客
04-24 698
Leetcode：第 860 题 在柠檬水摊上，每一杯柠檬水的售价为5美元。顾客排队购买你的产品，（按账单bills支付的顺序）一次购买一杯。 Leetcode：第 406 题 假设有打乱顺序的一群人站成一个队列，数组people表示队列中一些人的属性（不一定按顺序）。每个people[i] = [hi, ki]表示第i个人的身高为hi，前面正好有ki个身高大于或等于hi的人。 Leetcode：第 452 题 有一些球形气球贴在一堵用 XY 平面表示的墙面上。
Leetcode算法训练日记 | day08
m0_74882777的博客
03-27 840
给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。
C语言 LeetCode算法刷题30天全面提升教程百度网盘链接
06-19
C语言 C语言 LeetCode算法刷题30天全面提升教程算法刷题30天全面提升教程
LeetCode算法数据结构专训笔记,
03-26
LeetCode算法数据结构专训笔记, 刷完之后对于自生的算法能力有着绝对的提升, 而且好处，题目分类清晰，专项专训, 题目存在套路，不会出现说刷不下去的问题存在
LeetCode 算法
09-07
本资源收集于互联网， 为LeetCode 算法习题和答案，供大家共同学习和进步
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 494
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
MT2057 门票
l141930402的博客
05-15 759
前缀和+归并排序
力扣62 不同路径 Java版本
最新发布
m0_47066863的博客
05-20 185
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
技艺高超的魔法师：Java运算符
epitomizelu的专栏
05-14 788
Java运算符是构建复杂程序的基础，掌握它们的使用和优先级对于写出高效、清晰的代码至关重要。通过本文的介绍和实例，希望能帮助读者更好地理解和运用这些运算符，让代码表达更加精准和高效。记住，实践是学习的最好方式，不断编写代码并探索不同的场景，你会越来越熟练地掌握它们。
如何快速掌握LeetCode算法题
06-13
以下是一些快速掌握LeetCode算法题的建议，供您参考： 1. 学习数据结构和算法基础知识：LeetCode算法题需要掌握一些数据结构和算法基础知识，例如链表、树、堆、排序、查找、动态规划等。可以通过参考经典算法书籍...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值