华为OD机试- 可以处理的最大任务数【C++】

题目

在某个项目中有多个任务（用 tasks 数组表示）需要您进行处理，其中 tasks[i] = [si, ei]，你可以在 si <= day <= ei 中的任意一天处理该任务。请返回你可以处理的最大任务数。

注：一天可以完成一个任务的处理。

输入

第一行为任务数量n，1 <= n <= 100000。

后面n行表示各个任务的开始时间和终止时间，用si和ei表示，1 <= si <= ei <= 100000

输出

输出为一个整数，表示可以处理的最大任务数。

样例输入 复制

3
1 1
1 2
1 3

样例输出 复制

3

C++编码

#include <stdio.h>
#include <map>
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
#include <math.h>
using namespace std;

class CTask
{
public:
	unsigned int m_uiStart;
	unsigned int m_uiEnd;
	bool m_bCanDo;
	CTask(unsigned int start, unsigned int end)
		:m_uiStart(start),m_uiEnd(end),m_bCanDo(false)
	{
		if (m_uiStart <= m_uiEnd && m_uiStart > 0)
		{
			m_bCanDo = true;
		}
	}
	CTask()
		:m_uiStart(0),m_uiEnd(0),m_bCanDo(false)
	{
		if (m_uiStart <= m_uiEnd && m_uiStart > 0)
		{
			m_bCanDo = true;
		}
	}
	bool operator <(const CTask& oTaskRight)
	{
		if (Compare(oTaskRight) < 0)
		{
			return true;
		}
		return false;
	}

	bool operator >(const CTask& oTaskRight)
	{
		if (Compare(oTaskRight) > 0)
		{
			return true;
		}
		return false;
	}
	bool operator == (const CTask& oTaskRight)
	{
		bool bRet(false);
		if (m_uiStart == oTaskRight.m_uiStart && m_uiEnd == oTaskRight.m_uiEnd)
		{
			bRet = true;
		}
		return bRet;
	}
	int Compare(const CTask& oTaskRight)
	{
		int iRet = 0;
		if (*this == oTaskRight)
		{
			iRet = 0;
		}
		if (m_uiStart < oTaskRight.m_uiStart)
		{
			iRet = m_uiStart - oTaskRight.m_uiStart;
		}
		else if (m_uiStart == oTaskRight.m_uiStart)
		{
			iRet = m_uiEnd -oTaskRight.m_uiEnd;

		}
		else if(m_uiStart > oTaskRight.m_uiStart)
		{
			iRet =  m_uiStart - oTaskRight.m_uiStart;
		}
		return iRet;
	}
protected:
private:
};
class CTaskMan
{
public:
	CTaskMan (unsigned int arrTaskInfo[][2], int iTaskCount)
	{
		for (int i = 0; i < iTaskCount;i++)
		{
			m_vecTask.push_back(CTask(arrTaskInfo[i][0],arrTaskInfo[i][1]));
		}
		sort(m_vecTask.begin(),m_vecTask.end());
	}
	unsigned int GetMaxDealTaskCount()
	{
		unsigned int uiRet = 0;
		vector<CTask> vecTaskTemp = m_vecTask;
		sort(vecTaskTemp.begin(),vecTaskTemp.end());
		
		if (!vecTaskTemp.empty())
		{
			for (unsigned int uiTimeLoop = vecTaskTemp[0].m_uiStart;!vecTaskTemp.empty();uiTimeLoop++)
			{
				CTask oTask = vecTaskTemp[0];
				if (oTask.m_uiStart <= uiTimeLoop && oTask.m_uiEnd >= uiTimeLoop)
				{
					//任务可以被处理，处理它
					vecTaskTemp.erase(vecTaskTemp.begin());
					uiRet += 1;
				}
				else if (oTask.m_uiStart > uiTimeLoop)
				{
					//还没到处理的时间，不管他

				}
				else if (oTask.m_uiEnd < uiTimeLoop)
				{
					//任务已经过期，无法被处理，删除它
					vecTaskTemp.erase(vecTaskTemp.begin());
					uiTimeLoop -= 1;
					continue;
				}

				for (size_t sCurSize = 0 ;sCurSize < vecTaskTemp.size();sCurSize++)
				{
					if (vecTaskTemp[sCurSize].m_uiStart <= uiTimeLoop )
					{
						vecTaskTemp[sCurSize].m_uiStart += 1;
					}
				}
				sort(vecTaskTemp.begin(),vecTaskTemp.end());
			}
		}
		return uiRet;
	}
protected:
	vector<CTask> m_vecTask;
	map<unsigned int,vector<CTask>> m_mapTask;
private:
};

int main()
{
    //在某个项目中有多个任务（用 tasks 数组表示）需要您进行处理，其中 tasks[i] = [si, ei]，你可以在 si <= day <= ei 中的任意一天处理该任务。请返回你可以处理的最大任务数。
	//注：一天可以完成一个任务的处理。
	unsigned int taskInfo[][2] = {8,8,8,8,8,8,8,8,8,10,8,11,8,12,8,15,8,15,8,14,1,1,1,1,1,1,8,8,8,8,8,8,8,8,8,8};
	CTaskMan oTaskMan(taskInfo,13);
	unsigned int uiRet = oTaskMan.GetMaxDealTaskCount();
    return 0;
}