题意

写的很明白了，不需要解释。

\(\texttt{Data Range:}1\leq n\leq 234567\)

题解

国 际 计 数 水 平

首先考虑一开始只有一个黑点的情况怎么做。

我们钦定黑点为根，设 \(f_i\) 表示以 \(i\) 为子树，并且 \(i\) 这个节点为黑色的答案，那么我们得到：

\[f_u=(sz_u-1)!\prod\limits_{fa_v=u}\frac{f_v}{sz_v!}
\]

接下来我们阐述这个式子到底是在干什么。

首先我们枚举可能的排列，由于现在只有 \(u\) 是黑色的，第一轮肯定是先把 \(u\) 变成红色。也就是说，\(u\) 只能放在第一个，而剩下的可以任意。（注意这里是可能而不是合法）

接下来考虑排除掉所有不合法的排列，枚举每一棵子树，考虑某棵子树所有节点之间的偏序关系。

对于一个树 \(T\) 对应的可能的序列 \(P\) 来说，我们按顺序从 \(P\) 中选出一些元素构造 \(Q\)，使得 \(Q\) 中的每一个元素都是 \(T\) 中某个子树 \(S\) 中存在的节点的编号，并且 \(S\) 中每个节点的编号都要在 \(Q\) 中出现。

这里，\(T\) 的根为 \(u\)，\(S\) 的根为 \(v\) 且 \(fa_v=u\)。

然后我们发现，如果序列 \(Q\) 是不合法的，那么序列 \(P\) 也是不合法的。

对所有子树都这么做就得到同时满足所有约束的序列个数，也就是上面的式子。

接下来我们考虑直接计算根节点的答案。

\[f_{rt}=\frac{(sz_{rt}-1)!}{\prod\limits_{fa_v=rt}sz_v!}\prod\limits_{fa_v=rt}f_v
\]

然后我们对于所有根节点的儿子 \(v\) 代入进来，再将所有孙子代入进来……相当于我们枚举所有节点计算，于是有

\[f_{rt}=\prod\limits_{u=1}^{n}\frac{(sz_{u}-1)!}{\prod\limits_{fa_v=u}sz_v!}
\]

简单化开

\[f_{rt}=\frac{\prod\limits_{u=1}^{n}(sz_{u}-1)!}{\prod\limits_{u=1}^{n}\prod\limits_{fa_v=u}sz_v!}
\]

注意分母，也就是说我们对于每个节点 \(u\) 都枚举 \(u\) 的所有儿子，相当于枚举所有非根节点（因为每个非根节点总会是某个节点的儿子），于是有

\[f_{rt}=\frac{\prod\limits_{u=1}^{n}(sz_{u}-1)!}{\prod\limits_{u=1,u\neq rt}^{n}sz_u!}
\]

现在来拆分子。单独把 \(u=rt\) 的拿出来，剩下的合并并约分，得到

\[f_{rt}=(sz_{rt}-1)!\prod\limits_{u=1,u\neq rt}^{n}\frac{1}{sz_u}
\]

然后分子分母同乘一个 \(sz_{rt}\) 得到答案为

\[f_{rt}=sz_{rt}!\prod\limits_{u=1}^{n}\frac{1}{sz_u}
\]

接下来考虑两个黑点咋做，建立一个虚拟节点 \(s\)，向 \(a,b\) 连无向边，初始的时候只有 \(s\) 是黑点。

第一次只能变 \(s\)，然后就变成 \(s\) 是红点，\(a,b\) 是黑点。容易证明这样对答案没有任何影响。

于是树就变成了一颗基环树，考虑怎么求答案。

我们枚举环上染红的最后一个点的位置，但是这是不可行的。

那么我们就用类似于 NOIp2018 Day 2 T1 的方法，考虑枚举一条在环上的边并删除他来计算答案。

但是这样做可能会用重复的答案，所以我们要考虑如何来排除这些答案。

注意到对于一种染色方案来说，考虑这个方案在环上最后一个被染成红色的点。我们发现这个点可以有两种方案被染黑，也就是说每个方案都会算 \(2\) 此，于是最终答案要乘上 \(\frac{1}{2}\)。

对于不是环上的点和虚拟节点 \(s\) 我们都能用 \(\texttt{dfs}\) 求出子树大小，设他们的和为 \(z\)。

我们现在考虑这些在环上的点，对于某个在环上的点 \(u\) 来说，设 \(a_u\) 表示它的确定子树大小（也就是所有不在环上的儿子的大小之和加一），\(b_u\) 表示某种断环方式下的 \(sz_u\)，那么通过人类智慧我们发现

将环上的 \(k+1\) 个点编号，\(s\) 点为 \(0\)，其余的依次为 \(1\sim k\)，假设断的边是 \(r\to r+1\)，那么

\[b_u=\begin{cases}\sum\limits_{i=1}^{u}a_u,& 1\leq u\leq r\\\sum\limits_{i=u}^{k}a_u,&r+1\leq u\leq k\end{cases}
\]

我们对 \(a\) 做前缀和变成 \(c\)，那么可以发现

\[\prod b=\prod_{i\neq j}\vert c_i-c_j\vert
\]

其中 \(c_0=0\)。

然后我们可以用快速插值的套路去优化这个东西，复杂度 \(O(n\log^2n)\)。

代码

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<cctype>
  4. #include<cmath>
  5. #include<iostream>
  6. #include<algorithm>
  7. #include<vector>
  8. #define clr(f,n) memset(f,0,sizeof(int)*(n))
  9. #define cpy(f,g,n) memcpy(f,g,sizeof(int)*(n))
  10. #pragma GCC optimize("Ofast")
  11. #pragma GCC optimize("unroll-loops")
  12. using namespace std;
  13. typedef int ll;
  14. typedef long long int li;
  15. typedef unsigned long long int ull;
  16. const ll MAXN=524291,MOD=998244353,G=3,INVG=332748118;
  17. struct Edge{
  18.     ll to,prev;
  19. };
  20. Edge ed[MAXN];
  21. ll n,x,y,z,fct,from,to,tot,tp,cur,res;
  22. ll rev[MAXN],omgs[MAXN],invo[MAXN];
  23. ll last[MAXN],sz[MAXN],fa[MAXN],st[MAXN],p[MAXN],c[MAXN];
  24. ll pr[MAXN],px[MAXN];
  25. inline ll read()
  26. {
  27.     register ll num=0,neg=1;
  28.     register char ch=getchar();
  29.     while(!isdigit(ch)&&ch!='-')
  30.     {
  31.         ch=getchar();
  32.     }
  33.     if(ch=='-')
  34.     {
  35.         neg=-1;
  36.         ch=getchar();
  37.     }
  38.     while(isdigit(ch))
  39.     {
  40.         num=(num<<3)+(num<<1)+(ch-'0');
  41.         ch=getchar();
  42.     }
  43.     return num*neg;
  44. }
  45. inline void addEdge(ll from,ll to)
  46. {
  47.     ed[++tot].prev=last[from];
  48.     ed[tot].to=to;
  49.     last[from]=tot;
  50. }
  51. inline void dfs(ll node,ll f)
  52. {
  53.     sz[node]=1,fa[node]=f;
  54.     for(register int i=last[node];i;i=ed[i].prev)
  55.     {
  56.         if(ed[i].to!=f)
  57.         {
  58.             dfs(ed[i].to,node),sz[node]+=sz[ed[i].to];
  59.         }
  60.     }
  61. }
  62. inline ll qpow(ll base,ll exponent)
  63. {
  64.     ll res=1;
  65.     while(exponent)
  66.     {
  67.         if(exponent&1)
  68.         {
  69.             res=(li)res*base%MOD;
  70.         }
  71.         base=(li)base*base%MOD,exponent>>=1;
  72.     }
  73.     return res;
  74. }
  75. inline void setupOmg(ll cnt)
  76. {
  77.     ll limit=log2(cnt)-1,omg;
  78.     omg=qpow(G,(MOD-1)>>(limit+1)),omgs[cnt>>1]=1;
  79.     for(register int i=(cnt>>1|1);i!=cnt;i++)
  80.     {
  81.         omgs[i]=(li)omgs[i-1]*omg%MOD;
  82.     }
  83.     for(register int i=(cnt>>1)-1;i;i--)
  84.     {
  85.         omgs[i]=omgs[i<<1];
  86.     }
  87. }
  88. inline void NTT(ll *cp,ll cnt,ll inv)
  89. {
  90.     static ull tcp[MAXN];
  91.     register ll cur=0,x,shift=log2(cnt)-__builtin_ctz(cnt);
  92.     if(inv==-1)
  93.     {
  94.         reverse(cp+1,cp+cnt);
  95.     }
  96.     for(register int i=0;i<cnt;i++)
  97.     {
  98.         tcp[rev[i]>>shift]=cp[i];
  99.     }
  100.     for(register int i=2;i<=cnt;i<<=1)
  101.     {
  102.         cur=i>>1;
  103.         for(register int j=0;j<cnt;j+=i)
  104.         {
  105.             for(register int k=0;k<cur;k++)
  106.             {
  107.                 x=tcp[j|k|cur]*omgs[k|cur]%MOD;
  108.                 tcp[j|k|cur]=tcp[j|k]+MOD-x,tcp[j|k]+=x;
  109.             }
  110.         }
  111.     }
  112.     for(register int i=0;i<cnt;i++)
  113.     {
  114.         cp[i]=tcp[i]%MOD;
  115.     }
  116.     if(inv==1)
  117.     {
  118.         return;
  119.     }
  120.     x=MOD-(MOD-1)/cnt;
  121.     for(register int i=0;i<cnt;i++)
  122.     {
  123.         cp[i]=(li)cp[i]*x%MOD;
  124.     }
  125. }
  126. inline void conv(ll fd,ll *f,ll *g,ll *res)
  127. {
  128.     static ll tmpf[MAXN],tmpg[MAXN];
  129.     ll cnt=1,limit=-1;
  130.     while(cnt<(fd<<1))
  131.     {
  132.         cnt<<=1,limit++;
  133.     }
  134.     for(register int i=0;i<cnt;i++)
  135.     {
  136.         tmpf[i]=i<fd?f[i]:0,tmpg[i]=i<fd?g[i]:0;
  137.         rev[i]=(rev[i>>1]>>1)|((i&1)<<limit);
  138.     }
  139.     NTT(tmpf,cnt,1),NTT(tmpg,cnt,1);
  140.     for(register int i=0;i<cnt;i++)
  141.     {
  142.         tmpf[i]=(li)tmpf[i]*tmpg[i]%MOD;
  143.     }
  144.     NTT(tmpf,cnt,-1),cpy(res,tmpf,fd);
  145. }
  146. inline void inv(ll fd,ll *f,ll *res)
  147. {
  148.     static ll tmp[MAXN];
  149.     if(fd==1)
  150.     {
  151.         res[0]=qpow(f[0],MOD-2);
  152.         return;
  153.     }
  154.     inv((fd+1)>>1,f,res);
  155.     ll cnt=1,limit=-1;
  156.     while(cnt<(fd<<1))
  157.     {
  158.         cnt<<=1,limit++;
  159.     }
  160.     for(register int i=0;i<cnt;i++)
  161.     {
  162.         tmp[i]=i<fd?f[i]:0;
  163.         rev[i]=(rev[i>>1]>>1)|((i&1)<<limit);
  164.     }
  165.     NTT(tmp,cnt,1),NTT(res,cnt,1);
  166.     for(register int i=0;i<cnt;i++)
  167.     {
  168.         res[i]=(li)(2-(li)tmp[i]*res[i]%MOD+MOD)%MOD*res[i]%MOD;
  169.     }
  170.     NTT(res,cnt,-1),clr(res+fd,cnt-fd-1);
  171. }
  172. inline void mod(ll fd,ll gd,ll *f,ll *g,ll *r)
  173. {
  174.     static ll tmpf[MAXN],tmpg[MAXN],tinv[MAXN],q[MAXN];
  175.     if(fd<gd)
  176.     {
  177.         for(register int i=0;i<gd-1;i++)
  178.         {
  179.             r[i]=f[i];
  180.         }
  181.         return;
  182.     }
  183.     for(register int i=0;i<fd;i++)
  184.     {
  185.         tmpf[i]=f[fd-1-i];
  186.     }
  187.     for(register int i=0;i<gd;i++)
  188.     {
  189.         tmpg[i]=g[gd-1-i];
  190.     }
  191.     inv(fd-gd+2,tmpg,tinv);
  192.     ll cnt=1,limit=-1;
  193.     while(cnt<(fd<<1))
  194.     {
  195.         cnt<<=1,limit++;
  196.     }
  197.     for(register int i=0;i<cnt;i++)
  198.     {
  199.         rev[i]=(rev[i>>1]>>1)|((i&1)<<limit);
  200.     }
  201.     NTT(tmpf,cnt,1),NTT(tinv,cnt,1);
  202.     for(register int i=0;i<cnt;i++)
  203.     {
  204.         q[i]=1ll*tmpf[i]*tinv[i]%MOD;
  205.     }
  206.     NTT(q,cnt,-1),reverse(q,q+fd-gd+1);
  207.     for(register int i=0;i<cnt;i++)
  208.     {
  209.         tmpf[i]=tinv[i]=tmpg[i]=0;
  210.         q[i]=i<fd-gd+1?q[i]:0,g[i]=i<gd?g[i]:0;
  211.     }
  212.     cnt>>=1,limit--;
  213.     for(register int i=0;i<cnt;i++)
  214.     {
  215.         rev[i]=(rev[i>>1]>>1)|((i&1)<<limit);
  216.     }
  217.     NTT(q,cnt,1),NTT(g,cnt,1);
  218.     for(register int i=0;i<cnt;i++)
  219.     {
  220.         tmpf[i]=1ll*q[i]*g[i]%MOD;
  221.     }
  222.     NTT(g,cnt,-1),NTT(tmpf,cnt,-1);
  223.     for(register int i=0;i<gd-1;i++)
  224.     {
  225.         r[i]=(f[i]-tmpf[i]+MOD)%MOD;
  226.     }
  227.     for(register int i=0;i<cnt;i++)
  228.     {
  229.         q[i]=tmpf[i]=0;
  230.     }
  231. }
  232. vector<ll> tmpf2[MAXN<<2];
  233. void dnc(ll *pts,ll l,ll r,ll node)
  234. {
  235.     static ll tmp[MAXN],tmp2[MAXN];
  236.     if(l==r)
  237.     {
  238.         tmpf2[node].push_back((MOD-pts[l])%MOD),tmpf2[node].push_back(1);
  239.         return;
  240.     }
  241.     ll mid=(l+r)>>1,ls=node<<1,rs=ls|1;
  242.     dnc(pts,l,mid,ls),dnc(pts,mid+1,r,rs);
  243.     ll d=tmpf2[ls].size(),d2=tmpf2[rs].size();
  244.     copy(tmpf2[ls].begin(),tmpf2[ls].end(),tmp);
  245.     copy(tmpf2[rs].begin(),tmpf2[rs].end(),tmp2);
  246.     ll cnt=1,limit=-1;
  247.     while(cnt<(d+d2))
  248.     {
  249.         cnt<<=1,limit++;
  250.     }
  251.     for(register int i=0;i<cnt;i++)
  252.     {
  253.         rev[i]=(rev[i>>1]>>1)|((i&1)<<limit);
  254.     }
  255.     NTT(tmp,cnt,1),NTT(tmp2,cnt,1);
  256.     for(register int i=0;i<cnt;i++)
  257.     {
  258.         tmp[i]=(li)tmp[i]*tmp2[i]%MOD;
  259.     }
  260.     NTT(tmp,cnt,-1),tmpf2[node].resize(d+d2-1);
  261.     copy(tmp,tmp+d+d2-1,tmpf2[node].begin()),clr(tmp,cnt),clr(tmp2,cnt);
  262. }
  263. ll tmpf3[19][MAXN];
  264. void dnc2(ll fd,ll *f,ll depth,ll l,ll r,ll node,ll *res)
  265. {
  266.     static ll tmp[MAXN],pw[17];
  267.     if(r-l<=1024)
  268.     {
  269.         for(register int i=l;i<=r;i++)
  270.         {
  271.             ll x=c[i],cur=f[fd-1],v1,v2,v3,v4;
  272.             pw[0]=1;
  273.             for(register int j=1;j<=16;j++)
  274.             {
  275.                 pw[j]=1ll*pw[j-1]*x%MOD;
  276.             }
  277.             for(register int j=fd-2;j-15>=0;j-=16)
  278.             {
  279.                 v1=(1ll*cur*pw[16]+1ll*f[j]*pw[15]+
  280.                     1ll*f[j-1]*pw[14]+1ll*f[j-2]*pw[13])%MOD;
  281.                 v2=(1ll*f[j-3]*pw[12]+1ll*f[j-4]*pw[11]+
  282.                     1ll*f[j-5]*pw[10]+1ll*f[j-6]*pw[9])%MOD;
  283.                 v3=(1ll*f[j-7]*pw[8]+1ll*f[j-8]*pw[7]+
  284.                     1ll*f[j-9]*pw[6]+1ll*f[j-10]*pw[5])%MOD;
  285.                 v4=(1ll*f[j-11]*pw[4]+1ll*f[j-12]*pw[3]+
  286.                     1ll*f[j-13]*pw[2]+1ll*f[j-14]*pw[1])%MOD;
  287.                 cur=(0ll+v1+v2+v3+v4+f[j-15])%MOD;
  288.             }
  289.             for(register int j=((fd-1)&15)-1;~j;j--)
  290.             {
  291.                 cur=(1ll*cur*x+f[j])%MOD;
  292.             }
  293.             res[i]=cur;
  294.         }
  295.         return;
  296.     }
  297.     ll sz=tmpf2[node].size()-1;
  298.     for(register int i=0;i<sz+1;i++)
  299.     {
  300.         tmp[i]=tmpf2[node][i];
  301.     }
  302.     clr(tmpf3[depth],sz+10),mod(fd,sz+1,f,tmp,tmpf3[depth]);
  303.     ll mid=(l+r)>>1;
  304.     dnc2(sz,tmpf3[depth],depth+1,l,mid,node<<1,res);
  305.     dnc2(sz,tmpf3[depth],depth+1,mid+1,r,(node<<1)|1,res);
  306.     for(register int i=0;i<sz;i++)
  307.     {
  308.         tmpf3[depth][i]=0;
  309.     }
  310. }
  311. inline void eval(ll fd,ll pcnt,ll *f,ll *pts,ll *res)
  312. {
  313.     dnc(pts,0,pcnt-1,1),dnc2(fd,f,0,0,pcnt-1,1,res);
  314. }
  315. int main()
  316. {
  317.     setupOmg(524288),n=read(),x=read(),y=read();
  318.     for(register int i=0;i<n-1;i++)
  319.     {
  320.         from=read(),to=read();
  321.         addEdge(from,to),addEdge(to,from);
  322.     }
  323.     dfs(x,0);
  324.     while(y!=x)
  325.     {
  326.         st[++tp]=y,p[y]=1,y=fa[y];
  327.     }
  328.     st[++tp]=y,p[y]=1,y=fa[y],z=n+1,fct=1;
  329.     for(register int i=1;i<=tp;i++)
  330.     {
  331.         c[i]=1;
  332.         for(register int j=last[st[i]];j;j=ed[j].prev)
  333.         {
  334.             if(!p[ed[j].to])
  335.             {
  336.                 c[i]+=sz[ed[j].to];
  337.             }
  338.         }
  339.     }
  340.     for(register int i=1;i<=n;i++)
  341.     {
  342.         fct=(li)fct*i%MOD;
  343.         if(!p[i])
  344.         {
  345.             z=(li)z*sz[i]%MOD;
  346.         }
  347.     }
  348.     fct=(li)fct*(n+1)%MOD;
  349.     for(register int i=1;i<=tp;i++)
  350.     {
  351.         c[i]=(c[i-1]+c[i])%MOD;
  352.     }
  353.     dnc(c,1,tp+1,1);
  354.     for(register int i=1;i<=tp+1;i++)
  355.     {
  356.         pr[i-1]=(li)i*tmpf2[1][i]%MOD;
  357.     }
  358.     memset(tmpf2,0,sizeof(tmpf2)),eval(n+1,tp+1,pr,c,px);
  359.     for(register int i=0;i<=tp;i++)
  360.     {
  361.         cur=(li)fct*qpow((li)px[i]*z%MOD,MOD-2)%MOD;
  362.         res=(res+(((tp-i)&1)?MOD-cur:cur))%MOD;
  363.     }
  364.     printf("%d\n",(li)res*499122177%MOD);
  365. }

Luogu P5450 [THUPC2018]淘米神的树的更多相关文章

  1. 【LOJ】#6391. 「THUPC2018」淘米神的树 / Tommy

    题解 一道非常神仙的计数题 如果只有一个点,就是非常简单的树型dp \(f_{u} = (siz_{u} - 1)! \prod_{v \in son_{u}} \frac{f_{v}}{siz_{v ...

  2. Luogu 2680 NOIP 2015 运输计划（树链剖分，LCA，树状数组，树的重心，二分，差分）

    Luogu 2680 NOIP 2015 运输计划(树链剖分,LCA,树状数组,树的重心,二分,差分) Description L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之 ...

  3. [Luogu 3701] 「伪模板」主席树

    [Luogu 3701] 「伪模板」主席树 这是一道网络流,不是主席树,不是什么数据结构,而是网络流. 题目背景及描述都非常的暴力,以至于 Capella 在做此题的过程中不禁感到生命流逝. S 向 ...

  4. [题解] Luogu P5446 [THUPC2018]绿绿和串串

    [题解] Luogu P5446 [THUPC2018]绿绿和串串 ·题目大意 定义一个翻转操作\(f(S_n)\),表示对于一个字符串\(S_n\), 有\(f(S)= \{S_1,S_2,..., ...

  5. 上午小测3 T1 括号序列 && luogu P5658 [CSP/S 2019 D1T2] 括号树 题解

    前 言: 一直很想写这道括号树..毕竟是在去年折磨了我4个小时的题.... 上午小测3 T1 括号序列 前言: 原来这题是个dp啊...这几天出了好几道dp,我都没看出来,我竟然折磨菜. 考试的时候先 ...

  6. 【kAri OJ】621. 廖神的树

    时间限制 3000 ms 内存限制 65536 KB 题目描述 廖神和男神在植树节的时候准备玩一个奇怪的游戏,他们现在有一个被分割成n*n个格子的矩形土地,他们现在准备往这个地里种树,但这个种树游戏必 ...

  7. Luogu Dynamic Ranking (带修改的主席树)

    题目大意: 网址:https://www.luogu.org/problemnew/show/2617 给定一个序列a[1].a[2].....a[N],完成M个操作,操作有两种: [1]Q i j ...

  8. Luogu 4294 [WC2008]游览计划 | 斯坦纳树

    题目链接 Luogu 4294 (我做这道题的时候BZOJ全站的SPJ都炸了 提交秒WA 幸好有洛谷) 题解 这道题是[斯坦纳树]的经典例题.斯坦纳树是这样一类问题:带边权无向图上有几个(一般约10个 ...

  9. Luogu 3369 / BZOJ 3224 - 普通平衡树 - [替罪羊树]

    题目链接: https://www.lydsy.com/JudgeOnline/problem.php?id=3224 https://www.luogu.org/problemnew/show/P3 ...

随机推荐

  1. Win10安装Ubuntu子系统

    相信我,这是最后一次折腾系统了qaq,以后一定开始认真用Linux编程 跟的一个博客安装,传送门:Win10安装Ubuntu子系统及图形化界面详细教程 文章是2019的,加上我装的是Ubuntu 20 ...

  2. OpenCV图像处理学习笔记-Day03

    OpenCV图像处理学习笔记-Day03 目录 OpenCV图像处理学习笔记-Day03 第31课:Canny边缘检测原理 第32课:Canny函数及使用 第33课:图像金字塔-理论基础 第34课:p ...

  3. 伺服电机的Arduino库函数

    servo.attach(pin)  //连接伺服电机的信号线于控制板的引脚,9或10号引脚servo.attach(pin, min, max) servo: a variable of type ...

  4. Ubuntu常用工具安装

    安装 aptitude 管理软件 $ sudo apt-get install aptitude 安装gdebi(安装deb包) # 安装: $ sudo apt install gdebi-core ...

  5. winfrom加载自定义控件、窗口pannel后闪烁问题

    我用一个panel当容器,里面有好多控件,加载的时候一直闪烁. 借鉴网友的思路: 窗口初始化界面加入代码 this.DoubleBuffered = true;//设置本窗体   SetStyle(C ...

  6. Docker镜像仓库Harbor部署

    一.Harbor组件 组件 功能 harbor-adminserver 配置管理中心 harbor-db Mysql数据库 harbor-jobservice 负责镜像复制 harbor-log 记录 ...

  7. TP5上传图片到七牛云，并且删除七牛云的图片

    一,通过composer 下载七牛云 sdk composer require qiniu/php-sdk 二,手动下载七牛云sdk 1,https://developer.qiniu.com/kod ...

  8. OpenCV计算机视觉学习（4）——图像平滑处理（均值滤波，高斯滤波，中值滤波，双边滤波）

    如果需要处理的原图及代码,请移步小编的GitHub地址 传送门:请点击我 如果点击有误:https://github.com/LeBron-Jian/ComputerVisionPractice &q ...

  9. Java bean 链式获取成员变量无需判空的工具设计

    Java bean 链式获取成员变量无需判空的工具设计 本篇文章已发布至公众号 Hollis 对于Java程序员来说,null是令人头痛的东西.时常会受到空指针异常(NPE)的骚扰.连Java的发明者 ...

  10. C++ 构造函数、拷贝构造函数、赋值运算符

    <C++ Primer Plus> 12.1 动态内存和类 12.1.1 复习示例和静态类成员 不能在类声明中初始化静态成员变量,这是因为声明描述了如何分配内存,但并不分配内存 如果在头文 ...