[HNOI2011]XOR和路径

题目大意

具体题目：戳我
题目：
给定一个n个点，m条边的有重边、有自环的无向图，其中每个边都有一个边权。
现在随机选择一条1到n的路径，路径权值为这条路径上所有边权的异或和。
特别注意，如果同一条边在路径中经过了多次，那么路径权值也要异或对应次数的边权。
请回答这条路径的 期望权值 为多少。
数据范围：\(n \leq 100\) , \(m \leq 10^4\) 。对于所有边，\(val_E \leq 10^9\)。

思路及解法

A

首先，求异或问题拆成每一个二进制位来算这都是老套路了。
本题也是一样，把每一个边权拆成二进制的每一位。
那么此时我们只用考虑这一位为\(1\)的概率,最后贡献乘上一个对应系数即可。
倒着\(DP\) , 设\(f[u]\)表示\(u\)到\(n\)路径异或和为\(1\)的概率。
转移还是挺简单的：
\[f[u] = \sum \frac{f[v]}{degree[u]}[E(u,v)=0] + \sum \frac{(1-f[v])}{degree[u]}[E(u,v)=1]\]
然后你会发现这样转移不了，因为对应的\(f[v]\)可能还未确定。
所以\(f[x]\)之间是互相影响的，没有办法直接转移。怎么办呢？

B

本题最超神的地方来了。
我们观察每一个方程：
\[f[u] = \sum \frac{f[v]}{degree[u]}[E(u,v)=0] + \sum \frac{(1-f[v])}{degree[u]}[E(u,v)=1]\]
移项：
\[f[u]+\sum \frac{f[v]}{degree[u]}[E(u,v)=1] - \sum \frac{f[v]}{degree[u]}[E(u,v)=0] = \sum [E(u,v)=1]\]
把每一个\(f[i]\)看做一个未知数\(x_i\)，那么刚好有\(n\)个方程。
高斯消元即可（太神奇了原来高斯消元还可以这么用）.......

实现代码：

#include<bits/stdc++.h>
#define RG register
#define IL inline
#define _ 105
using namespace std;

struct Road{int to,next,val;}t[2*_*_];
double ans , f[_][_] , deg[_]; int head[_],d[_],n,m,cnt;

IL void Build(RG int jd){
    memset(f,0,sizeof(f));
    for(RG int u = 1; u < n; u ++){   //注意n的方程要特判！！
        f[u][u] = 1.0;
        for(RG int e = head[u]; e ; e = t[e].next){
            RG int v = t[e].to , w = ((t[e].val>>jd)&1);
            if(w!=0)f[u][n+1] += 1.0/deg[u] , f[u][v] += 1.0/deg[u];
            else f[u][v] -= 1.0/deg[u];
        }
    }f[n][n] = 1.0;  return;
}

IL void Gauss(){
    for(RG int j = 1; j <= n; j ++){
        RG int rgt = 0;
        for(RG int i = j; i <= n; i ++)
            if(f[i][j]){rgt = i; break;}
        if(!rgt)continue;
        if(rgt ^ j)swap(f[rgt],f[j]);
        for(RG int i = j+1; i <= n; i ++){
            RG double div = f[i][j] / f[j][j];
            for(RG int k = 1; k <= n+1; k ++)
                f[i][k] -= 1.0 * f[j][k] * div;
        }
    }
    for(RG int j = n; j >= 1; j --){
        f[j][n+1] = f[j][n+1] / f[j][j];
        for(RG int i = j-1; i >= 1; i --)
            f[i][n+1] -= 1.0*f[i][j] * f[j][n+1];
    }return;
}

int main(){
    cin >> n >> m;
    for(RG int i = 1; i <= m; i ++){
        RG int u,v,w;
        cin >> u >> v >> w;
        t[++cnt] = (Road){v,head[u],w} , head[u] = cnt , d[u]++;
        if(u^v)t[++cnt] = (Road){u,head[v],w} , head[v] = cnt , d[v]++;
        //特别注意如果这里是自环只能连一条边。
    }
    for(RG int i = 1; i <= n; i ++)deg[i] = d[i];
    ans = 0;
    for(RG int e = 0; e <= 30; e ++){
        Build(e);  Gauss();
        double nm = 1.0*(1<<e);
        ans = ans + 1.0*nm*f[1][n+1];
    }
    printf("%.3lf",ans); return 0;
}

补充题：[HNOI2013]游走

然而，你以为这样就完了吗.......
这里还有一道更加恶心的：[HNOI2013]游走

壮哉我大湖南，尽出这种毒瘤题........

题目大意：

一个无向连通图，顶点从\(1\)编号到\(N\)，边从\(1\)编号到\(M\)。
小Z在该图上进行随机游走，初始时小Z在\(1\)号顶点，
每一步小Z以相等的概率随机选择当前顶点的某条边，
沿着这条边走到下一个顶点，获得等于这条边的编号的分数。
当小Z到达\(N\)号顶点时游走结束，总分为所有获得的分数之和。
现在，请你对这\(M\)条边进行编号，使得小Z获得的总分的期望值最小。
数据范围：\(N\leq 500\) , \(M\leq 100000\)

题目解法：

这题作为补充就不写的那么详细了，那个贪心直接跳过。
关键的一步：把求边的概率转换到求点的概率。
假设一个点\(x\)在\(1\)到\(n\)的路径上被经过的概率为\(p_x\) , 那么
\[p_{<u,v>} = \frac{p_{u}}{degree[u]} + \frac{p_{v}}{degree[v]} \]
然后就只要求\(p_u\)了。显然有方程式： \(p_u = \sum \frac{p_v}{degree[v]}\)
移一下项得到：\(p_u - \sum \frac{p_v}{degree[v]} = 0\) ;与上题类似高斯消元即可。
然后注意一下子边界问题，我在代码里面详细讲了。

实现代码：

注：这题 \(Luogu\) 数据真的太卡精度了，这份代码交上去只能获得 70分。

#include<bits/stdc++.h>
#define RG register
#define IL inline
#define _ 505
#define eps 1e-7
using namespace std;

double fc[_][_] , deg[_] , ans[_]; int n,m;
struct Edge{
    int x1,x2; double p;
    bool operator < (const Edge &B)const{
        return p > B.p;}
}eg[2*_*_];
struct Road{int to,next;}t[_*_*2];  int head[_],cnt;

IL void Gauss(){
    for(RG int j = 1; j < n; j ++){
        RG int r = 0;
        for(RG int i = j; i < n; i ++)
            if(fc[i][j]){r = i; break;}
        if(r <= eps)continue;
        if(r ^ j)swap(fc[r] , fc[j]);
        for(RG int i = j+1; i < n; i ++){
            RG double div = (fc[i][j] / fc[j][j]);
            for(RG int k = 1; k <= n; k ++)
                fc[i][k] -= div*fc[j][k];
        }
    }
    for(RG int j = n-1; j >= 1; j --){
        ans[j] = fc[j][n] / fc[j][j];
        for(RG int i = j-1; i >= 1; i --)
            fc[i][n] -= ans[j] * fc[i][j];
    }return;
}

int main(){
    cin >> n >> m;
    for(RG int i = 1; i <= n; i ++)
        fc[i][i] = 1.0;
    for(RG int sq = 1; sq <= m; sq ++){
        RG int u , v;
        cin >> u >> v;
        eg[sq] = (Edge){u,v,0};
        deg[u] += 1.0 ; if(u^v)deg[v] += 1.0;
        t[++cnt] = (Road){v,head[u]}; head[u] = cnt;
        if(u ^ v)t[++cnt] = (Road){u,head[v]}; head[v] = cnt;
    }
    for(RG int u = 1; u < n; u ++){
        for(RG int i = head[u]; i; i = t[i].next){
            RG int v = t[i].to;
            if(v ^ n)fc[u][v] -= 1.0/deg[v];
        }
    }
    fc[1][n] = 1.0;
    //注：由于到了n之后游走就结束了，所以为了不影响其它方程的求解，f[n] = 0;
    //为了省空间，把原来的常数项（答案项）向左移了一个移到了fc[i][n];
    //由于1、n是一定会经过的，所以它们的答案为1.0，即fc[1][n] = fc[n][n] = 1.0;
    Gauss();
    for(RG int i = 1,u,v; i <= m; i ++)
        u = eg[i].x1,v = eg[i].x2 ,
        eg[i].p = ans[u]/deg[u] + ans[v]/deg[v];
    sort(eg+1,eg+m+1);
    RG double res =0,oo;
    for(RG int i = 1; i <= m; i ++)
        oo = i , res = res + 1.0*oo*eg[i].p; //p从大到小排序。
    printf("%.3lf",res); return 0;
}