假设图G采用邻接矩阵存储，设计算法判断u到v之间是否存在路径

【问题描述】假设图G采用邻接矩阵存储，设计算法判断u到v之间是否存在路径。
【输入形式】输入表示图的二维数组  u 和 v 的值
【输出形式】输出判断结果，有路径输出1，没有路径输出0
【样例输入】

0 1 1

1 0 1

1 1 0

0 2
【样例输出】

1
【样例说明】
【评分标准】

#include
using namespace std;
int visited[100];
struct queue
{
    int no;//顶点编号 
    int parent;//前一个顶点的编号 
};
template  
struct arcnode//边结点类型 
{
    int adjvex;//该边的终点编号 
    arcnode*nextarc;// 指向下一条边的指针 
    T weight;//该边的权值 
};
template  
struct vnode//表头结点类型 
{
    char data[100];//顶点信息 
    arcnode*firstarc;//指向第一条边的结点 
};
template  
struct algraph//图的邻接表 
{
    vnode adjlist[100];//邻接表数组 
    int n,e;//顶点和边 
};
template  
class graphclass
{
    algraph* G;
public:
    graphclass();
    ~graphclass();
    bool HasPath(int u,int v);
    void creategraph(T a[][3],int n,int e);
   
private:
    void destroygraph();
    void HasPath1(int u,int v,bool &has);
};
template  
graphclass::graphclass()
{
    G=NULL;
}
template  
graphclass::~graphclass()
{
    if(G!=NULL)
    destroygraph();
}
 template
 void graphclass::creategraph(T a[][3],int n,int e)
 {
     int i,j;
    arcnode*p;
     G=new algraph();
     G->n=n;G->e=e;
     for(i=0;in;i++)
     for(j=G->n-1;j>=0;j--)
     if(a[i][j]!=0&&a[i][j]!=10000)
     {
         p=new arcnode();
         p->adjvex=j;p->weight=a[i][j];
         p->nextarc=G->adjlist[i].firstarc;
             G->adjlist[i].firstarc=p;
     }
 }
template  
void graphclass::destroygraph()
{
    int i;
    arcnode*pre,*p;
    for(i=0;in;i++)
    {
        pre=G->adjlist[i].firstarc;
        if(pre!=NULL)
        {
            p=pre->nextarc;
            while(p!=NULL)
            {
                delete pre;
                pre=p;
                p=p->nextarc;
            }
            delete pre;
        }
    }
    delete G;
}
template
bool graphclass::HasPath(int u,int v)
{
    int i;
    bool has=false;
    for(i=0;in;i++)
    visited[i]=0;
    HasPath1(u,v,has);
    return has;
}
template
void graphclass::HasPath1(int u,int v,bool &has)
{
    arcnode*p;int w;
    visited[u]=1;
    p=G->adjlist[u].firstarc;
    while(p!=NULL)
    {
        w=p->adjvex;
        if(w==v)
        {
            has=true;
            return;
        }
        if(visited[w]==0) HasPath1(w,v,has);
        p=p->nextarc;
    }
}
int main()
{int a[3][3],k=0;
graphclass m;
for(int i=0;i<3;i++)
   for(int j=0;j<3;j++)
      {
          cin>>a[i][j];
          if(a[i][j]==1) k++;
      }
m.creategraph(a,3,k);
int u,v;
cin>>u>>v;
if(m.HasPath(u,v)) cout<<"1";
else cout<<"0";
    return 0;
}