[Dijkstra算法]

题目链接:poj 1847 Tram

有n个点，这些点和其他点有些路径，每个点是一个开关，开关只能有一个方向走一条路，而第一个数就是默认的开关指向，不用旋转。

题目给的实例

3 2 1 //有3个开关点，计算从第二个到第一个最少需要旋转几次

2 2 3//第1个开关可以通向2 和3 ，通向2不需要旋转，通向3需要旋转1次

2 3 1//第2个开关可以通向3 和1， 通向3不需要旋转，通向1需要旋转1次

2 1 2//第3个开关可以通向1和2，通向1不需要旋转，通向2需要旋转1次

思路：
让每一个开关直接通向的开关之间的距离设置为0，需要旋转一次的设置为1，其他的设置为INF。

#include <iostream>
#include <vector>
using namespace std;
const int maxn = 110;
const int INF = 0x3fff;
int G[maxn][maxn];
bool vis[maxn] = {false};
int dis[maxn];
int N, A, B;

int Dijkstra()
{
    dis[A] = 0;
    for (int i = 1; i <= N; i++) //循环n次
    {
        int u = -1; //使d[u]最小且还没有被访问的结点
        int min = INF;
        for (int j = 1; j <= N; j++)
        {
            if (vis[j] == false && dis[j] < min)
            {
                u = j;
                min = dis[j];
            }
        }
        if (u == -1)
        {
            break;
        }
        vis[u] = true;
        for (int i = 1; i <= N; i++)
        {
            if (vis[i] == false && G[u][i] != INF && dis[i] > dis[u] + G[u][i])
            {
                dis[i] = dis[u] + G[u][i];
            }
        }
    }
    return dis[B];
}

int main()
{
    cin >> N >> A >> B;
    fill(G[0], G[0] + maxn * maxn, INF);
    fill(vis, vis + maxn, false);
    fill(dis, dis + maxn, INF);
    for (int i = 1; i <= N; i++)
    {
        int num;
        cin >> num;
        int list;
        cin >> list;
        G[i][list] = 0;
        for (int j = 1; j < num; j++)
        {
            cin >> list;
            G[i][list] = 1;
        }
    }
    int res = Dijkstra();
    if (res == INF)
    {
        cout << -1 << endl;
    }
    else
    {
        cout << Dijkstra() << endl;
    }
    return 0;
}