LeetCode Day4

495. 提莫攻击
难度：中等
在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄，他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。现在，给出提莫对艾希的攻击时间序列和提莫攻击的中毒持续时间，你需要输出艾希的中毒状态总时长。

你可以认为提莫在给定的时间点进行攻击，并立即使艾希处于中毒状态。

示例1:

输入: [1,4], 2
输出: 4
原因: 在第 1 秒开始时，提莫开始对艾希进行攻击并使其立即中毒。中毒状态会维持 2 秒钟，直到第 2 秒钟结束。
在第 4 秒开始时，提莫再次攻击艾希，使得艾希获得另外 2 秒的中毒时间。
所以最终输出 4 秒。

示例2:

输入: [1,2], 2
输出: 3
原因: 在第 1 秒开始时，提莫开始对艾希进行攻击并使其立即中毒。中毒状态会维持 2 秒钟，直到第 2 秒钟结束。
但是在第 2 秒开始时，提莫再次攻击了已经处于中毒状态的艾希。
由于中毒状态不可叠加，提莫在第 2 秒开始时的这次攻击会在第 3 秒钟结束。
所以最终输出 3。

注意：
你可以假定时间序列数组的总长度不超过 10000。
你可以假定提莫攻击时间序列中的数字和提莫攻击的中毒持续时间都是非负整数，并且不超过 10,000,000。

解：
执行用时 : 5 ms, 在Teemo Attacking的Java提交中击败了88.44% 的用户
内存消耗 : 49.5 MB, 在Teemo Attacking的Java提交中击败了52.66% 的用户
思路：累加min(中毒时间，此攻击时间点与下一次攻击时间点的差)即可
Code:

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        if(timeSeries.length==0)
            return 0;
        if(timeSeries.length==1)
            return duration;
        int totaltimes=0;
        for(int i=0;i<timeSeries.length-1;++i){
                totaltimes+=Math.min(duration,timeSeries[i+1]-timeSeries[i]);
        }
        totaltimes+=duration;
        return totaltimes;
        
    }
}

446. 等差数列划分 II - 子序列
难度：困难
数组 A 包含 N 个数，且索引从 0 开始。该数组子序列将划分为整数序列 (P0, P1, …, Pk)，P 与 Q 是整数且满足 0 ≤ P0 < P1 < … < Pk < N。
如果序列 A[P0]，A[P1]，…，A[Pk-1]，A[Pk] 是等差的，那么数组 A 的子序列 (P0，P1，…，PK) 称为等差序列。值得注意的是，这意味着 k ≥ 2。
函数要返回数组 A 中所有等差子序列的个数。
示例：

输入：[2, 4, 6, 8, 10]
输出：7
解释：
所有的等差子序列为：
[2,4,6]
[4,6,8]
[6,8,10]
[2,4,6,8]
[4,6,8,10]
[2,4,6,8,10]
[2,6,10]

解:
执行用时 : 276 ms, 在Arithmetic Slices II - Subsequence的Java提交中击败了67.74% 的用户
内存消耗 : 64.7 MB, 在Arithmetic Slices II - Subsequence的Java提交中击败了93.55% 的用户
思路：参考了别人的做法，用HashMap进行dp

class Solution {
    public int numberOfArithmeticSlices(int[] A) {
    int res = 0;
    HashMap<Integer, Integer>[] dp = new HashMap[A.length];
        
    for (int i = 0; i < A.length; i++) {
        dp[i] = new HashMap<>();    
        for (int j = 0; j < i; j++) {
            long diff = (long)A[i] - A[j];
            if (diff <= Integer.MIN_VALUE || diff > Integer.MAX_VALUE) continue; //差值超过范围，忽略
                
            int d = (int)diff;
            res += dp[j].getOrDefault(d, 0);
            dp[i].put(d, dp[i].getOrDefault(d, 0) + dp[j].getOrDefault(d, 0) + 1);
        }
    }
        
    return res;
}
}

763. 划分字母区间
字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一个字母只会出现在其中的一个片段。返回一个表示每个字符串片段的长度的列表。

示例 1:

输入: S = "ababcbacadefegdehijhklij"
输出: [9,7,8]
解释:
划分结果为 "ababcbaca", "defegde", "hijhklij"。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。

解:
执行用时 : 16 ms, 在Partition Labels的Java提交中击败了32.96% 的用户
内存消耗 : 36.6 MB, 在Partition Labels的Java提交中击败了81.20% 的用户
思路：图方便、代码简洁，但有更高效的方法，比如数组记录每个字母最后的位置，这样就不需要每次循环都调用lastIndexOf方法。
Code:

class Solution {
    public List<Integer> partitionLabels(String S) {
        List<Integer> list=new ArrayList<>();
        int last=S.lastIndexOf(S.substring(0,1)); //第一个字母在字符串最晚出现的位置
        int pre=0;
        for(int i=0;i<S.length();++i){
            if(last<S.lastIndexOf(S.substring(i,i+1))){ //如果当前字母最后出现的位置比之前的后，则替换
                last=S.lastIndexOf(S.substring(i,i+1));
            }
            if(i==last){ //此时可以分段
                list.add(last+1-pre);
                pre=last+1;
            }
            
        }
        return list;
    }
}