文章目录
- 数字统计（数学+模拟）
- 两个数组的交集（哈希）
- 点击消除（栈）
- 牛牛的快递（模拟）
- 最小花费爬楼梯（动态规划）
- 数组中两个字符串的最小距离（滑动窗口or贪心+模拟）
数字统计（数学+模拟）
这个程序的目标是计算在给定区间 [L, R] 内，所有数字中数字 2 出现的次数。下面是逐步分析和注释程序的过程：
解题思路：
输入区间：首先，程序从标准输入中接收两个整数 L 和 R，表示闭区间 [L, R]。
计数器：使用一个 count 变量来累计数字 2 出现的次数。
遍历区间：通过一个 for 循环，从 L 到 R 逐一遍历每一个整数。
逐位检查：对于每一个整数 i，通过一个 while 循环逐位提取其数字（从个位到最高位），检查是否有数字等于 2。
如果找到 2，则计数器 count 增加。
无论是否找到 2，都会通过 num = num / 10 将当前数的最后一位去掉，继续检查剩下的位。（核心）
输出结果：遍历完所有数字后，输出 count，即数字 2 出现的总次数。
#include <iostream>
using namespace std;
int main()
{
// 定义L和R，用于存储输入的区间边界
int L = 0, R = 0;
// 从输入中读取L和R的值，表示遍历的区间 [L, R]
cin >> L >> R;
// 定义count用于记录数字2出现的总次数
int count = 0;
// 遍历区间中的每一个数，从L到R
for(int i = L; i <= R; i++)
{
// num用于逐位检查当前数 i
int num = i;
// 逐位分解num，检查是否存在数字2
while(num)
{
// 如果当前数的个位是2，则计数器增加
if(num % 10 == 2)
{
count++; // 找到一个2，计数器增加
}
// 去掉num的个位，继续检查下一位
num = num / 10;
}
}
// 输出数字2出现的总次数
cout << count << endl;
return 0;
}
两个数组的交集（哈希）
这个程序的目标是找到两个数组 nums1 和 nums2 的交集，即两个数组中共同存在的元素，并返回这些元素组成的结果数组。具体来说，程序利用一个布尔类型的哈希表来跟踪 nums1 中的元素，然后在 nums2 中查找这些元素是否存在。如果存在，则将其加入到结果数组中。
解题思路：
使用哈希表：利用一个布尔类型的数组 hash，来记录 nums1 中每个元素的存在情况。哈希表的大小为 1010，因此它能够记录值在 0 到 1009 范围内的元素。（已经足够大了，观察数据范围）
遍历 nums1：首先遍历 nums1，将 nums1 中出现的每个元素对应的哈希表位置设为 true，表示该元素存在于 nums1 中。
遍历 nums2：然后遍历 nums2，检查当前元素在哈希表中是否标记为 true。如果是，说明该元素既在 nums1 中也在 nums2 中，因此将该元素加入到结果数组中，并将哈希表中对应位置设置为 false，以避免重复添加该元素。
返回结果：最终返回包含交集元素的结果数组。
class Solution
{
// 定义一个大小为1010的布尔数组，用于标记元素是否在nums1中出现
bool hash[1010] = { 0 }; // 初始化为全0，表示所有数字初始都没有出现过
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
{
// 定义一个存放交集结果的数组
vector<int> ret;
// 遍历nums1，将nums1中出现的元素在hash表中标记为true
for(auto x : nums1)
{
hash[x] = true; // 在nums1中出现的元素，设置为true
}
// 遍历nums2，检查nums2中的元素是否在nums1中也存在（通过hash表）
for(auto x : nums2)
{
// 如果当前元素x在hash表中为true，说明它在nums1中也存在
if(hash[x])
{
ret.push_back(x); // 将该元素添加到结果数组中
hash[x] = false; // 防止重复添加，将hash表中对应位置重置为false
}
}
// 返回结果数组ret，包含nums1和nums2的交集
return ret;
}
};
点击消除（栈）
这个程序的目标是从输入字符串中删除相邻的重复字符，最终返回处理后的字符串。如果字符串被完全消除，则输出 0。这个任务可以使用一个栈结构来解决，其中每次遇到相同的相邻字符时，就将其删除。
解题思路：
栈的思想：利用一个字符串变量 stack 作为栈，逐一遍历输入字符串 s，将每个字符入栈（即加入到 stack 末尾）。如果遇到的字符与栈顶字符（栈的最后一个字符）相同，则将栈顶字符弹出（删除）。
处理逻辑：
如果当前字符与栈顶字符相同，则消去（从栈中删除栈顶元素）。
如果当前字符与栈顶字符不同，则将该字符添加到栈中。
最终结果：遍历结束后，栈中剩下的字符就是处理后的字符串。如果栈为空，则说明所有字符都被消去，输出 0。否则，输出栈中的字符。
#include <iostream>
#include <string>
using namespace std;
int main()
{
// 定义一个字符串s，用于存储输入
string s;
// 从标准输入读取字符串
cin >> s;
// 定义一个空字符串stack，模拟栈的作用
string stack; // 栈
// 遍历输入字符串中的每一个字符
for(auto ch : s)
{
// 如果栈不为空，并且栈顶元素与当前字符相同
if(stack.size() && stack.back() == ch)
{
// 栈顶元素与当前字符相同，弹出栈顶元素（即消除这一对相同字符）
stack.pop_back();
}
else
{
// 栈顶元素与当前字符不同，将当前字符压入栈中
stack += ch;
}
}
// 如果栈为空，输出"0"，表示所有字符都被消去；否则输出栈中的字符串
cout << (0 == stack.size() ? "0" : stack) << endl;
return 0;
}
牛牛的快递（模拟）
#include <iostream>
#include <cmath> // 引入cmath库，用于使用ceil函数
using namespace std;
int main()
{
double a = 0; // 定义双精度变量a，用于表示数值输入
char b = 0; // 定义字符变量b，用于表示是否有额外费用的标志
cin >> a >> b; // 输入变量a和b
int ret = 0; // 定义最终费用变量ret，并初始化为0
// 根据输入a的值计算基础费用
if(a <= 1) // 如果a小于等于1
{
ret += 20; // 费用为20
}
else // 如果a大于1
{
ret += 20; // 首先，前1单位的费用为20
a -= 1; // 去掉前1单位的部分
ret += ceil(a); // 剩余部分向上取整，每单位加1的费用
}
// 判断是否需要额外加费
if(b == 'y') // 如果b是字符'y'
{
ret += 5; // 增加额外费用5
}
cout << ret << endl; // 输出最终计算的费用
return 0;
}
最小花费爬楼梯（动态规划）
解题思路：
这道题目使用动态规划（Dynamic Programming）来解决楼梯问题，目的是计算从起点到达楼梯顶端（第 n 步）的最小花费。具体解题步骤如下：
定义输入：
需要爬的楼梯步数为 n。
输入每一步对应的花费，存储在 cost 数组中，其中 cost[i] 表示到达第 i 步所需的花费。
状态定义：
dp[i] 表示到达第 i 步的最小花费。通过递推计算得到，使用动态规划来避免重复计算。
状态转移方程：
要到达第 i 步，有两种选择：
从第 i-1 步到达第 i 步，花费为 dp[i-1] + cost[i-1]。
从第 i-2 步跳到第 i 步，花费为 dp[i-2] + cost[i-2]。
我们取这两者中的最小值作为 dp[i]，即：
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
初始条件：
dp[0] = 0 和 dp[1] = 0。即在没有走楼梯前不需要花费，开始爬楼梯的第一步可以从地面直接跳到第 1 或第 2 步。
最终输出：
输出 dp[n]，即到达第 n 步的最小花费。
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n = 0; // 定义n，表示楼梯的阶数（或需要计算的步骤数）
cin >> n; // 输入n的值
vector<int> cost(n + 1); // 定义一个大小为n+1的向量，用于存储每一步的花费
vector<int> dp(n + 1); // 定义一个dp向量，用于存储到达每一步的最小花费
// 输入每一步的花费
for(int i = 0; i <= n; i++)
{
cin >> cost[i];
}
// 动态规划求解最小花费
for(int i = 2; i <= n; i++)
{
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
// 到达第i步的最小花费是：
// 要么从i-1步到i，花费dp[i-1] + cost[i-1]
// 要么从i-2步跳到i，花费dp[i-2] + cost[i-2]
// 取其中较小的值作为dp[i]的值
}
// 输出到达第n步的最小花费
cout << dp[n] << endl;
return 0;
}
数组中两个字符串的最小距离（滑动窗口or贪心+模拟）
解题思路：
这道题的目的是根据输入的两个变量计算最终的费用。一个变量是数值 a，另一个是标志位 b。根据不同的情况，费用的计算方式也不同，具体思路如下：
输入解析：
a 表示某个数值（例如距离、时间等），这是需要计算费用的基础数据。
b 是一个字符标志，表示是否有额外费用。当 b 为 ‘y’ 时，需要在基础费用上额外加收 5 元。
费用计算规则：
当 a <= 1 时，直接收取固定费用 20 元。
当 a > 1 时，费用的计算分为两部分：
第一单位的费用固定为 20 元。
从第 2 单位开始，按每个单位 1 元的费用计算，但需要对剩余部分向上取整，也就是通过 ceil 函数来确保任何非整数的部分都按整单位计算。
额外费用：
如果 b == ‘y’，则需要额外收取 5 元作为附加费用。
最终输出：
通过以上的规则，累加计算得到总费用，并输出结果。
#include <iostream>
#include <vector>
#include <string>
#include <cmath> // 为了使用abs函数
using namespace std;
int findMinDistance(const vector<string>& strs, const string& str1, const string& str2) {
int n = strs.size();
int pos1 = -1, pos2 = -1;
int minDistance = n + 1; // 初始化为比数组长度大的值
// 遍历数组
for (int i = 0; i < n; ++i) {
if (strs[i] == str1) {
pos1 = i;
}
if (strs[i] == str2) {
pos2 = i;
}
// 如果两个字符串都出现过，更新最小距离
if (pos1 != -1 && pos2 != -1) {
minDistance = min(minDistance, abs(pos1 - pos2));
}
}
// 如果两者都没有找到，返回-1
if (pos1 == -1 || pos2 == -1) {
return -1;
}
return minDistance;
}
int main() {
int n;
cin >> n; // 输入数组长度
string str1, str2;
cin >> str1 >> str2; // 输入str1和str2
vector<string> strs(n); // 定义字符串数组
for (int i = 0; i < n; ++i) {
cin >> strs[i]; // 输入每个字符串
}
int result = findMinDistance(strs, str1, str2);
cout << result << endl; // 输出结果
return 0;
}
首先，遍历字符串序列，逐个检查当前字符串是否是 s1 或 s2。如果遇到 s1，则向前找最近一次 s2 出现的位置，计算距离并更新最短距离。同理，遇到 s2 时向前找最近一次 s1 出现的位置，更新最短距离。
通过这种双指针的方式，在一次遍历中就能解决问题，时间复杂度为 O(n)，非常高效。
#include <iostream>
#include <string>
using namespace std;
int main()
{
int n; // 字符串序列的长度
string s1, s2; // 目标字符串 s1 和 s2
string s; // 当前输入的字符串
cin >> n; // 输入字符串数量
cin >> s1 >> s2; // 输入目标字符串 s1 和 s2
int prev1 = -1, prev2 = -1; // 记录上一次 s1 和 s2 出现的位置，初始值为 -1 表示还没有出现
int ret = 0x3f3f3f3f; // 初始化最小距离为一个非常大的值
// 遍历字符串序列
for (int i = 0; i < n; i++)
{
cin >> s; // 输入当前字符串
// 如果当前字符串是 s1，尝试向前找最近的 s2
if (s == s1)
{
if (prev2 != -1) // 确保之前有出现过 s2
{
ret = min(ret, i - prev2); // 更新最小距离
}
prev1 = i; // 更新 s1 的位置
}
// 如果当前字符串是 s2，尝试向前找最近的 s1
else if (s == s2)
{
if (prev1 != -1) // 确保之前有出现过 s1
{
ret = min(ret, i - prev1); // 更新最小距离
}
prev2 = i; // 更新 s2 的位置
}
}
// 判断是否找到了合法的最短距离
if (ret == 0x3f3f3f3f)
cout << -1 << endl; // 如果没有找到，则输出 -1
else
cout << ret << endl; // 否则输出最短距离
return 0;
}
