AI刷题-理想火车站定位、数字魔法的加一操作-CSDN博客

初始化：
- 设置一个变量 min_distance 来记录当前最小的总距离，初始值设为无穷大。
- 设置一个变量 best_location 来记录当前最佳位置，初始值设为一个无效的位置（例如 [-1, -1]）。
遍历所有备选位置：
- 对于每一个备选位置 loc，计算所有市民到该位置的总距离。
- 计算总距离的方法是遍历所有市民，累加每个市民到该位置的曼哈顿距离。
更新最佳位置：
- 如果当前备选位置的总距离小于 min_distance，则更新 min_distance 和 best_location。
返回结果：
- 遍历完所有备选位置后，返回 best_location。

最终代码：

#include <iostream>
#include <vector>
#include <limits>  // 用于获取无穷大值

std::vector<int> solution(int n, int m, std::vector<std::vector<int>> citizens, std::vector<std::vector<int>> locations) {
    int min_distance = std::numeric_limits<int>::max();  // 初始化最小距离为无穷大
    std::vector<int> best_location = {-1, -1};           // 初始化最佳位置
    
    for (const auto& loc : locations) {                   // 遍历所有备选位置
        int total_distance = 0;                          // 当前备选位置的总距离
        
        for (const auto& citizen : citizens) {            // 遍历所有市民
            int distance = abs(citizen[0] - loc[0]) + abs(citizen[1] - loc[1]);  // 计算曼哈顿距离
            total_distance += distance;                   // 累加总距离
        }
        
        // 若当前位置的总距离小于已记录的最小距离，进行更新
        if (total_distance < min_distance) {
            min_distance = total_distance;               // 更新最小距离
            best_location = loc;                         // 更新最佳位置
        }
    }
    
    return best_location;                                // 返回最佳位置
}

bool vectorEqual(std::vector<int> a, std::vector<int> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (size_t i = 0; i < a.size(); ++i) {
        if (a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

int main() {
    std::vector<std::vector<int>> citizens1 = {
  
  {-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
    std::vector<std::vector<int>> locations1 = {
  
  {3, 2}, {1, 0}, {0, 0}};

    std::vector<int> result = solution(4, 3, citizens1, locations1);
    std::cout << (vectorEqual(result, {1, 0}) ? "True" : "False") << std::endl;
    return 0;
}

运行结果：

二、数字魔法的加一操作

问题描述

数字魔法师小U发现了一种特殊的数字变换魔法。这个魔法可以对一个数字字符串进行"进位"操作。每次操作规则如下：

对字符串中的每个数字进行加一操作
当某位数字为9时，加一后变成 0，并在前面补 1

例如：

"798" 经过一次操作变成 "8109"（7→8, 9→0并向前增加一个1, 8→9）
"999" 经过一次操作变成 "101010"

现在给定一个数字字符串 num_str（长度为n）和操作次数 k，请计算经过 k 次操作后得到的最终结果。由于结果可能非常大，请将答案对 1000000007 (10^9 + 7) 取模。

输入

第一行包含两个整数 n 和 k（1 ≤ n ≤ 50, 1 ≤ k ≤ 100）
第二行包含一个长度为n的数字字符串 num_str，仅由数字0-9组成

返回一个整数，表示最终结果对 1000000007 取模后的值

测试样例

样例1：

输入：n = 3 ,k = 1 ,num_str = "798"
返回：8109
解释：798 经过一次操作变成 8109

样例2：

输入：n = 3 ,k = 3 ,num_str = "798"
返回：103221

第一次操作：798 → 8109
第二次操作：8109 → 92110
第三次操作：92110 → 103221

样例3：

输入：n = 4 ,k = 3 ,num_str = "7989"
返回：10322132

解题思路：

问题理解

我们需要对一个数字字符串进行多次"进位"操作。每次操作的规则是：

对字符串中的每个数字进行加一操作。
如果某位数字为9，加一后变成0，并在前面补1。

数据结构选择

由于我们需要频繁地在字符串的前面和后面进行插入和删除操作，使用deque（双端队列）是一个不错的选择。deque允许我们在两端高效地进行插入和删除操作。

算法步骤

初始化：将输入的数字字符串转换为deque，方便后续操作。
多次操作：
- 对于每次操作，遍历deque中的每个数字。
- 对每个数字进行加一操作。
- 如果数字变为10，将其变为0，并在前面补1。
结果生成：
- 将deque中的数字重新组合成一个整数。
- 对结果取模1000000007。

最终代码：

#include <iostream>
#include <deque>
#include <string>

const long long MOD = 1000000007;

int solution(int n, int k, std::string numStr) {
    std::deque<int> numString;
    for (int i = 0; i < n; ++i) {
        numString.push_back(numStr[i] - '0');
    }

    for (int t = 0; t < k; ++t) {
        int l = numString.size();
        for (int i = 0; i < l; ++i) {
            int num = numString.front();
            numString.pop_front();
            num += 1;
            if (num == 10) {
                numString.push_back(1);
                numString.push_back(0);
            } else {
                numString.push_back(num);
            }
        }
    }

    long long result = 0;
    int l = numString.size();
    for (int i = 0; i < l; ++i) {
        result = (result * 10 + numString.front()) % MOD;
        numString.pop_front();
    }

    return result;
}

int main() {
    // You can add more test cases here
    std::cout << (solution(3, 1, "798") == 8109) << std::endl;
    std::cout << (solution(3, 3, "798") == 103221) << std::endl;

    return 0;
}