LeetCode.495 Teemo Attacking

题目：

In LOL world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo's attacking ascending time series towards Ashe and the poisoning time duration per Teemo's attacking, you need to output the total time that Ashe is in poisoned condition.

You may assume that Teemo attacks at the very beginning of a specific time point, and makes Ashe be in poisoned condition immediately.

Example 1:

Input: [1,4], 2
Output: 4
Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned immediately. 
This poisoned status will last 2 seconds until the end of time point 2. 
And at time point 4, Teemo attacks Ashe again, and causes Ashe to be in poisoned status for another 2 seconds. 
So you finally need to output 4.

Example 2:

Input: [1,2], 2
Output: 3
Explanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned. 
This poisoned status will last 2 seconds until the end of time point 2. 
However, at the beginning of time point 2, Teemo attacks Ashe again who is already in poisoned status. 
Since the poisoned status won't add up together, though the second poisoning attack will still work at time point 2, it will stop at the end of time point 3. 
So you finally need to output 3.

Note:

1. You may assume the length of given time series array won't exceed 10000.
2. You may assume the numbers in the Teemo's attacking time series and his poisoning time duration per attacking are non-negative integers, which won't exceed 10,000,000.

分析1(原创-推荐)：

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        //给定一个攻击事件的时间点的数组，长度不超过10000，每次攻击持续性事件duration。
        //攻击持续事件只在当前时间点开始叠加，计算攻击一共持续的时间。
        //思路：迭代计算，当两个时间点有重复，减去即可。
        
        //假设没有交集的总的持续时间
        int sum=timeSeries.length*duration;
        
        //重叠时间
        int overlap=0;
        
        for(int i=1;i<timeSeries.length;i++){
            //求交叉部分
            if(timeSeries[i]<=(timeSeries[i-1]-1+duration)){
                //存在交叉
                overlap+=timeSeries[i-1]+duration-timeSeries[i];
            }
        }
        
        return sum-overlap;
    }
}

分析2(原创-对于数组长度过长容易超时):

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        //给定一个攻击事件的时间点的数组，长度不超过10000，每次攻击持续性事件duration。
        //攻击持续事件只在当前时间点开始叠加，计算攻击一共持续的时间。
        //思路：采用一个数组记录时间点是否有攻击的效果，最后进行累加总的攻击事件即可。
        if(timeSeries.length==0||timeSeries==null) return 0;
        
        int len=timeSeries.length;
        //关键一步:取最后的攻击时间点加上持续时间作为最长长度。
        boolean [] flag=new boolean[timeSeries[len-1]+duration];
        //用于记录有多少个true
        int count=0;
        for(int i=0;i<timeSeries.length;i++){
            for(int j=timeSeries[i]-1;j<timeSeries[i]-1+duration;j++){
                if(flag[j]==true){
                    continue;
                }else{
                    flag[j]=true;
                    count++;
                }
            }
        }

        return count;
        
    }
}