HDOJ 4418 Time travel (bfs + 高斯消元）

点击打开链接

题意：有一根编号为0~n-1的数轴，起点编号为x，终点编号为y，从起点开始，每次可以走1~m步中的任意步数，如果走到头就返回。如果d为1，那么一开始的走的方向是逆着数轴的，如果d为0，那么一开始走的方向是顺着数轴的。特别的，如果起点是0或者n-1，那么方向一定是确定的，所以d=-1.问从起点到终点的期望步数。

这道题有一个折返走的特殊现象，为了使得操作简便，可以把这根数轴再虚拟出一部分，0~n-1是原来的部分，n-2~1(n>2)。如果1<=n<=2，就不用虚拟了。现在讨论一下一般情况，如果d=1，那么把起点改为2*n-2-x，如果d=0或者-1，那么起点还是x.这样的话，只要一直往顺着数轴的方向走，就相当于折返走。如果当前位置是u，i为要走的步数，那么下一个位置就是(u+i)%(2*n-2) 。再讨论特殊情况，如果n=2,也是满足之前一般情况的式子的。当n=1时，会出现mod 0的情况，所以在一开始就要特判。

注意因为p[i]可能等于0，所以会出现某些点到不了的情况，所以先用bfs确定那些到不了的点，那些点对应的未知数一定是无解的。如果不把这些无解的挑出来，就不能求出其他的唯一解的情况，因为Gauss过程中会跳出。注意由于进行了虚拟数轴，所以可能有两个终点，如果两个终点都达到不了就输出impossible，并且把两个终点都标上已经求出解为0。

两个bug。一个是没有在bfs过程中判断p[i]=0时，不能扩展出一个新的结点。第二个就是后面对于从同一个位置出发，可能在走不同步数以后会到达同一个点。

dp[i]表示走到该点到达终点还需要的步数的期望。

dp[i]=∑pk/100*(dp[i+k]+k)。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define VN 300
#define eps 1e-8
using namespace std;
int n, m, d, x, y, u, v, T, N;
queue <int> q;
double a[VN][VN], b[VN], p[VN];
int flag[VN];
void Gauss(int n)
{
    int i,j,k,r;
    for(i=0;i<n;++i)
    {
        //数据稳定性优化
        r = i;
        for(j=i+1;j<n;++j) if(fabs(a[j][i]) > fabs(a[r][i])) r=j;
        if(fabs(a[r][i]) < eps) continue;
        if(r!=i)
        {
            for(j=0;j<n;++j)swap(a[r][j],a[i][j]);
            swap(b[r],b[i]);
        }
        //消元
        for(j=n;j>=i;j--)
        for(k=i+1;k<n;++k)
            if(j==n) b[k]-=a[k][i]/a[i][i]*b[i];
            else a[k][j]-=a[k][i]/a[i][i]*a[i][j];
    }
    //回代
    for(i=n-1;i>=0;--i)
    {
        if(fabs(a[i][i]) < eps) continue;
        for(j=i+1;j<n;++j)b[i]-=a[i][j]*b[j];
        b[i]/=a[i][i];
    }
}
void bfs()
{
    memset(flag, 0, sizeof(flag));
    while (!q.empty()) q.pop();
    if (d == 0 || d == -1) u = x;
    else u = 2*n-x-2;
    q.push(u);
    flag[u] = 1;
    while (!q.empty())
    {
        u = q.front();
        for (int i = 1; i <= m; i++)
            {
                if (p[i] < eps) continue;//bug1
                v = (u+i) % (2*n-2);
                if (flag[v] == 0)
                {
                    flag[v] = 1;
                    q.push(v);
                }
            }
        q.pop();
    }
}
int main()
{
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d%d%d%d", &n, &m, &y, &x, &d);
        for (int i = 1; i <= m; i++) scanf("%lf", &p[i]);
        if (n == 1)
        {
            printf("0.00\n");
            continue;
        }
        bfs();
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        N = 2*n-2;
        for (int i = 0; i < N; i++)
            if (flag[i] == 0) b[i] = 1;
        for (int i = 0; i < N; i++)
            if (flag[i] != 0 && i != y && i !=(2*n-2-y))
        {
            a[i][i] = 1;
            for (int j = 1; j <= m; j++)
            {
                a[i][(i+j) % N] += -p[j]/100.0; //bug2
                b[i] += p[j]/100.0*j;
            }
        }
        a[y][y] = 1;
        a[2*n-2-y][2*n-2-y] = 1;
        if (flag[y] == 1 || flag[2*n-2-y] == 1)
        {
            Gauss(N);
            if (d == 0 || d == -1) printf("%.2f\n", b[x]);
            else printf("%.2f\n", b[2*n-x-2]);
        }
        else printf("Impossible !\n");
    }
    return 0;

}