USACO4.1 篱笆回路Fence Loops

题意

有N(1<=N<=100)条双向边，我们知道每条边的三个属性：边的长度，边的一端所连接的边，边的另一端所连接的边。边不连接自身，且只在端点处连接其他边。求其中的最小环。

输入格式
第一行：N（1<=N<=100）。
第2到3*N+1行：每三行为一组：
每组第一行有四个整数：边的标号s(1<=s<=N)，长度L(1<=L<=255)，一端连接的边的数量Num1(1<=Num1<=8)，另一端连接的边的数量Num2(1<=Num2<=8)。
第二行有Num1个数，为一端连接的边的序号。

第三行有Num2个数，为另一端连接的边的序号。

输出格式

一行，表示最小的周长。

正解

第一步，我们考虑一下建边的方法：
我的第一个想法是把每条篱笆两端各设置一个点，若两条篱笆相连接，则把其对应点给连条权为0的边，表示可以任意通行。那问题就是怎么找到这条篱笆的这端应该跟那条篱笆的哪端相连呢？有人采用了并查集，亦可以暴力存储，其存储的依据是它们是相互连接的。意思是1与2、3连接，那么2与1、3连接。记下1、2、3，可以证明数集{1，2，3}最多只会出现一次。
进一步思考，我们考虑这些点其实可以缩成一个点，那关键就是怎么找到一条篱笆两端的点的编号？同样根据上面讲到的特性，把每一个点连接的边的编号记下来，作为改点的标记。后面寻找篱笆一端的点时，把输入的边的编号作为在搜索素材，在以往出现的点中匹配。若有标记与搜索素材完全相同的点，那么返回这个点的编号；没有，则新加入一个点，同时把以搜索素材给它附上标记。
仔细观察样例的输入，发现其输入有一个隐含的规律：假设一条篱笆两端分别为A和B。篱笆1的A连接了2、3，B连接了4、5。那么2、3的A会连接1；4、5的B会连接1。根据这样一个特性，我们可以记录篱笆x的A连接y为ma[x][y]=1；篱笆x的B连接y为ma[x][y]=2。所以，如果这次从1来，下次就要去到2，同时保证会经过了该篱笆。

第二步，求最小环：
这个可以用floyd来解决，也可以用原始的spfa来解决。
floyd就是一个裸的floyd求最小环。不会？
spfa要枚举所有的边，每次去掉这条边，从这条边的一端出发，看看去到另一端最短距离是多少，再加上这条边的长度，即是经过这条边的最小环了。

这题因为数据极小，还可以用dfs爆搜枚举所有环。别忘了剪枝：超过目前的最小环的长度的就不需要枚举下去了。

代码

采用第二种构图方法。
floyd求最小环：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=522133279;
const int maxn=110;
 
int dis[maxn][maxn],ma[maxn][maxn];
 
bool q[maxn][maxn];int cc=0;
int uu[10];
int find_id(int ss)
{
    for(int i=1;i<=cc;i++)
    {
        int j;
        for(j=0;j<=ss;j++)
        {
            if(q[i][uu[j]]==false) break;
        }
        if(j>ss) return i;
    }
    cc++;
    for(int i=0;i<=ss;i++)
    {
        q[cc][uu[i]]=true;
    }
    return cc;
}
 
void floyd()
{
    int ans=inf;
    for(int k=1;k<=cc;k++)
    {
        for(int i=1;i<k;i++)
            for(int j=i+1;j<k;j++) ans=min(ans,dis[i][j]+ma[i][k]+ma[k][j]);
        for(int i=1;i<=cc;i++)
            for(int j=1;j<=cc;j++) dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
    }
    printf("%d\n",ans);
}
 
int main()
{
    memset(dis,31,sizeof(dis));
    memset(ma,31,sizeof(ma));
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int x,c,ls,rs;
        scanf("%d%d%d%d",&x,&c,&ls,&rs);
        uu[0]=x;
        for(int j=1;j<=ls;j++) scanf("%d",&uu[j]);
        int l=find_id(ls);
        for(int j=1;j<=rs;j++) scanf("%d",&uu[j]);
        int r=find_id(rs);
        dis[l][r]=dis[r][l]=ma[l][r]=ma[r][l]=c;
    }
    floyd();
    return 0;
}

spfa求最小环：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=522133279;
const int maxn=110;
 
bool ma[maxn][maxn];
struct edge
{
    int x,y,c,next;
    bool v;
}e[maxn*2];int len=0,last[maxn];
void ins(int x,int y,int c)
{
    e[++len]=(edge){x,y,c,last[x],true};last[x]=len;
}
 
bool q[maxn][maxn];int cc=0;
int uu[10];
int find_id(int ss)
{
    for(int i=1;i<=cc;i++)
    {
        int j;
        for(j=0;j<=ss;j++)
        {
            if(q[i][uu[j]]==false) break;
        }
        if(j>ss) return i;
    }
    cc++;
    for(int i=0;i<=ss;i++)
    {
        q[cc][uu[i]]=true;
    }
    return cc;
}
 
int dis[maxn];
int list[maxn];int head,tail;
bool vis[maxn];
int spfa(int st,int ed)
{
    memset(dis,63,sizeof(dis));dis[st]=0;
    memset(vis,false,sizeof(vis));
     
    int head=0,tail=0;
    list[tail++]=st;
    while(head!=tail)
    {
        int x=list[head++];if(head==maxn*2) head=0;
        vis[x]=false;
        for(int k=last[x];k;k=e[k].next)
        {
            int y=e[k].y;
            if(!e[k].v) continue;
            if(dis[y]>dis[x]+e[k].c)
            {
                dis[y]=dis[x]+e[k].c;
                if(vis[y]==false)
                {
                    vis[y]=true;
                    list[tail++]=y;if(tail==maxn*2) tail=0;
                }
            }
        }
    }
     
    return dis[ed];
}
 
int main()
{
//  memset(ma,false,sizeof(ma));
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int x,c,ls,rs;
        scanf("%d%d%d%d",&x,&c,&ls,&rs);
        uu[0]=x;
        for(int j=1;j<=ls;j++) scanf("%d",&uu[j]);
        int l=find_id(ls);
        for(int j=1;j<=rs;j++) scanf("%d",&uu[j]);
        int r=find_id(rs);
        if(ma[l][r]==false) ins(l,r,c),ins(r,l,c);
        ma[l][r]=ma[r][l]=true;//两点间只建一次边
    }
     
    int ans=inf;
    for(int i=1;i<=len;i+=2)
    {
        e[i].v=e[i+1].v=false;//断边
        ans=min(ans,spfa(e[i].x,e[i].y)+e[i].c);//记得加回e[i].c以建成完整的环
        e[i].v=e[i+1].v=true;
    }
    printf("%d\n",ans);
     
    return 0;
}