leetcode-每日一题-1710-卡车上的最大单元数(简单,哈希,暴力)

今天的这道题其实很好读懂，因为很容易可以看出来暴力求解，但其实还是隐藏一个hash求解法很巧妙，因为我在很久之前就用过hash解答过这样类似的题，所以这个题也是可以使用的，可以看看我第二个hash解法

目录

暴力效率(效率低下):

hash排版:

---

请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi] ：

numberOfBoxesi 是类型 i 的箱子的数量。
numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。
整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。

返回卡车可以装载 单元 的 最大 总数。

示例 1：

输入：boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
输出：8
解释：箱子的情况如下：
- 1 个第一类的箱子，里面含 3 个单元。
- 2 个第二类的箱子，每个里面含 2 个单元。
- 3 个第三类的箱子，每个里面含 1 个单元。
可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。
单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8
示例 2：

输入：boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
输出：91
 

提示：

1 <= boxTypes.length <= 1000
1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000
1 <= truckSize <= 106

 暴力效率(效率低下):

void sort(int *key,int *value,int size)
{
    int i,j,e;
    for(i=0;i<size;i++)
    {
        for(j=i+1;j<size;j++)
        {
            if(value[i]<value[j])
            {
                e=value[i];
                value[i]=value[j];
                value[j]=e;

                e=key[i];
                key[i]=key[j];
                key[j]=e;
            }
        }
    }
}
int maximumUnits(int** boxTypes, int boxTypesSize, int* boxTypesColSize, int truckSize){
    int i,j,k;
    int *key=(int*)malloc(sizeof(int)*boxTypesSize);
    int *value=(int*)malloc(sizeof(int)*boxTypesSize);
    memset(key,0,sizeof(key));
    memset(value,0,sizeof(value));
    for(i=0;i<boxTypesSize;i++)
    {
        key[i]=boxTypes[i][0];
        value[i]=boxTypes[i][1];
    }
    sort(key,value,boxTypesSize);
    int sum=0;
    for(i=0;i<boxTypesSize;i++)
    {
        if(truckSize-key[i]>0)
        {
            truckSize-=key[i];
            sum+=key[i]*value[i];
        }else{
            sum+=truckSize*value[i];
            break;
        }
    }
    return sum;
}

 

 

hash排版:

hash其实我们都很熟悉我们了解hash数组，hash分组，hash分区等等，而且很多算法底层都有hash的身影，那么我们看看这题的hash思想是啥，其实主要就是对boxtypes这个数组进行排序，大的放在前面小的放在后面，我们从前面开始取，取到没有为止，那我们思路就清洗了，用max将当前的最大值进行记录，然后我们就可以减少循环次数，其实这个循环次数在3次左右几乎减少没减少区别不大，我们将hash初始化成0之后就可以使用了，只要将当前boy[i][0]的值放入我们的hash[i]里面，记住这里面是累加的状态而不是直接等的状态，这一点必须清楚，其次就是用sum进行求和了，就很简单了，注意细节即可

int maximumUnits(int** boxTypes, int boxTypesSize, int* boxTypesColSize, int truckSize){
    int i,j,max=-1;
    int hash[1010];
    //int *hash=(int*)malloc(sizeof(int)*1010);
    memset(hash,0,sizeof(hash));
    for(i=0;i<boxTypesSize;i++)
    {
        hash[boxTypes[i][1]]+=boxTypes[i][0];
        max=fmax(max,boxTypes[i][1]);
    }
    int sum=0;
    for(i=max;i>=1;i--)
    {
        if(hash[i]!=0&&truckSize-hash[i]>0)
        {
            sum+=hash[i]*i;
            truckSize-=hash[i];
            //printf("i=%d hash[i]=%d sum=%d\n",i,hash[i],sum);
        }else if(hash[i]!=0&&truckSize-hash[i]<=0)
        {
            sum+=truckSize*i;
            //printf("i=%d hash[i]=%d sum=%d\n",i,hash[i],sum);
            break;
        }
    }
    return sum;
}

 可以明显看到经过第二次hash调整之后，时间复杂度和空间复杂度都提升了很多