算法：一组灯，最少按几次开关才能点亮所有的灯

题目描述

给定一个数组arr，长度为N
arr中的值不是0就是1
arr[i]表示第i盏灯的状态，0代表灭灯，1代表亮灯
每一栈灯都有开关，但是按下i号灯的开关，会同时改变i-1、i、i+1栈灯的状态

如果N盏灯排成一条直线,请问最少按下多少次开关,能让灯都亮起来排成一条直线

说明：

i为中间位置时，i号灯的开关能影响i-1、i和i+1
0号灯的开关只能影响0和1位置的灯
N-1号灯的开关只能影响N-2和N-1位置的灯

题目解析

假如当前来到了i，那么 $i$ 有两种可能性：

按下
不按下

如果“按下”，它会影响i-1，i，i+1

那么我们假设 $i - 2$ (包括 $i - 2$ 在内)之前的所有等都点亮了。

问题是 $i$ 能不能按下呢？它要被 $i - 1$ 的状态影响，假设 $i - 1$ 的状态为preStatus，那么：

如果preStatus不亮，那么 $i$ 必须按下（否则到了i+1的位置就不能补救i-1的位置了）
如果preStatus亮，那么 $i - 1$ 不能按下（如果按下了，i-1位置会变暗）

也就是两个位置绑在一起做决定

因此定义 $f (n e x t I n d e x, p re St a t u s, c u rr St a t u s)$

nextIndex：表示当前位置的下一位置
currIndex = nextIndex-1：当前位置
preStatus：前一位置的状态

应该把变化的部分提取出来作为参数

递归

// 当前在(curr = nextIndex - 1)位置上做选择
// 0....cur-2  已经全亮
int process(std::vector<int> &arr, int nextIndex, int preStatus, int curStatus){
    if(nextIndex == arr.size()){ //当前来到最后一个开关的位置
        return preStatus != curStatus ? INT32_MAX : curStatus ^ 1;  //currStatus为0时，就按下；否则就不按
    }

    // 没到最后一个按钮
    if(preStatus == 0){ // 一定要改变
        int next = process(arr, nextIndex + 1, curStatus ^ 1, arr[nextIndex] ^ 1);  //因为有可能不合法，所以我们单独写一行
        return next == INT32_MAX ? next : next + 1;
    }else{ // 一定不能改变
        return process(arr, nextIndex + 1, curStatus, arr[nextIndex]);
    }
}


int noLoopRight(std::vector<int> arr){
    if(arr.empty()){
        return 0;
    }

    if(arr.size() == 1){
        return arr[0] == 1 ? 0 : 1;
    }

    if(arr.size() == 2){
        return arr[0] != arr[1] ? INT32_MAX : 1;
    }


    int p1 = process(arr, 2, arr[0], arr[1]);    // 不变0位置的状态
    int p2 = process(arr, 2, arr[0] ^ 1, arr[1] ^ 1);// 改变0位置的状态
    if(p2 != INT32_MAX){
        p2++; //加上它自己
    }
    return std::min(p1, p2);
}

改成迭代

int traceNoLoop(std::vector<int> &arr, int preStatus, int curStatus) {
    int i = 2;
    int op = 0;
    while (i != arr.size()) {
        if (preStatus == 0) {
            op++;
            preStatus = curStatus ^ 1;
            curStatus = arr[i++] ^ 1;
        } else {
            preStatus = curStatus;
            curStatus = arr[i++];
        }
    }
    return (preStatus != curStatus) ? INT32_MAX : (op + (curStatus ^ 1));
}

int noLoopRight(std::vector<int> arr){
    if(arr.empty()){
        return 0;
    }
    
    if(arr.size() == 1){
        return arr[0] == 1 ? 0 : 1;
    }
    
    if(arr.size() == 2){
        return arr[0] != arr[1] ? INT32_MAX : 1;
    }


    int p1 = traceNoLoop(arr, arr[0], arr[1]);    // 不变0位置的状态
    int p2 = traceNoLoop(arr,  arr[0] ^ 1, arr[1] ^ 1);// 改变0位置的状态
    if(p2 != INT32_MAX){
        p2++; //加上它自己
    }
    return std::min(p1, p2);
}

迭代器


std::default_random_engine e;
std::vector<int>  generateRandom(int maxLen, int minValue, int maxValue){
    std::uniform_int_distribution<int> distS(1, maxLen);
    std::uniform_int_distribution<int> distV(minValue, maxValue);
    std::vector<int> arr;
    int size = distS(e);
    arr.resize(size);
    for (int i = 0; i < size; ++i) {
        arr[i] = distV(e);
    }

    return arr;
}

template<typename T>
void copyVector(std::vector<T>& vec1, std::vector<T>& vec2) {
    if (vec2.empty()) { // copy the vec2 to the vec1
        return;
    }
    vec1 = vec2;
}
int main() {

    e.seed(time(NULL));
    int testCount(1000);    // epoch
    int maxSize(10);    // max size of the vector
    int minValue(0);  // min value
    int maxValue(1);     // maxvalue

    for (int i = 0; i < testCount; ++i) {
        std::vector<int> arr1 = generateRandom(maxSize,  minValue, maxValue);
        arr1 = {1, 0};
        std::vector<int> arr2;
        copyVector(arr2, arr1);
        int p1 = noLoopRight(arr1);
        int p2 = noLoopLight(arr2);
        if(p1 != p2){
            std::cout << "[" << p1 << "," << p2 << "]\n";
        std::copy(arr1.begin(), arr1.end(), std::ostream_iterator<int>(std::cout, " "));
        std::cout << "\n";
            return 0;
        }
    }

    std::cout << "\n";
    return 1;
}

小结

难点在于【即影响左右，右影响自己】，相似的问题还有leetcode：968. 监控二叉树，但是本题更难。

所有递归题目：

尽量不要修改数组这样的复杂结构，因为改成动态规划会很难
然后解决这个问题时，先把位置提取出来
怎么提取呢？看提供的数据结构。比如本题中，提供了一个数组。那么依照题目意思，这个数组有如下可能：
- 一个灯也没有（特殊情况）
- 只有一个灯时（特殊情况）
- 只有两个灯时（特殊情况）
- 三个以及三个以上的灯（普通情况）
先把特殊情况处理，然后处理普通情况