动态规划题目—栅栏染色，打劫房屋

最近在lintcode上看动态规划的题目，总结了动态规划的一类题目，动态规划一般会用于求最优解，最大值等题目中，核心是找状态方程，请看以下题目：

第一题：

对于这类题目中出现不存在超过2个相邻这种字眼应该首先想到动态规划，所以接下来首先找状态转移方程，请看以下推导：
当n==1的时候，有k种；
当n==2的时候，有k*k种；
当n==3的时候，分两种情况：
a.如果3和2颜色相同，则有k*(k-1)；
b.如果3和2颜色不同，则有(k*k)*(k-1)；
所以第三个栅栏总共的方案数=k*(k-1)+(k*k)(k-1) = (k-1)(k+k*k)。
则状态转移方程为：opt[i] = (k - 1) * (opt[i-1]+opt[i-2]);
找到了状态转移方程，动态规划可以用如下代码实现：

class Solution {
public:
    /**
     * @param n: non-negative integer, n posts
     * @param k: non-negative integer, k colors
     * @return: an integer, the total number of ways
     */
    int numWays(int n, int k) {
        // write your code here
        int opt[n] = {0};
        opt[0] = k;
        opt[1] = k*k;
        for(int i = 2;i<n;i++)
        {
            //opt[i]会保存第i个栅栏的方案数
            opt[i] =(k-1)* (opt[i-1]+opt[i-2]);
        }
        return opt[n-1];
    }
};

---

第二题：

描述
假设你是一个专业的窃贼，准备沿着一条街打劫房屋。每个房子都存放着特定金额的钱。你面临的唯一约束条件是：相邻的房子装着相互联系的防盗系统，且 当相邻的两个房子同一天被打劫时，该系统会自动报警。

给定一个非负整数列表，表示每个房子中存放的钱， 算一算，如果今晚去打劫，你最多可以得到多少钱 在不触动报警装置的情况下。

您在真实的面试中是否遇到过这个题？
样例
给定 [3, 8, 4], 返回 8.

挑战
O(n) 时间复杂度 且 O(1) 存储。

解题：约束条件是不能同时打劫相邻的屋子。如下图，假设有6个屋子，分别将其标为0,1,2,3,4,5，将每个屋子的金钱数存进一个house数组，首先看第五间房子，每间房子有两种选择，一种是打劫，一种是不打劫，如果第五间房子不打劫则最优值是opt(4),如果第五间房子打劫则最优解是opt(3)+house[5]，(右边的图我用v代表了house，v(5)相当于house[5])，因此要返回打劫与不打劫的最大值，opt也是一个数组用来存放最优解的数组。

根据上图的推导，可以得出动态规划的状态转移方程：

打劫第i个房子：A= house[i] + opt[i-2];
不打劫第i个房子： B= opt[i-1]；

要返回max(A,B)

#include <iostream>
#include<vector>
using namespace std;
int max(int a, int b)
{
    if (a >= b)
    {
        return a;
    }
    else
    {
        return b;
    }
}
//递归形式(递归主要要找到递归出口)
int houseRobber(vector<int> &A, int i) {
    // write your code here
    if (A.size() == 0)
    {
        return 0;
    }
    if (i == 0)
    {
        return A[0];
    }
    else if (i == 1)
    {
        return max(A[0], A[1]);
    }
    else
    {
        int x = houseRobber(A, i - 2) + A[i];
        int y = houseRobber(A, i - 1);
        return max(x, y);
    }
}
//动态规划(将每个子问题的解保存下来，下次用到直接从内存中读取),opt数组就是保存子问题解得数组
int dynamic_houseRobber(vector<int>&A)
{
    if (A.size() == 0)
    {
        return 0;
    }
    int len = A.size();
    int opt[1000] = {0};
    opt[0] = A[0];
    opt[1] = max(A[0], A[1]);
    for (int i = 2; i < len; i++)
    {
        //假设选择i=2时，就不能选择1，只能选择0，加上它本身的数字A[2]
        int select = opt[i - 2] + A[i];
        //假设不选择2时，就能选择1
        int nonselect = opt[i - 1];
        opt[i] = max(select, nonselect);
    }
    return opt[len - 1];
}
int main()
{
    int n, value;
    vector<int>A;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> value;
        A.push_back(value);
    }
    cout << houseRobber(A, n - 1) << endl;
    cout << dynamic_houseRobber(A) << endl;
}

希望能对各位有所帮助！