LeetCode 刷题 （十） 算法入门 动态规划

70. 爬楼梯70. 爬楼梯70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢

思路：很经典的动态规划。由于每次只能上一个或者两个台阶，所以你到达n阶台阶的方式只能是（1）从n-1阶上去；（2）从n-2阶上去。所以很容易得出转移方程：f（n） = f（n-1）+f（n-2）；

所以我们这时就可以借助数学方法求数列通项了。但是没必要。我们只需要从n=0，n=1开始，每次记录两个数f（i-1）和f（i-2）即可；

class Solution {
public:
    int climbStairs(int n) {
        //从n=1开始
        int p = 0, q = 0, r = 1;
        //每一轮计算i个台阶的方法个数，
        for (int i = 1; i <= n; ++i) {
            p = q; 
            q = r; 
            r = p + q;
        }
        return r;
    }
};

​​​​​​198. 打家劫舍

 思路：分析一下问题，我们可以得出：（1）如果只有一个房间，那么直接抢了就是最大金额；（2）如果有两个房间，那么我们就要选择抢金额较大的那个才能实现最大金额；（3）如果房间数n大于2，那么当我们抢到第n个房间时，我们的最大金额（i）第n个房间不抢，则第n-1个房间可以抢，所以最大金额就等于抢完前n-1个房间的最大金额；（ii）第n个房间抢，则第n-1个房间不能抢，我们的最大金额就是抢完前n-2个房间的最大金额加上第那个房间的金额。显然我们应该选择上述两种情况中最大的一个，所以转移方程为：dp[k] = max(dp[k-1],dp[k-2]+nums[k)；

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n==1)
            return nums[0];
        if(n==2)
            return max(nums[0],nums[1]);
        int dp0=nums[0],dp1=max(nums[0],nums[1]),dp=0;
        for(int i=2;i<n;i++){
            dp = max(dp1,dp0+nums[i]);
            dp0 = dp1;
            dp1 = dp;
        }
        return dp;
    }
};

120. 三角形最小路径和

思路：在三角形矩阵中，到达当前位置（i，j）的路径长度由（i-1，j）和（i-1，j-1）的路径长度决定。我们很容易就可以得到转移方程：f（i，j） =  min（f（i-1，j），f（i-1，j-1））+代价（triangle[i][j]）；边界条件需要注意：第一列（j=0）只能从上方来计算，每一行的最后一个位置（j = i）只能从左上方来计算。 最后我们只需要去最后一行找最小值就可以了。

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        if(n==1)
            return triangle[0][0];
        //到达当前位置的最小路径长度由上方、左上方的最下距离决定
        for(int i=1;i<n;i++){
            for(int j=0;j<i+1;j++){
                //第一列由其上一行决定
                if(j==0&&i>0)
                    triangle[i][j] +=triangle[i-1][j];
                else if(j==i&&i>0)
                    triangle[i][j] += triangle[i-1][j-1];
                else
                    triangle[i][j] += min(triangle[i-1][j],triangle[i-1][j-1]);  
            }
        }
        //在最后一行找最小值
        int ans = triangle[n-1][0];
        for(int i=0;i<n;i++){
            ans = min(ans,triangle[n-1][i]);
        }
        return ans;
    }
};

190. 颠倒二进制位

如图所示:

数的& | ！ 三种位运算，与特定的数位运算会得到让人满意的结果。

 

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        //前16位于后16位交换
        n = (n >> 16) | (n << 16);
        //每块的前8位于后8位交换
        n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8);
        n = ((n & 0xf0f0f0f0) >> 4) | ((n & 0x0f0f0f0f) << 4);
        n = ((n & 0xcccccccc) >> 2) | ((n & 0x33333333) << 2);
        n = ((n & 0xaaaaaaaa) >> 1) | ((n & 0x55555555) << 1);
        return n;
    }
};