LeetCode.495 Teemo Attacking

最新推荐文章于 2021-07-05 17:24:22 发布

xiakexiaohu

最新推荐文章于 2021-07-05 17:24:22 发布

阅读量238

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode算法编程

本文链接：https://blog.youkuaiyun.com/xiakexiaohu/article/details/78344053

LeetCode算法编程专栏收录该内容

225 篇文章

订阅专栏

本文介绍了一种算法，用于计算在给定英雄Teemo攻击时间序列和每次攻击导致敌人中毒持续时间的情况下，敌人Ashe总共处于中毒状态的时间。通过示例说明了如何处理连续攻击和中毒时间重叠的情况。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

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:

You may assume the length of given time series array won't exceed 10000.
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;
        
    }
}