2.29log | 968.监控二叉树，509. 斐波那契数,70. 爬楼梯,746. 使用最小花费爬楼梯

968.监控二叉树

class Solution {
public:
    int result=0;
    int traversal(TreeNode* root,int& result){
        if(root==NULL) return 2;
        int left=traversal(root->left,result);
        int right=traversal(root->right,result);
        if(left==2&&right==2) return 0;
        else if(left==0||right==0){
            result++;
            return 1; 
            }
        else return 2;
        return -1;
    }
    int minCameraCover(TreeNode* root) {
        if(traversal(root,result)==0) result++;
        return result;
    } 
};

这道题主要是要知道叶子节点的三种情况，由叶子节点推父节点 ，用0,1,2来标记叶子节点和父节点，0表示没有被覆盖，1表示摄像头，2表示被覆盖，只要叶子节点有一个为0，则父节点为1，result+1，叶子节点均为2，则父节点为0，其余情况父节点均为2，递归完之后如果根节点返回为0，则说明出现了第四种情况，子节点为0且没有父节点，result++

 

509. 斐波那契数

class Solution {
public:
    int fib(int n) {
        if(n<=1) return n;
        vector<int> dp(n+1);
        dp[0]=0;
        dp[1]=1;
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-2]+dp[i-1]; 
        }
        return dp.back();
    }
};

dp数组下标含义为F(n)的n，递推公式为F(n)=F(n-1)+F(n-2)，dp数组初始化为dp[0]=0,dp[1]=1,遍历顺序为从左到右

class Solution {
public:
    int fib(int n) {
        if(n<=1) return n;
        return fib(n-2)+fib(n-1);
    }
};

这道题用递归来做很简洁，也很巧妙，F(1）和 F(0)在最开始防止数据溢出的条件中

70. 爬楼梯

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

这道题代码和斐波那契数列差不多，首先要找规律得出递推公式，dp[n]下标的含义就是n个台阶，走完n个台阶，最后一步只有两个选择，就是一次踏一步还是一次踏两步，一次踏一步，那么之前一定是走了n-1个台阶，所以有dp[n-1]种方法，同理踏两步，走完n步台阶方法一定是dp[n-2],所以走完n步台阶方法为dp[n-1]+dp[n-2],递推公式为dp[n]=dp[n-1]+dp[n-2];dp数组初始化，根据题目给出条件，只能走一步，两步，所以初始化dp[1]=1,dp[2]=2,遍历顺序为从左到右，后面要根据前面递推

746. 使用最小花费爬楼梯

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n=cost.size();
        vector<int> dp(n+1);
        dp[0]=0;
        dp[1]=0;
        for(int i=2;i<=n;i++){
            dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        } 
        return dp[n];
    }
};

这道题的题目描述很奇怪，而且是从台阶0开始跳到台阶cost.size()的，跳到台阶0,1是不需要花费的，所以dp数组起始值dp[0]=0,dp[1]=0，递推公式比斐波那契数列多了花费，递推公式为dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]),遍历顺序还是从左到右