[LeetCode]1814. 统计一个数组中好对子的数目（java\c++以及反转两种思路）

给你一个数组 nums ，数组中只包含非负整数。定义 rev(x) 的值为将整数 x 各个数字位反转得到的结果。比方说 rev(123) = 321 ， rev(120) = 21 。我们称满足下面条件的下标对 (i, j) 是 好的 ：

• 0 <= i < j < nums.length
• nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])

请你返回好下标对的数目。由于结果可能会很大，请将结果对 109 + 7 取余 后返回。

示例 1：

输入：nums = [42,11,1,97]
输出：2
解释：两个坐标对为：
 - (0,3)：42 + rev(97) = 42 + 79 = 121, 97 + rev(42) = 97 + 24 = 121 。
 - (1,2)：11 + rev(1) = 11 + 1 = 12, 1 + rev(11) = 1 + 11 = 12 。

示例 2：

输入：nums = [13,10,35,24,76]
输出：4

提示：

• 1 <= nums.length <= 105
• 0 <= nums[i] <= 109

方法：哈希表

思路：

• 先预处理反转后的数，数学方法或者字符串反转，这里建议数学方法，字符串反转耗时
• nums[i]+rev(nums[j])==nums[j]+rev(nums[i])<=>nums[i]−rev(nums[i])==nums[j]−rev(nums[j])，所以我们在遍历每个数组中每个数字的时候，只要加上哈希表中num[i]−rev(nums[i])的数量就行
• 这个思路重中之重，别只会用你的双层for循环遍历，这里巧妙的记录了好下标对

代码：

1. cpp

（1）循环反转

class Solution {
public:
    int countNicePairs(vector<int>& nums) {
        long long ans = 0;
        unordered_map<int,int> map;//存储每个nums[i] - rev(nums[i])个数
        for(int i :nums){
            int j = 0;
            int temp = i;
            while(temp){
                j = j*10+temp%10;
                temp/=10;
            }
            ans+=(map[i-j]++);//这里还有一个全排的思想
        }
        return (int)(ans%(int)(1E9+7));
    }
    
};

（2）字符串反转

 

class Solution {
public:
    int countNicePairs(vector<int>& nums) {
        long long ans = 0;
        unordered_map<int,int> map;//存储每个nums[i] - rev(nums[i])个数
        for(int i :nums){
            int j = reverse(i);
            ans+=(map[i-j]++);//这里还有一个全排的思想
        }
        return (int)(ans%(int)(1E9+7));
    }

    int reverse(int num){
        string str = to_string (num);
        std::reverse(str.begin(), str.end());
        return stoi(str);
    }
    
};

2. java

（1）循环反转

class Solution {
    public int countNicePairs(int[] nums) {
        long ans = 0;
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();//存储每个nums[i] - rev(nums[i])个数
        for (int i : nums) {
            int temp = i, j = 0;
            while (temp > 0) {
                j = j * 10 + temp % 10;
                temp /= 10;
            }
            ans += map.getOrDefault(i - j, 0);//这里还有一个全排的思想
            map.put(i - j, map.getOrDefault(i - j, 0) + 1);
        }
        return (int)(ans%(1E9+7));
    }
}

（2）字符串反转 

class Solution {
    public int countNicePairs(int[] nums) {
        long ans = 0;
        Map<Integer,Integer> map= new HashMap<>();//存储每个nums[i] - rev(nums[i])个数
          for (int i : nums) {
            int temp = i, j = 0;
            j = reverse(i);
            ans += map.getOrDefault(i - j, 0);//这里还有一个全排的思想
            map.put(i - j, map.getOrDefault(i - j, 0) + 1);
        }
        return (int)(ans%(1E9+7));
    }

    //字符串反转
    public int reverse(int num){
        StringBuilder sb = new StringBuilder(Integer.toString(num));//字符串存入容器
        sb.reverse();//字符串反转
        return Integer.parseInt(sb.toString());//字符串转为Int 并返回
    }
}