Kruskal最小生成树

#include<iostream>
#include<algorithm>

using namespace std;

#define MAX 101

struct stuEdge
{
int nFrom;
int nCost;
int nTo;
};

int nInput(stuEdge stuArr[],int nN);
void vSort(int nEdge,stuEdge stuArr[]);
bool bCmp(const stuEdge &stuA,const stuEdge &stuB);
void vMem(int nArr[],int nN);
int nKruskal(int nArr[],stuEdge stuArr[],int nN);
void vCombine(int nN,int nArr[],int nFrom,int nTo);
void vOutput(int nOut);

int main()
{
int nNum;
int nEdgeNum;
int nSet[MAX];
int nAns;
stuEdge stuEdgeArr[MAX*(MAX-1)/2+1];

while(1==scanf("%d",&nNum))
{
nEdgeNum=nInput(stuEdgeArr,nNum);
vSort(nEdgeNum,stuEdgeArr);
vMem(nSet,nNum);
nAns=nKruskal(nSet,stuEdgeArr,nNum);
vOutput(nAns);
}

return 0;
}

int nInput(stuEdge stuArr[],int nN)
{
int i,j;
int nCount;
int nTemp;

nCount=0;
for(i=1;i<=nN;i++)
{
for(j=1;j<=nN;j++)
{
scanf("%d",&nTemp);
if(i<j)
{
nCount++;
stuArr[nCount].nCost=nTemp;
stuArr[nCount].nFrom=i;
stuArr[nCount].nTo=j;
}
}
}
return nCount;
}

void vSort(int nEdge,stuEdge stuArr[])
{
sort(&stuArr[1],&stuArr[nEdge+1],bCmp);

}

bool bCmp(const stuEdge &stuA,const stuEdge &stuB)
{
return (stuA.nCost<stuB.nCost);
}

void vMem(int nArr[],int nN)
{
int i;

for(i=1;i<=nN;i++)
{
nArr[i]=i;
}
}

int nKruskal(int nArr[],stuEdge stuArr[],int nN)
{
int nRet;
int nCount;
int nEdgeInd;
int nF,nT;

nRet=0;
nCount=nN;
nEdgeInd=1;
while(nCount>1)
{
nF=nArr[stuArr[nEdgeInd].nFrom];
nT=nArr[stuArr[nEdgeInd].nTo];

if(nF!=nT)
{
nRet+=stuArr[nEdgeInd].nCost;
nCount--;
vCombine(nN,nArr,nF,nT);
}
nEdgeInd++;
}

return nRet;
}

void vOutput(int nOut)
{
printf("%d\n",nOut);
}

void vCombine(int nN,int nArr[],int nFrom,int nTo)
{
int i;

for(i=1;i<=nN;i++)
{
if(nArr[i]==nTo)
{
nArr[i]=nFrom;
}
}
}