【BZOJ】【2878】【NOI2012】迷失游樂園

樹形+基環樹DP/數學期望

---

　　然而我並不會做……

　　題解戳這里：http://blog.csdn.net/u011265346/article/details/46328543

　　好吧先考慮一個簡單點的，當m=n-1時，整個是一個樹形的結構，無根樹我們一般還是轉成有根樹來處理……然后既然是無法回頭的，那么我們可以定一下方向：向下或者向上（廢話）

　　定義一下：

　　son[x]為x的兒子的數量

　　down[x]表示從x這個點出發，向葉子們走的期望長度。

　　怎么算呢？其實就是所有可能的情況（所有的兒子）加起來，再求個平均，所以我們有$$down[x]=\frac{\sum (down[y]+len(x->y))}{son[x]}$$

　　up[x]表示從x這個點出發，經過父親，走到某個葉子的期望長度。

　　這個看上去好難算啊……怎么算呢？我們先算出來每個結點的down[x]，然后從上往下DP，這里我們需要考慮的是x的父親 f ，我們從x向上走到他父親 f 后（len(x->f)），可以向 f 其他的兒子走，這種方案的期望長度之和為$$ son[f]*down[f]-down[x]-len(f->x) $$如果是繼續向上，這種方案的期望長度為$up[f]$，所以有$$up[x]=len(x->f) + \frac{ son[f]*down[f]-down[x]-len(f->x) + up[f]}{son[f]-1+1}$$這里son[f]-1表示是向其他兒子走，+1表示的是繼續向上，這么多種方案的概率是相等的。

　　那么答案怎么算？當然是$$ans=\sum_{i=1}^n \frac{down[i]*son[i]+up[i]}{son[i]+1} $$

　　好的到這里我們就解決了樹上的問題，那么環套樹其實就是需要特殊處理一下 環上的結點以及與環直接相連的結點，怎么做呢？

　　肯定是要先找環的啦= =那么我們dfs搞搞找出環上所有結點，題目限制這樣的結點不多，就20個= =

　　有一個東西是跟樹的情況一樣的，那就是從環上某個結點直接向與它相連的外向樹上走的期望長度，也就是所有的down[cir[i]]，這里cir[i]表示環上的點。

　　算出down[cir[i]]以后，跟據剛剛的經驗，我們就可以用down來算up啦！同樣是從上往下算up的值，只不過這里的“樹根”變成了一個環，環上的點的up值其實就是沿着環走到其他的任意一個環上的點，然后再向下走的期望長度啦，舉個例子吧：（其實這一段看代碼比較好……）

　　環上的點編號為1、2、3、4、5，那么對於1來說，順時針走的話，走到2的概率為1，走到3的概率為$\frac{1}{son[2]+1}$，走到4的話就再乘$\frac{1}{son[3]+1}$……逆時針走的話同理。

　　同時我們沿着環每走到一個位置就加上從這里向外向樹走的期望長度（注意繞一圈走到頭的地方與之前的不一樣，因為出發點不可能經過兩次）。

　　表達式比較難寫……好吧其實是我懶，而且長得並不好看，還是看代碼比較好：

F(i,1,tot){
    int x=cir[i];
    double k=1;
    for(int j=nex[x];j!=x;j=nex[j]){
        if (nex[j]!=x)
            up[x]+=k*(len[hash[pre[j]]][hash[j]]+down[j]*son[j]/(son[j]+1));
        else
            up[x]+=k*(len[hash[pre[j]]][hash[j]]+down[j]);
        k/=(son[j]+1);
    }
    k=1;
    for(int j=pre[x];j!=x;j=pre[j]){
        if (pre[j]!=x)
            up[x]+=k*(len[hash[nex[j]]][hash[j]]+down[j]*son[j]/(son[j]+1));
        else 
            up[x]+=k*(len[hash[nex[j]]][hash[j]]+down[j]);
        k/=(son[j]+1);    
    }
    up[x]/=2;
}

　　算出所有環上的點的up[i]以后，外向樹的up[i]就跟樹上情況一樣了……不過由於環上的點的父節點相當於是有兩個，所以這里重新定義一個fa[i]，表示 i 的父親結點的數量。那么有$$up[x]=len(x->f) + \frac{ son[f]*down[f]-down[x]-len(f->x) + up[f]*fa[f] }{son[f]-1+fa[f]}$$

 

另外，對於上面的所有公式，要小心分母可能為0的情況。

/**************************************************************
    Problem: 2878
    User: Tunix
    Language: C++
    Result: Accepted
    Time:556 ms
    Memory:9876 kb
****************************************************************/
 
//BZOJ 2878
#include<vector>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define rep(i,n) for(int i=0;i<n;++i)
#define F(i,j,n) for(int i=j;i<=n;++i)
#define D(i,j,n) for(int i=j;i>=n;--i)
#define pb push_back
using namespace std;
inline int getint(){
    int v=0,sign=1; char ch=getchar();
    while(ch<'0'||ch>'9'){ if (ch=='-') sign=-1; ch=getchar();}
    while(ch>='0'&&ch<='9'){ v=v*10+ch-'0'; ch=getchar();}
    return v*sign;
}
const int N=1e5+10,INF=~0u>>2;
typedef long long LL;
/******************tamplate*********************/
int to[N<<1],nxt[N<<1],head[N],cnt;
double l[N<<1];
void ins(int x,int y,double z){
    to[++cnt]=y; nxt[cnt]=head[x]; head[x]=cnt; l[cnt]=z;
}
 
int n,m;
 
int vis[N],flag;
double son[N],fa[N],up[N],down[N];
int cir[N],tot,hash[N];
int pre[N],nex[N];
double len[25][25];
 
void Findcir(int x,int f){
    vis[x]=1;
    for(int i=head[x];i;i=nxt[i])
        if (to[i]!=f){
            if (vis[to[i]]){
                flag=to[i];
                return;
            }
            Findcir(to[i],x);
            if (flag>0){
                if (flag==x) flag=-1;
                return;
            }
            if (flag==-1) break;
        }
    vis[x]=0;
}
void dfs_cir(int x,int f){
    if (hash[x]) return;
    cir[++tot]=x;
    hash[x]=tot;
    fa[x]=2;
    for(int i=head[x];i;i=nxt[i]){
        if (to[i]==f) continue;
        if (!vis[to[i]]) continue;
         
        pre[to[i]]=x;
        nex[x]=to[i];
        dfs_cir(to[i],x);
        len[hash[x]][hash[to[i]]]=len[hash[to[i]]][hash[x]]=l[i];
        break;
    }
}
 
void dfsdown(int x,int f){
    for(int i=head[x];i;i=nxt[i])
        if (!vis[to[i]] && to[i]!=f){
            fa[to[i]]=1;
            dfsdown(to[i],x);
            son[x]++;
            down[x]+=down[to[i]]+l[i];
        }
    if (son[x]) down[x]/=son[x];
}
 
void dfsup(int x,int f,double ee){
    up[x]=ee;
    if (fa[f]+son[f]>1)
        up[x]+=(fa[f]*up[f]+son[f]*down[f]-down[x]-ee)/(fa[f]+son[f]-1);
    for(int i=head[x];i;i=nxt[i])
        if (to[i]!=f) dfsup(to[i],x,l[i]);
}
 
int main(){
#ifndef ONLINE_JUDGE
    freopen("2878.in","r",stdin);
    freopen("2878.out","w",stdout);
#endif
    n=getint(); m=getint();
    F(i,1,m){
        int x=getint(),y=getint(),z=getint();
        ins(x,y,z); ins(y,x,z);
    }
    Findcir(1,0);
    if (m<n){
        dfsdown(1,0);
        for(int i=head[1];i;i=nxt[i])
            dfsup(to[i],1,l[i]);
    }else{
        F(i,1,n)
            if (vis[i]){
                dfs_cir(i,0);
                break;
            }
        F(i,1,tot) dfsdown(cir[i],0);
        F(i,1,tot){
            int x=cir[i];
            double k=1;
            for(int j=nex[x];j!=x;j=nex[j]){
                if (nex[j]!=x)
                    up[x]+=k*(len[hash[pre[j]]][hash[j]]+down[j]*son[j]/(son[j]+1));
                else
                    up[x]+=k*(len[hash[pre[j]]][hash[j]]+down[j]);
                k/=(son[j]+1);
            }
            k=1;
            for(int j=pre[x];j!=x;j=pre[j]){
                if (pre[j]!=x)
                    up[x]+=k*(len[hash[nex[j]]][hash[j]]+down[j]*son[j]/(son[j]+1));
                else
                    up[x]+=k*(len[hash[nex[j]]][hash[j]]+down[j]);
                k/=(son[j]+1);
             
            }
            up[x]/=2;
        }
        F(j,1,tot){
            for(int i=head[cir[j]];i;i=nxt[i])
                if (!hash[to[i]]) dfsup(to[i],cir[j],l[i]);
        }
    }
    double ans=0;
    F(i,1,n) ans+=(up[i]*fa[i]+down[i]*son[i])/(fa[i]+son[i]);
    printf("%.5lf\n",ans/n);
    return 0;
}

2878: [Noi2012]迷失游樂園

Time Limit: 10 Sec  Memory Limit: 512 MBSec  Special Judge
Submit: 503  Solved: 321
[Submit][Status][Discuss]

Description

放 假了，小Z覺得呆在家里特別無聊，於是決定一個人去游樂園玩。進入游樂園后，小Z看了看游樂園的地圖，發現可以將游樂園抽象成有n個景點、m條道路的無向 連通圖，且該圖中至多有一個環（即m只可能等於n或者n-1）。小Z現在所在的大門也正好是一個景點。小Z不知道什么好玩，於是他決定，從當前位置出發， 每次隨機去一個和當前景點有道路相連的景點，並且同一個景點不去兩次（包括起始景點）。貪玩的小Z會一直游玩，直到當前景點的相鄰景點都已經訪問過為止。 小Z所有經過的景點按順序構成一條非重復路徑，他想知道這條路徑的期望長度是多少？小Z把游樂園的抽象地圖畫下來帶回了家，可是忘了標哪個點是大門，他只 好假設每個景點都可能是大門（即每個景點作為起始點的概率是一樣的）。同時，他每次在選擇下一個景點時會等概率地隨機選擇一個還沒去過的相鄰景點。

Input

第一行是兩個整數n和m，分別表示景點數和道路數。 接下來行，每行三個整數Xi, Yi, Wi，分別表示第i條路徑的兩個景點為Xi, Yi，路徑長Wi。所有景點的編號從1至n，兩個景點之間至多只有一條道路。

Output

 共一行，包含一個實數，即路徑的期望長度。

Sample Input

4 3
1 2 3
2 3 1
3 4 4

Sample Output

6.00000000

【樣例解釋】樣例數據中共有6條不同的路徑: 路徑 長度 概率
1-->4 8 1/4
2-->1 3 1/8
2-->4 5 1/8
3-->1 4 1/8
3-->4 4 1/8
4-->1 8 1/4
因此期望長度 = 8/4 + 3/8 + 5/8 + 4/8 + 4/8 + 8/4 = 6.00
【評分方法】本題沒有部分分，你程序的輸出只有和標准答案的差距不超過0.01時，才能獲得該測試點的滿分，否則不得分。
【數據規模和約定】對於100%的數據，1 <= Wi <= 100。 測試點編號 n m 備注
1 n=10 m = n-1 保證圖是鏈狀
2 n=100 只有節點1的度數大於2
3 n=1000 /
4 n=100000 /
5 n=100000 /
6 n=10 m = n /
7 n=100 環中節點個數<=5
8 n=1000 環中節點個數<=10
9 n=100000 環中節點個數<=15
10 n=100000 環中節點個數<=20

HINT

Source

鳴謝Ljcc提供SPJ

[ Submit][ Status][ Discuss]