算法刷题 DAY52

198.打家劫舍

int rob(int* nums, int numsSize) {

    if(numsSize==0) return 0;
    if(numsSize==1) return nums[0];//i<2下面for循环会报溢出

    int dp[numsSize];
    dp[0]=nums[0];
    dp[1]=fmax(nums[0],nums[1]);
    //必须初始化前两个元素，因为递推式左侧由前两个推得→第三个及以后元素初始化为任意值均无影响

    for(int i=2;i<numsSize;i++){
        dp[i]=fmax(dp[i-2]+nums[i],dp[i-1]);
    }

    return dp[numsSize-1];
    
}

213.打家劫舍II

//将环形情况分解成线性情况

int max_money(int* nums,int left,int right){

    if(left>right) return 0;
    if(left==right) return nums[left];
    if(right-left==1) return fmax(nums[left],nums[right]);

    int dp[right+1];
    dp[left]=nums[left];
    dp[left+1]=fmax(nums[left],nums[left+1]);
    for(int i=left+2;i<=right;i++){
        dp[i]=fmax(dp[i-1],dp[i-2]+nums[i]);
    }

    return dp[right];
}


int rob(int* nums, int numsSize) {

    if(numsSize==0) return 0;
    if(numsSize==1) return nums[0];
    if(numsSize==2) return fmax(nums[0],nums[1]);

    int money_1=max_money(nums,0,numsSize-2);
    int money_2=max_money(nums,1,numsSize-1);

    return fmax(money_1,money_2);
    
}

337.打家劫舍3

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int* last_order(struct TreeNode* root) {

    int* dp = (int*)calloc(2, sizeof(int));
    if (!root)
        return dp;

    int* left_dp=last_order(root->left);//用指针而不是数组来接结果
    int* right_dp=last_order(root->right);

    dp[0]=fmax(left_dp[0],left_dp[1])+fmax(right_dp[0],right_dp[1]);//该节点不偷
    dp[1]=root->val+left_dp[0]+right_dp[0];//该节点偷
    return dp;

}

int rob(struct TreeNode* root) {

    int* dp=last_order(root);

    return fmax(dp[0],dp[1]);
}