万人千题计划-28

推荐社区：万人千题（上周第一）

推荐专栏：算法零基础100讲（买了的都说好，但是白嫖更香哈哈）

交替打印FooBar

思路：先给大家讲一下什么是原子操作
原子操作（atomic operation）指的是由多步操作组成的一个操作。如果该操作不能原子地执行，则要么执行完所有步骤，要么一步也不执行，不可能只执行所有步骤的一个子集。
然后和大家说一下这里面最精华的位置：this_thread::yield();
作用：暂停当前线程的调度将CPU让给其他线程
要做这一题，其实要对操作系统有部分了解，作为计算机学科的基础四大件之一，大家最好还是早点了解比较好

class FooBar {
private:
    int n;
    atomic<bool> foo_done = false;
public:
    FooBar(int n) : n(n) {}

    void foo(function<void()> printFoo) {
        for (int i = 0; i < n; i++) {
            while (foo_done) {
                this_thread::yield();
            }
            printFoo();
            foo_done = true;
        }
    }

    void bar(function<void()> printBar) {
        for (int i = 0; i < n; i++) {
            while (!foo_done) {
                this_thread::yield();
            }
            printBar();
            foo_done = false;
        }
    }
};

斐波那契数列

思路：我用的是动态规划来解决的，大致思路就是下面五步
1、确定dp数组（dp table）以及下标的含义
2、确定递推公式
3、dp数组如何初始化
4、确定遍历顺序
5、举例推导dp数组
递归的时间复杂度太高了，大家可以尽量用其他思路来写

class Solution {
public:
    int fib(int n) {
        if (n <= 1) return n;
        vector<int> dp(n + 1);//dp数组初始化
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {//从前往后遍历
            dp[i] = dp[i - 1] + dp[i - 2];//递推公式
        }
        return dp[N];
    }
};

泰波那契数

思路：依旧是动态规划
按照上面的五步来写，甚至可以优化
我们只需要维护三个数就行了，不用记录整个数组
这样空间复杂度就降到了O(1)，不再是上一题的O(n)

class Solution {
public:
    int tribonacci(int n) {
        int dp[3];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;
        if(n==0) return 0;
        for(int i=3; i<=n; i++)
        {
            int sum = dp[0]+dp[1]+dp[2];
            dp[0] = dp[1];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};

杨辉三角

思路：作为动态规划的入门题，以后大家肯定是需要学的，不如看看我的思路吧
除了两边的情况，每一项都等于上面一层的对应数字和其前一个数字的和
对两边的数组特殊处理：res[i][0] = res[i][i] = 1;
推出递推公式：res[i][j] = res[i-1][j] + res[i-1][j-1];

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> res(numRows);
        for(int i=0; i<numRows; ++i)
        {
            res[i].resize(i+1);
            res[i][0] = res[i][i] = 1;
            for(int j=1; j<i; ++j)
            {
                res[i][j] = res[i-1][j] + res[i-1][j-1];
            }
        }
        return res;
    }
};

杨辉三角Ⅱ

思路：
1、首先，当前行依赖于上一行，可以用一个一维数组来存储。
2、当前行的值只依赖于上一行的两个值，可以直接开辟一个存储结果的空间，滚动数组，当前行的 i 可以由数组中的 i 项和 i - 1 项得到

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<int> res(rowIndex + 1);
        res[0] = 1;
        for (int i = 1; i <= rowIndex; ++i) {
            for (int j = i; j > 0; --j) {
                res[j] += res[j - 1];
            }
        }
        return res;
    }
};

爬楼梯

思路：动态规划：我想我前面讲的蛮清楚的，和第二、三题没什么区别
照着那个思路来，很快就能写出来了

class Solution {
public:
    int climbStairs(int n) {
        if(n <= 1) return n;
        vector<int> dp(n+1);
        dp[1] = 1;
        dp[2] = 2;
        for(int i=3; i<=n; i++)
        {
            int sum = dp[1]+dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};

圆圈中最后剩下的数字(约瑟夫环)

思路：公式法 f(N,M)=(f(N−1,M)+M)%N
f(N,M)：表示N个人报数，每报到M时杀掉那个人，最终胜利者的编号
f (N − 1, M)：表示N-1个人报数，每报到M时杀掉那个人，最终胜利者的编号

class Solution {
public:
    int lastRemaining(int n, int m) {
        int res = 0;
        for(int i=2; i<=n; i++) {
            res = (res + m) % i;
        }
        return res;
    }
};

翻转字符

思路：一个神奇的动态规划

class Solution {
public:
    int minFlipsMonoIncr(string s) {
        int dp = 0, one = 0;
        for(int i=0; i<s.size(); i++) {
            if(s[i] == '0') {//当前等于 0 ，看反转前面全是 1 的为0 和 反转当前为1的代价哪个大
                dp++;
            }else one++;//记录前面为1 的个数
            dp = min(dp, one);
        }
        return dp;
    }
};