Codeforces 711 C. Coloring Trees (dp)

题目链接：http://codeforces.com/problemset/problem/711/C

给你n棵树，m种颜色，k是指定最后的完美值。接下来一行n个数 表示1~n树原本的颜色，0的话就是没颜色(一定要上色)，非0就是有颜色（不能上色）。

接下来n行 每行m个数，第i行第j个数表示 编号为i的树上第j种颜色的代价为a[i][j]。

问你最后要使完美值为k的上色代价最小为多少，要是不可能的话就为-1。

我们来考虑dp，每个树和前一个树有联系。

dp[i][j][x] 表示第i棵树 完美值为j 上第x种颜色的最小代价。

如果前一个树颜色和此树颜色相同，dp[i - 1][j][x]  --> dp[i][j][x]

否则，dp[i - 1][j][y] --> dp[i][j + 1][x]

//#pragma comment(linker, "/STACK:102400000, 102400000")
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <ctime>
#include <list>
#include <set>
#include <map>
using namespace std;
typedef __int64 LL;
typedef pair <int, int> P;
const int N = 1e2 + 5;
LL dp[N][N][N], a[N][N], val[N], INF = 1e16;
//dp[i][k][j]  i棵树 k完美值 j颜色

int main()
{
    LL n, k, m;
    scanf("%lld %lld %lld", &n, &m, &k);
    for(LL i = 1; i <= n; ++i)
        scanf("%lld", val + i);
    for(LL i = 1; i <= n; ++i) {
        for(LL j = 1; j <= m; ++j) {
            scanf("%lld", &a[i][j]);
        }
    }
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= k; ++j) {
            for(int x = 1; x <= m; ++x) {
                dp[i][j][x] = INF;
            }
        }
    }
    if(val[1]) { //已有颜色
        dp[1][1][val[1]] = 0;
    } else {
        for(LL i = 1; i <= m; ++i) {
            dp[1][1][i] = a[1][i];
        }
    }
    for(LL i = 2; i <= n; ++i) {
        for(LL j = 1; j <= k; ++j) {
            for(LL x = 1; x <= m; ++x) {
                if(dp[i - 1][j][x] == INF)
                    continue;
                if(val[i]) { 
                    if(val[i] == x) { //与前一个颜色一致
                        dp[i][j][val[i]] = min(dp[i - 1][j][x], dp[i][j][val[i]]);
                    } else {
                        dp[i][j + 1][val[i]] = min(dp[i - 1][j][x], dp[i][j + 1][val[i]]);
                    }
                } else {
                    for(LL y = 1; y <= m; ++y) {
                        if(y == x) {
                            dp[i][j][y] = min(dp[i][j][y], dp[i - 1][j][x] + a[i][y]);
                        } else {
                            dp[i][j + 1][y] = min(dp[i][j + 1][y], dp[i - 1][j][x] + a[i][y]);
                        }
                    }
                }
            }
        }
    }
    LL res = INF;
    for(LL i = 1; i <= m; ++i) {
        if(dp[n][k][i] == -1)
            continue;
        res = min(res, dp[n][k][i]);
    }
    printf("%lld\n", res == (LL)INF ? -1: res);
    return 0;
}