cf期望概率专题

傷城~ 2023-10-12 08:22 18阅读 0赞

cf1009E：求到第i段期望和的比较困难，但是单独求每段的期望是比较容易的，所以单独对每段求和，然后累计总和

E\[i\]=1/2\*a1+1/4\*a2+...+1/2^(i-1)\*ai-1+1/2^(i-1)\*ai，E\[1-n\]是可以递推的

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define ll long long
    
    const int maxn = 1e6+10;
    const ll mod = 998244353;
    
    int n;
    ll a[maxn],dp[maxn],P[maxn];
    
    int main(){
        cin>>n;
        for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
        P[0]=1;
        for(int i=1;i<=n;i++)P[i]=P[i-1]*2%mod;
    
        dp[1]=a[1]*P[n-1]%mod;
        for(int i=2;i<=n;i++){
            dp[i]=((dp[i-1]-a[i-1]*P[n-i]%mod)%mod+mod)%mod;    
            dp[i]=(dp[i]+a[i]*P[n-i]%mod)%mod;
        }
        
        ll ans=0;
        for(int i=1;i<=n;i++)
            ans=(ans+dp[i])%mod;    
        cout<<ans<<'\n';
    }

cf168b：概率+背包dp，每件物品有获得概率p，有的物品会消耗掉一格体积，有的物品可以扩容，问得到l个物品并且都装下的概率

dp\[i\]\[j\]\[l\]表示前i个物品，得到j个，剩下容量为l的概率，转移方程：dp\[i\]\[j\]\[k\]=pi\*dp\[i-1\]\[j-1\]\[k-ai\]+(1-pi)dp\[i-1\]\[j\]\[k\]

因为是无序的，所以背包偏移+200来保证第三维下标为正，注意要从当前状态推导到下一状态

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define N 205
    double dp[N][N][N<<1];
    int n,L,k,a[N];
    double p[N];
    int main(){
        cin>>n>>L>>k;
        for(int i=1;i<=n;i++)cin>>p[i],p[i]*=0.01;
        for(int i=1;i<=n;i++)cin>>a[i];
        
        dp[0][0][200+k]=1;
        for(int i=1;i<=n;i++){ 
            for(int j=0;j<=i;j++)
                for(int l=0;l<=400;l++){
                    dp[i][j][l]+=(1-p[i])*dp[i-1][j][l];//没赢 
                    if(a[i]==-1){
         //是奖品 
                        if(l)dp[i][j+1][l-1]+=p[i]*dp[i-1][j][l];
                    }
                    else {
         //是背包 
                        dp[i][j+1][min(l+a[i],400)]+=p[i]*dp[i-1][j][l];
                    }
                }
        }
        
        double ans=0;
        for(int j=L;j<=n;j++)
            for(int l=200;l<=400;l++)
                ans+=dp[n][j][l];
        printf("%.10lf\n",ans);
    }

cf513C——细节题：枚举拍卖价格i，用长度为n的二进制位，1表示第j个人出价>=i

n个里起码选两个1 ，这时有两种情况 1：一个选择>i,剩下的选的=i的概率，2：都选i的概率

每种状态的12情况的概率叠加，i的所有状态概率叠加就是价格为i时的概率

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/*
    枚举拍卖价格i
    用长度为n的二进制位，1表示第j个人出价>=i,0反之
        n个里起码选两个1 
            1：一个选择>i,剩下的选的=i的概率 
            2：都选i的概率
        每种状态的12情况的概率叠加
    所有状态概率叠加就是价格为i时的概率 
    */ 
    #include<bits/stdc++.h>
    using namespace std;
    #define N 10005
    int n,L[10],R[10];
    double ans[N]; 
    int count(int x){
        int res=0;
        for(int i=0;i<n;i++)
            if(x>>i & 1)res++;
        return res;
    }
    int main(){
        cin>>n;
        for(int i=0;i<n;i++)cin>>L[i]>>R[i];
        for(int i=1;i<=10000;i++){
            for(int S=0;S<(1<<n);S++)if(count(S)>=2){
                double pp1=0; 
                for(int j=0;j<n;j++)if(S>>j & 1){
         //情况1，枚举第j个作为>i的选项 
                    double p1=1;
                    if(L[j]>i)p1=1;
                    else if(R[j]<=i)p1=0;
                    else if(R[j]>i && L[j]<=i)p1*=1.0*(R[j]-i)/(R[j]-L[j]+1);
                    
                    for(int k=0;k<n;k++)if(k!=j){
                        if(S>>k & 1){
                            if(R[k]<i || L[k]>i)p1=0;
                            else p1*=1.0/(R[k]-L[k]+1);
                        }
                        else {
                            if(L[k]>=i)p1=0;
                            else if(R[k]<i)p1*=1;
                            else if(L[k]<i && R[k]>=i)p1*=1.0*(i-L[k])/(R[k]-L[k]+1);
                        }
                    }
                    
                    pp1+=p1;
                }
                
                double p2=1;//情况2，都选i 
                for(int j=0;j<n;j++){
                    if(S>>j & 1){
         //第j人等于i 
                        if(L[j]>i || R[j]<i)p2=0;
                        p2*=1.0/(R[j]-L[j]+1);
                    }    
                    else {
         //第j人小于i 
                        if(R[j]<i)p2*=1;
                        else if(L[j]>=i)p2=0;
                        else if(L[j]<i && R[j]>=i)p2*=1.0*(i-L[j])/(R[j]-L[j]+1);
                    }
                }
                
                ans[i]+=pp1+p2;
            }
        }
        double sum=0;
        for(int i=1;i<=10000;i++)
            sum+=ans[i]*i;
        printf("%.10lf\n",sum);
    }

cf846F——期望线性性

由期望的线性可加性，每个ai的贡献可以单独计算，每个ai的贡献当且仅当其作为区间\[L,R\]第一个出现的值  
设ai上一次出现的位置是L\[ai\], 那么ai有贡献的区间总共有2\*(i-L\[ai\])\*(n-i+1)-1  
用序列自动机往前跳

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define ll long long
    #define N 1000005
    int n,a[N],L[N],pos[N];
    double ans; 
    int main(){
        cin>>n;
        for(int i=1;i<=n;i++)cin>>a[i];
        for(int i=1;i<=n;i++){
            L[i]=pos[a[i]];
            pos[a[i]]=i;
        }
        for(int i=1;i<=n;i++)
            if(L[i]==i) ans+=2*(n-i+1)-1;
            else ans+=2ll*(i-L[i])*(n-i+1)-1;
        ans/=1ll*n*n;
        printf("%.10lf\n",ans); 
    }

cf109b——求概率转化为 统计所有合法情况个数/所有情况个数

1.  先把所有lucky数打表，排序后存在数组里
2.  一段区间内恰好有k个数，那么这k个数必定是连续的，我们枚举枚举这一段连续的的左右下标i,j可以得到两个取值区间
3.   左边界 \[v\[i-1\]+1,v\[i\]\] 右边界\[v\[j\],v\[j+1\]-1\]，然后这两个边界再和\[pl,pr\],\[vl,vr\]求交，求有多少可能的取值
4.  求出对于每个i,j的合法边界个数，然后统计求和就可以

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std; 
    #define ll long long 
    ll a[2005],cnt,pl,pr,vl,vr,k;
    void dfs(ll num){
        if(num>=1e9)return;
        if(num)a[++cnt]=num;
        dfs(num*10+4);dfs(num*10+7);
    }
    ll jiao(ll L1,ll R1,ll L2,ll R2){
          //求区间交的长度 
        if(R1<L2 || R2<L1)return 0;//不相交
        ll L=max(L1,L2),R=min(R1,R2);
        return R-L+1; 
    }
    int main(){
        dfs(0);
        cin>>pl>>pr>>vl>>vr>>k;
        sort(a+1,a+1+cnt);
        a[cnt+1]=1e9;
        
        ll ans=0;
        for(int i=1;i+k-1<=cnt;i++){
            int j=i+k-1;
            ll tmp1=jiao(pl,pr,a[i-1]+1,a[i]);
            ll tmp2=jiao(vl,vr,a[j],a[j+1]-1);
            ll tmp3=jiao(vl,vr,a[i-1]+1,a[i]);
            ll tmp4=jiao(pl,pr,a[j],a[j+1]-1);
            if(k==1){
         //特判处理 
                ans+=tmp1*tmp2+tmp3*tmp4;
                ll tmp5=jiao(pl,pr,a[i],a[i]); 
                ll tmp6=jiao(vl,vr,a[i],a[i]);
                if(tmp5 && tmp6)ans--;//(a[i],a[i]这种情况算了两次) 
            }
            else 
                ans+=tmp1*tmp2+tmp3*tmp4;
        } 
        printf("%.10lf\n",1.0*ans/((pr-pl+1)*(vr-vl+1)));
    }

cf54C——求概率转化为 统计所有合法情况个数/所有情况个数

问题：n个数，每个数的取值范围是\[Li,Ri\], 那么 k%的数第一个数为1的概率是多少

思路：先求出每个数取到首位为1的概率，然后用背包dp\[i\]\[j\]表示前i个数有j个首位为1的概率

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define ll long long 
    #define N 1005
    ll n,L[N],R[N],K,k;
    double p[N],dp[N][N];
    
    ll jiao(ll L1,ll R1,ll L2,ll R2){
    /*    cout<<R1-L2<<" ";
        cout<<R2-L1<<"\n";
    */    if(R1<L2 || R2<L1) return 0;
        ll L=max(L1,L2),R=min(R1,R2);
        return R-L+1;
    }
    double calc(ll low,ll up){
        ll sum=0;
        for(ll p=1;p<=1e18;p*=10){
            sum+=jiao(p,p*2-1,low,up);
            if(p==1e18)break;
        }
        return 1.0*sum/(up-low+1);
    }
    
    int main(){
        cin>>n;
        for(int i=1;i<=n;i++){
            cin>>L[i]>>R[i];
            p[i]=calc(L[i],R[i]);
        }
        cin>>K;
        k=(n*K)/100;
        if(n*K%100!=0)    
            k++;
        
        dp[0][0]=1;
        for(int i=1;i<=n;i++)
            for(int j=0;j<=n;j++){
                dp[i][j]+=(1-p[i])*dp[i-1][j];
                if(j)
                    dp[i][j]+=p[i]*dp[i-1][j-1];
            }
        double ans=0;
        for(int i=k;i<=n;i++)
            ans+=dp[n][i];
        printf("%.10lf\n",ans);
    }

CF540D——概率递推dp(倒序dp或记忆化搜索)

用r个石头，s个剪刀，p个布，两个不同的相遇会减掉输的那个，相同的相遇则会不变  
问最后只剩下石头，只剩下剪刀，只剩下布的概率  
dp\[i\]\[j\]\[k\]表示剩下i个石头，j个剪刀，k个布的概率  
因为本题初始状态是dp\[r\]\[s\]\[p\]=1，目标状态是dp\[0\]\[0\]\[0\],所以沿着这个状态从后往前推导就行  
最后求出dp\[1-r\]\[0\]\[0\]就是石头的答案，其它同理

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define N 105
    int r,s,p;
    double dp[N][N][N];
    int main(){
        cin>>r>>s>>p;
        dp[r][s][p]=1;
        for(int i=r;i>=0;i--)
            for(int j=s;j>=0;j--)
                for(int k=p;k>=0;k--){
                    if(i==r && j==s && k==p)continue;
                    int base=(i+j+k+1)*(i+j+k+1);
                    if(i+1<=r && (j!=0||k!=0))dp[i][j][k]+=2.0*(i+1)*k/(base-(i+1)*(i+1)-j*j-k*k)*dp[i+1][j][k];
                    if(j+1<=s && (i!=0||k!=0))dp[i][j][k]+=2.0*(j+1)*i/(base-i*i-(j+1)*(j+1)-k*k)*dp[i][j+1][k];
                    if(k+1<=p && (i!=0||j!=0))dp[i][j][k]+=2.0*(k+1)*j/(base-i*i-j*j-(k+1)*(k+1))*dp[i][j][k+1];
                } 
        double ans1=0,ans2=0,ans3=0;
        for(int i=1;i<=r;i++)ans1+=dp[i][0][0];
        for(int j=1;j<=s;j++)ans2+=dp[0][j][0];
        for(int k=1;k<=p;k++)ans3+=dp[0][0][k];
        printf("%.10lf %.10lf %.10lf\n",ans1,ans2,ans3);
    }

cf351b——期望递推dp

给定一个初始排列\{n\},AB两个人轮流操作  
A选择一个相邻的对交换位置  
B 0.5概率随机交换一个相邻的逆序对，0.5几率随机交换一个相邻的顺序对，如果没有则不交换  
当排列为递增排列时结束操作，A的策略是使两人操作次数最少，问期望操作次数  
先统计逆序对cnt,然后每次要么减一个逆序对，要么加一个逆序对，然后再减一个逆序对  
E\[i\]消i个逆序对的期望步数，因为AB两个操作分割后难以递推，那么直接一轮一轮绑定来算，  
E\[i\]=0.5\*(E\[i-2\]+2)+0.5\*(E\[i\]+2)  
E\[0\]=0,E\[1\]=1，求E\[cnt\]

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define N 3005
    int n,p[N];
    int C[N];
    void update(int x,int v){
        while(x<=n){
            C[x]+=v;
            x+=x&-x;
        }    
    }
    int query(int x){
        int res=0;
        while(x){
            res+=C[x];
            x-=x&-x;
        }
        return res;
    }
    double E[N*N];
    int main(){
        cin>>n;
        int cnt=0;
        for(int i=1;i<=n;i++){
            cin>>p[i];
            cnt+=query(n)-query(p[i]);
            update(p[i],1);
        }
        E[0]=0;E[1]=1;
        for(int i=2;i<=cnt;i++)
            E[i]=4+E[i-2];
        printf("%lf\n",E[cnt]);
    }

cf235b——概率期望的性质，

n个点，第i个点有pi概率是1，对于一段连续的长度为len的1，得分为len\*len,问这个序列的得分期望值

核心：把求连续段的期望 转化成求在这个连续段内任意点对(i,j)的贡献期望和+单点的贡献期望和

长度为len的段得分为len\*len，考虑到平方，可以将其转化为统计点对  
那么 len\*len=2\*C(len,2)+len  
由这个等式右边第一项可以看出，长为len的连续段里每个点对(i,j)的贡献是2，这个点对出现的概率是mul\{p\[i\]...p\[j\]\}  
原来要求的是len段的期望：len\*len\*其出现的概率，现在把这个段的期望拆成很多点对期望的和，(i,j)的期望就是2\*mul\{p\[i\]..p\[j\]\}  
右边第二项可以看出每个单点的贡献是1， 其出现概率就是pi

最后的结果是任意两个点对的期望和\*2+单点期望和

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include <cstdio>
    #include <cstring>
    #include <algorithm>
    using namespace std;
    int const MAX = 1e5 + 5;
    double dp[MAX], p[MAX];
     
    int main()
    {
        int n;
        scanf("%d", &n);
        double ans = 0;
        for(int i = 1; i <= n; i++)
        {
            scanf("%lf", &p[i]);
            ans += p[i];
        }
        for(int i = 2; i <= n; i++)
        {
            dp[i] = (dp[i - 1] + p[i - 1]) * p[i];
            ans += 2 * dp[i];
        }
        printf("%.10f\n", ans);
    }

cf768D——标准二维概率dp

一开始想着按求期望那个套路来求，最后发现一个二维概率dp可以直接解决

有k种不同的球，每天随机得到一种颜色的球，问每种球至少得到一个的概率大于p的期望天数  
dp\[i\]\[j\]表示前i天得到j个不同的求的概率  
dp\[0\]\[0\]=1,dp\[1\]\[1\]=1  
dp\[i\]\[j\]=j/k\*dp\[i-1\]\[j\]+(k-(j-1))/k\*dp\[i-1\]\[j-1\]  
目标状态是dp\[1..10000\]\[k\]  
对于每个询问p，枚举i\[1,10000\],只要dp\[i\]\[k\]>=p,就是答案

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define N 1005
    double p,dp[10005][N];
    int k,q; 
    int main(){
        cin>>k>>q;
        dp[0][0]=1;
        for(int i=1;i<=10000;i++)
            for(int j=1;j<=min(i,k);j++)
                dp[i][j]=1.0*j/k*dp[i-1][j]+1.0*(k-(j-1))/k*dp[i-1][j-1];
        while(q--){
            cin>>p;
            p/=2000;
            for(int i=1;i<=10000;i++)
                if(dp[i][k]>=p){
                    cout<<i<<'\n';
                    break;
                }
        }
    }

cf15E——状态压缩+概率dp

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/*
    dp[S]表示状态为S的概率
    dp[(1<<n)-1]=1,从大到小枚举S（或记忆化搜索），然后再枚举任意一个数位，来更新其他状态就可以
    复杂度约为2^26 
    */
    #include<bits/stdc++.h>
    using namespace std;
    int n;
    double dp[1<<18],a[20][20];
    int count(int S){
        int res=0;
        for(int i=0;i<n;i++)
            if(S>>i & 1)res++;
        return res;
    }
    int main(){
        cin>>n;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                cin>>a[i][j];
                
        int mask=(1<<n)-1;
        dp[mask]=1;
        
        for(int S=mask;S;S--){
            int cnt=count(S);
            if(cnt<=1)continue;
            cnt=cnt*(cnt-1)/2; 
            for(int i=0;i<n;i++)if(S>>i & 1){
                for(int j=i+1;j<n;j++)if(S>>j & 1){
                    if(i==j)continue;
                    dp[S-(1<<j)]+=a[i][j]*dp[S]/cnt;
                    dp[S-(1<<i)]+=a[j][i]*dp[S]/cnt;
                }
            }
        }
        
        for(int i=0;i<n;i++)
            printf("%.10lf ",dp[1<<i]);
        
        return 0; 
    }

cf912d——优先队列贪心

1.  在nm网格图上标记k个点，然后用r\*r的矩阵随机覆盖网格图，得分是覆盖住的点的个数
2.  现在求一种标记策略，使随机覆盖得分的期望最大
3.  对于一种标记策略，随机覆盖的期望可以转化为每个点被覆盖的期望值之和
4.   显然最中间的点的被覆盖期望最大，然后是其四周，依次类推
5.  用优先队列来维护，每次弹出一个元素，加入其周围四个元素，取前k个

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    #include<queue>
    using namespace std;
    #define N 100005
    #define ll long long
    struct Node{
        ll x,y;
        double e;
        Node(){}
        Node(ll x,ll y,double e):x(x),y(y),e(e){}
    };
    bool operator<(Node a,Node b){
        return a.e<b.e;
    }
    priority_queue<Node>pq;
    map<pair<ll,ll> ,int>vis;
    double ans;
     
    ll n,m,r,k;
    double calc(ll x,ll y){
        ll up=max(1ll,x-r+1),down=min(n-r+1,x);
        ll left=max(1ll,y-r+1),right=min(m-r+1,y);
        return 1.0*(down-up+1)*(right-left+1)/(n-r+1)/(m-r+1);
    }
     
    int a[4]={-1,1,0,0},b[4]={
         0,0,1,-1};
     
    int main(){
        cin>>n>>m>>r>>k;
        Node s;
        s.x=r;s.y=r;
        s.e=calc(s.x,s.y);
        pq.push(s);
        
        while(pq.size() && k){
            Node c=pq.top();pq.pop();
            ll x=c.x,y=c.y;
            if(vis[make_pair(x,y)]==1)continue;
            vis[make_pair(x,y)]=1;
            k--;ans+=c.e;
            
            for(int i=0;i<4;i++){
                ll dx=x+a[i],dy=y+b[i];
                if(dx<1 || dy<1 || dx>n || dy>m)continue;
                Node t;
                t.x=dx,t.y=dy;
                t.e=calc(dx,dy);
                pq.push(t);
            }
        }
        
        printf("%.10lf\n",ans);
    }

cf452C——组合数学概率推导

一副牌n张牌，把m副牌混在一起，再抽出n张，有放回地抽取两张，问一样的概率  
当只有一副牌时，抽到和原来一样的概率是1/n  
当有m副牌时，分成两部分考虑  
　　第一部分：第二次抽的是第一次抽的那张牌，概率是1/n  
　　第二部分，第二次抽的不是第一次抽的那张牌，但是和第一次抽的相同，概率是(n-1)/n\*(n-1)/(n\*m-1)  
为什么要分阶段考虑：因为两次洗牌时的洗牌范围不同，所以需要对每个范围求一次概率  
　　先在n\*m张牌里取一张牌，然后放到范围n里洗牌，那么下一次还取到这张牌的概率是1/n，不取到这张牌的概率是(n-1)/n  
　　从其他n-1张牌里取出和这张牌相同的概率是(n-1)/(n\*m-1)

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    
    int main()
    { 
        double n,m;
        cin>>n>>m;
        if (n==1&&m==1){printf("1\n");return 0;}
        double a=1.0/n;
        double b=(n-1)*(m-1)/n/(n*m-1);
        printf("%.7lf\n",a+b);
        
    }

cf261b ——组合数学+dp，期望=总量/总方案数

1.  给定一个序列ai表示第i个人的体积，现在这n个人随机排列，依次进入体积为n的房间里，问房间里人数的期望
2.  原问题转化成 总方案数/全排列 
3.  假定第一个无法进入的人是x，那么进入餐厅的人体积可以是区间\[p-a\[x\]+1,p\]
4.  令dp\[i,j,k\]表示前i个人，进了j个，体积是k的方案数
5.  dp\[0\]\[0\]\[0\]=1,
6.  dp\[i\]\[j\]\[k\]=dp\[i-1\]\[j\]\[k\]+dp\[i-1\]\[j-1\]\[k-a\[i\]\]
7.  最后要求的是每个 j\*j!\*(n-j-1)!\*dp\[n\]\[j\]\[p-a\[x\]+1,p\]，即j\*进入j个人的方案数，然后求和就是总方案数

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include<bits/stdc++.h>
    using namespace std;
    #define N 55
    int n,a[N],p;
    double dp[N][N][N],F[N];
    
    int main(){
        F[0]=1;
        for(int i=1;i<=50;i++)F[i]=1.0*i*F[i-1];
        
        cin>>n;int sum=0;
        for(int i=1;i<=n;i++)
            cin>>a[i],sum+=a[i];
        cin>>p;
        if(sum<=p){cout<<n<<endl;return 0;}
        
        double ans=0;
        for(int x=1;x<=n;x++){
            memset(dp,0,sizeof dp);
            dp[0][0][0]=1;
            for(int i=1;i<=n;i++)
                for(int j=0;j<=i;j++)
                    for(int k=0;k<=p;k++){
                        if(x==i){dp[i][j][k]=dp[i-1][j][k];continue;}
                        dp[i][j][k]=dp[i-1][j][k];
                        if(j && k>=a[i])dp[i][j][k]+=dp[i-1][j-1][k-a[i]];
                    }
            for(int j=1;j<n;j++)
                for(int k=max(0,p-a[x]+1);k<=p;k++)
                    ans+=F[j]*F[n-j-1]*j*dp[n][j][k];
        }    
        printf("%.10lf\n",ans/F[n]);
    }

转载于:https://www.cnblogs.com/zsben991126/p/11446533.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif