杜教BM模板

最新推荐文章于 2020-08-17 16:15:47 发布
最新推荐文章于 2020-08-17 16:15:47 发布
阅读量346 收藏 1
点赞数 1
分类专栏： 推公式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45458915/article/details/106040237
版权

找规律的黑科技

用法：先在vector a中放上线性数列的前几项，就可以很快递推出任一项

注意：

  1. 可以取模，但模数必须为质数
  2. 必须为线性方程

模板：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <cassert>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef long long ll;
typedef pair<int,int> PII;
const ll mod=998244353;
ll powmod(ll a,ll b)
{
    ll res=1;
    a%=mod;
    assert(b>=0);
    for(;b;b>>=1)
    {
        if(b&1)
            res=res*a%mod;
        a=a*a%mod;
    }
    return res;
}
int _,n;
namespace linear_seq {
    const int N=10010;
    ll res[N],base[N],_c[N],_md[N];
    vector<int> Md;
    void mul(ll *a,ll *b,int k) {
        for(int i = 0 ; i < k + k ; ++i)
        _c[i]=0;
        for(int i = 0 ; i < k ;++i)
         if (a[i])
         for(int j = 0 ;j < k ;++ j)
            _c[i+j]=(_c[i+j]+a[i]*b[j])%mod;
        for (int i=k+k-1;i>=k;i--)
            if (_c[i])
            for(int j = 0 ; j<(int ) Md.size() ; ++ j)
                _c[i-k+Md[j]]=(_c[i-k+Md[j]]-_c[i]*_md[Md[j]])%mod;
        for(int i =0 ; i< k ; ++i)
        a[i]=_c[i];
    }
    int solve(ll n,VI a,VI b) {
        ll ans=0,pnt=0;
        int k=SZ(a);
        assert( SZ(a) == SZ(b) );
        for(int i = 0 ;i < k ; ++ i)
         _md[k-1-i] = -a[i] ; _md[k] = 1 ;
        Md.clear() ;
        for(int i =0 ; i < k ; ++ i)
            if (_md[i]!=0)
                Md.push_back(i);
        for(int i = 0; i< k ;++ i)
         res[i]=base[i]=0;
        res[0]=1;
        while ((1ll<<pnt)<=n)
        pnt++;
        for (int p=pnt;p>=0;p--) {
            mul(res,res,k);
            if ((n>>p)&1) {
                for (int i=k-1;i>=0;i--) res[i+1]=res[i];res[0]=0;
                for(int j = 0 ;j < (int)Md.size() ; ++ j)
                 res[ Md[j] ]=(res[ Md[j] ]-res[k]*_md[Md[j]])%mod;
            }
        }
        rep(i,0,k) ans=(ans+res[i]*b[i])%mod;
        if (ans<0) ans+=mod;
        return ans;
    }
    VI BM(VI s) {
        VI C(1,1),B(1,1);
        int L=0,m=1,b=1;
        for(int n= 0 ;n < (int)s.size(); ++ n ) {
            ll d=0;
            for(int i =0 ; i < L +1 ;++ i)
            d=(d+(ll)C[i]*s[n-i])%mod;
            if (d==0) ++m;
            else if (2*L<=n) {
                VI T=C;
                ll c=mod-d*powmod(b,mod-2)%mod;
                while (SZ(C)<SZ(B)+m)
                    C.push_back(0);
                for(int i =0 ; i < (int)B.size(); ++ i)
                    C[i+m]=(C[i+m]+c*B[i])%mod;
                L=n+1-L; B=T; b=d; m=1;
            } else {
                ll c=mod-d*powmod(b,mod-2)%mod;
                while (SZ(C)<SZ(B)+m)
                    C.push_back(0);
                for(int i = 0 ;i <(int) B.size() ; ++ i)
                    C[i+m]=(C[i+m]+c*B[i])%mod;
                ++m;
            }
        }
        return C;
    }
    ll gao(VI a,ll n) {
        VI c=BM(a);
        c.erase(c.begin());
        for( int i = 0 ; i < (int)c.size( );++i )
            c[i]=(mod-c[i])%mod;
        return (ll)solve(n,c,VI(a.begin(),a.begin()+SZ(c)));
    }
};
int main() {
    long long n;VI a;
    int N,v;
    a.push_back(4);
    a.push_back(12);
    a.push_back(33);
    a.push_back(88);
    a.push_back(232);
    a.push_back(609);
    a.push_back(1596);
    for (;~scanf("%lld",&n);)
    printf("%lld\n",linear_seq::gao(a,n-1));
    return 0 ;
}

输出公式版

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,n) for(int i=a;i<n;i++)
namespace linear
{
    ll mo=1000000009;
    vector<ll> v;
    double a[105][105],del;
    int k;
    struct matrix
    {
        int n;
        ll a[50][50];
        matrix operator * (const matrix & b)const
        {
            matrix c;
            c.n=n;
            rep(i,0,n)rep(j,0,n)c.a[i][j]=0;
            rep(i,0,n)rep(j,0,n)rep(k,0,n)
            c.a[i][j]=(c.a[i][j]+a[i][k]*b.a[k][j]%mo)%mo;
            return c;
        }
    }A;
    bool solve(int n)
    {
        rep(i,1,n+1)
        {
            int t=i;
            rep(j,i+1,n+1)if(fabs(a[j][i])>fabs(a[t][i]))t=j;
            if(fabs(del=a[t][i])<1e-6)return false;
            rep(j,i,n+2)swap(a[i][j],a[t][j]);
            rep(j,i,n+2)a[i][j]/=del;
            rep(t,1,n+1)if(t!=i)
            {
                del=a[t][i];
                rep(j,i,n+2)a[t][j]-=a[i][j]*del;
            }
        }
        return true;
    }
    void build(vector<ll> V)
    {
        v=V;
        int n=(v.size()-1)/2;
        k=n;
        while(1)
        {
            rep(i,0,k+1)
            {
                rep(j,0,k)a[i+1][j+1]=v[n-1+i-j];
                a[i+1][k+1]=1;
                a[i+1][k+2]=v[n+i];
            }
            if(solve(n+1))break;
            n--;k--;
        }
        A.n=k+1;
        rep(i,0,A.n)rep(j,0,A.n)A.a[i][j]=0;
        rep(i,0,A.n)A.a[i][0]=(int)round(a[i+1][A.n+1]);
        rep(i,0,A.n-2)A.a[i][i+1]=1;
        A.a[A.n-1][A.n-1]=1;
    }
    void formula()
    {
        printf("f(n) =");
        rep(i,0,A.n-1)printf(" (%lld)*f(n-%d) +",A.a[i][0],i+1);
        printf(" (%lld)\n",A.a[A.n-1][0]);
    }
    ll cal(ll n)
    {
        if(n<v.size())return v[n];
        n=n-k+1;
        matrix B,T=A;
        B.n=A.n;
        rep(i,0,B.n)rep(j,0,B.n)B.a[i][j]=i==j?1:0;
        while(n)
        {
            if(n&1)B=B*T;
            n>>=1;
            T=T*T;
        }
        ll ans=0;
        rep(i,0,B.n-1)ans=(ans+v[B.n-2-i]*B.a[i][0]%mo)%mo;
        ans=(ans+B.a[B.n-1][0])%mo;
        while(ans<0)ans+=mo;
        return ans;
    }
}
int main(void){
    vector<ll> V;
    V.push_back(3);
    V.push_back(9);
    V.push_back(20);
    V.push_back(46);
    V.push_back(106);
    V.push_back(244);
    V.push_back(560);
    V.push_back(1286);
    V.push_back(2956);
    V.push_back(6794);
    V.push_back(15610);
    linear::build(V);
    linear::formula();
//    ll n;
//    while(~scanf("%lld",&n))
//    {
//        printf("%lld\n",linear::cal(n-1));
//    }
    return 0;
}

求任意模数的BM模板（模数可以为非质数）

#include <bits/stdc++.h>
 
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>//用tree
 
using namespace __gnu_pbds;
 
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
#define mp make_pair
#define pb push_back
#define sqr(x) ((x)*(x))
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int mn = 105;
const int mod = 1000000000;
 
int n, m;
 
// given first m items init[0..m-1] and coefficents trans[0..m-1] or
// given first 2 *m items init[0..2m-1], it will compute trans[0..m-1]
// for you. trans[0..m] should be given as that
//      init[m] = sum_{i=0}^{m-1} init[i] * trans[i]
struct LinearRecurrence {
    using int64 = long long;
    using vec = std::vector<int64>;
 
    static void extand(vec &a, size_t d, int64 value = 0) {
        if (d <= a.size()) return;
        a.resize(d, value);
    }
 
    static vec BerlekampMassey(const vec &s, int64 mod) {
        std::function<int64(int64)> inverse = [&](int64 a) {
            return a == 1 ? 1 : (int64) (mod - mod / a) * inverse(mod % a) % mod;
        };
        vec A = {1}, B = {1};
        int64 b = s[0];
        for (size_t i = 1, m = 1; i < s.size(); ++i, m++) {
            int64 d = 0;
            for (size_t j = 0; j < A.size(); ++j) {
                d += A[j] * s[i - j] % mod;
            }
            if (!(d %= mod)) continue;
            if (2 * (A.size() - 1) <= i) {
                auto temp = A;
                extand(A, B.size() + m);
                int64 coef = d * inverse(b) % mod;
                for (size_t j = 0; j < B.size(); ++j) {
                    A[j + m] -= coef * B[j] % mod;
                    if (A[j + m] < 0) A[j + m] += mod;
                }
                B = temp, b = d, m = 0;
            } else {
                extand(A, B.size() + m);
                int64 coef = d * inverse(b) % mod;
                for (size_t j = 0; j < B.size(); ++j) {
                    A[j + m] -= coef * B[j] % mod;
                    if (A[j + m] < 0) A[j + m] += mod;
                }
            }
        }
        return A;
    }
 
    static void exgcd(int64 a, int64 b, int64 &g, int64 &x, int64 &y) {
        if (!b) x = 1, y = 0, g = a;
        else {
            exgcd(b, a % b, g, y, x);
            y -= x * (a / b);
        }
    }
 
    static int64 crt(const vec &c, const vec &m) {
        int n = c.size();
        int64 M = 1, ans = 0;
        for (int i = 0; i < n; ++i) M *= m[i];
        for (int i = 0; i < n; ++i) {
            int64 x, y, g, tm = M / m[i];
            exgcd(tm, m[i], g, x, y);
            ans = (ans + tm * x * c[i] % M) % M;
        }
        return (ans + M) % M;
    }
 
    static vec ReedsSloane(const vec &s, int64 mod) {
        auto inverse = [](int64 a, int64 m) {
            int64 d, x, y;
            exgcd(a, m, d, x, y);
            return d == 1 ? (x % m + m) % m : -1;
        };
        auto L = [](const vec &a, const vec &b) {
            int da = (a.size() > 1 || (a.size() == 1 && a[0])) ? a.size() - 1 : -1000;
            int db = (b.size() > 1 || (b.size() == 1 && b[0])) ? b.size() - 1 : -1000;
            return std::max(da, db + 1);
        };
        auto prime_power = [&](const vec &s, int64 mod, int64 p, int64 e) {
            // linear feedback shift register mod p^e, p is prime
            std::vector<vec> a(e), b(e), an(e), bn(e), ao(e), bo(e);
            vec t(e), u(e), r(e), to(e, 1), uo(e), pw(e + 1);;
            pw[0] = 1;
            for (int i = pw[0] = 1; i <= e; ++i) pw[i] = pw[i - 1] * p;
            for (int64 i = 0; i < e; ++i) {
                a[i] = {pw[i]}, an[i] = {pw[i]};
                b[i] = {0}, bn[i] = {s[0] * pw[i] % mod};
                t[i] = s[0] * pw[i] % mod;
                if (t[i] == 0) {
                    t[i] = 1, u[i] = e;
                } else {
                    for (u[i] = 0; t[i] % p == 0; t[i] /= p, ++u[i]);
                }
            }
            for (size_t k = 1; k < s.size(); ++k) {
                for (int g = 0; g < e; ++g) {
                    if (L(an[g], bn[g]) > L(a[g], b[g])) {
                        ao[g] = a[e - 1 - u[g]];
                        bo[g] = b[e - 1 - u[g]];
                        to[g] = t[e - 1 - u[g]];
                        uo[g] = u[e - 1 - u[g]];
                        r[g] = k - 1;
                    }
                }
                a = an, b = bn;
                for (int o = 0; o < e; ++o) {
                    int64 d = 0;
                    for (size_t i = 0; i < a[o].size() && i <= k; ++i) {
                        d = (d + a[o][i] * s[k - i]) % mod;
                    }
                    if (d == 0) {
                        t[o] = 1, u[o] = e;
                    } else {
                        for (u[o] = 0, t[o] = d; t[o] % p == 0; t[o] /= p, ++u[o]);
                        int g = e - 1 - u[o];
                        if (L(a[g], b[g]) == 0) {
                            extand(bn[o], k + 1);
                            bn[o][k] = (bn[o][k] + d) % mod;
                        } else {
                            int64 coef = t[o] * inverse(to[g], mod) % mod * pw[u[o] - uo[g]] % mod;
                            int m = k - r[g];
                            extand(an[o], ao[g].size() + m);
                            extand(bn[o], bo[g].size() + m);
                            for (size_t i = 0; i < ao[g].size(); ++i) {
                                an[o][i + m] -= coef * ao[g][i] % mod;
                                if (an[o][i + m] < 0) an[o][i + m] += mod;
                            }
                            while (an[o].size() && an[o].back() == 0) an[o].pop_back();
                            for (size_t i = 0; i < bo[g].size(); ++i) {
                                bn[o][i + m] -= coef * bo[g][i] % mod;
                                if (bn[o][i + m] < 0) bn[o][i + m] -= mod;
                            }
                            while (bn[o].size() && bn[o].back() == 0) bn[o].pop_back();
                        }
                    }
                }
            }
            return std::make_pair(an[0], bn[0]);
        };
 
        std::vector<std::tuple<int64, int64, int>> fac;
        for (int64 i = 2; i * i <= mod; ++i)
            if (mod % i == 0) {
                int64 cnt = 0, pw = 1;
                while (mod % i == 0) mod /= i, ++cnt, pw *= i;
                fac.emplace_back(pw, i, cnt);
            }
        if (mod > 1) fac.emplace_back(mod, mod, 1);
        std::vector<vec> as;
        size_t n = 0;
        for (auto &&x: fac) {
            int64 mod, p, e;
            vec a, b;
            std::tie(mod, p, e) = x;
            auto ss = s;
            for (auto &&x: ss) x %= mod;
            std::tie(a, b) = prime_power(ss, mod, p, e);
            as.emplace_back(a);
            n = std::max(n, a.size());
        }
        vec a(n), c(as.size()), m(as.size());
        for (size_t i = 0; i < n; ++i) {
            for (size_t j = 0; j < as.size(); ++j) {
                m[j] = std::get<0>(fac[j]);
                c[j] = i < as[j].size() ? as[j][i] : 0;
            }
            a[i] = crt(c, m);
        }
        return a;
    }
 
    LinearRecurrence(const vec &s, const vec &c, int64 mod) :
            init(s), trans(c), mod(mod), m(s.size()) {}
 
    LinearRecurrence(const vec &s, int64 mod, bool is_prime = true) : mod(mod) {
        vec A;
        if (is_prime) A = BerlekampMassey(s, mod);
        else A = ReedsSloane(s, mod);
        if (A.empty()) A = {0};
        m = A.size() - 1;
        trans.resize(m);
        for (int i = 0; i < m; ++i) {
            trans[i] = (mod - A[i + 1]) % mod;
        }
        std::reverse(trans.begin(), trans.end());
        init = {s.begin(), s.begin() + m};
    }
 
    int64 calc(int64 n) {
        if (mod == 1) return 0;
        if (n < m) return init[n];
        vec v(m), u(m << 1);
        int msk = !!n;
        for (int64 m = n; m > 1; m >>= 1) msk <<= 1;
        v[0] = 1 % mod;
        for (int x = 0; msk; msk >>= 1, x <<= 1) {
            std::fill_n(u.begin(), m * 2, 0);
            x |= !!(n & msk);
            if (x < m) u[x] = 1 % mod;
            else {// can be optimized by fft/ntt
                for (int i = 0; i < m; ++i) {
                    for (int j = 0, t = i + (x & 1); j < m; ++j, ++t) {
                        u[t] = (u[t] + v[i] * v[j]) % mod;
                    }
                }
                for (int i = m * 2 - 1; i >= m; --i) {
                    for (int j = 0, t = i - m; j < m; ++j, ++t) {
                        u[t] = (u[t] + trans[j] * u[i]) % mod;
                    }
                }
            }
            v = {u.begin(), u.begin() + m};
        }
        int64 ret = 0;
        for (int i = 0; i < m; ++i) {
            ret = (ret + v[i] * init[i]) % mod;
        }
        return ret;
    }
 
    vec init, trans;
    int64 mod;
    int m;
};
 
ll f[25005];
 
ll powmod(ll a, ll b, ll P) {
    ll t = 1;
    for (; b; b >>= 1, a = a * a % P)
        if (b & 1) t = t * a % P;
    return t;
}
 
int main() {
#ifdef trote
    //freopen("in.txt", "r", stdin);
    freopen("../1.txt", "r", stdin);
    //freopen("out2.txt", "w", stdout);
    size_t st = clock();
#endif
    scanf("%d%d", &n, &m);
    f[0] = 0;
    f[1] = 1;
    for (int i = 2; i <= 25000; i++) {
        f[i] = (f[i - 1] + f[i - 2]) % mod;
    }
    vector<ll> v;
    ll S = 0;
    for (int i = 0; i < 900; i++) {
        S = (S + powmod(f[i], m, mod)) % mod;
        v.pb(S);
    }
    LinearRecurrence solver(v, mod, false);
    printf("%lld\n", solver.calc(n));
 
    return 0;
}

 

Frozen_Guardian
关注
专栏目录
BMFont工具 (unity使用BMFont制作位图字体)
11-07
BMFont是一款专门用于创建位图字体的工具，它能够帮助开发者将TTF或OTF等矢量字体转换为纹理 Atlas 和配置文件，便于在Unity中高效地渲染文本。以下是对BMFont工具以及如何在Unity中使用BMFont制作位图字体的详细...
BM77 bm78蓝牙资料BM77和BM78 50K库存
12-25
【标题】"BM77与BM78蓝牙资料——50K库存详解" 【内容】： 在物联网领域，蓝牙技术的应用越来越广泛，特别是在智能家居、可穿戴设备和智能移动配件等方面。这里我们关注的是两个关键的蓝牙芯片：BM77和BM78。这两种...
BM递推杜教版
qq_36876305的博客
05-11 2610
#include &lt;bits/stdc++.h&gt; using namespace std; #define rep(i,a,n) for (long long i=a;i&lt;n;i++) #define per(i,a,n) for (long long i=n-1;i&gt;=a;i--) #define pb push_back #define mp make_pair #d...
杜教BM
qq_43490894的博客
07-26 114
#include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <vector> #include <string> #include <map> #include <set> #include &...
BM模板
sugarbliss
10-21 288
1.0 #include <bits/stdc++.h> using namespace std; typedef long long ll; #define rep(i,a,n) for(int i=a;i<n;i++) namespace linear { ll mo=1e9+7; vector<ll> v; double a[1...
杜教BM 模板
EDGiboy的博客
05-08 248
用于解决： 求一个递推方程，暴力求出前几项之后放进去，然后跑这个算法就可以求出递推方程式来或者直接就跑F[n]的答案，复杂度挺小的。 放的话放8个以上，最好10个左右。 模板 求任意模数的BM模板 #include <bits/stdc++.h> #include<ext/pb_ds/assoc_container.hpp> #include<ext/pb_ds...
BM3D.zip_BM3D_BM3D matlab代码_BM3D代码_图像去噪_图像去噪 matlab
07-15
BM3D.zip是一个包含BM3D算法实现的MATLAB代码集合，主要用于图像去噪处理。BM3D（Block-Matching and 3D filtering）是一种基于块匹配和三维滤波的图像去噪方法，由E. A. Yaglom等人在2007年提出。该算法以其出色的...
bm3d_denoising_BM3D_
09-29
**BM3D降噪算法详解** 在数字图像处理领域，噪声是常见的问题，它可能源自图像获取过程中的各种因素，如光照不均、传感器缺陷等。为了提高图像质量，降噪是一个至关重要的步骤。其中，BM3D（Block Matching and 3D ...
BM1422AGMV (1).zip_BM1422AGMV_BM1422AGMV 代码_BM1422AGMV软件_地磁传感器
07-15
《BM1422AGMV地磁传感器与Msp430微控制器的集成应用》 在现代物联网设备和智能硬件领域，传感器技术扮演着至关重要的角色。BM1422AGMV是一款高精度、低功耗的地磁传感器，广泛应用于导航、定位、无人机控制等领域。...
任意模数NTT（学习笔记）
继续学吧
11-29 1928
FFTFFTFFT有时候会被卡精度？所以可能会有模数，有了模数以后就需要模数的原根。 原根是什么？（留坑待填） NTTNTTNTT有很多种解决方法 1.1.1.特殊模数 (2k+1)∣(p−1)，(p−1)&amp;amp;amp;gt;DFT的长度(2k+1)|(p−1)，(p−1)&amp;amp;amp;gt;DFT的长度(2k+1)∣(p−1)，(p−1)&amp;amp;gt;DFT的长度，可以直接暴力求原根ggg，用ggg代替单位复...
知识点 - BM模板 高阶线性递推方程
qq_41848675的博客
08-15 688
知识点 - BM模板 高阶线性递推方程 解决问题类型： 密码学算法 Reeds-Sloane Peterson decoder算法的一种代替算法。（降维打击） 对于k阶线性递推方程，即 a(k+n)=∑i=1i&lt;=kC(k−i+1)⋅a(n+k−i) a(k+n)=\sum_{i=1}^{i&lt;=k}C(k-i+1)\cdot a(n+k-i) a(k+n)=i=1∑i&...
杜教BM（线性求递推答案）
Happig的博客
08-17 420
简介 对于线性递推式，都是有规律的，不管是斐波那契形式的还是加入了其他运算，如果能找到递推规律可以直接写 否则，一种简便且行之有效的方法是：先求出前TTT项（不放心可以求1e61e61e6项）然后套用杜教BM板子直接求出结果 时间复杂度O(T)O(T)O(T)，有翻车的可能性 模板 #define rep(i,a,n) for (int i=a;i<n;i++) #define SZ(x) ((int)(x).size()) typedef vector<int> VI; typedef
c++中 rep()函数简介
o_7_2_0的博客
02-19 6576
懒得了解是否允许转载，不放文 放网址，自己看 https://www.cnblogs.com/wangshenwen/p/3235866.html
排序算法
weixin_30243533的博客
11-15 112
给某个很笨的人准备的 一，sort，时间复杂度0(nlogn)，小于1e7差不多都可以用，可以用于排序次数比较少的时候; 1,sort是给数组排序用的，可以直接调用C++里面的函数使用，记住，是C++别在给我用c，而且还要加上#include<algorithm> 用法一，直接使用，是从小到大排序 int a[[1005]; sort(a,a+n);//n指的是要排序的长度，...
2017ACM/ICPC亚洲区沈阳站_Infinite Fraction Path(BFS)
Sangria's Blog
11-14 974
#include #include #include #include #include #define INF 0x3f3f3f3f #define rep0(i, n) for (int i = 0; i < n; i++) #define rep1(i, n) for (int i = 1; i <= n; i++) #define rep_0(i, n) for (int i =
2554: Color
limboman的博客
01-11 734
#include<bits/stdc++.h> #define rep(i,k,n) for(int i=k;i<=n;i++) using namespace std; typedef double db; typedef long long ll; const int N=1e4+7; struct f{ db a,b;f(db a=0.0,db b=0.0):a(a),b(b){} }
牛客多校6 - Binary Vector(组合数学+推公式)
Falcon的博客
07-28 787
题目链接：点击查看 题目大意：给出一个 n * n 的 01 矩阵，求满秩的概率 题目分析：首先公式是： 稍微解释一下吧，将 n * n 的矩阵视为 n 个长度为 n 的向量，对于每一个长度为 n 的向量，都有 2^n 种情况，因为要求 n 个向量线性独立，所以我们依次讨论： 对于第一个向量来说，只需要至少有一个位置为 1 即可，即全部为 0 的情况不满足条件，此时满足条件的情况为 对于第二个向量来说，需要满足的条件是，不能全部为 0 ，且不能被第一个向量所表示，此时满足条件的情况为 对于第三个
2019ICPC(银川) - Take Your Seat(概率公式)
Falcon的博客
08-31 574
题目链接：点击查看 题目大意：朵哈要坐飞机去旅游，出发的时候包括朵哈在内一共有n个人要上飞机，这班飞机有n个座位，第i个人的座位号是i，朵哈的座位号是1。 现在n个人按照座位号是从1到n的顺序上飞机，但朵哈忘了自己的座位，于是她就等概率随机选了一个位置坐下了，而其余人都记得自己的位置，如果他们中的一个人上飞机之后发现自己的位置被占了，则会在剩下的位置中等概率随机选一个坐下，如果没被占，则会直接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Frozen_Guardian

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值