poj-1260

#include <stdio.h>
#include <malloc.h>


struct pearlInfo{
    int number;
    int price;
};

typedef struct pearlInfo pearlInfo;

struct BuyOP {
    int cost;
    int higerGlass;
};

typedef struct BuyOP BuyOP;

void getLowestCost(pearlInfo * pearlBuyList, int buyListSize) {

    
    BuyOP Min[101][101] = {0};

    int sum[101] = {0};

    sum[0] = pearlBuyList[0].number;
    for (int i = 1; i < buyListSize; i++) {
        sum[i] = sum[i-1] + pearlBuyList[i].number;
        // printf("%d\n", sum[i]);
    }

    for (int i = buyListSize; i >= 1; i--) {
        for (int j = buyListSize - 1; j >= 0; j--) {
            if (j > i-1) {
                Min[i][j].cost = -1;
            } else if (i == buyListSize) { // only can but the highest glass.
                if (j == i -1) {
                    Min[i][j].cost = (sum[buyListSize - 1] + 10)* (pearlBuyList[i-1].price);
                } else {
                    Min[i][j].cost = (sum[buyListSize - 1] - sum[buyListSize - 1 - j - 1] + 10) * (pearlBuyList[i-1].price);
                }
            } else {
                int buyThisGlass;
                if (j == i - 1) {
                    buyThisGlass = (sum[i - 1] + 10) * (pearlBuyList[i-1].price) + Min[i+1][0].cost;
                } else {
                    buyThisGlass = (sum[i - 1] - sum[i - j - 1 - 1] + 10) * (pearlBuyList[i-1].price) + Min[i+1][0].cost;
                }
                int butHigherGlass = Min[i+1][j+1].cost;
                // printf("%d %d\n", buyThisGlass, butHigherGlass);
                Min[i][j].cost = buyThisGlass < butHigherGlass ? buyThisGlass : butHigherGlass;
            }
        }
    }

    printf("%d\n", Min[1][0].cost);
}

int main() {
    int caseNum = 0;
    scanf("%d", &caseNum);
    for (int i = 0; i < caseNum; i++) {
        int buyNum = 0;
        scanf("%d", &buyNum);
        pearlInfo * pearlBuyList = (pearlInfo *)malloc(sizeof(pearlInfo) * buyNum);
        for (int j = 0; j < buyNum; j++) {
            scanf("%d %d", &((pearlBuyList+j)->number), &((pearlBuyList+j)->price));
            // printf("%d %d\n", (pearlBuyList+j)->number, (pearlBuyList+j)->price);
        }
        getLowestCost(pearlBuyList, buyNum);
        free(pearlBuyList);
    }

}

DP, 难点在于递归的关系难得到。

基本用二维矩阵就可以，

第一维的参数用第几class就可以，最多100个。

一开始想着用没有购买的珍珠个数 作为 二维 参数，结果需要 100*（100*100）（ 每个class可能买100颗）， 直接内存不够segment fault了.

后来又想用类似于数组连续最大和的方式， 试图一维搞出来，结果也不对.

最后想了想， 用要求购买的珍珠个数做为第二维的参数是完全没有必要的。

只需用前面有多少档class的珍珠没有购买作为二维参数即可（最多只需100 * 100）

那么Low[i][j]就可以定义了：

及从第iclass购买珍珠， 前面还有j class的珍珠没有购买的情况下， 所花费的最小值。

那么一些极限情况:

<1> i = 最后一个class,  这种情况下， 只能将没有购买的前 j class的珍珠 和 本class 要购买的珍珠 都 买成 最高class 的 珍珠1.

<2> j > i - 1 ， 及 还没有购买的class 数 超过了 i 之前的 class总数， 那么这种情况是没有意义的.

其他正常的情况:

Low[i][j] 下有两个选择： (1) 购买此class的珍珠， 那么之前没有购买的glass的珍珠也都在此class购买（因为如果不在此购买， 选择更高的class， 肯定要比在此class的花费多， 根据题目的表述， 更高的class， 更高价， 但是看discuss里有人说 检测时输入的也有可能不是这种情况， 唉， 不care了， poj有时候还是挺扯的）

(2) 不购买此class的珍珠， 那么Low[i][j] 就等于Low[i+1][j+1], 及从下一class开始， 之前有 j+1 class珍珠没买的情况。

而为了能够尽快的得到某个连续class range要购买的珍珠总数， 之前要对珍珠的个数做一次预处理， 搞一个数组来保存 从 1 到 2... N的range内的珍珠的总数sum，

这样后面如果要求 range(i, j)内的珍珠总数， 就直接用sum[j] - sum[i-1]即可， 还有一个特殊情况是，range(1, j), 及从头到j-1个class的珍珠都没买， 那么显然range(1, j) = sum[j].

数组从0开始真是坑人呀， 经常出现 +-1的错误， 干脆以后多浪费一个空间来从1开始吧。

这道题不使用 要购买的珍珠个数 而用没有购买的珍珠 class数 ， 是一个值得牢记的经验， 珍珠数在这道题中其实是一系列的离散值， 在这种情况下，更应该尝试别的离散性的表述来描述递推关系.