[M模拟] lc3265. 统计近似相等数对 I(模拟+代码实现+分类讨论+周赛412_2)

1. 题目来源

链接：3265. 统计近似相等数对 I

2. 题目解析

这场周赛并没有参加，补下题。

T2 思路：

• 比较简单直接的一个模拟哈，数据量非常非常小，想怎么写都行。
• 注意代码实现细节。
  • 当 1001 与 11 此类时，因为允许前导零的存在，所以也是成立的。
  • stoi 可以比较快速的将含有前导 0 的字符串转为 int，就不用自己去判断了。
  • 自己再判断的时候，需要判断 前面是不是全部都是前导0 && 后面的要和另一个串完全相等。
  • 注意用临时字符串进行 swap 操作，或者要进行恢复现场的操作。

上面的模拟情况多，容易错…简单暴力模拟思路：

• 枚举 a, b。再枚举 a, b 中的较长的一个，交换它自身的所有数位，判断是否存在与 b 相等的字符串即可。
• 注意此时数位可以相等，代表不交换。
• 注意此时应该用较长的字符串进行数位的枚举，如果是单纯的枚举 a 或者 b 的情况下，可能由于它的数位较短，而无法进行交换到较长数位的字符串中取。例如：10、1 这个情况。

---

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

---

简洁写法：

class Solution {
public:
    int countPairs(vector<int>& nums) {
        int res = 0;
        int n = nums.size();

        auto ok = [&](string a, string b) -> bool {
            if (a.size() > b.size()) swap(a, b); // 遍历字符串较长的一方。它有更多的机会去交换，与短的一方相等

            for (int k = 0; k < b.size(); k++) {
                for (int q = k; q < b.size(); q++) {
                    string tb = b; swap(tb[k], tb[q]);
                    
                    if (stoi(tb) == stoi(a)) return true;
                }
            }

            return false;
        };

        for (int i = 0; i < n; i++) 
            for (int j = i + 1; j < n; j++) 
                res += ok(to_string(nums[i]), b = to_string(nums[j]));

        return res;
    }
};

分类讨论：

class Solution {
public:
    int countPairs(vector<int>& nums) {
        int res = 0;
        int n = nums.size();

        for (int i = 0; i < n; i ++ ) {
            for (int j = i + 1; j < n; j ++ ) {
                string a = to_string(nums[i]), b = to_string(nums[j]);
                
                // 判断是否本身相等
                if (a == b) { res ++ ; continue; }
                
                // 判断长度不相等的情况。较长一方必须要有前导 0 存在
                // 注意 11、1001 这种情况的出现，所以长度差是 >= 1 而非 == 1
                int na = a.size(), nb = b.size();
                if (abs(na - nb) >= 1) {
                    if (b.size() > a.size()) swap(a, b);    // 将 a 视作较长的串

                    for (int i = 0; i < a.size(); i ++ ) {
                        if (a[i] != '0') continue;

                        // 较长串的每个 0 都需要和首位去做一下 swap 操作，判断是否可以组成答案
                        bool flag = true;
                        string t = a;
                        swap(t[0], t[i]);
                        int k = a.size() - 1;

                        // 判断前面需要全部都是前导零
                        int diff = a.size() - b.size();
                        for (int j = 0; j < diff; j ++ ) 
                            if (t[j] != '0') {
                                flag = false;
                                break;
                            }

                        // 判断剩余的有效位是否和 b 相等
                        for (int j = b.size() - 1; j >= 0; k -- , j -- ) {
                            if (t[k] != b[j]) {
                                flag = false;
                                break;
                            }
                        }

                        if (flag) {
                            res ++ ; break; 
                        }
                        
                        // 这是最简单的判断方法.....忘记了
                        // if (stoi(t) == stoi(b)) { res ++; continue; }
                    }
                    continue;
                }

                int l = -1;
                for (int i = 0; i < a.size(); i ++ ) {
                    if (l == -1 && a[i] != b[i]) {
                        l = i;
                        continue;
                    }

                    if (a[i] != b[i]) {
                        swap(a[l], a[i]);
                        if (a == b) res ++ ;
                        break;
                    }
                }
            }
        }

        return  res;    
    }
};