557. 反转字符串中的单词 III；841. 钥匙和房间；486. 预测赢家；71. 简化路径

最新推荐文章于 2023-04-25 14:13:47 发布

LifelongLearningPan

最新推荐文章于 2023-04-25 14:13:47 发布

阅读量148

点赞数

分类专栏： LeetCode

本文为LifelongLearningPan博主原创文章，转载请注明出处。

本文链接：https://blog.youkuaiyun.com/qq_24854861/article/details/108302368

版权

LeetCode 专栏收录该内容

95 篇文章

订阅专栏

本文探讨了字符串操作和游戏策略的算法问题，包括字符串中单词的字符顺序反转、预测分数游戏的赢家以及简化Unix风格的文件路径。通过具体示例展示了不同算法的实现方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例：

输入："Let's take LeetCode contest"
输出："s'teL ekat edoCteeL tsetnoc"

提示：

在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

class Solution {
public:
    string reverseWords(string s) {
        string res;
        stringstream ss(s);
        while (getline(ss, s, ' ')) {
            reverse(s.begin(), s.end());    //
            res += s + ' ';
        }
        if (res.size()) {
            res.pop_back();
        }
        return res;
    }
};

有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，...，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，...，N-1] 中的一个整数表示，其中 N = rooms.length。钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。

最初，除 0 号房间外的其余所有房间都被锁住。

你可以自由地在房间之间来回走动。

如果能进入每个房间返回 true，否则返回 false。

示例 1：

输入: [[1],[2],[3],[]]
输出: true
解释:
我们从 0 号房间开始，拿到钥匙 1。
之后我们去 1 号房间，拿到钥匙 2。
然后我们去 2 号房间，拿到钥匙 3。
最后我们去了 3 号房间。
由于我们能够进入每个房间，我们返回 true。

示例 2：

输入：[[1,3],[3,0,1],[2],[0]]
输出：false
解释：我们不能进入 2 号房间。

提示：

   1 <= rooms.length <= 1000
   0 <= rooms[i].length <= 1000
   所有房间中的钥匙数量总计不超过 3000。

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n =rooms.size(), cnt = 1;
        vector<bool> vis(n, false);
        queue<int> q;
        q.push(0);
        vis[0] = true;
        while (q.size()) {
            auto cur = q.front();
            q.pop();         
            for (auto &r: rooms[cur]) {
                if (vis[r]) continue;
                // start
                vis[r] = true;
                ++cnt;
                // end
                q.push(r);
            }
        }
        return cnt == n;
    }
};

给定一个表示分数的非负整数数组。玩家 1 从数组任意一端拿取一个分数，随后玩家 2 继续从剩余数组任意一端拿取分数，然后玩家 1 拿，…… 。每次一个玩家只能拿取一个分数，分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总和最多的玩家获胜。

给定一个表示分数的数组，预测玩家1是否会成为赢家。你可以假设每个玩家的玩法都会使他的分数最大化。

示例 1：

输入：[1, 5, 2]
输出：False
解释：一开始，玩家1可以从1和2中进行选择。
如果他选择 2（或者 1 ），那么玩家 2 可以从 1（或者 2 ）和 5 中进行选择。如果玩家 2 选择了 5 ，那么玩家 1 则只剩下 1（或者 2 ）可选。
所以，玩家 1 的最终分数为 1 + 2 = 3，而玩家 2 为 5 。
因此，玩家 1 永远不会成为赢家，返回 False 。

示例 2：

输入：[1, 5, 233, 7]
输出：True
解释：玩家 1 一开始选择 1 。然后玩家 2 必须从 5 和 7 中进行选择。无论玩家 2 选择了哪个，玩家 1 都可以选择 233 。
最终，玩家 1（234 分）比玩家 2（12 分）获得更多的分数，所以返回 True，表示玩家 1 可以成为赢家。

提示：

   1 <= 给定的数组长度 <= 20.
   数组里所有分数都为非负数且不会大于 10000000 。
   如果最终两个玩家的分数相等，那么玩家 1 仍为赢家。

class Solution {   
    vector<int> nums;
public:
    bool PredictTheWinner(vector<int>& nums) {
        int nSize = nums.size();
        if (nSize <= 2) return true;
        this->nums = nums;
        return helper(1, 0, nSize - 1, 0);
    }
    bool helper(bool player, int le, int ri, int sum){
        if(le > ri)
            return sum >= 0;
        if (player) {               // 存在一true即为true
            if (helper(!player, le + 1, ri, sum + nums[le])) {
                return true;
            }
            if (helper(!player, le, ri - 1, sum + nums[ri])) {
                return true;
            } 
            return false;
        }
        else{                       // 存在一false即false
            if (!helper(!player, le + 1, ri, sum - nums[le])) {
                return false;
            }
            if (!helper(!player, le, ri - 1, sum - nums[ri])) {
                return false;
            } 
            return true;
        }
    }
};

以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点（..）表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。更多信息请参阅：Linux / Unix中的绝对路径 vs 相对路径

请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 / 结尾。此外，规范路径必须是表示绝对路径的最短字符串。

示例 1：

输入："/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。

示例 2：

输入："/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根是你可以到达的最高级。

示例 3：

输入："/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。

示例 4：

输入："/a/./b/../../c/"
输出："/c"

示例 5：

输入："/a/../../b/../c//.//"
输出："/c"

示例 6：

输入："/a//bc/d//././/.."
输出："/a/b/c"

class Solution { // 思路：栈
public:
    string simplifyPath(string path) {
        string res;
        stack<string> sta;
        for (int i = 0, substr_n = 0; i <= path.size(); ++i) {
            if (path[i] == '/' || (i == path.size() && path.back() != '/')) { // 3 path不是以/结尾的特殊情况
                if (substr_n) {
                    auto tmp = path.substr(i - substr_n, substr_n);
                    if (tmp == "..") { 
                        if (sta.size()) {   // 2 "/../" 的情况
                            sta.pop();
                        }
                    } else if (tmp == ".") {
                        substr_n = 0;       // 1
                        continue;           // 1 注意continue的时候保证尾代码一致
                    } else {
                        sta.push(tmp);
                    }
                }
                substr_n = 0;               // 1
            } else {
                ++substr_n;
            }
        }
        while (sta.size()) {
            res = "/" + sta.top() + res;
            sta.pop();
        }
        if (res.size() == 0) {
            res = "/";
        }
        return res;
    }
};