【leetcode第29天】2006.差的绝对值为K的数对数目、91.解码方法、139.单词拆分

第二十九天

2006 差的绝对值为K的数对数目

给你一个整数数组 nums 和一个整数 k ，请你返回数对 (i, j) 的数目，满足 i <j 且 |nums[i] - nums[j]| == k 。

|x| 的值定义为：

• 如果 x >= 0 ，那么值为 x 。

• 如果 x < 0 ，那么值为 -x 。

方法

使用一个长度为101的数组记录所有数字出现的次数。numsOfI表示数字i出现的次数。求解是，只需要从0遍历到100-K，然后将数量相乘后累加即可。

class Solution {
    public int countKDifference(int[] nums, int k) {
        int[] numsOfI = new int[101];
        for (int i : nums) numsOfI[i]++;
        int res = 0;
        for (int i = 1; i <= 100 - k; ++i) res += numsOfI[i] * numsOfI[i + k];
        return res; 
    }
}

91 解码方法

一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：

'A' -> "1"
'B' -> "2"
...
'Z' -> "26"

要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：

• "AAJF" ，将消息分组为 (1 1 10 6)

• "KJF" ，将消息分组为 (11 10 6)

注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6"和 "06" 在映射中并不等价。

给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。

题目数据保证答案肯定是一个 32 位 的整数。

方法 动态规划

考虑解码最后一个数字，最后一个数字可以单独解码，也可以和前一个字符结合起来然后共同组成一个整体作为一个字符。因此，如果我们定义dp[i]表示从0到i的子串中所包含的解码方法数量。同时记录下前一个字符pre和当前第i位置上的字符cur。

第一种情况：

• 如果当前的字符cur不是0，这说明该位置上的字符可以单独被解码出来，在这种情况下dp[i] = dp[i-1]

第二种情况：

• 如果前一个字符不为0，同时前一个字符pre和当前的字符cur组成的数字不超过26，也就是在字母表的范围之内，这说明它们两者可以结合起来，作为一个整体来被解码，此时dp[i] = dp[i-2]

第三种情况：

• 如果前一个字符超过了2并且当前的字符cur为0，或者前一个字符和当前字符都是0，在这种情况下，不可能解码，直接返回0即可。

由于前两种情况是可以同时存在的，因此在写状态转移方程的时候，应当采取累加的方法。

class Solution {
    public int numDecodings(String s) {
        if (s.charAt(0) == '0') return 0;
        if (s.length() == 1) return 1;
        int[] dp = new int[s.length()];
        dp[0] = 1;
        char first = s.charAt(0);
        char second = s.charAt(1);
        //处理边界情况
        if ((first - '0') * 10 + second - '0' <= 26 && second != '0') dp[1] = 2;
        else if (first > '2' && second == '0') return 0;
        else dp[1] = 1;
        for (int i = 2; i < s.length(); ++i){
            char pre = s.charAt(i - 1);
            char cur = s.charAt(i);
            if (pre == '0' && cur == '0') return 0;
            if (cur != '0'){
                dp[i] += dp[i - 1];
            }
            if (10 * (pre - '0') + cur - '0' <= 26 && pre != '0' && i - 2 >= 0){
                dp[i] += dp[i - 2];                        
            }
            else if (pre > '2' && cur == '0') return 0;
        }
        return dp[s.length() - 1];
    }
}

139 单词拆分

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。

**注意：**不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

方法

由于所给的字符串是连续的，如果我们直到的从开始位置0到位置j的子串能够被所给的字典组成，那我们只需要判断以下从位置j + 1到位置i的子串就能够得到从开始位置0到位置0的子串也是能够由所给的字典内的单词所拼接而成的。

为此我们定义数组dp[i]表示从位置0到位置i的子串能否由所给的字典内的单词所拼接而成。依据上述结论。可以知道状态转移方程为：
$$dp[i]=dp[j-1]\&\&s(j,i)$$
我们只需要遍历i，每次让j从开始位置0开始检查一遍，如果满足组条件，则将dp[i]标记为true即可。

剪枝：记录字典中所有字符串的最大长度，当j和i之间的距离大于最大长度时，不进行判断

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> set = new HashSet<>();
        int maxLength = 0;
        for (String i : wordDict) {set.add(i);maxLength = Math.max(maxLength, i.length());}
        boolean[] dp = new boolean[s.length()];
        if (s.length() == 1) return set.contains(s.substring(0, 1));
        for (int end = 0; end < s.length(); ++end){
            for (int start = 0; start <= end; ++start){
                if (end - start + 1 > maxLength) continue;
                if (start == 0 && set.contains(s.substring(start, end + 1))){
                    dp[end] = true;
                    break;
                }
                else if (start >=1 && dp[start - 1] && set.contains(s.substring(start, end + 1))){
                    dp[end] = true;
                    break;
                }

            }
        }
        return dp[s.length() - 1];
    }
}