【拓扑排序】【 图论】1203. 项目管理

最新推荐文章于 2024-04-29 20:33:27 发布
最新推荐文章于 2024-04-29 20:33:27 发布
阅读量807 收藏 17
点赞数 15
分类专栏： # 困难算法题 文章标签： 图论 算法 leetcode c++ 拓扑排序 组 项目管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/136904872
版权

本文涉及知识点

拓扑排序 图论

LeetCode1203. 项目管理

有 n 个项目，每个项目或者不属于任何小组，或者属于 m 个小组之一。group[i] 表示第 i 个项目所属的小组，如果第 i 个项目不属于任何小组，则 group[i] 等于 -1。项目和小组都是从零开始编号的。可能存在小组不负责任何项目，即没有任何项目属于这个小组。
请你帮忙按要求安排这些项目的进度，并返回排序后的项目列表：
同一小组的项目，排序后在列表中彼此相邻。
项目之间存在一定的依赖关系，我们用一个列表 beforeItems 来表示，其中 beforeItems[i] 表示在进行第 i 个项目前（位于第 i 个项目左侧）应该完成的所有项目。
如果存在多个解决方案，只需要返回其中任意一个即可。如果没有合适的解决方案，就请返回一个 空列表 。
示例 1：
输入：n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3,6],[],[],[]]
在这里插入图片描述

输出：[6,3,4,1,5,2,0,7]
示例 2：

输入：n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3],[],[4],[]]
输出：[]
解释：与示例 1 大致相同，但是在排序后的列表中，4 必须放在 6 的前面。

提示：

1 <= m <= n <= 3 * 104
group.length == beforeItems.length == n
-1 <= group[i] <= m - 1
0 <= beforeItems[i].length <= n - 1
0 <= beforeItems[i][j] <= n - 1
i != beforeItems[i][j]
beforeItems[i] 不含重复元素

拓扑排序

同一小组的项目，排序后在列表中彼此相邻。 → \rightarrow → Ａ小组的某项目依赖B小组的某项目，则B小组全部完成后，才能处理A小组的项目。
最容易想到的办法，先对项目组拓扑排序，再对组内项目拓扑排序。这样内存超了。时间也很可能超。错误代码如下：

class CTopSort
{
public:
void Init(const vector<vector>& vNeiBo)
{
m_c = vNeiBo.size();
m_vBackNeiBo.resize(m_c);
vector vOutDeg(m_c);
for (int cur = 0; cur < m_c; cur++)
{
vOutDeg[cur] = vNeiBo[cur].size();
for (const auto& next : vNeiBo[cur])
{
m_vBackNeiBo[next].emplace_back(cur);
}
}
queue que;
for (int i = 0; i < m_c; i++)
{
if (0 == vOutDeg[i])
{
que.emplace(i);
m_vLeaf.emplace_back(i);
OnDo(-1, i);
}
}
while (que.size())
{
const int cur = que.front();
que.pop();
for (const auto& next : m_vBackNeiBo[cur])
{
vOutDeg[next]–;
if (0 == vOutDeg[next])
{
que.emplace(next);
OnDo(cur, next);
}
}
};
}
int m_c;
vector m_vLeaf;
protected:
virtual void OnDo(int pre, int cur) = 0;
vector<vector> m_vBackNeiBo;
};

class CMyTopSort : public CTopSort
{
public:
vector m_vTopSort;
protected:
virtual void OnDo(int pre, int cur) override
{
m_vTopSort.emplace_back(cur);
}
};
class Solution {
public:
vector sortItems(int n, int m, vector& group, vector<vector>& beforeItems) {
int iMaxGroup = *std::max_element(group.begin(), group.end());
for (auto& n : group)
{
if (-1 == n)
{
n = ++iMaxGroup;
}
}
vector<vector> vNeiBo(1 + iMaxGroup);
vector<vector<vector>> vItemNeiBo(1 + iMaxGroup, vector<vector>(n));
for (int i = 0; i < beforeItems.size(); i++)
{
for (const auto& bef : beforeItems[i])
{
if (group[i] != group[bef]) {
vNeiBo[group[i]].emplace_back(group[bef]);
}
else {
vItemNeiBo[group[i]][i].emplace_back(bef);
}
}
}
for (auto& v : vNeiBo)
{
unordered_set tmp(v.begin(), v.end());
vector(tmp.begin(), tmp.end()).swap(v);
}
CMyTopSort top;
top.Init(vNeiBo);
vector<vector> vNodeOfGroup(iMaxGroup + 1);
for (int i = 0; i < group.size(); i++)
{
vNodeOfGroup[group[i]].emplace_back(i);
}
vector vRet;
for (const auto& iGroup : top.m_vTopSort)
{
CMyTopSort topItem;
topItem.Init(vItemNeiBo[iGroup]);
for (const auto& n : topItem.m_vTopSort)
{
if (group[n] == iGroup)
{
vRet.emplace_back(n);
}
}
}
return (vRet.size() == group.size()) ? vRet : vector{};
}
};

改进方法

一，修改拓扑排序封装类，使得支持哈希映射，这样可以处理非连续节点。
二，修改拓扑封装类，项目和项目组出度同时为0，才进行拓扑排序。
有一个简单的方法，不用修改拓扑类。
每个项目组增加两个虚拟节点，组前节点，组内所有项目都依赖它；组后节点，它依赖所有组内项目。
A组依赖Ｂ组，则Ａ组的组前节点A1，依赖B组的组后节点B2。
下图展示了A组包括两个节点{0,1},B组也包括两个节点{2,3}。
在这里插入图片描述
2,3 处理完才会处理B2,B2处理完，才会处理A1。A1处理完才会处理0和1。

细节很多

组号为-1的项目要重复分配新的组号，避免把-1的项目看成同一项目组。
邻接点不能有重复节点。
这样并不能保证同一个项目组挨在一起。
m_vNodeOfGroup 记录各项目组的拓扑序。m_vGroupNo记录拓扑序各节点的项目组号。按m_vGroupNo的顺序将结果复制到vRet。m_vGroupNo可以用哈希集合去重，也可以复制完就删除。

代码

class CTopSort
{
public:	
	void Init(const vector<vector<int>>& vNeiBo)
	{
		m_c = vNeiBo.size();
		m_vBackNeiBo.resize(m_c);
		vector<int> vOutDeg(m_c);
		for (int cur = 0; cur < m_c; cur++)
		{
			vOutDeg[cur] = vNeiBo[cur].size();	
			for (const auto& next : vNeiBo[cur])
			{
				m_vBackNeiBo[next].emplace_back(cur);
			}
		}
		queue<int> que;
		for (int i = 0; i < m_c; i++)
		{
			if (0 == vOutDeg[i])
			{
				que.emplace(i);
				m_vLeaf.emplace_back(i);
				OnDo(-1, i);
			}
		}

		while (que.size())
		{
			const int cur = que.front();
			que.pop();
			for (const auto& next : m_vBackNeiBo[cur])
			{
				vOutDeg[next]--;
				if (0 == vOutDeg[next])
				{
					que.emplace(next);
					OnDo(cur, next);
				}
			}
		};
	}
	int m_c;
	vector<int> m_vLeaf;
protected:
	virtual void OnDo(int pre, int cur) = 0;
	vector<vector<int>> m_vBackNeiBo;
};

class CMyTopSort : public CTopSort
{
public:
	CMyTopSort(const vector<int>& vNodeToGroup,int iGroupCount):m_vNodeToGroup(vNodeToGroup)
	{
		m_vNodeOfGroup.resize(iGroupCount);
	}
	vector<vector<int>> m_vNodeOfGroup;
	vector<int> m_vGroupNo;
protected:
	virtual void OnDo(int pre, int cur) override
	{
		if (cur < m_vNodeToGroup.size())
		{
			const int iGroup = m_vNodeToGroup[cur];
			m_vNodeOfGroup[iGroup].emplace_back(cur);
			m_vGroupNo.emplace_back(iGroup);
		}		
	}
	const vector<int>& m_vNodeToGroup;
};
class Solution {
public:
	vector<int> sortItems(int n, int m, vector<int>& group, vector<vector<int>>& beforeItems) {
		int iMaxGroup = *std::max_element(group.begin(), group.end());
		for (auto& tmp : group)
		{
			if (-1 == tmp)
			{
				tmp = ++iMaxGroup;
			}
		}
		vector<vector<int>> vNodeOfGroup(iMaxGroup + 1);
		for (int i = 0; i < group.size(); i++)
		{
			vNodeOfGroup[group[i]].emplace_back(i);
		}
		vector<vector<int>> vNeiBo((1 + iMaxGroup)*2+n );
		for (int i = 0; i < vNodeOfGroup.size(); i++)
		{
			for (const auto& tmp : vNodeOfGroup[i])
			{
				vNeiBo[tmp].emplace_back(n + 2 * i);//组内所有节点都依赖组前节点
				vNeiBo[n + 2 * i + 1].emplace_back(tmp);//组后节点依赖所有组内节点
			}
		}	
		for (int i = 0; i < beforeItems.size(); i++)
		{
			for (const auto& bef : beforeItems[i])
			{
				if (group[i] == group[bef]) {
					vNeiBo[i].emplace_back(bef);
				}	
				else {
					vNeiBo[n + 2 * group[i]].emplace_back(n + 2 * group[bef] + 1);
				}
			}
		}
		for (auto& v : vNeiBo)
		{//删除重复节点
			unordered_set<int> tmp(v.begin(), v.end());
			vector<int>(tmp.begin(), tmp.end()).swap(v);
		}		
		CMyTopSort top(group,iMaxGroup+1);
		top.Init(vNeiBo);		
		vector<int> vRet;
		for (const auto& tmp : top.m_vGroupNo)
		{
			auto& v = top.m_vNodeOfGroup[tmp];
			vRet.insert(vRet.end(), v.begin(), v.end());
			v.clear();
		}
		return (vRet.size() == group.size()) ? vRet : vector<int>{};
	}
};

测试用例

template<class T, class T2>
void Assert(const T& t1, const T2& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}

}

int main()
{
	int n,  m;
	vector<int> group;
	vector<vector<int>> beforeItems;
	{
		Solution sln;
		n = 8, m = 2, group = { -1,-1,1,0,0,1,0,-1 }, beforeItems = { {},{6},{5},{6},{3},{},{4},{} };
		auto res = sln.sortItems(n, m, group, beforeItems);
		Assert({ }, res);
	}
	{
		Solution sln;
		n = 8, m = 2, group = { -1,-1,1,0,0,1,0,-1 }, beforeItems = { {},{6},{5},{6},{3,6},{},{},{} };
		auto res = sln.sortItems(n, m, group, beforeItems);
	//	Assert({ 6,3,4,1,5,2,0,7 }, res);
	}	
}

2023年4月

class Solution {
public:
vector sortItems(int n, int m, vector& group, vector<vector>& beforeItems) {
//没有分组的分配一个新组号
m_vGroupItems.resize(m );
for (int j = 0; j < n;j++ )
{
auto& g = group[j];
if (-1 == g)
{
g = m_vGroupItems.size();
m_vGroupItems.emplace_back();
}
m_vGroupItems[g].emplace_back(j);
}
const int GroupNum = m_vGroupItems.size();
vector<set> vGroupBefore(GroupNum), vGroupAfter(GroupNum);
for (int j = 0; j < n; j++)
{
const auto& v = beforeItems[j];
for (const auto& before : v)
{
const int iGroup = group[j];
const int iBeforeGroup = group[before];
if (iGroup == iBeforeGroup)
{
continue;
}
vGroupBefore[iGroup].emplace(iBeforeGroup);
vGroupAfter[iBeforeGroup].emplace(iGroup);
}
}
auto vGroups = Order(vGroupBefore, vGroupAfter);
if (vGroups.size() != m_vGroupItems.size())
{
return vector();
}
vector vRet;
for (const auto& iCurGroup : vGroups)
{
const auto& vItemsCurGroup = m_vGroupItems[iCurGroup];
const int iCurGroupItemSize = vItemsCurGroup.size();
std::unordered_map<int, int> mIndexToGroupIndex;
for (const int& item : vItemsCurGroup)
{
mIndexToGroupIndex[item] = mIndexToGroupIndex.size();
}
vector<set> vItemBefore(iCurGroupItemSize), vItemAfter(iCurGroupItemSize);
for (const int& item : vItemsCurGroup)
{
const int iCurItemIndex = mIndexToGroupIndex[item];
for (const int& before : beforeItems[item])
{
if (group[before] != iCurGroup)
{
continue;
}
const int iBeforeIndex = mIndexToGroupIndex[before];
vItemBefore[iCurItemIndex].emplace(iBeforeIndex);
vItemAfter[iBeforeIndex].emplace(iCurItemIndex);
}
}
vector vCurGroupItemOrder = Order(vItemBefore,vItemAfter);
if (iCurGroupItemSize != vCurGroupItemOrder.size())
{
return vector();
}
for (const int iCurGroupItem : vCurGroupItemOrder)
{
vRet.emplace_back(vItemsCurGroup[iCurGroupItem]);
}
//std::copy(vGroupItems[g].begin(), vGroupItems[g].end(), std::back_inserter(vRet));
}

	return vRet;
}
vector<int> Order(vector<set<int>>& vBefore, vector<set<int>>& vAfter)
{	
	vector<int> vOrders;
	for (int j = 0; j < vBefore.size(); j++)
	{
		if (vBefore[j].size() == 0)
		{
			vOrders.emplace_back(j);
		}
	}

	int hasDo = 0;
	while (hasDo < vOrders.size())
	{
		const auto cur = vOrders[hasDo];
		hasDo++;
		for (auto& after : vAfter[cur])
		{
			vBefore[after].erase(cur);
			if (vBefore[after].empty())
			{
				vOrders.emplace_back(after);
			}
		}
		vAfter[cur].clear();
	}
	return vOrders;
}
vector<vector<int>> m_vGroupItems;

};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关

下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

闻缺陷则喜何志丹
关注
  • 15
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
拓扑排序与关键路径.pptx
01-11
拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键路径.pptx拓扑排序与关键...
LeetCode 1203. 项目管理
Aries_young的博客
01-13 154
题目描述 1203. 项目管理 解法：双层拓扑排序 其实考虑到利用拓扑排序是很容易的，项目完成的先后顺序即是拓扑排序序列 但是这仅解决了项目之间的依赖关系，那么如何满足同一小组的项目在排序后彼此相邻呢？ 可以这么理解，每一时刻只有一个小组在工作，假设小组 0 先开始工作，有 3 个项目，那么小组 0 先完成这 3 个项目，之后小组 1 再开始完成其他的任务。于是，便可以想到第二层循环是哪里来的了，其实就是对小组之间的关系也进行一次拓扑排序 我们还是考虑示例 1， 第一步：完成项目和小组的对应关系 这里我
LeetCode - 1203. 项目管理
一只羊
01-12 101
描述 公司共有n个项目和 m个小组，每个项目要不无人接手，要不就由 m 个小组之一负责。 group[i] 表示第i个项目所属的小组，如果这个项目目前无人接手，那么group[i] 就等于-1。（项目和小组都是从零开始编号的）小组可能存在没有接手任何项目的情况。 请你帮忙按要求安排这些项目的进度，并返回排序后的项目列表： 同一小组的项目，排序后在列表中彼此相邻。 项目之间存在一定的依赖关系，我们用一个列表 beforeItems来表示，其中beforeItems[i]表示在进行...
每日一题——1203. 项目管理
weixin_42955230的博客
01-12 171
1203. 项目管理 分类：图、拓扑排序 这题不会，照着题解做的 一个组有一些任务，没有被发配组的任务假设由从m开始递增的唯一组接手（如果不存在没有被分配组的任务，那么这些组接手的任务数量为0，总保持组的数量与任务数量相等）。由于任务与任务存在前后依赖，且同一组的任务需要排在一起。所以通过任务之间的依赖关系形成组之间的依赖关系。 故，先对组进行拓扑排序，再依次对组所拥有的任务进行拓扑排序，即为结果 class Solution { public: vector<int> topSort
搜索与图论之拓扑排序
wat1r的博客
02-19 1200
搜索与图论之拓扑排序 207. 课程表 课程表三剑客之课程表I[Ladybird] 210. 课程表 II 课程表三剑客之课程表II[Dung Beetle] 269.火星字典 public String alienOrder(String[] words) { Map<Character, Set<Character>> g = new HashMap<>(); int[] indegree = new int[26];
拓扑排序_As.pptx
02-03
拓扑排序课件 ，解答较为详细，对于拓扑排序、图论、BFS/DFS有较为详细的理解，适合入门一段时间的ACMer和想自学编程，研究学习算法者。
数据结构拓扑排序课程设计.docx
07-11
拓扑排序的任务是在这个偏序上得到一个全序，即得到一个完成整个项目的各步骤的序列。 2．解决拓扑排序的方法如下： （1）在有向图中选一个没有前驱的顶点且输出之。 （2）从图中删除该顶点和所有以它为尾的弧。 ...
拓扑排序应用系统java.zip
11-02
拓扑排序拓扑排序应用系统java.zip拓扑排序应用系统java.zip拓扑排序应用系统java.zip
拓扑排序知识点.pptx
08-18
为了涂色，APM 需要使用一组刷子。每个刷子蘸了颜色 。APM 拿起一把蘸有颜色 的刷子，并给所有颜色为 的矩形涂色。请注意，涂色有顺序要求：为了避免颜料渗漏使颜色混合，一个矩形只能在所有紧靠它上方的矩形涂色后...
从递归角度串联二叉树-图论-动态规划
qwertyasdfghh的博客
04-26 423
先不管所谓前中后序，单看traverse函数，你说它在做什么事情？
【算法基础实验】图论-UnionFind连通性检测之quick-find
Greyplayground
04-26 1128
Union-Find 是解决连通性问题的一种非常高效的数据结构。它能够快速合并集合并快速判断元素之间的连通性。通过路径压缩和按秩合并的优化，Union-Find 在实际应用中可以接近常数时间完成操作。因此，它在算法竞赛、网络连接和社交网络分析等领域有广泛的应用。
c++图论基础(2)
2301_79249663的博客
04-26 228
当数据中0较多，比较占用内存空间，可以考虑用邻接表。每一行第一列表示的是最外层vector数组的下标。用来计算顶点的入度和出度,入度看行，出度看列。无向图的邻接矩阵是对称的，2是自环。
【算法基础实验】图论-UnionFind连通性检测之quick-union
Greyplayground
04-26 936
Union-Find 是解决连通性问题的一种非常高效的数据结构。它能够快速合并集合并快速判断元素之间的连通性。通过路径压缩和按秩合并的优化，Union-Find 在实际应用中可以接近常数时间完成操作。因此，它在算法竞赛、网络连接和社交网络分析等领域有广泛的应用。
图论单源最短路径——spfa
qq_44630195的博客
04-29 379
本题测试数据为随机数据，在考试中可能会出现构造数据让SPFA不通过，如有需要请移步。
【算法基础实验】图论-深度优先搜索和深度优先路径
Greyplayground
04-26 943
深度优先搜索是一个递归的过程，它尝试深入到每一个分支直到不能再深入为止，然后通过回溯继续探索其他分支。它的核心在于尝试所有可能的路径直到找到解决方案或覆盖所有的节点。DFS 的记忆点在于它的递归性质和回溯机制，这使得它非常适合处理需要探索所有可能性的问题。
【算法基础实验】图论-构建加权无向图
Greyplayground
04-27 700
在图论中，加权无向图是一种每条边都分配了一个权重或成本的图形结构。这种类型的图在许多实际应用中都非常有用，如路由算法、网络流量设计、最小生成树和最短路径问题等。加权无向图的研究和应用提供了一种强大的工具，可以解决实际中的许多优化和规划问题。在算法和数据结构的领域中，理解并有效使用这些工具是非常重要的。
【C++算法竞赛 · 图论】树
最新发布
黑洞极客的博客
04-29 267
这篇文章会介绍一种树。顾名思义，树是一种长得很像现实中的树的图，只是它是倒过来的。如图，这就是一棵十分普通的树。每一个数称为 节点 (node)。作为所有其他节点的“起源”的节点称为 根节点（root），也就是图中的 0。如果 u 是 v 的上一个节点（例如 1 和 4），那么 u 是 v 的父节点（parent node），v 是 u 的子节点（child node）。
算法刷题day46
weixin_60033897的博客
04-23 758
今天复习了一下高精度的所有模板，包括加法、减法、乘法、除法，因为自己当时在蓝桥杯的时候没有看出来那个题使用高精度，因为对于一个数的大小和一个数的长度，自己有时候搞不清楚概念，所以当时没看出来，一个数就算是 $long\ long$ 也只有 $18、19$ 那么长，所以得记住这个概念。然后就是树形 $DP$ 和状压 $DP$ 了，做了已经很多遍了，已经慢慢的理解了其深层含义，所以还是要先多做题然后才能明白其内涵，以后打算把基础课的题全部刷一遍，好好巩固基础，加油！
拓扑排序 逆拓扑排序
04-16
拓扑排序是种对有向无环图（DAG进行排序的算法。它将图中节点按照种特定的顺序进行排序，使得对于任意一条有向边 (u, v)，节点 u 在排序结果中都出现节点 v 的前面。 拓扑排序的实现方式如下： 1. 首先，找到图入度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值