UVA - 10959 The Party, Part I

这个题目，也不知道为啥，看到后就想是深搜，但是用邻接矩阵就愉快的超时了 ，然后就用前向星试了试，刚好卡时间过了。。。

#include<bits/stdc++.h>
#define maxn 10005
using namespace std;
struct node
{
    int to,next;
}edge[maxn];
int cnt=0,head[maxn],vis[maxn];
int ans,n,m;
void add(int u,int v)
{
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void dfs(int i,int sum)
{
    if(i==0)
    {
        ans=min(ans,sum);
        return ;
    }
    if(sum>=ans)
        return ;
    for(int j=head[i];j!=-1;j=edge[j].next)
    {
        if(!vis[edge[j].to])
        {
            vis[edge[j].to]=1;
            sum++;
            dfs(edge[j].to,sum);
            sum--;
            vis[edge[j].to]=0;
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            add(x,y);
            add(y,x);
        }
        for(int i=1;i<n;i++)
        {
            ans=n;
            dfs(i,0);
            printf("%d\n",ans);
        }
        if(t)
        printf("\n");
    }
}

后来挺他们说用广搜，然后写了下，果真省时间。

#include<bits/stdc++.h>
#define maxn 10005
using namespace std;
struct node
{
    int to,next;
}edge[maxn];
struct node1
{
    int id,step;
};
int cnt=0,head[maxn],vis[maxn];
int n,m;
void add(int u,int v)
{
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void bfs(int s)
{
    memset(vis,0,sizeof(vis));
    queue<node1>Q;
    node1 temp,tt;
    temp.id=s;  temp.step=0;
    Q.push(temp);
    while(!Q.empty())
    {
        temp=Q.front();
        Q.pop();
        for(int i=head[temp.id];i!=-1;i=edge[i].next)
        {
            int to=edge[i].to;
            if(!vis[to])
            {

                tt.id=to;
                tt.step=temp.step+1;
                if(to==0)
                {
                    printf("%d\n",tt.step);
                    return ;
                }
                Q.push(tt);
            }

        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(head,-1,sizeof(head));
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            add(x,y);
            add(y,x);
        }

        for(int i=1;i<n;i++)
        {
            bfs(i);
        }
        if(t)
        printf("\n");
    }
}

还有一种方法就是用邻接矩阵的广搜了，那个代码短，时间稍长一点。

#include<bits/stdc++.h>
#define maxn 10005
using namespace std;
int G[maxn][maxn],dis[maxn];
int m,n;
void bfs(int cur)
{
    for(int i=1;i<n;i++)
        dis[i]=n;
    queue<int> q;
    q.push(cur);
    while(!q.empty())
    {
        int a=q.front();
        q.pop();
        for(int i=0;i<n;i++)
        {
            if(G[a][i]&&dis[i]>dis[a]+1)
            {
                dis[i]=dis[a]+1;
                q.push(i);
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(G,0,sizeof(G));
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            G[x][y]=1;
            G[y][x]=1;
        }
        bfs(0);
        for(int i=1;i<n;i++)
            printf("%d\n",dis[i]);
        if(t)
        printf("\n");
    }
}

总结一下：  求最短路径的问题还是往广搜上想好。。。