贪心法求解会议安排问题以及单源最短路径问题（C++实现）

会议安排问题

会议安排问题要求在有限的时间内召开更多的会议。并且会议之间不能同时进行。

每个会议都有自己的起始时间和结束时间。

会议安排，时间安排这类问题在时间轴上都是左闭右开的

//按照贪心策略有以下三种可选：

1.每次从剩下未安排的会议中选具有最早开始时间且与已安排的会议相容的会议安排

2.从剩下未安排的会议中选择持续时间最短且与已安排的会议相容的会议安排

3.从剩下未安排的会议中选择具有最早结束时间且与已安排的会议相容的会议安排，
这样可以尽快安排下一个会议

这里采用第三种贪心策略.

每次从剩下的会议中选择具有最早结束时间且与已安排的会议相容的会议安排

这样的话，最好使用一个结构体包含上面的信息

结构体
struct Meet
{
    int beg;

    int end;

}meet[1000];

关键的步骤在于排序

我们使用刚才建立的结构体，设置贪心策略的排序方式

bool cmp(Meet x,Meet y)
{
    if(x.end==y.end)

    	return x.beg>y.beg;

     return x.end<y.end;

}sort(meet,meet+n,cmp);

值得注意的是：上面代码段的最后排序sort中多出了一个cmp，请不要介意，这是我们定义的排序方法名。

下面对会议安排问题具体求解：

//会议安排的贪心求解
int ans = 1;
int last = meet[0].end;
for(i = 1; i <n; i++)
{
    if(meet[i].beg >= last)
    {//如果会议i开始时间大于等于最后一个选中的会议的结束时间
        ans++;
        last = meet[i].end;    
    }
}
return ans;//返回可以安排的会议最大值

上面的代码段中只是返回了可以安排的会议最大数，而不知道具体的会是哪个。

显然，可以进一步优化。

---

下面是会议安排问题的具体实现

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
struct Meet
{
	int beg;
	int end;
	int num;
}meet[1000];
class setMeet {
public:
	void init();
	void solve();
private:
	int n, ans;//会议总数 ans: 最大会议安排总数
};
void setMeet::init()
{
	cout << "输入会议总数: " << endl;
	cin >> n;
	int i;
	cout << "输入会议开始时间和结束时间，以空格分卡：" << endl;
	int s, e;
	for (i = 0; i < n; ++i)
	{
		cin >> s >> e;
		meet[i].beg = s;
		meet[i].end = e;
		meet[i].num = i + 1;
	}
}

bool cmp(Meet x, Meet y)
{
	if (x.end == y.end) {
		return x.beg > y.beg;
	}
	return x.end < y.end;
}
void setMeet::solve()
{
	sort(meet, meet + n, cmp); //对会议结束时间的排序
	cout << "排完序的会议时间如下: " << endl;
	int i;
	cout << "会议编号" << " 开始时间" << "结束时间" << endl;
	for (i = 0; i < n; i++)
	{
		cout << "  " << meet[i].num << "\t\t" << meet[i].beg << "\t" << meet[i].end << endl;
	}
	cout << "-------------------------------------" << endl;
	cout << "选择的会议的过程：" << endl;
	cout << " 选择第" << meet[0].num << "个会议" << endl;//选中了第一个会议
	ans = 1;
	int last = meet[0].end;
	for (i = 1; i < n; ++i)
	{
		if (meet[i].beg >= last)
		{
			ans++;//如果会议i开始时间大于最后一个选中的会议的结束时间
			last = meet[i].end;
			cout << " 选择第" << meet[i].num << "个会议" << endl;
		}
	}
	cout << "最多可以安排" << ans << " 个会议" << endl;
}

int main()
{
	setMeet sm;
	sm.init();
	sm.solve();
	return 0;
}

---

单源最短路径问题的求解策略以及实例

假定源点为u，则顶点集合被分为两部分S 和V-S

S相当于与源点直接相连的点，V-S相当于它们之间的距离

以下是具体的步骤：

1.设地图的带权邻接矩阵为map[][]，即从源点u到顶点i有边，
map[u][i]等于<u,i>的权值,否则权值无线大dist[]记录源点到顶点最短路径长度
p[i]记录最短路径上i顶点的前驱

2.初始化
 	dist[i]=map[u][i],如果源点u到顶点i有边相连，初始化p[i]=u,
否则p[i]=-1;

3.找最小	
 	dist[t]=min(),则顶点t就是集合V-S中距离源点u最近的顶点

4.加入栈队
 	将顶点t加入集合S中，同时更新V-S

5.判断结束
  	如果集合V-S为空，算法结束，否则转6

6.走捷径
 	所有与顶点t相邻的顶点j可以借助t走捷径。如果dis[j]>dist[t]+map[t][j]
dist[j]=dist[i]+map[t][j],记录顶点j记录顶点j的前驱为t，有p[j]=t

 我们使用的算法就是Dijkstra所创

举例子---要好好看--静下心来才能学地透彻

 1.做出了带权邻接矩阵的图

2.初始化       map集合分为两部分，s={1},V-S={2,3,4,5}, 对于集合V-S中所有顶点x 初始化最短距离数组dist[i]=map[1][i] ,初始化第一个点 dist[i]=map[1][j],dist[u]=0,接下来谁根源点1相连，就将谁p[i]=1; 否则就设为-1表示没有相连

3.找最小，很轻易的我们在dist[]中找到了2这个顶点dist[]最小

4.加入战队
将t=2，加入集合S中，那么久一个减去V-S中的2，因为已经选过了
那么V-S={3,4,5}

5.走捷径。刚才我们找到了源点t=2的最短路径，可以借助这条路径继续走下去
那么我们就沿着最短路径走到了t=2位置处，那么此刻2的邻接点是3和4.
先看看能否走捷径：dist[2]+map[2][3]=2+2=4;dist[]表示当前节点与源点的距离
当前dist[3]=5>dist[2]+map[2][3],所以借助捷径走的路径更短，可以走捷径
    再看看4号能不能走捷径，dist[2]+map[2][4]=2+6=8 ,而当前dist[4]=无穷
这个map相当于两点之间的距离，dist相当于与源点之间的连线距离
因此也可以走4.那么记录一下4的前驱为顶点2,p[4]=2;

 更新过后应该是这样

6.找最小
在集合V-S={3,4,5}中，按照贪心策略寻找dist[]最小的顶点t，依照贪心策略寻找V-S集合中
dist[]最小的顶点t，找到最小值为4，结点t为3

7.加入S战队
将t=3加入集合S中，S={1,2,3},同时更新V-S={4,5}

8.还是走捷径，发现我们每选完一次就要去跟着之前的最短路径比一下
那么对结点4来说它的dist是上一次我们所选出的dist[4]=8
如果我们现在试着走3到4这条路，那么dist[3]+map[3][4]=4+7=11>原来的值
那么这条路更长，我们不选。
那么我们看看5能不能借3走，一看就是可以的，因为5跟1不直接连，因此它的dist[5]应该是无穷。并且我们之前从未走到过5，所以它的dist[5]还是无穷，
不过现在有了3，我们先走最短路径到3，然后从3走到5就会更新dist[5]，那么这个新的dist[5]=最短路径dist[3]+（3->5）(也就是map[3][5])=4+1=5；
记录一下5的前驱等于3 .p[5]=3

9.走完捷径后，要找最小t
此时t=5

10.加入战队
还剩最后一个节点，

11.走捷径，走不了，5没有了

12.找最小，最小8，t=4

13.加入战队。此时S={1,2,3,5,4}
V-S={},算法结束
那么我们最后用上前驱表示从1-5走路最短路径
p[5]=
1-2-3-5

终于写完了