数据的第1行为两个整数N和E，以空格分隔，分别表示森林中的景点数和连接相邻景点的路的条数。 第2行包含两个整数C和M，以空格分隔，分别表示初始时聪聪和可可所在的景点的编号。 接下来E行，每行两个整数，第i+2行的两个整数Ai和Bi表示景点Ai和景点Bi之间有一条路。 所有的路都是无向的，即：如果能从A走到B，就可以从B走到A。 输入保证任何两个景点之间不会有多于一条路直接相连，且聪聪和可可之间必有路直接或间接的相连。

输出1个实数，四舍五入保留三位小数，表示平均多少个时间单位后聪聪会把可可吃掉。

【输入样例1】
4 3
1 4
1 2
2 3
3 4
【输入样例2】
9 9
9 3
1 2
2 3
3 4
4 5
3 6
4 6
4 7
7 8
8 9

【输出样例1】
1.500
【输出样例2】
2.167

【样例说明1】
开始时，聪聪和可可分别在景点1和景点4。
第一个时刻，聪聪先走，她向更靠近可可(景点4)的景点走动，走到景点2，然后走到景点3；假定忽略走路所花时间。
可可后走，有两种可能：
第一种是走到景点3，这样聪聪和可可到达同一个景点，可可被吃掉，步数为1，概率为 。
第二种是停在景点4，不被吃掉。概率为 。
到第二个时刻，聪聪向更靠近可可(景点4)的景点走动，只需要走一步即和可可在同一景点。因此这种情况下聪聪会在两步吃掉可可。
所以平均的步数是1* +2* =1.5步。

对于所有的数据，1≤N,E≤1000。
对于50%的数据，1≤N≤50。

---

Solution

#include<bits/stdc++.h>

using namespace std;

struct Node {

    int u, v, nex;

    Node(int u = , int v = , int nex = ) :

        u(u), v(v), nex(nex) { }

} Edge[];

int h[], stot;

void add(int u, int v) {

    Edge[++stot] = Node(u, v, h[u]);

    h[u] = stot;

}

int n, m, vis[], dis[], nex[][];

void spfa(int t) {

    queue < int > q;

    memset(vis, , sizeof(vis));

    memset(dis, 0x3f3f3f3f, sizeof(dis));

    q.push(t); dis[t] = ; vis[t] = ;

    while(!q.empty()) {

        int u = q.front(); q.pop(); vis[u] = ;

        for(int i = h[u]; i; i = Edge[i].nex) {

            int v = Edge[i].v;

            if(dis[v] > dis[u] + ) {

                dis[v] = dis[u] + ;

                if(!vis[v]) {

                    vis[v] = ;

                    q.push(v);

                }

            }

        }

    }

    for(int u = ; u <= n; u ++) {

        if(u != t) {

            int res = 0x3f3f3f3f;

            for(int i = h[u]; i; i = Edge[i].nex) {

                int v = Edge[i].v;

                if(dis[v] < res)    res = dis[v], nex[u][t] = v;

                else if(dis[v] == res && v < nex[u][t])    nex[u][t] = v;

            }

        }

    }

}

int d[], s, t;

double dp[][];

double dfs(int s1, int s2) {

    if(dp[s1][s2] != -)        return dp[s1][s2];

    if(s1 == s2)        return dp[s1][s2] = ;

    if(nex[s1][s2] == s2 || nex[nex[s1][s2]][s2] == s2)    return dp[s1][s2] = ;

    double res = ;

    for(int i = h[s2]; i; i = Edge[i].nex) {

        int v = Edge[i].v;

        res += ( + dfs(nex[nex[s1][s2]][s2], v)) / (d[s2] + 1.0) * 1.0;

    }

    res += ( + dfs(nex[nex[s1][s2]][s2], s2)) / (d[s2] + 1.0) * 1.0;

    return dp[s1][s2] = res;

}

int main() {

    ios :: sync_with_stdio();

    cin >> n >> m;

    cin >> s >> t;

    for(int i = ; i <= n; i ++)    for(int j = ; j <= n; j ++)    dp[i][j] = -;

    for(int i = ; i <= m; i ++) {

        int u, v;

        cin >> u >> v;

        add(u, v); add(v, u);

        d[u] ++; d[v] ++;

    }

    for(int i = ; i <= n; i ++)

        spfa(i);

    double ans = dfs(s, t);

    printf("%.3lf", ans);

    return ;

}