Question is

Nom the Panda is back with another one of his peanut butter adventures! He$$s got a list of peanut butter treats to make, but they have to be done in a particular order. Some treats depend on others, which means Nom can$$t start a new treat until all its ingredients or prep steps are ready.

Nom$$s goal is to whip up all these treats as quickly as possible, grouping together as many treats as he can in each round of cooking, as long as none of them depend on each other. Every $$round$$ is a time slot where Nom can work on multiple treats that don$$t require waiting on any other treats.

Help Nom by figuring out two things:

A good order for preparing all his treats, making sure he follows the steps in the right order.

The minimum number of rounds Nom needs to finish everything by grouping treats that can be prepared together.

Can you help Nom complete his peanut butter extravaganza in record time?

Constraints:

$1$ N $10^5$: Number of peanut butter treats Nom wants to make.

$1$ N $10^5$: Number of dependencies between treats.

$$For each dependency pair $($a$,$b$),$ treat b depends on treat a$,$ meaning Nom can$$t start on treat b until he finishes treat a$.$

$$ Each treat is labeled from $1$ to N$.$

Input $($from a$.$txt$)$:

$$ The first line contains two integers N and M: the number of treats Nom wants to make and the number of dependencies between them.

$$ The next M lines each contain two integers a and b$,$ representing a dependency where treat b depends on treat a$.$

Output $($to b$.$txt$)$:

$$ Print a single integer x$,$ the minimum number of rounds Nom needs to complete all his treats

$$ Follow this with x lines, where each line represents a round. Each line contains the treat numbers $($in ascending order$)$ that Nom can prepare in that round.

Sample Case $1$:

Input $($a$.$txt$)$:

$44$

$12$

$13$

$23$

$34$

Output $($b$.$txt$)$:

$4$

$1$

$2$

$3$

$4$

Sample Case $2$:

Input $($a$.$txt$)$:

$1012$

$12$

$13$

$24$

$34$

$45$

$36$

$57$

$68$

$78$

$89$

$210$

$109$

Output $($b$.$txt$)$:

$6$

$1$

$23$

$4610$

$5$

$78$

$9$

so i have written code in c language for the above question i took of chatgpt and used my logic to write the code so go through the code make it humanize it with same logic so here is the c language code

#include

#include

#define MAX $1000$

$//$ Function to calculate the sum of dependency pairs $($not used in main$)$

int sumConstraintNomPb$($int dependencies$[][2],$ int M$)\{$

int sum $=0$;

for $($int i $=0$; i $<$ M; i$++)\{$

sum $+=$ dependencies$[$i$][0]+$ dependencies$[$i$][1]$;

$\}$

return sum;

$\}$

$//$ Comparison function for qsort to sort integers in ascending order

int compare$($const void $*$a$,$ const void $*$b$)\{$

return $(*($int $*)$a $-*($int $*)$b$)$;

$\}$

$//$ Topological Sort to determine order and group into rounds

void topologicalSort$($int N$,$ int adj$[$MAX$][$MAX$],$ int inDegree$[$MAX$],$ FILE $*$outputFile$)\{$

int queue$[$MAX$],$ front $=0,$ rear $=0$;

int rounds $=0$;

for $($int i $=1$; i $<=$ N; i$++)\{$

if $($inDegree$[$i$]==0)\{$

queue$[$rear$++]=$ i;

$\}$

$\}$

while $($front $<$ rear$)\{$

int roundSize $=$ rear $-$ front;

int temp$[$MAX$],$ tempSize $=0$;

rounds$++$;

for $($int i $=0$; i $<$ roundSize; i$++)\{$

int curr $=$ queue$[$front$++]$;

temp$[$tempSize$++]=$ curr;

for $($int j $=1$; j $<=$ N; j$++)\{$

if $($adj$[$curr$][$j$])\{$

inDegree$[$j$]--$;

if $($inDegree$[$j$]==0)\{$

queue$[$rear$++]=$ j;

$\}$

$\}$

$\}$

$\}$

$//$ Sort and output treats in this round

qsort$($temp$,$ tempSize, sizeof$($int$),$ compare$)$;

for $($int i $=0$; i $<$ tempSize; i$++)\{$

fprintf$($outputFile$,"\%$d $",$ temp$[$i$])$;

$\}$

fprintf$($outputFile$,"$

$")$;

$\}$

$//$ Write number of rounds at the top of the output

fseek$($outputFile$,0,$ SEEK$\_$SET$)$;

fprintf$($outputFile$,"\%$d

$",$ rounds$)$;

$\}$

int main$()\{$

FILE $*$inputFile $=$ fopen$("$a$.$txt$","$r$")$;

FILE $*$outputFile $=$ fopen$("$b$.$txt$","$w$+")$;

if $(!$inputFile $||!$outputFile$)\{$

printf$("$Error opening file.

$")$;

return $1$;

$\}$

int N$,$ M;

fscanf$($inputFile$,"\%$d $\%$d$",$ &N$,$ &M$)$;

int adj$[$MAX$][$MAX$]=\{0\}$;

int inDegree$[$MAX$]=\{0\}$;

int dependencies$[$M$][2]$;

for $($int i $=0$; i $<$ M; i$++)\{$

int a$,$ b;

fscanf$($inputFile$,"\%$d $\%$d$",$ &a$,$ &b$)$;

adj$[$a$][$b$]=1$;

inDegree$[$b$]++$;

dependencies$[$i$][0]=$ a;

dependencies$[$i$][1]=$ b;

$\}$

fprintf$($outputFile$,"0$

$")$; $//$ Placeholder for number of rounds

topologicalSort$($N$,$ adj, inDegree, outputFile$)$;

fclose$($inputFile$)$;

fclose$($outputFile$)$;

return $0$;

$\}$