贪心法求解活动安排问题

完整题目

实验内容：假设有一个需要使用某一资源的n个活动所组成的集合S，S={1，…，n}。该资源任何时刻只能被一个活动所占用，活动i有一个开始时间bi和结束时间ei（bi<ei），其执行时间为ei-bi，假设最早活动执行时间为0。一旦某个活动开始执行，中间不能被打断，直到其执行完毕。若活动i和活动j有bi≥ej或bj≥ei，则称这两个活动兼容。设计算法求一种最优活动安排方案，使得所有安排的活动个数最多。

本人严重怀疑这道题其实是项让我用贪心算法求解，所以下面代码其实是贪心算法(不知道老师看到半个班级的人都用贪心算法是什么感受）
代码还是有一些乱，只有大题思路的注释。

注意：这段代码只能在VS上运行，VS code结果有错误
原因应该是因为未定义行为，i++的操作在不同编译器中不一样导致的、

另外提一嘴，vs code在代码有错误时直接不能运行，并且不告诉你错的位置，错的类型，甚至连你有代码错了都不告诉你。。。开始我用list.sort()的方法错了，又是不能运行，让我一度以为是调了几个小时的环境又崩了，还好开了vs，所以像我这样的半吊子还是先用Visual Studio，不过vscode的代码风格真是好看

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


struct LNode
{
    int name;
    int b;
    int e;
    LNode(int n, int b, int e) :name(n), b(b), e(e) {}
    LNode() :name(NULL), b(NULL), e(NULL) {}
};

//对比，排序用
bool Compare(LNode& a, LNode& b)
{
    return a.b < b.b;
}


void GetBorder(list<LNode>& l, int& begin, int& end)
{
    l.sort(Compare);
    begin = l.front().b;
    end = l.back().e;
}


list<LNode> Envy(list<LNode> l, int maxTime, int& Count)
{
    //列表排序
    l.sort(Compare);
    list<LNode> maxList;
    list<LNode>::iterator itrC, itr, minitr;
    //循环取每一个做第一个
    for (int i = 0; i < l.size(); i++)
    {
        int begin, end, curDistance, minDistance = 999, curCount = 1;
        LNode curNode, minNode;
        list<LNode> curList = l, pushedList;
        itrC = curList.begin();
        for (int j = 0; j < i; j++) itrC++;
        pushedList.push_front(*itrC);
        curList.erase(itrC);
        //选出最近的一个
        while (curList.size() > 0)
        {
            minDistance = 999;
            //获取当前边界，顺便排序
            GetBorder(pushedList, begin, end);
            //将未加入集合并且与目前集合有重合的项删除找出离当前序列最近最短的项
            for (itr = curList.begin(); itr != curList.end();)
            {
                curNode = *itr;
                if (curNode.b < begin && curNode.e <= begin)
                {
                    if ((begin - curNode.e) < minDistance)
                    {
                        minitr = itr;
                    }
                    else if ((begin - curNode.e) == minDistance)
                    {
                        minNode = *minitr;
                        minitr = (minNode.e - minNode.b) > (curNode.e - curNode.b) ? itr : minitr;
                    }
                    minDistance = (begin - curNode.e) < minDistance ? begin - curNode.e : minDistance;
                    itr++;
                    continue;
                }
                else if (curNode.b >= end && curNode.e > end)
                {
                    if ((curNode.b - end) < minDistance)
                    {
                        minitr = itr;
                    }
                    else if ((curNode.b - end) == minDistance)
                    {
                        minNode = *minitr;
                        minitr = (minNode.e - minNode.b) > (curNode.e - curNode.b) ? itr : minitr;
                    }
                    minDistance = (curNode.b - end) < minDistance ? curNode.b - end : minDistance;
                    itr++;
                    continue;
                }
                else
                    curList.erase(itr++);
            }
            pushedList.push_front(*minitr);
            curList.erase(minitr);
            curCount++;
        }//当前最小的加入集合
        maxList = curCount > Count ? pushedList : maxList;
        Count = curCount > Count ? curCount : Count;
    }
    return maxList;
}

int main()
{
    list<LNode> l,n;
    LNode a;
    //初始数据
	 a = LNode(1, 1, 2);
	 l.push_front(a);
	 a = LNode(2, 1, 4);
	 l.push_front(a);
	 a = LNode(3, 4, 9);
	 l.push_front(a);
	 a = LNode(4, 9, 10);
	 l.push_front(a);
	 a = LNode(5, 3, 4);
	 l.push_front(a);
	 a = LNode(6, 5, 7);
	 l.push_front(a);
	// l.sort(Compare);
    list<LNode>::iterator o;
    // o=l.begin();
    // for (int i = 0; i < l.size(); i++)
    // {
    //     a=*o;
    //     cout<<a.name<<endl;
    //     o++;
    // }
    int c;
    n= Envy(l, 10, c);
    n.sort(Compare);
    for (o = n.begin(); o != n.end(); o++)
    {
        a = *o;
        cout << '(' << a.b << ',' << a.e << ')' << "--";
    }
    cout << "total:" << c << endl;
    system("pause");
}

流程图也留一下吧