贪心算法

贪心算法：分阶段的工作，在每个阶段做出当前最好的选择，从而希望得到结果是最好或最优的算法。

贪心算法与动态规划的不同在于它对每个子问题的解决方案都做出选择，不能回退。动态规划则会保存以前的运算结果，并根据以前的结果对当前进行选择，有回退功能。

任务调度问题（简单）

这是一个经典简单的贪心问题，只是题目有点长需要认真读。解决这个问题，重点要想好贪心的策略:

阶段性：每个时间表选择哪一个任务。

贪心策略：根据“误时惩罚”对任务进行排序，优先排惩罚大的任务，如果这个时间点已经被占了，依次向前找，判断任务是否能安排?

#include <stdio.h>
#include <stdlib.h>
typedef struct{
    int time;
    int weight;
}obj,*object;

object objs;
int num = 0;//任务数
int totle = 0;
int order[500];//任务序列

//冒泡排序
void bubble(){
    obj tmp;
    for(int i=0;i<num-1;i++){
        for(int j=0;j<num-i-1;j++)
            if(objs[j].weight>objs[j+1].weight){
                tmp = objs[j];
                objs[j] = objs[j+1];
                objs[j+1] = tmp;
            }
    }
}

void range(){
    for(int i=num-1;i>=0;i--){
        if(order[objs[i].time]==0){
            order[objs[i].time] = 1;
        }else{
            int j = objs[i].time;
            bool change = false;
            for(;j>=1;j--)
                if(order[j]==0){
                    change = true;
                    order[j] = 1;
                    break;
                }
            if(!change)
                totle+=objs[i].weight;
        }
    }
}

int main()
{
    scanf("%d",&num);
    //初始化结构体对象
    objs = (object)malloc(num*sizeof(obj));
    for(int i=0;i<num;i++)
        scanf("%d",&objs[i].time);
    for(int i=0;i<num;i++)
        scanf("%d",&objs[i].weight);
    bubble();
    range();
    printf("%d",totle);
    return 0;
}

 

区间覆盖（开始没思路）

感觉这个贪心的策略比较难想，不过接触一次以后就会有思路啦。

阶段性：每个区间选择那两个点

贪心策略：

1. 　　对于所有的区间按右端点从小到大排序。（根据右端点排序）
2. 　　从第一个区间开始扫描是否覆盖了两个点?扫描下一个：从右断点覆盖，直到覆盖两个点；（从左端扫描，右端覆盖）

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

struct node
{
    int x,y;
}a[10005];
bool used[10005];
int n;
int ans;

int cmp(node a,node b)
{
    return a.y<b.y;
}

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i].x>>a[i].y;
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=n;i++)
    {
        int k=0;
        for(int j=a[i].x;j<=a[i].y;j++)
            if(used[j])
                k++;
        for(int j=a[i].y;j>=a[i].x&&k<2;j--)
            if(!used[j])
            {
                used[j]=1;
                k++;
                ans++;
            }
    }
    cout<<ans<<endl;
    return 0;
}

最小差距 （题有点坑，提交了好多次）

贪心策略：

1. 　　读入数码，然后排序。
2. 　　当只有两个数码的时候是特殊情况，直接输出大的减去小的。
3. 　　如果有奇数个数码，那么组成了[n/2]和[n/2]+1位数，使得[n/2]+1位数尽可能的小，[n/2]位数尽可能大，如果有零要安排在[n/2]+1位数的次高位上。
4. 　　如果是偶数个数码，那么枚举最高位（一定是排序后相邻的两个），然后使得大数尽可能小，小数尽可能大。

#include<bits/stdc++.h>
using namespace std;
int a[15];
int n;
int abs(int x){ return (x<0?-x:x); }
int simple(){
    if (a[1]==0) swap(a[1],a[2]);
    int s1=0,s2=0;
    for (int i=1;i<=n/2+1;i++) s1=s1*10+a[i];
    for (int i=n;i>=n/2+2;i--) s2=s2*10+a[i];
    return abs(s1-s2);
}
int doubles(){
    int book[15];
    int s1,s2;
    int ans=(1<<31)-1;
    for (int i=2;i<=n;i++)
        if (a[i-1]){
            s1=a[i],s2=a[i-1];
            memset(book,0,sizeof(book));
            book[i]=book[i-1]=1;
            int l=1,r=n;
            for (int j=1;j<=(n-2)/2;j++){
                while (book[l]) l++;
                while (book[r]) r--;
                book[l]=book[r]=1;
                s1=s1*10+a[l];s2=s2*10+a[r];
            }
            ans=min(ans,abs(s1-s2));
      }
    return ans;
}
int main(){
    int t;
    cin>>t;
    while (t--){
        scanf("%d",&n);
        for (int i=1;i<=n;i++) scanf("%d",&a[i]);
        sort(a+1,a+1+n);
        if (n==2) {
            printf("%d
",a[2]-a[1]);
            continue;
        }
        if (n%2==1)
            printf("%d
",simple());
        else
            printf("%d
",doubles());
    }
}

/*
N为奇数    N为偶数    N=2
对于第一种情况，不难想到这样的贪心策略：将最小的非0数字作为x的最高位，然后依次从左往右取k位加入x，从右往左取k位作为y，x-y的绝对值即为答案。
对于第二种情况，稍微复杂些：枚举非零数字a[i]作为x的最高位，a[i+1]作为y的最高位，从右往左取k-1位加入x，从左往右取k-1位加入y，打擂台更新答案。
对于第三种情况，特判输出。
*/

最近做了一些贪心算法的题，感觉贪心算法主要是根据问题的要求想出贪心策略，上面提到了没有涉及到什么数据结构和高精度的问题。所以用到最多的就是排序。