Wormholes(虫洞)

poj3259

题目大意：给出一个F代表农场的个数，其实就是测试样例组数，给出个N代表每个农场包含N个厂区，M代表N个厂区之间之间的路径条数，W表示有W个虫洞

题目上说路径是双向的，虫洞是单向的，意味着是有向图，并且说虫洞从一个顶点到另一个顶点让时间倒流，意味着路的权值是负值，接下来的M行是路径的条数，并且题目已经说明是一个厂区到另一个厂区不一定只有一条路（Two fields might be connected by more than one path.），接下来的W行是虫洞的起始和结束位置，还有让时间倒退的值。

解决：首先是建图，我用邻接矩阵，建图的时候要注意两个厂区之间不一定只有一条路，要添加一条语句让最小的进图，M个是双向的，W个是单向的，单向的不用判断直接赋值肯定没有比

它的值还小的。然后是找负回路用的是 spfa

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int N=3000;
const int MAX=0x3f3f3f3f;
int cost[N][N];
int inq[N];
int dist[N];
int n,m,w;
int cnt[N];
bool spfa(int v)
{
    int i;
    memset(dist,0x3f3f,sizeof(dist));
    memset(inq,0,sizeof(inq));
    memset(cnt,0,sizeof(cnt));
    int v0=v;
    dist[v0]=0;
    queue<int> q;
    q.push(v0);
    inq[v0]=1;
    // 源点进队列与不进队列虽然关系不大，但是进队列可以缩短运行时间，每进一次可是不要小看，
  //这个点面对的是所有的边，所以进队列要将cnt的值置为1
    cnt[v0]=1;
    while(!q.empty())
    {
        v0=q.front();
        q.pop();
        inq[v0]=0;
        for(i=1;i<=n;i++)
        {
            if(cost[v0][i]<MAX && dist[v0]+cost[v0][i]<dist[i])
            {
                dist[i]=dist[v0]+cost[v0][i];
                if(!inq[i])
                {
                    inq[i]=1;
                    q.push(i);
                    //共有n条边，等于结点总数返回，大于当然可以，但是何必呢。费时不是
                    if(++cnt[i]==n)return true;
                }
            }
        }
    }
    return false;
}
int main()
{
    int icase,i,a,b,val;
    scanf("%d",&icase);
    while(icase--)
    {
        memset(cost,0x3f3f,sizeof(cost));
        scanf("%d%d%d",&n,&m,&w);
        for(i=0;i<m;i++)
        {//输入时比较一下，由于邻接矩阵两个顶点只能放一条边，只好选最短边放了
            scanf("%d%d%d",&a,&b,&val);
            if(cost[a][b]>val){cost[a][b]=cost[b][a]=val;}
        }
        for(i=0;i<w;i++)
        {//这个地方也是可以判断一下，选最短的边放,万一两个厂区之间有两个洞呢
            scanf("%d%d%d",&a,&b,&val);
            cost[a][b]=-val;
        }//自己假设的1是源点，若是不连通，就惨了，

        if(spfa(1)){puts("YES");}
         else puts("NO");
    } 
    system("pause");
    return 0;
}

　　虽然ac了，但是感觉漏洞百出，只是数据通过了，不只是为了通过数据，就万事大吉了。

#include <queue>
#include <cstring>
const int MAX=0x3f3f3f3f;
using namespace std;
const int N=3000;
int cost[N][N];
int inq[N];
int dist[N];
int n,m,w;
int cnt[N];
bool spfa()
{
    int i;
    memset(dist,0,sizeof(dist));
    memset(inq,0,sizeof(inq));
    memset(cnt,0,sizeof(cnt));
    int v0;
  //为了防止图不连通。将所有顶点入队，并且初始化dist为0，意味着
 //虚拟源点到各个顶点的距离为0
   queue<int> q;
    for(int i=1;i<=n;i++)q.push(i);//虽然进队，但是不能cnt[i]++,
    while(!q.empty())
    {
        v0=q.front();
        q.pop();
        inq[v0]=0;
        for(i=1;i<=n;i++)
        {
            if(cost[v0][i]<MAX && dist[v0]+cost[v0][i]<dist[i])
            {
                dist[i]=dist[v0]+cost[v0][i];
                if(!inq[i])
                {
                    inq[i]=1;
                    q.push(i);//判断的时候还要是n，虚拟的无视
                    if(++cnt[i]==n)return true;
                }
            }
        }
    }
    return false;
}
int main()
{
    int icase,i,a,b,val;
    scanf("%d",&icase);
    while(icase--)
    {
        memset(cost,0x3f3f,sizeof(cost));
        scanf("%d%d%d",&n,&m,&w);
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&val);
            if(cost[a][b]>val){cost[a][b]=cost[b][a]=val;}
        }
        for(i=0;i<w;i++)
        {
            scanf("%d%d%d",&a,&b,&val);
            cost[a][b]=-val;
        }
        if(spfa()){puts("YES");}
         else puts("NO");
    } 
    system("pause");
    return 0;
}
               

　以上的程序虽然都可以但是时间复杂度已经达到了1500ms，以下用spfa+邻接表实现。

#include <iostream>
#include <queue>
#include <cstdio>
using namespace std;
const int N=510;
struct node
{
    int v,w,next;
};
node e[50000];
int n,m,w,ss,ee,t;
int pos;
int head[N];
int cnt[N];
int dist[N];
bool inq[N];
void init()
{
         memset(head,-1,sizeof(head));
         memset(dist,0,sizeof(dist));
         memset(cnt,0,sizeof(cnt));
         memset(inq,0,sizeof(inq));
}
void addedge(int u,int v,int w)
{
    e[pos].v=v;
    e[pos].w=w;
    e[pos].next=head[u];
    head[u]=pos++;
}
bool spfa()
{
     int v0,v,w,i;
    queue<int> q;//虚拟顶点各个顶点入队
    for(i=1;i<=n;i++)q.push(i);
    while(!q.empty())
    {
        v0=q.front();
        q.pop();
        inq[v0]=false;
        for(i=head[v0];i!=-1;i=e[i].next)
        {
            v=e[i].v;
            w=e[i].w;
            if(dist[v0]+w<dist[v])
            {
                dist[v]=dist[v0]+w;
                if(!inq[v])
                {
                    inq[v]=1;
                    q.push(v);
                    if(++cnt[v]==n)return true;
                }
            }
        }
    }
    return false;
}
int main()
{
    int i,f;
    scanf("%d",&f);
    while(f--)
    {
        pos=0;
      
        scanf("%d%d%d",&n,&m,&w); 
        init();//就因为init放在了scanf前面导致不断错误，并提出了可笑的问题
        for(i=0;i<m;i++) 
        {
            scanf("%d%d%d",&ss,&ee,&t);
            addedge(ss,ee,t);
            addedge(ee,ss,t);
        }
        for(i=0;i<w;i++)
        {
            scanf("%d%d%d",&ss,&ee,&t);
            addedge(ss,ee,-t);
        }
        if( spfa() )puts("YES");
        else puts("NO");
    }
    system("pause");
    return 0;
}