贪心算法实例

最新推荐文章于 2024-07-12 15:24:07 发布

快乐一只小青蛙

最新推荐文章于 2024-07-12 15:24:07 发布

阅读量85

点赞数

文章标签：贪心算法算法

本文链接：https://blog.csdn.net/qq_54901023/article/details/132269745

版权

1、概念：通过当前情况循环获取局部最优解，最终根据多个局部最优解得出全局最优解。

例题1：

#include<iostream>
using namespace std;
#include<algorithm>
int main()
{
    int data[] = { 8,20,5,80,3,420,14,330,70 };
    int max = 500;//最多500公斤
    int cout = sizeof(data) / sizeof(int);
    sort(data,data+cout);//数组的起始位置和结束位置

    int tem = 0;
    int n = 0;//能装的古董个数
    for (int i = 0; i < cout; i++)//根据当前情况 选出最优选择
    {
        tem += data[i];
        if (tem >max)
        {
            break;
        }
        n++;
    }
    printf("%d\n", n);
    return 0;
}

示例2：初级训练-字节跳动

#include<iostream>
using namespace std;
#include<algorithm>

int canPlaceFlowers(int* data, int dataSize, int n)//(&data)[] 引用整个数组
{
    int i = 0;
    int count = 0;
    if (n==0) 
    {
        return true;
    }
    while (i<dataSize)
    {
        if (data[i] == 1)
        {
            i+=2;
        }
        else if(i>0&&data[i-1]==1)
        {
            i++;
        }
        else if (i+1 <dataSize && data[i +1] == 1)
        {
            i +=3;
        }
        else
        {
            //种花 data[i] = 1;
            count++;
            i += 2;
            if (count ==n)
            {
                return count;
            }
        }
    }

    return count;
}

int main()
{
    int data[] = { 1,0,0,0,1,0,1,0};
    int size = sizeof(data) / sizeof(int);
    int a = canPlaceFlowers(data,size,3);
    cout << a << endl;
}

实例3：中级训练-华为

#include<iostream>
using namespace std;
#include<algorithm>
#include<math.h>
int* collision(int* data, int dataSize, int* retSize)//retSize返回个数
{
    int n = 0;
    while (1) 
    {
        int pre = 0;
        int next = 1;
        
        while (next <dataSize)
        {
            //方向相反的情况
            if (data[pre] * data[next] <0)
            {
                if (data[pre] <0)
                {
                    pre = next;
                    next++;
                    continue;
                }

                if (abs(data[pre]) >abs(data[next]))
                {
                    data[next] = 0;
                    n++;
                }
                else if (abs(data[pre]) < abs(data[next]))
                {
                    data[pre] = 0;
                    n++;
                }
                else//相等值情况
                {
                    data[pre] = 0;
                    data[next] = 0;
                    n +=2;
                }
                break;
            }
            //有坑:已经爆炸后的
            if (data[pre] ==0)
            {
                pre = next;
                next++;
            }
            else if(data[next] == 0)
            {
                next++;
            }
            else
            {
                pre = next;
                next++;
            }
        }
        if (next >=dataSize) 
        {
            break;
        }   
    }

    *retSize = dataSize - n;
    int* retArray = (int*)malloc(*retSize* sizeof(int));//声明数组
    for (int i = 0,k=0; i < dataSize; i++)
    {
        if (data[i] !=0)
        {
            retArray[k++] = data[i];
        }
    }
    return retArray;
}

int main()
{
    int data[] = { 10,2,-5};
    int size;
    int* a = collision(data,3,&size);
    cout << size << endl;
}