题目624：数组列表的最大距离（NO）
- 解题思路：记录每个数组的最大最小值，循环判断最大距离。
给定 m 个数组，每个数组都已经按照升序排好序了。
现在你需要从两个不同的数组中选择两个整数（每个数组选一个）并且计算它们的距离。两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b| 。
返回最大距离。
cpp
class Solution {
public:
int maxDistance(vector<vector<int>>& arrays) {
//这题的做题思路其实就是遍历每个数组，记录数组的最大最小值
//先记录第一组的最大最小值
//.back()是获取最后一个值
int max_value=arrays[0].back();
int min_value=arrays[0][0];
int max_Distance=0;
//从第二个数组开始遍历
//这里可以是可以进入for循环的，因为题目限制了
//这里有个限制，最大最小值不能再同一个数组中
for(int i=1;i<arrays.size();i++)
{
//当前数组的最大最小值
int current_min=arrays[i][0];
int current_max=arrays[i].back();
max_Distance=max(max_Distance,abs(current_max-min_value));
max_Distance=max(max_Distance,abs(current_min-max_value));
//更新最大最小值
max_value=max(current_max,max_value);
min_value=min(current_min,min_value);
}
return max_Distance;
}
};题目280：摆动排序（YES）
- 解题思路：这里有规律，排序后再指定位置插入。
给你一个的整数数组 nums, 将该数组重新排序后使 nums[0] <= nums[1] >= nums[2] <= nums[3]...
输入数组总是有一个有效的答案。
cpp
class Solution {
public:
void wiggleSort(vector<int>& nums) {
//我发现了其中的规律，他是排序后按位置插入的
sort(nums.begin(),nums.end());
vector<int>ans=nums;
int size=ans.size();
int count=0;
for(int i=0;i<size;i++)
{
if(i%2==0)
{
//偶数的不用变
nums[i]=ans[count];
}else
{
//奇数要变
nums[i]=ans[size-(count+1)];
count++;
}
}
}
};题目1056：易混淆数（NO）
- 解题思路：按照题目的思路，讲所有的数反转再进行比较。
给定一个数字 N，当它满足以下条件的时候返回 true：
原数字旋转 180° 以后可以得到新的数字。
如 0, 1, 6, 8, 9 旋转 180° 以后，得到了新的数字 0, 1, 9, 8, 6 。
2, 3, 4, 5, 7 旋转 180° 后，得到的不是数字。
易混淆数 (confusing number) 在旋转180°以后，可以得到和原来不同的数，且新数字的每一位都是有效的。
cpp
class Solution {
public:
bool confusingNumber(int n) {
//这题的解题思路是按照题目的意思走，比较旋转反转后是否相同
//用哈希表来表示旋转后的数
unordered_map<char,char>map=
{
{'0','0'},
{'1','1'},
{'9','6'},
{'8','8'},
{'6','9'}
};
string ret=to_string(n);
string ans="";//最终结果
for(char c:ret)
{
if(map.find(c)==map.end())
{
//存在不能反转的返回false
return false;
}
ans=map[c]+ans;//反转的数放在最前面
}
return ans!=ret;
}
};题目1427：字符串的左右移（YES）
- 解题思路：根据题目的思路，模拟出来就行。
给定一个包含小写英文字母的字符串 s 以及一个矩阵 shift，其中 shift[i] = [direction, amount]：
direction 可以为 0 （表示左移）或 1 （表示右移）。
amount 表示 s 左右移的位数。
左移 1 位表示移除 s 的第一个字符，并将该字符插入到 s 的结尾。
类似地，右移 1 位表示移除 s 的最后一个字符，并将该字符插入到 s 的开头。
对这个字符串进行所有操作后，返回最终结果。
cpp
class Solution {
public:
string stringShift(string s, vector<vector<int>>& shift) {
//这种最常规的方法就是根据题目的思路进行移动
for(int i=0;i<shift.size();i++)
{
for(int j=0;j<shift[i][1];j++)
{
//移动的位数
if(shift[i][0]==0)
{
//左移
char c=s[0];
//从0位置开始删除1个
s.erase(0,1);
s=s+c;
}else
{
//右移
char c=s[s.size()-1];
s.erase(s.size()-1,1);
s=c+s;
}
}
}
return s;
}
};题目161：相隔为1的编辑距离（NO）
- 解题思路：这题也是要迎合这题目的思路，首先就是要将情况分清楚，大于1的必然不行，后面就是对长度差等于0和等于1的情况进行单独的处理就行。方法其实是相似的。
给定两个字符串 s 和 t ，如果它们的编辑距离为 1 ，则返回 true ，否则返回 false 。
字符串 s 和字符串 t 之间满足编辑距离等于 1 有三种可能的情形：
往 s 中插入 恰好一个 字符得到 t
从 s 中删除 恰好一个 字符得到 t
在 s 中用 一个不同的字符 替换 恰好一个 字符得到 t
cpp
class Solution {
public:
bool isOneEditDistance(string s, string t) {
//这题的难点在于你要将情况分析清楚
//1.长度差大于1的必然是不行的
//2.长度差等于1或者为0这是两种可能可以编辑的情况
//这里全局默认s<t
int len_s=s.size();
int len_t=t.size();
if(abs(len_s-len_t)>1)
{
return false;
}
//这里筛选下来的都是有可能的，先切换
if(len_s>len_t)
{
swap(s,t);
swap(len_s,len_t);
}
if(len_s==len_t)
{
//相等的情况
bool check=false;
for(int i=0;i<len_s;i++)
{
if(s[i]!=t[i])
{
if(check)
{
//再次出现不相等就是错误的
return false;
}
//出现一个不相等
check=true;
}
}
return check;
}else
{
//差值为1的情况
//其实和上面的非常相似，就是要找到一个不相等的
int i=0;
int j=0;
for(;i<len_s&&j<len_t;)
{
if(s[i]==t[j])
{
//都相等的情况
i++;
j++;
}else
{
//头一次找到不相等的
if(i==j)
{
//第一次不相等是允许的
j++;
}else
{
return false;
}
}
}
return true;
}
}
};题目186：反转字符串中的单词（NO）
- 解题思路：先反转整体，再反转单个单词。
给你一个字符数组 s ，反转其中 单词 的顺序。
单词 的定义为：单词是一个由非空格字符组成的序列。s 中的单词将会由单个空格分隔。
必须设计并实现 原地 解法来解决此问题，即不分配额外的空间。
cpp
class Solution {
public:
void reverseWords(vector<char>& s) {
// 1. 反转整个字符数组
reverseRange(s, 0, s.size() - 1);
// 2. 逐个反转每个单词
int start = 0;
while (start < s.size()) {
int end = start;
// 找到单词的结束位置
while (end < s.size() && s[end] != ' ') {
end++;
}
// 反转当前单词
reverseRange(s, start, end - 1);
// 移动到下一个单词
start = end + 1;
}
}
private:
void reverseRange(vector<char>& s, int start, int end) {
while (start < end) {
swap(s[start], s[end]);
start++;
end--;
}
}
};