bzoj 3143 [Hnoi2013]游走（贪心，高斯消元，期望方程）

【题目链接】

http://www.lydsy.com/JudgeOnline/problem.php?id=3143

【题意】

给定一个无向图，从1走到n，走过一条边得到的分数为边的标号，问一个边的标号方法，使得路径上得分最少。

【思路】

设f[i]表示经过i点的期望次数。有：

f[1]=1+sigma{ f[v] }

f[u]=sigma{ f[v] }

特别地，令f[n]=0，因为n点不会对任何连边做出贡献，于是记之为0。

于是得到了n个线性方程组，可以用高斯消元法求解。

对于一条边(u,v)的期望经过次数为：

e=f[u]/du[u] + f[v]/du[v]

du[u]为u点的度数。

然后对每条边贪心地赋值，期望经过次数越大地赋值越小。

【代码】

 #include<set>
 #include<cmath>
 #include<queue>
 #include<vector>
 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)
 using namespace std;

 typedef long long ll;
 const int N = ;
 const int M = N*N;

 ll read() {
     char c=getchar();
     ll f=,x=;
     while(!isdigit(c)) {
         if(c=='-') f=-; c=getchar();
     }
     while(isdigit(c))
         x=x*+c-'',c=getchar();
     return x*f;
 }

 struct Edge {
     int v,nxt;
 }e[M];
 int en=,front[N];
 void adde(int u,int v)
 {
     e[++en]=(Edge){v,front[u]}; front[u]=en;
 }

 int n,m,du[N],flag[N][N];
 double ef[N],a[N][N]; int tot;

 void gause()
 {
     for(int i=;i<=n;i++)
     {
         int r=i;
         for(int j=i+;j<=n;j++)
             if(fabs(a[j][i])>fabs(a[r][i])) r=i;
         if(r!=i) for(int j=;j<=n+;j++) swap(a[i][j],a[r][j]);
         for(int j=n+;j>=i;j--)
             for(int k=i+;k<=n;k++)
                 a[k][j]-=a[k][i]/a[i][i]*a[i][j];
     }
     for(int i=n;i;i--)
     {
         for(int j=i+;j<=n;j++)
             a[i][n+]-=a[i][j]*a[j][n+];
         a[i][n+]/=a[i][i];
     }
 }

 int main()
 {
     n=read(),m=read();
     int u,v;
     FOR(i,,m)
     {
         u=read(),v=read();
         adde(u,v),adde(v,u);
         du[u]++,du[v]++;
     }
     FOR(u,,n-)
     {
         if(u==) a[u][n]=;
         a[u][u]=;
         trav(u,i)
         {
             int v=e[i].v;
             if(v!=n) a[u][v]-=1.0/du[v];
         }
     }
     a[][n]=;
     n--;
     gause();
     FOR(u,,n)
     {
         trav(u,i)
         {
             int v=e[i].v;
             if(v!=u&&!flag[u][v])
                 ef[++tot]=a[u][n+]/du[u]+a[v][n+]/du[v],
                 flag[u][v]=flag[v][u]=;
         }
     }
     sort(ef+,ef+tot+);
     double ans=0.0;
     FOR(i,,tot)
         ans+=ef[i]*(tot-i+);
     printf("%.3lf\n",ans);
     return ;
 }