OD机试-采样过滤

题目描述

【采样过滤】
在做物理实验时，为了计算物体移动的速率，通过相机等工具周期性的采样物体移动距离。
由于工具故障，采样数据存在误差甚至错误的情况。
需要通过一个算法过滤掉不正确的采样值，不同工具的故障模式存在差异，算法的相关门
限会根据工具类型做相应的调整。
请实现一个算法，计算出给定一组采样值中正常值的最长连续周期。
判断第i个周期的采样数据Si是否正确的规则如下(假定物体移动速率不超过10个单元前一个采样周期S[i-1]):

• S[i]<=0，即为错误值
• S[i]<S[i-1]，即为错误值
• S[i]-S[i-1]>=10，即为错误值。其它情况为正常值

判断工具是否故障的规则如下:

• 在M个周期内，采样数据为错误值的次数为T(次数可以不连续)，则工具故障。

判断故障恢复的条件如下:

• 产生故障后的P个周期内，采样数据一直为正常值，则故障恢复

错误采样数据的处理方式

• 检测到故障后，丢弃从故障开始到故障恢复的采样数据
• 在检测到工具故障之前，错误的采样数据，则由最近一个正常值代替;如果前面没有正常的采样值，则丢弃此采样数据

给定一段周期的采样数据列表S，计算正常值的最长连续周期。

输入描述

故障确认周期数和故障次数门限分别为M和T，故障恢复周期数为P。第i个周期，检测点的状态为S[i]。
输入为两行，格式如下:
M T P
s1 s2 s3 …
M、T 和 P的取值范围为[1,100000]
si取值范围为[0，100000]，从0开始编号

输出描述

一行，输出正常值的最长连续周期。
示例1 输入输出示例仅供调试，后台判题数据一般不包含示例
输入
10 6 3
-1 1 2 3 100 10 13 9 10
输出
8

题目分析

提取题目约束条件

1. 工具是否故障的规则
   1. 在 M 个周期内，故障次数为 T 次
   2. 这里假如 M 个周期内，故障总次数超过 T 次该如何处理？
      1. 检测到故障，直接进入恢复周期
2. 判断故障恢复的条件
   1. 产生故障后（确认工具故障，才为产生故障后） p 个周期内，采样数据一直为正常值�
3. 错误采样数据的处理方式
   1. 检测到故障之后，丢弃从故障开始到故障恢复的采样数据.�
      1. 这里注意是检测到故障之后，然后进入恢复周期
   2. 检测到故障之前，错误的采样数据，由最近一个正常值代替；如果前面没有正常的采样值，则丢弃该采样数据.�
      1. 这里错误的数据被正常值代替之后，被认为是正常值？
         

解题思路

:::success
分为两种情况讨论

• 第一个采样数据为错误数据，即小于等于0的情况
  • baseCase:需要寻找到底一个有效的正确采样数据，来计算正常值的连续周期
  • case1:在第一个 M 周期内，如果故障次数没有超过门限值 T，那么在第一个周期内即可以找到第一个正确采样数据
  • case2:连续错误采样数据（丢弃），进入恢复周期，第一个正确且有效的采样数据在故障恢复后获得
    • 这里如果故障恢复后，丢弃掉之前的采样数据。需要从baseCase逻辑重新计算
  • 这里如果检测到正常数据了，在当前M个周期内故障门限次数还没有到
    • 接下来如果故障次数累积不超过T，那么进入下一个周期。
    • 如果故障次数超过T，那么进入恢复周期
• 第一个采样数据为正确数据
  • 则从第一个数据起就可以计算出一个正常值的连续周期
  • 然后 case1 case2
    :::
    

上代码

/**
 * 采样过滤.
 * @param M         故障确认周期数.
 * @param T         故障次数门限.
 * @param P         故障恢复周期数.
 * @param samples   样品数据.
 * @return          正常值的最长连续周期.
 *
 * 工具是否故障的规则：     在 m 个周期内，故障次数为 t 次
 * 判断故障恢复条件：      产生故障后（确认工具故障，才为产生故障后） e 个周期内，采样数据一直为正常值.
 * 错误采样数据处理方式：   检测到故障之后，丢弃从故障开始到故障恢复的采样数据.
 *                      检测到故障之前，错误的采样数据，由最近一个正常值代替；如果前面没有正常的采样值，则丢弃该采样数据.
 *
 *  错误采样数据确认方式：s[i] <= 0
 *                    s[i] < s[i-1]
 *                    s[i] - s[i-1] >= 10
 *
 *  首先要在 每一个 m 周期内，统计错误采样数据的次数.
 */
private static int takeSampleFilter(int M, int T, int P, int[] samples) {
    // 下标 i ->  正常迭代下标.
    int i= 0;
    int n = samples.length;
    int cycle = 0,fail = 0;

    // 用一个栈把正常数据的下标都给保存下来.
    Deque<Integer> deque = new LinkedList<>();

    while(i < n) {
        //  直接判断在 M 周期内是不是进入了故障恢复期.
        if(cycle <= M) {
            // cycle永远小于M，因为进入下一个周期，会重置 cycle 和 fail.
            if(fail == T) {
                // 这个时候进入恢复周期，产生故障之后，优先进入恢复周期，即使 M 周期没有走完.
                // 恢复周期为 T
                int count = P;
                while(count > 0 && i < n) {
                    if(judge(samples, i)) {
                        // 这里的话， 表示数据还是异常.
                        count = P;
                    } else {
                        count--;
                    }
                    i++;
                }
                // 如果已经恢复，那么进入到正常的周期循环，此时 i 的位置代表了，数据恢复正常之后的第一个数据位置.
                cycle = fail = 0;
                continue;
            }
            if(cycle == M) {
                // 进入下一个周期.
                cycle = fail = 0;
                continue;
            }
        }

        // true ： 数据采样错误.
        if(judge(samples, i)) {
            // 故障次数+1
            fail++;
            //  数据故障，判断是否可以被近似正常值代替.
            //  栈不为空，表示存在近似正常数据.
            if(!deque.isEmpty()) {
                samples[i] = samples[deque.peek()];
                deque.push(i);
            }
        } else {
            //  如果是正确采样数据的话，保存下标.
            deque.push(i);
        }
        // 周期数+1
        cycle++;
        i++;
    }

    int ans = 0;
    int lastIndex = deque.pop();
    int temp = 1;
    while(!deque.isEmpty()) {
        if(deque.peek() + 1 == lastIndex) {
            temp++;
            lastIndex = deque.pop();
        } else {
            ans = Math.max(ans, temp);
            lastIndex = deque.pop();
            temp = 1;
        }
    }

    return ans==0?temp:ans;
}

private static boolean judge(int[] samples, int i) {
    return samples[i] <= 0 || (i >= 1 && (samples[i] < samples[i-1])) || samples[i] - samples[i-1] >= 10;
}