332. 重新安排行程；657. 机器人能否返回原点；214. 最短回文串

最新推荐文章于 2021-04-14 18:14:58 发布

原创最新推荐文章于 2021-04-14 18:14:58 发布 · 183 阅读

0 ·

CC 4.0 BY-SA版权

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

LeetCode 专栏收录该内容

95 篇文章

订阅专栏

本文探讨了机票行程的合理规划，确保从指定起点出发的旅行者能按字符自然排序最小的方式完成行程。同时，分析了二维平面上机器人移动序列，判断其是否能返回原点，以及如何通过在字符串前添加字符将其转换为回文串。

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

给定一个机票的字符串二维数组 [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"]。但是它自然排序更大更靠后。

class Solution {
    vector<string> res_path;
    unordered_map<string, vector<string>> sel;
    unordered_map<string, vector<bool>> vis;
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        for (auto &t: tickets) {
            sel[t[0]].push_back(t[1]);                      // !!!邻接表
        }
        for (auto &s: sel) {
            sort(s.second.begin(), s.second.end());
            vis[s.first].resize(s.second.size(), false);    // !!!记录邻接表visited[from][to]中的to是否已访问过
        }
        int nums = tickets.size() + 1;                      // 节点总个数不是tickets.size() << 1
        string start = "JFK";
        res_path.push_back(start);  
        backTrack(start, nums - 1);
        return res_path;
    }
    bool backTrack(const string& start, const int& nums) {
        if (nums == 0) {
            return true;
        }        
        for (int i = 0, end = sel[start].size(); i < end; ++i) {
            if (vis[start][i]) continue;
            res_path.push_back(sel[start][i]);    
            vis[start][i] = true; 
            if (backTrack(sel[start][i], nums - 1)) return true;
            vis[start][i] = false;
            res_path.pop_back();
        }
        return false;
    }
};

在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。

移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。

注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。

示例 1:

输入: "UD"
输出: true
解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。

示例 2:

输入: "LL"
输出: false
解释：机器人向左移动两次。它最终位于原点的左侧，距原点有两次 “移动” 的距离。我们返回 false，因为它在移动结束时没有返回原点。

class Solution {
public:
    bool judgeCircle(string moves) {
        vector<int> dx = {1, -1, 0, 0}, dy = {0, 0, 1, -1};
        unordered_map<char, int> direct = {
            {'R', 0}, {'L', 1}, {'U', 2}, {'D', 3}
        };
        int x = 0, y = 0;
        for (auto &m: moves) {
            x += dx[direct[m]];
            y += dy[direct[m]];
        }
        return x == 0 && y == 0;
    }
};

给定一个字符串 s，你可以通过在字符串前面添加字符将其转换为回文串。找到并返回可以用这种方式转换的最短回文串。

示例 1:

输入: "aacecaaa"
输出: "aaacecaaa"

示例 2:

输入: "abcd"
输出: "dcbabcd"

/*思路
在字符串 s 中找出一个最长的前缀回文串 s1
反转（s减去s1部分）+s 即是答案
*/
class Solution {
public:
    string shortestPalindrome(string s) {
        int n = s.size();
        // 选取一个大于字符集大小的质数作为 base，再选取一个在字符串长度平方级别左右的质数作为 mod，产生哈希碰撞的概率就会很低
        int base = 131, mod = pow(10, 9)+7;
        long long left = 0, right = 0, mul = 1;
        int best = -1;
        for (int i = 0; i < n; ++i) {
            left = (left * base + s[i]) % mod;
            right = (right + mul * s[i]) % mod; // mul
            mul = mul * base % mod;             // 
            if (left == right) best = i;          
        }
        string add = (best == n - 1 ? "" : s.substr(best + 1, n));
        reverse(add.begin(), add.end());
        return add + s;
    }
};