LeetCode 502. IPO

https://leetcode-cn.com/problems/ipo/
假设 力扣（LeetCode）即将开始 IPO 。为了以更高的价格将股票卖给风险投资公司，力扣 希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限，它只能在 IPO 之前完成最多 k 个不同的项目。帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。

给你 n 个项目。对于每个项目 i ，它都有一个纯利润 profits[i] ，和启动该项目需要的最小资本 capital[i] 。

最初，你的资本为 w 。当你完成一个项目时，你将获得纯利润，且利润将被添加到你的总资本中。

总而言之，从给定项目中选择 最多 k 个不同项目的列表，以 最大化最终资本 ，并输出最终可获得的最多资本。

答案保证在 32 位有符号整数范围内。

typedef struct{
    int profits;
    int capital;
}pcgroup;

//按profits降序排列
int cmp_capital(const void *a, const void *b){
    const pcgroup *aa = a;
    const pcgroup *bb = b;
    return bb->profits - aa->profits;
}

int findMaximizedCapital(int k, int w, int* profits, int profitsSize, int* capital, int capitalSize){
    if(profitsSize!=capitalSize){
        return -1;
    }
clock_t start, finish;  
double  duration;
start = clock(); 
    pcgroup *pc0 = malloc(profitsSize*sizeof(pcgroup));
    for(int i=0;i<profitsSize;i++){
        pc0[i].profits = profits[i];
        pc0[i].capital = capital[i];
    }
finish = clock();  
duration = (double)(finish - start) / CLOCKS_PER_SEC;  
printf( "%f seconds\n", duration ); 
    qsort(pc0,profitsSize,sizeof(pcgroup),cmp_capital);//按profits降序排列
    // for(int i=0;i<profitsSize;i++){
    //     printf("%d,%d,%d\n",i,pc0[i].profits,pc0[i].capital);
    // }
    for(int i=0;i<k;i++){
        int temp0 = 0;
        while(temp0<profitsSize && pc0[temp0].capital>w){
            temp0++;
        }
        if(temp0>=profitsSize){
            //printf("break!\n");
            break;
        }
        w += pc0[temp0].profits;
        pc0[temp0].capital = (int)(((unsigned int)-1)>>1);
    }
start = clock();  
duration = (double)(start - finish) / CLOCKS_PER_SEC;  
printf( "%f seconds\n", duration ); 
    return w;
}

上面的代码超时了，测了一下发现，栈访问效率比堆差很多，导致数据赋值部分耗费了很多时间，更改如下：

typedef struct{
    int profits;
    int capital;
}pcgroup;

//按profits降序排列
int cmp_capital(const void *a, const void *b){
    const pcgroup *aa = a;
    const pcgroup *bb = b;
    return bb->profits - aa->profits;
}

int findMaximizedCapital(int k, int w, int* profits, int profitsSize, int* capital, int capitalSize){
    if(profitsSize!=capitalSize){
        return -1;
    }
// clock_t start, finish;  
// double  duration;
// start = clock(); 
    pcgroup pc0[profitsSize];
    memset(pc0, 0, sizeof(pc0));
    for(int i=0;i<profitsSize;i++){
        pc0[i].profits = profits[i];
        pc0[i].capital = capital[i];
    }
// finish = clock();  
// duration = (double)(finish - start) / CLOCKS_PER_SEC;  
// printf( "%f seconds\n", duration ); 
    qsort(pc0,profitsSize,sizeof(pcgroup),cmp_capital);//按profits降序排列
    // for(int i=0;i<profitsSize;i++){
    //     printf("%d,%d,%d\n",i,pc0[i].profits,pc0[i].capital);
    // }
    for(int i=0;i<k;i++){
        int temp0 = 0;
        while(temp0<profitsSize && pc0[temp0].capital>w){
            temp0++;
        }
        if(temp0>=profitsSize){
            //printf("break!\n");
            break;
        }
        w += pc0[temp0].profits;
        pc0[temp0].capital = 0x7fffffff;//(int)(((unsigned int)-1)>>1);
    }
// start = clock();  
// duration = (double)(start - finish) / CLOCKS_PER_SEC;  
// printf( "%f seconds\n", duration ); 
    return w;
}

还是超时，别人的算法：

#define MIN(a, b) ((a) <= (b) ? (a) : (b))
#define MAX_INT_NUMBER 0x7FFFFFFE

typedef struct {
    int capital;
    int profit;
} ProNode;

int CompareProfit(const ProNode *a, const ProNode *b)
{   /* 从大到小排序 */
    return  b->profit - a->profit;
}

int findMaximizedCapital(int k, int W, int* Profits, int ProfitsSize, int* Capital, int CapitalSize){
    int i, j;
    int maxCap;
    int flag;
    /* minIndex最小开始扫描的索引，每次循环扫描第1个资本不够但是利润最大的索引，
       每次有新的项目收入，都立刻重新从最小索引开始扫描（意味着可能会有原来资本不够，但是利润很大的项目可以重新启动了）*/
    int minIndex; 
    int minFlag;  /* 第一个资本不够，但是利润最大的索引的辅助标志，辅助判断是否要记录minIndex */
    ProNode node[ProfitsSize];
    int maxCnt = MIN(k, CapitalSize);
    if (k == 0 || CapitalSize == 0 || ProfitsSize == 0) {
        return W;
    }
    for (i = 0; i < CapitalSize; i++) {
        node[i].profit = Profits[i];
        node[i].capital = Capital[i];
    }
    /* 将所有项目按照利润从大到小排序 */
    qsort(node, ProfitsSize, sizeof(ProNode), CompareProfit);
    maxCap = W;
    for (j = 1; j <= maxCnt;) {
        flag = 0;
        minIndex = 0;
        minFlag = 0;
        /* 每次扫描剩下的项目，将未访问的，资本允许，利润最大的项目启动 */
        for (i = minIndex; i < CapitalSize; i++) {
            if (maxCap >= node[i].capital) {
                maxCap = maxCap + node[i].profit;                
                node[i].capital =  MAX_INT_NUMBER;
                flag = 1;
                j++;
                /* 注意：这里是不超时的关键点，如果前面已经有利润大的项目被记录了，要立刻停止，重新判断是否可以启动原来利润大的项目 
                   否则，继续找利润大的项目，可以节省很多循环*/
                if (minFlag == 1) {
                    break;
                }  
            } else if (node[i].capital != MAX_INT_NUMBER && minFlag == 0) {
                /* 因为资本不够未能启动的项目，记录第一个即可， 下次要从此处开始扫描 */
                minIndex = i;
                minFlag = 1;
            }
            if (j > maxCnt) {
                break;
            }
        }
        /* 说明已经没有可以启动的项目了 */
        if (flag == 0) {
            break;
        }
    }
    return maxCap;
}

作者：kkk-h1
链接：https://leetcode-cn.com/problems/ipo/solution/cyu-yan-28hao-miao-chao-guo-100de-ti-jia-mmd0/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。