CodeForces

1.求达到某个状态的最小值，考虑用动态规划方式求解。

2.考虑第i棵树的决策，他的颜色对答案及状态的贡献受两个因素的影响：

①上一颗树颜色的选取

②考虑前i-1棵树已经分成了几段

定义dp[i][j][k] ： 第i棵树 当涂j颜色 分成k段时的最小消耗是多少

如果已经涂上色了 dp[i][j][k] = min(dp[i-1][j][k], dp[i-1][w!=j][k-1])

如果没有涂上色 dp[i][j][k] = min(dp[i-1][j][k], dp[i-1][w!=j][k-1] + cost[i][j]  ---->实现比较考代码能力

注意初始化 

dp把i= 1作为开始点 i=0作为原始点 给i=0初始化 让它的状态 传递到下一个状态

dp[0][0][0] = 0----->因为不存在0树 所以成本为0

其余memset(dp, INF, sizeof(dp))

#include <iostream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <map>
#include <fstream>
#include <set>
#define MAXC 107
#define INF 1e15+7 //最开始0x6f6f6f6f 在test12挂了 说明肯定是大数爆了  INF 设小了
#define READ() freopen("in.txt", "r", stdin);
using namespace std;
typedef long long ll;
int n, m, k;
int color[MAXC];
ll cost[MAXC][MAXC];
ll dp[MAXC][MAXC][MAXC];

ll solve()
{
    for (int i = 0; i <= n; i++)
    {
        for (int j = 0; j <= m; j++)
        {
            for (int l = 0  ; l <= k; l++)
            {
                dp[i][j][l] = INF;
            }
        }
    }
    dp[0][0][0] = 0;
    for (int i = 1; i <= n; i++)
    {
        if (color[i] != 0)
        {
            for (int l = 1; l<= k; l++)
            {
                dp[i][color[i]][l] = min(dp[i][color[i]][l], dp[i-1][color[i]][l]);//和i-1同一个色
                ll minn = INF;
                for (int z = 0; z <= m; z++)//--->>要从dp[0][0][0] 状态转出来
                {
                    if (z != color[i]) minn = min(minn, dp[i-1][z][l-1]);//跟前i-1种不同色 前i-1种有l-1组
                }
                dp[i][color[i]][l] = min(dp[i][color[i]][l], minn);
            }

        }
        else
        {
            for (int l = 1; l <= k; l++)
            {
                for (int j = 1; j <= m; j++)
                {
                    dp[i][j][l] = min(dp[i][j][l], dp[i-1][j][l]) + cost[i][j];//涂一样
                    ll minn = INF;
                    for (int z = 0; z <= m; z++)
                    {
                        if (z != j) minn = min(minn, dp[i-1][z][l-1]);
                    }
                    dp[i][j][l] = min(dp[i][j][l], minn + cost[i][j]);
                }
            }
        }
    }
    ll res = INF;
    for (int j = 1; j <=m; j++)
    {
        res = min(res, dp[n][j][k]);
    }
    return res;
}


int main()
{
    READ()
    scanf("%d%d%d",&n, &m, &k);
    for (int i = 1; i <= n; i++)
    {
        int c;
        scanf("%d", &c);
        color[i] = c;
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            scanf("%lld", &cost[i][j]);
        }
    }
    ll ans = solve();
    if (ans == INF) cout << -1 << endl;
    else cout << ans << endl;
}

对dp的一点小总结 

dp的特征 数据不是很大 求解最优值 并要在每一步做出决策

如果纯搜 复杂度m^n次 

但是dp得好处在于有信息的传递  ---> 对信息的压缩

考虑的这一点就比较容易得出思路 确定有几个维度

j-1 告诉 j 颜色用什么 -->显然需要一个颜色维度

k-1 告诉 k已经分成了多少段 --> 显然需要对段数记录的维度

当然第几棵树做什么决策 也需要对第几棵树记录 可以用之前的数组 的重复利用节省内存

也可以添加 i维度 记录第几棵树