bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<vector<int>> vertex(numCourses, vector<int>());
vector<int> indegree(numCourses, 0);
queue<int> q;
for(int i = 0; i < prerequisites.size(); i++) {
vertex[prerequisites[i].first].push_back(prerequisites[i].second);
indegree[prerequisites[i].second]++;
}
for(int i = 0; i < numCourses; i++) {
if(indegree[i] == 0) {
q.push(i);
}
}
int num = 0;
while(!q.empty()) {
vector<int> next = vertex[q.front()];
q.pop();
for(int i = 0; i < next.size(); i++) {
if(--indegree[next[i]] == 0) {
q.push(next[i]);
}
}
num++;
}
return num == numCourses;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<unordered_set<int>> pre(numCourses, unordered_set<int>());
vector<int> indegree(numCourses, 0);
for (pair<int, int> &p : prerequisites) {
if (pre[p.second].find(p.first) == pre[p.second].end()) {
pre[p.second].insert(p.first);
indegree[p.first]++;
}
}
stack<int> zeroes;
for (int i = 0; i < indegree.size(); i++) {
if (indegree[i] == 0) {
zeroes.push(i);
}
}
vector<int> res;
while (!zeroes.empty()) {
int course = zeroes.top();
zeroes.pop();
for (int i : pre[course]) {
if (--indegree[i] == 0) {
zeroes.push(i);
}
}
res.push_back(course);
}
for (int ind : indegree) {
if (ind > 0) { return vector<int>(); }
}
return res;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<int> res(numCourses);
vector<vector<int> > graph(numCourses, vector<int>());
vector<int> indegree(numCourses);
for(auto i : prerequisites){
graph[i.second].push_back(i.first);
++indegree[i.first];
}
queue<int> q;
for(int i = 0; i < numCourses; ++i)
if(indegree[i] == 0)
q.push(i);
int idx = 0, visitCnt = 0;
while(!q.empty()){
int cur = q.front();
res[idx++] = cur;
q.pop();
++visitCnt;
for(int i = 0; i < graph[cur].size(); ++i){
int next = graph[cur][i];
--indegree[next];
if(indegree[next] == 0)
q.push(next);
}
}
return visitCnt == numCourses ? res : vector<int>();
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
if(numCourses <= 0) return {};
vector<unordered_set<int>> graph(numCourses);
for(auto pre: prerequisites){
graph[pre.second].insert(pre.first);
}
vector<int> indegree(numCourses);
for(auto ngb: graph){
for(int node: ngb){
++indegree[node]; //mark incoming edges;
}
}
queue<int> noPre;
for(int i = 0; i < numCourses; ++i){
if(!indegree[i])
noPre.push(i);
}
vector<int> order;
for(int i = 0; i < numCourses; ++i){
if(noPre.empty()) return {}; // a cycle exists
int v = noPre.front();
noPre.pop();
order.push_back(v);
for(int u: graph[v]){
if(!--indegree[u]){
noPre.push(u);
}
}
}
return order;
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
if (numCourses <= 0) return true;
int n = numCourses;
vector<int> indegree(n, 0);
vector<vector<int>> edge(n);
for (auto& p : prerequisites) {
edge[p.second].push_back(p.first);
indegree[p.first]++;
}
stack<int> stk;
for (int i = 0; i < n; i++) {
if (indegree[i] == 0) {
stk.push(i);
}
}
int count = 0;
while (!stk.empty()) {
int node = stk.top();
stk.pop();
count++;
for (int x : edge[node]) {
if (--indegree[x] == 0) {
stk.push(x);
}
}
}
return count == n;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<int> order;
vector<int> indegree(numCourses, 0);
queue<int> que;
int len = prerequisites.size();
for(int i=0; i<len; i++)
{
int num = prerequisites[i].first;
indegree[num]++;
}
int count =0;
for(int i=0; i<numCourses; i++)
{
if(indegree[i] ==0)
que.push(i);
}
while(!que.empty())
{
int num = que.front();
order.push_back(num);
que.pop();
count++;
for(int i=0; i<len; i++)
{
if(prerequisites[i].second == num)
{
int next = prerequisites[i].first;
indegree[next]--;
if(indegree[next] == 0)
que.push(next);
}
}
}
if(count == numCourses)
return order;
else
{
vector<int> empty;
return empty;
}
}
main()
{
int i, j = 0, k;
int topsort[ MAX ], indeg[ MAX ];
create_graph();
printf( "The adjacency matrix is :\n" );
display();
/*Find the indegree of each node*/
for ( i = 1;i <= n;i++ )
{
indeg[ i ] = indegree( i );
if ( indeg[ i ] == 0 )
insert_queue( i );
}
while ( front <= rear ) /*Loop till queue is not empty */
{
k = delete_queue();
topsort[ j++ ] = k; /*Add node k to topsort array*/
/*Delete all edges going fron node k */
for ( i = 1;i <= n;i++ )
{
if ( adj[ k ][ i ] == 1 )
{
adj[ k ][ i ] = 0;
indeg[ i ] = indeg[ i ] – 1;
if ( indeg[ i ] == 0 )
insert_queue( i );
}
} /*End of for*/
} /*End of while*/
printf( "Nodes after topological sorting are :\n" );
for ( i = 0;i < j;i++ )
printf( "%d ", topsort[ i ] );
printf( "\n" );
} /*End of main()*/
vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
vector<int> res;
if(!n)
return res;
vector<int> indegree(n, 0);
remain.assign(n, true);
for(int i=0; i<n-1; i++)
{
indegree[edges[i].first] ++;
indegree[edges[i].second] ++;
}
int count =0;
while(count< n -2)
{
vector<int> leaves;
for(int i=0; i<n; i++)
if(indegree[i] ==1)
{
indegree[i] --;
remain[i] = false;
leaves.push_back(i);
}
count+= leaves.size();
for(int i=0; i<leaves.size(); i++)
{
int leaf = leaves[i];
for(int j=0; j<n-1; j++)
{
if(edges[j].first == leaf)
indegree[edges[j].second]--;
if(edges[j].second == leaf)
indegree[edges[j].first]--;
}
}
}
for(int i=0; i<n; i++)
if(remain[i])
res.push_back(i);
return res;
}
main()
{
int i,v,count,topo_order[MAX],indeg[MAX];
create_graph();
/*Find the indegree of each vertex*/
for(i=0;i<n;i++)
{
indeg[i] = indegree(i);
if( indeg[i] == 0 )
insert_queue(i);
}
count = 0;
while( !isEmpty_queue( ) && count < n )
{
v = delete_queue();
topo_order[++count] = v; /*Add vertex v to topo_order array*/
/*Delete all edges going fron vertex v */
for(i=0; i<n; i++)
{
if(adj[v][i] == 1)
{
adj[v][i] = 0;
indeg[i] = indeg[i]-1;
if(indeg[i] == 0)
insert_queue(i);
}
}
}
if( count < n )
{
printf("No topological ordering possible, graph contains cycle\n");
exit(1);
}
printf("Vertices in topological order are :\n");
for(i=1; i<=count; i++)
printf( "%d ",topo_order[i] );
printf("\n");
}/*End of main()*/
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
if(numCourses<2)
return true;
vector<int> indegree(numCourses, 0);
queue<int> que;
int len = prerequisites.size();
for(int i=0; i<len; i++)
{
int num = prerequisites[i].first;
indegree[num]++;
}
int count =0;
for(int i=0; i<numCourses; i++)
{
if(indegree[i] ==0)
que.push(i);
}
while(!que.empty())
{
int num = que.front();
que.pop();
count++;
for(int i=0; i<len; i++)
{
if(prerequisites[i].second == num)
{
int next = prerequisites[i].first;
indegree[next]--;
if(indegree[next] == 0)
que.push(next);
}
}
}
return count == numCourses;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<unordered_set<int>> graph(numCourses);
for(auto p : prerequisites)
graph[p.second].insert(p.first);
vector<int> indegree(numCourses);
for(auto p : graph)
for(int node : p)
indegree[node]++;
queue<int> zeros;
for(int i = 0; i < numCourses; i++)
if(!indegree[i]) zeros.push(i);
vector<int> res;
for(int i = 0; i < numCourses; i++){
if(zeros.empty()) return {};
int j = zeros.front();
zeros.pop();
for(int node : graph[j])
if(!--indegree[node]) zeros.push(node);
res.push_back(j);
}
return res;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<int> result;
vector< unordered_set<int> > graph(numCourses, unordered_set<int>());
vector<int> indegree(numCourses,0);
for(int i =0 ; i < prerequisites.size(); ++i){
if(graph[prerequisites[i].second].find(prerequisites[i].first) == graph[prerequisites[i].second].end()){
++indegree[prerequisites[i].first];
}
graph[prerequisites[i].second].insert(prerequisites[i].first);
}
queue<int> beingVisit;
for(int i = 0; i < numCourses; ++i){
if(indegree[i] == 0)
beingVisit.push(i);
}
while(!beingVisit.empty()){
int vertex = beingVisit.front();
beingVisit.pop();
result.push_back(vertex);
for(auto it = graph[vertex].begin(); it != graph[vertex].end(); ++it){
--indegree[*it];
if(indegree[*it] == 0){
beingVisit.push(*it);
}
}
}
if(result.size() != numCourses){
return {};
}
return result;
}
//BFS solution
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
if(numCourses <= 0) return false;
vector<unordered_set<int> > forward_map(numCourses);
vector<int> indegree(numCourses,0);
for(int i = 0; i < prerequisites.size(); ++i) {
forward_map[prerequisites[i].second].insert(prerequisites[i].first);
}
for(int i = 0; i < forward_map.size(); ++i) {
for(auto it:forward_map[i]) {
++indegree[it];
}
}
for(int i = 0; i < numCourses; ++i) {
int k;
for(k = 0; k < numCourses && indegree[k] != 0; ++k);
if(k == numCourses) return false;
indegree[k] = -1;
for(auto it:forward_map[k]) {
--indegree[it];
}
}
return true;
}
vector<int> findOrder(int numCourses, vector<pair<int,int>> &prerequisites) {
vector<int> res;
if (numCourse == 0)
return res;
vector<int> indegree(numCourses, 0);
unordered_map<int, vector<int>> edge;
for(const auto &a_b : prerequisites) {
indegree[a_b.first]++;
edge[a_b.second].push_back(a_b.first);
}
queue<int> que;
for(int i=0; i<numCourses; ++i) {
if (indegree[i] == 0) {
que.push(i);
}
}
int cnt = 0;
while (!que.empty()) {
int course = que.front();
que.pop();
res.push_back(course);
for(const auto &node : edge[course]) {
if (--indegree[node] == 0) {
que.push(node);
}
}
if (++cnt == numCourses)
break;
}
if (cnt == numCourses && que.empty())
return res;
else
return vector<int>{};
}
static void
validate(graph_t * g)
{
node_t *n;
edge_t *e;
int i, cnt;
cnt = 0;
for (n = GD_nlist(g);n; n = ND_next(n)) {
assert(outdegree(g,n) == ND_out(n).size);
for (i = 0; (e = ND_out(n).list[i]); i++) {
assert(agtail(e) == n);
assert( e == agfindedge(g, n, aghead(e)));
}
assert(indegree(g,n) == ND_in(n).size);
for (i = 0; (e = ND_in(n).list[i]); i++) {
assert(aghead(e) == n);
assert( e == agfindedge(g, agtail(e), n));
}
cnt++;
}
assert (agnnodes(g) == cnt);
}
main()
{
int i,v;
int topo_order[MAX],indeg[MAX];
int count;
int j;
create_graph();
/*Find the indegree of each vertex*/
for(i=0; i<n; i++)
{
indeg[i] = indegree(i);
if( indeg[i] == 0 )
insert_queue(i);
}
for(j=0; j<n; j++)
printf("In(%d) = %d\t",j, indeg[j]);
printf("\n");
display_queue();
count = 0;
while( !isEmpty_queue() && count<n )
{
v = delete_queue();
printf("Delete %d and edges going from it\n",v);
topo_order[++count] = v; /*Add vertex v to topo_order array*/
/*Delete all edges going fron vertex v */
for(i=0; i<n; i++)
{
if(adj[v][i]==1)
{
adj[v][i] = 0;
indeg[i] = indeg[i]-1;
if(indeg[i] == 0)
{
printf("Now vertex %d has zero indegree so insert it in the queue\n",i);
insert_queue(i);
}
}
}
for(j=0; j<n; j++)
{
if(indeg[j]!=0)
printf("In(%d) = %d\t",j, indeg[j]);
}
printf("\n");
display_queue();
STOP;
}
printf("count = %d\n",count);
if( count < n )
{
printf("No topological ordering possible, graph contains cycle\n");
exit(1);
}
printf("Vertices in topological order are :\n");
for(i=1; i<=count; i++)
printf( "%d ",topo_order[i] );
printf("\n");
}/*End of main()*/
