CSU - 1256 天朝的单行道

天朝的单行道

Time Limit: 1000MS

Memory Limit: 131072KB

64bit IO Format: %lld & %llu

[Submit]   [Go Back]   [Status]  

Description

    在另一个平行宇宙中，有一个神奇的国度名叫天朝。天朝一共有N个城市（标号分别为1, 2, …, N），M条道路，为了方便交通管制，天朝的M条道路都是单行道。

    不久前天朝大选，小Q当选了天朝的总统。小Q家住在城市1，但天朝的办公地点在城市N，于是为了便于工作，小Q决定举家从城市1搬迁到城市N去居住。然而小Q惊奇的发现，现在并不存在从城市1出发到城市N路线。

    但这点难题是无法阻挡天朝总统的，小Q决定行使总统的权利下令更改一些道路的通行方向，使得至少存在一条从城市1出发到城市N的路线，但为了节省时间和资源，他希望更改通行方向的道路尽可能少，你能帮帮小Q吗？

Input

    输入包含多组测试数据。

    对于每组测试数据，第一行包含两个正整数N (2<=N<=5000)、M (1<=M<=10000)，表示天朝一共有N个城市、M条道路。接下来M行每行有两个正整数u、v (1<=u, v<=N)，表示城市u和城市v之间有一条通行方向为u->v的单行道。两个城市之间可能有多条道路。

Output

    对于每组测试数据，用一行输出一个整数表示最少需要更改多少条单行道的通行方向，才能使得至少存在一条路线能够让小Q从城市1出发到城市N。

    如果没办法使得至少存在一条路线让小Q从城市1出发到城市N，则输出“-1”（不包括引号）。

Sample Input

2 1
1 2

2 1
2 1

2 0 

Sample Output

0
1
-1 

Hint

Source

2012暑期集训中期测试赛

题意：
给出一张有向图，问最少改变多少条边的方向，使得图中存在一条从1到N的路径


解法：
对u->v的边                              add_edge(u,v,0)
增加一条u->v反向边            add_edge(v,u,1)
求一遍1->n的最短路

之前是这样写的：

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=5005;
const int inf=0xfffffff;
int cost[maxn],visit[maxn],map[maxn][maxn],q[maxn];
int n,m,sp,ep;
void getmap()
{
  int i,j,a,b,c;
  for(i=1;i<=n;i++)
  for(j=1;j<=n;j++)
  map[i][j]=inf;
  for(i=0;i<n;i++)
  map[i][i]=0;//这两行可以不用（但为了逻辑清晰，还是加上好，毕竟只有一重循环）
  for(i=0;i<m;i++)
  {
      scanf("%d%d",&a,&b);
      //map[a][b]=map[b][a]=min(map[a][b],c);
      map[a][b]=0;
      map[b][a]=1;
  }
}


void spfa()
{
    int front=0,rear=0,i,j,x;
    q[++rear]=sp;//q从下标1开始
    memset(visit,0,sizeof(visit));
    visit[sp]=1;
    for(i=1;i<=n;i++)
    cost[i]=inf;
    cost[sp]=0;
    while(front!=rear)
    {
        front=(front+1)%(n+1);//保证q从1到n
        x=q[front];
        visit[x]=0;//设置出队的点为未标志
        for(i=1;i<=n;i++)
          if(cost[i]>cost[x]+map[x][i])//如果松弛成功
          {
              cost[i]=cost[x]+map[x][i];//更新路径，得到新的权值（新的最短路）
              if(!visit[i])//如果未被标志，即未入队
              {
                  rear=(rear+1)%(n+1);
                  q[rear]=i;//入队
                  visit[i]=1;//更新标志
              }
          }
    }
   printf("%d\n",cost[ep]==inf?-1:cost[ep]);
}


int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        getmap();
        //scanf("%d%d",&sp,&ep);
        sp=1;ep=n;
        spfa();
    }
    return 0;
}

结果TLE（ Time Limit Exceed）了。因为遍历过程中做了大量无用功。

修改后的程序，AC了：

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=5005,maxm=20005;//此处maxm=10000*2。
const int inf=0xfffffff;
int cost[maxn],visit[maxn],w[maxm],value[maxm],q[maxn],first[maxn],next[maxm];
int n,m,sp,ep;
void getmap()
{
  int i,j,a,b,c;
  memset(first,-1,sizeof(first));
  for(i=0,j=0;i<m;i++)
  {
      scanf("%d%d",&a,&b);
      next[++j]=first[a];
      first[a]=j;
      value[j]=b;
      w[j]=0;
      next[++j]=first[b];
      first[b]=j;
      value[j]=a;
      w[j]=1;
  }
}




void spfa()
{
    int front=0,rear=0,i,j,x;
    q[++rear]=sp;//q从下标1开始
    memset(visit,0,sizeof(visit));
    visit[sp]=1;
    for(i=1;i<=n;i++)
    cost[i]=inf;
    cost[sp]=0;
    while(front!=rear)
    {
        front=(front+1)%(n+1);//保证q从1到n
        x=q[front];
        visit[x]=0;//设置出队的点为未标志
        for(i=first[x];i!=-1;i=next[i])
          if(cost[value[i]]>cost[x]+w[i])//如果松弛成功
          {
              cost[value[i]]=cost[x]+w[i];//更新路径，得到新的权值（新的最短路）
              if(!visit[value[i]])//如果未被标志，即未入队
              {
                  rear=(rear+1)%(n+1);
                  q[rear]=value[i];//入队
                  visit[value[i]]=1;//更新标志
              }
          }
    }
   printf("%d\n",cost[ep]>=inf?-1:cost[ep]);//也可以==inf。
}


int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        getmap();
        //scanf("%d%d",&sp,&ep);
        sp=1;ep=n;
        spfa();
    }
    return 0;
}

通过剪枝，减少了无用遍历。用到了邻接表（两个一维数组，本质上应该也是邻接表吧）。