Leetcode算法训练日记 | day30

news2024/10/6 4:01:25

专题九  贪心算法

一、重新安排行程

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1626403.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

对于AIGC（人工智能）我们应该如何看待

对于AIGC（人工智能）我们应该如何看待

文章目录 前言一、AIGC技术的现状与特点二、AIGC技术在各个领域的应用三、AIGC技术对未来社会的影响四、AIGC技术的可能发展方向 前言 随着科技的飞速发展&#xff0c;人工智能与大数据的结合日益紧密&#xff0c;AIGC&#xff08;人工智能生成内容&#xff09;技术作为这一领域…
阅读更多...
【产品经理修炼之道】- 车载语音产品需求分析与产品设计

【产品经理修炼之道】- 车载语音产品需求分析与产品设计

目录 一、车载语音产品概述 1. 车载语音交互具有以下特点和优势 2. 车载语音产品脑图框架 二、需求与竞品分析 1. 车载语音交互痛点分析 2. 基于实际驾驶情景的分析 3. 车载语音体验地图 4. 车载语音产品的竞品分析 三、需求分类与功能设计 1. 车载语音产品场景控制划…
阅读更多...
划分子网练习

划分子网练习

某个院系有4个专业&#xff0c;A专业有100台主机&#xff0c;B专业有58台主机&#xff0c;C专业有30台主机&#xff0c;D专业有28台主机&#xff0c;现申请了一个C类地址&#xff1a;192.32.250.0。 &#xff08;1&#xff09;请尝试为他们分配请按要求划分子网&#xff0c;使…
阅读更多...
php动态高亮web源代码

php动态高亮web源代码

php动态高亮web源代码 注&#xff1a;配置好不允许高亮的文件名&#xff0c;安全第一 #php实现动态展示目录树结构源代码 适用于开放源代码&#xff0c;结合html缓存使用效果更佳&#xff0c;因循环较多不适合放首页 能力有限没实现行号 演示&#xff1a;show source|开放…
阅读更多...
短视频素材去哪里找，而且不带水印的那种？

短视频素材去哪里找，而且不带水印的那种？

为了确保视频创作者能够接触到全球范围内的优质资源&#xff0c;下面列出的视频素材网站各具特色&#xff0c;提供从标准视频到高动态范围&#xff08;HDR&#xff09;的素材&#xff0c;满足你在不同项目中的需求。 1. 蛙学府 (中国) 提供专业级的视频素材&#xff0c;特别适…
阅读更多...
制糖工业智能工厂数字孪生可视化平台，推进制糖产业数字化转型

制糖工业智能工厂数字孪生可视化平台，推进制糖产业数字化转型

制糖工业智能工厂数字孪生可视化平台&#xff0c;推进制糖产业数字化转型。随着信息技术的快速发展&#xff0c;数字化转型已成为各行各业的重要趋势。在糖果加工制造领域&#xff0c;智能工厂数字孪生可视化平台的出现&#xff0c;为行业数字化转型注入了新的活力。 糖果加工制…
阅读更多...
【002_音频开发_基础篇_Linux音频架构简介】

【002_音频开发_基础篇_Linux音频架构简介】

002_音频开发_基础篇_Linux音频架构简介 文章目录 002_音频开发_基础篇_Linux音频架构简介创作背景Linux 音频架构ALSA 简介ASoC 驱动硬件架构软件架构MachinePlatformCodec ASoC 驱动 PCMALSA设备文件结构 ALSA 使用常用概念alsa-libALSA Open 流程ALSA Write 流程2种写入方法…
阅读更多...
抖音获客新技能，品牌光彩夺目秘籍！

抖音获客新技能，品牌光彩夺目秘籍！

在数字化的浪潮中&#xff0c;社交媒体营销已成为品牌推广的重要手段。尤其是短视频平台&#xff0c;以其快速、直观的特点捕获了亿万用户的注意力。在这样的背景下&#xff0c;抖音作为一个重量级的短视频平台&#xff0c;吸引了大量的企业和品牌入驻&#xff0c;希望通过短视…
阅读更多...
Rancher 应用商店离线环境使用

Rancher 应用商店离线环境使用

前言 Rancher (v2.5 ) 应用商店可以方便的安装 Helm3 构建的应用&#xff0c;并且支持私有 helm 应用仓库&#xff0c;方便了内网离线环境下的使用。本文以内网离线环境为前提、以 MySQL 5.7.43 版本为应用举例&#xff0c;从零开始手把手教你如何制作并应用。 1、环境准备 1.…
阅读更多...
H5点击复制功能 兼容安卓、IOS

H5点击复制功能 兼容安卓、IOS

效果图 HTML代码 <div>链接&#xff1a;<span style"color: #FF8A21" click"CopyUrl" id"copyId"> https://blog.csdn.net/qq_51463650?spm1000.2115.3001.5343</span> </div>复制方法 const CopyUrl () > {let …
阅读更多...
Git工具的使用

Git工具的使用

文章目录 Git概述本地仓库命令远程仓库命令分支操作标签操作 IDEA上执行Git Git概述 一般工作流程如下&#xff1a; 从远程仓库中克隆 Git 资源作为本地仓库&#xff1b; 从本地仓库中checkout代码然后进行代码修改&#xff1b; 在提交本地仓库前先将代码提交到暂存区&#xff…
阅读更多...
利用Spring Boot后端与Vue前端技术构建现代化电商平台

利用Spring Boot后端与Vue前端技术构建现代化电商平台

作者介绍&#xff1a;✌️大厂全栈码农|毕设实战开发&#xff0c;专注于大学生项目实战开发、讲解和毕业答疑辅导。 &#x1f345;获取源码联系方式请查看文末&#x1f345; 推荐订阅精彩专栏 &#x1f447;&#x1f3fb; 避免错过下次更新 Springboot项目精选实战案例 更多项目…
阅读更多...
python基础——正则表达式

python基础——正则表达式

&#x1f4dd;前言&#xff1a; 这篇文章主要想讲解一下python中的正则表达式&#xff1a; 1&#xff0c;什么是正则表达式 2&#xff0c;re模块三匹配 3&#xff0c;元字符匹配 4&#xff0c;具体示例 &#x1f3ac;个人简介&#xff1a;努力学习ing &#x1f4cb;个人专栏&am…
阅读更多...
【C++】STL-vector的使用

【C++】STL-vector的使用

目录 1、什么是vector&#xff1f; 2、vector的使用 2.1 vector的定义 ​编辑 2.2 遍历修改数据 2.3 迭代器 2.4 vector空间增长问题 2.5 vector的增删查改 3、迭代器失效 3.1 会引起其底层空间改变的操作&#xff0c;都有可能是迭代器失效 3.2 指定位置元素的删除操…
阅读更多...
【Linux】如何进行用户之间的切换——指令su

【Linux】如何进行用户之间的切换——指令su

&#x1f490; &#x1f338; &#x1f337; &#x1f340; &#x1f339; &#x1f33b; &#x1f33a; &#x1f341; &#x1f343; &#x1f342; &#x1f33f; &#x1f344;&#x1f35d; &#x1f35b; &#x1f364; &#x1f4c3;个人主页 &#xff1a;阿然成长日记 …
阅读更多...
消费新纪元：揭秘消费增值模式，让你的每一分钱都“钱生钱”

消费新纪元：揭秘消费增值模式，让你的每一分钱都“钱生钱”

你是否对传统消费方式有所不满&#xff0c;认为它只停留在物质层面的交换&#xff0c;缺乏更深层次的附加价值&#xff1f;那么&#xff0c;我要为你揭晓一种新颖的消费模式——消费增值&#xff0c;它将为你的消费观念带来全新的变革&#xff0c;让你的每一笔消费都充满无限可…
阅读更多...
CLIP图生文

CLIP图生文

CLIP模型本身并不是图生文的&#xff0c;CLIP模型用来做图片和文本描述的匹配。 但它可以与其他技术结合使用来实现这一点&#xff0c;以下是两种常见的方法&#xff1a; CLIP作为文本灵感检索系统&#xff1a; 这种方法利用了 CLIP 在寻找图像和文本之间相似表示方面的优势。…
阅读更多...
关于豆瓣电影数据抓取以及可视化

关于豆瓣电影数据抓取以及可视化

首先我们可以先了解以下网络爬虫的定义&#xff1a; 爬虫是一种按照一定的规则&#xff0c;自动地抓取万维网信息的程序或者脚本。它可以在互联网上自动抓取网页内容&#xff0c;将这些信息存储起来。爬虫可以抓取网站的所有网页&#xff0c;从而获取对于我们有价值的信…
阅读更多...
跨界客户服务：拓展服务边界，创造更多价值

跨界客户服务：拓展服务边界，创造更多价值

在日益激烈的市场竞争中&#xff0c;企业如何突破传统服务模式的限制&#xff0c;创造更多价值&#xff0c;已成为业界关注的焦点。跨界客户服务作为一种新兴服务模式&#xff0c;正逐渐受到企业的青睐。通过跨界合作&#xff0c;企业可以拓展服务边界&#xff0c;提供更加多元…
阅读更多...
数据治理和数据管理 傻傻分不清楚？

数据治理和数据管理 傻傻分不清楚？

互联网时代&#xff0c;数据&#xff0c;这一无形资产&#xff0c;已成为现代企业的核心竞争力。如何高效地管理和利用数据&#xff0c;成为企业关注的焦点。在这个过程中&#xff0c;数据治理&#xff08;Data Governance&#xff09;和数据管理&#xff08;Data Management&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023