关于 最优策略组合下的总的系统消耗资源数 的题解

最近看到一道题，就尝试做了下：

题目出处：

版权声明：本文为CSDN博主「羊族的希望」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_41010318/article/details/120740474

在通信系统中有一个常见的问题是对用户进行不同策略的调度
会得到不同系统消耗的性能
假设由N个待串行用户，每个用户可以使用A/B/C三种不同的调度策略
不同的策略会消耗不同的系统资源
请你根据如下规则进行用户调度
并返回总的消耗资源数
规则是：相邻的用户不能使用相同的调度策略
例如：
第一个用户使用A策略 则第二个用户只能使用B和C策略
对单的用户而言，不同的调度策略对系统资源的消耗可以规划后抽象为数值
例如
某用户分别使用ABC策略的系统消耗，分别为15 8 17
每个用户依次选择当前所能选择的对系统资源消耗最少的策略,局部最优
如果有多个满足要求的策略，选最后一个

输入描述：
    第一行表示用户个数N
    接下来表示每一行表示一个用户分别使用三个策略的资源消耗
    resA resB resC

输出描述：
    最优策略组合下的总的系统消耗资源数

 示例一：
  输入：
      3
      15 8 17
      12 20 9
      11 7 5
  输出：
      24
   说明:
    1号用户使用B策略
    2号用户使用C策略
    3号用户使用B策略
   系统资源消耗8+9+7
==============================================================

===============华丽的分割线=====================================

下面是我的思路：

设置一个dp[user_num][2][3]数组，对于dp[i][0][j]记录用户0~i在起始方案为j时总的资源消耗，

dp[i][1][j]记录当前用户i在起始方案为j时选择哪种方案（A:0 B:1 C:2）

用户i-1选择方案A时，则用户i选择方案B和C中较小的那个

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define min(a, b) ((a) < (b) ? (a) : (b))

void calc(int user, int last_flag, int **cost, int *tmp, int *flag)
{
        /* 如果上个用户使用A:0 本次用户则使用B:1或者C:2中较小的 */
        if (last_flag == 0) {
                if (cost[user][1] < cost[user][2]) {
                        *flag = 1; /* 记录本次使用那个方案，便于下个用户判断 */
                        *tmp = cost[user][1];
                } else {
                        *flag = 2;
                        *tmp = cost[user][2];
                }
        } else if (last_flag == 1) {
                if (cost[user][0] < cost[user][2]) {
                        *flag = 0;
                        *tmp = cost[user][0];
                } else {
                        *flag = 2;
                        *tmp = cost[user][2];
                }
        } else {
                if (cost[user][0] < cost[user][1]) {
                        *flag = 0;
                        *tmp = cost[user][0];
                } else {
                        *flag = 1;
                        *tmp = cost[user][1];
                }
        }
}

int main(void)
{
        int i, j;
        int min_value;
        int flag;
        int tmp;
        int **cost = NULL;
        int user_num;

        scanf("%d", &user_num);
		/* dp[i][0][j] 总共i用户时方案j的总资源消耗 */
		/* dp[i][1][j] 记录第i个用户采用的哪个方案j 0-A 1-B 2-C */
        int dp[user_num][2][3];
        memset(dp, 0, sizeof(dp));

        cost = (int **)malloc(user_num * sizeof(int *));
        for (i = 0; i < user_num; i++) {
                cost[i] = (int *)malloc(3 * sizeof(int));
        }
        for (i = 0; i < user_num; i++) {
                scanf("%d%d%d", &cost[i][0], &cost[i][1], &cost[i][2]);
        }
        printf("costA   costB   costC\n");
        for (i = 0; i < user_num; i++) {
                printf("%d      %d      %d\n", cost[i][0], cost[i][1], cost[i][2]);
        }
        for (i = 0; i < 3; i++) {
                dp[0][0][i] = cost[0][i];
                dp[0][1][i] = i; /* record method is A:0 B:1 C:2 */
        }
        for (i = 1; i < user_num; i++) {
                for (j = 0; j < 3; j++) {
                        calc(i, dp[i - 1][1][j], cost, &tmp, &flag);
                        dp[i][1][j] = flag;
                        dp[i][0][j] = dp[i - 1][0][j] + tmp;
                }
                printf("user:%d %d      %d      %d\n", i, dp[i][0][0],
                        dp[i][0][1], dp[i][0][2]);
                printf("flag:%d %d      %d      %d\n", i, dp[i][1][0],
                        dp[i][1][1], dp[i][1][2]);
        }
        min_value = min(dp[user_num - 1][0][0],
                min(dp[user_num - 1][0][1], dp[user_num - 1][0][2]));
        printf("min_value: %d\n", min_value);

        return 0;
}