250318 蓝桥杯练习 2

最长回文子串

class Solution {
public:
string longestPalindrome(string s) {
if (s.length() < 2) {
return s;
}
int start = 0; // 记录最大子串的开头
int maxLen = 1; // 记录最大子串的长度，初始值设为 1
for (int i = 0; i < s.length(); i++) {
// 处理奇数长度的回文子串
int left = i, right = i;
// 增加边界检查
while (left >= 0 && right < s.length() && s[left] == s[right]) {
if (right - left + 1 > maxLen) {
maxLen = right - left + 1;
start = left;
}
left--;
right++;
}

        // 处理偶数长度的回文子串
        left = i, right = i + 1;
        while (left >= 0 && right < s.length() && s[left] == s[right]) {
            if (right - left + 1 > maxLen) {
                maxLen = right - left + 1;
                start = left;
            }
            left--;
            right++;
        }
    }
    return s.substr(start, maxLen);
}

};

1819. 序列中不同最大公约数的数目

class Solution {
public:
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}

int countDifferentSubsequenceGCDs(std::vector<int>& nums) {
    int maxVal = *std::max_element(nums.begin(), nums.end());
    std::vector<bool> exists(maxVal + 1, false);
    
    for (int i = 0; i < nums.size(); ++i) {
        int num = nums[i];
        exists[num] = true;

}

    int ans = 0;
    for (int g = 1; g <= maxVal; ++g) {
        int subGcd = 0;
        for (int k = g; k <= maxVal; k += g) {
            if (exists[k]) {
                if (subGcd == 0) {
                    subGcd = k;
                } else {
                    subGcd = gcd(subGcd, k);
                }
                if (subGcd == g) {
                    ++ans;
                    break;
                }
            }
        }
    }
    return ans;
}

};

在LR字符串中交换相邻字符

include

class Solution {
public:
// 判断是否可以通过一系列移动操作将字符串 start 转换为字符串 end
// 移动操作规则：用一个 "LX" 替换一个 "XL"，或者用一个 "XR" 替换一个 "RX"
bool canTransform(std::string start, std::string end) {
int n = start.length();
// 初始化两个指针 i 和 j，分别用于遍历字符串 start 和 end
int i = 0, j = 0;

    // 同时遍历两个字符串，直到其中一个指针到达字符串末尾

//重点
while (i < n && j < n) {
// 跳过字符串 start 中所有的 'X' 字符，因为 'X' 可以被移动或跳过
while (i < n && start[i] == 'X') {
i++;
}
// 跳过字符串 end 中所有的 'X' 字符，因为 'X' 可以被移动或跳过
while (j < n && end[j] == 'X') {
j++;
}

        // 当两个指针都还未到达字符串末尾时，进行以下判断
        if (i < n && j < n) {
            // 如果当前指针指向的字符不相等，说明无法通过规定操作转换，返回 false
            if (start[i] != end[j]) {
                return false;
            }
            // 记录当前字符，后续根据字符是 'L' 还是 'R' 来判断移动规则是否符合
            char c = start[i];
            // 根据规则，'L' 只能向左移动，所以 start 中 'L' 的位置应大于等于 end 中 'L' 的位置
            // 'R' 只能向右移动，所以 start 中 'R' 的位置应小于等于 end 中 'R' 的位置
            // 如果不符合这个规则，返回 false
            if ((c == 'L' && i < j) || (c == 'R' && i > j)) {
                return false;
            }
            // 若当前字符符合规则，将两个指针都向后移动一位，继续检查后续字符
            i++;
            j++;
        }
    }

    // 处理字符串 start 中剩余的字符
    while (i < n) {
        // 如果剩余字符不是 'X'，说明无法通过规定操作转换，返回 false
        if (start[i] != 'X') {
            return false;
        }
        // 指针向后移动一位，继续检查下一个字符
        i++;
    }

    // 处理字符串 end 中剩余的字符
    while (j < n) {
        // 如果剩余字符不是 'X'，说明无法通过规定操作转换，返回 false
        if (end[j] != 'X') {
            return false;
        }
        // 指针向后移动一位，继续检查下一个字符
        j++;
    }

    // 如果前面的所有检查都通过，说明可以通过规定操作将 start 转换为 end，返回 true
    return true;
}

};