【博客】FFT基础及各种常数优化学习笔记

本文含NTT、MTT、拆系数FFT、共轭优化FFT、多项式求逆与ln

表示一个普通的项数为的幂次多项式,是他的点值表示。

代表单位根，表示次单位根。

代表一个数列。

表示原根。

多项式的表示：

多项式可以通过系数数列表示，是的系数。

多项式可以通过点值表示，对于一个次多项式，取种不同的取值带入，得到个值，在取相同这个数的意义下，可以唯一的表示这个多项式。

多项式乘法：

定义，在系数表示之下相乘复杂度，在点值表示之下，复杂度。

复数：

复数一般情况下可以表示成的形式，是实数，。

复数的幅角：平面直角坐标系上点所在的任意角。

复数的模长：

两个复数相乘：，复数相乘之后，模长等于原来两个复数的模长的乘积，幅角的角度等于原来两个幅角的和。

复数可以加减乘除，可以和实数一样的带入。

：

在单位圆上从开始平均取个点，从开始编号，分别是。

画图观察可得：

所代表的复数

所代表的复数

DFT&IDFT：

在科学的数学函数意义上DFT是讲一个函数转化成三角函数的加减乘除的形式，三角函数的系数是原函数系数与点值之间的变换规律。IDFT是DFT的逆变换。

g：

什么是：在意义下互不相同，即可以张成整个下的域。

存在的条件：，是奇素数。

如何求：把进行质因数分解，如果对于任意的，总有，暴力枚举即可。

CRT合并：

求解

由，得

带入二式，得

若，用逆元直接除便可；否则通过可求得，若无解则方程组无解。

最后。

什么是FFT：

FFT是利用DFT的特殊性质，把带入从而求一个系数多项式的点值表示，所以叫FDFT。

的具体应用：

可以方便的IDFT：

设的系数是，在的DFT下点值是，的系数是，在的DFT下点值是。

当时，否则根据等比数列求和公式得


由此可得：，

综上所述，对于点值取的相反数做DFT再除以可得到系数。

可以快速的DFT：

直接将带入多项式做DFT需要复杂度，我们利用的性质优化：

把按照奇偶分裂，

我们令

我们可以发现

现在我们把带入，令：

我们知道取时，的取值，就可以算出，而的长度都为的一半，所以可以递归计算。

非递归优化FFT：

优化原理：

画图可知，递归版FFT最底层结束状态第个位置的项是二进制翻转后的结果。我们可以的得到最底层的结果，然后向上模拟回溯合并即可。

蝴蝶变换：

由上述式子：

可得在迭代时与都只与有关，所以我们可以用临时变量记录下一层的两个信息向上迭代。

共轭复数优化FFT：

优化原理：

（在DFT时）

令


那么

证明：

：

：为方便起见，我们用代替

而在IDFT时，我们需要

数论优化FFT(NTT)：

与的共性：

和都互不相同。

，。

，由于原根的互不相同，，

，

，

因为有这些共性，所以可以代替。

喜闻乐见的模板：

FFT模板（共轭优化）

namespace FFT{
    const double pi = acos(-1);
    struct cp{
        double x, y;
        cp() {x = y = 0;}
        cp(double X,double Y) {x = X; y = Y; }
        cp conj() {return (cp) {x, -y};}
    }a[3000005], b[3000005], c[3000005], I(0, 1), d[3000005];

    cp operator+ (const cp &a, const cp &b) {return (cp){a.x + b.x, a.y + b.y}; }
    cp operator- (const cp &a, const cp &b) {return (cp){a.x - b.x, a.y - b.y}; }
    cp operator* (const cp &a, const cp &b) {return (cp){a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x};}
    cp operator* (const cp &a, double b) {return (cp){a.x * b, a.y * b};}
    cp operator/ (const cp &a, double b) {return (cp){a.x / b, a.y / b};}
    struct p_l_e{
        int wz[3000005];
        void FFT(cp *a, int N, int op) {
            for(int i = 0; i < N; i++)
                if (i<wz[i]) swap(a[i],a[wz[i]]);
            for(int le = 2; le <= N; le <<= 1) {
                int mid = le >> 1;
                for(int i = 0; i < N; i += le) {
                    cp x, y, w = (cp) {1, 0};
                    cp wn = (cp){cos(op * pi / mid), sin(op * pi / mid)};
                    for(int j = 0 ; j < mid; j++) {
                        x = a[i + j]; y = a[i + j + mid] * w;
                        a[i + j] = x + y;
                        a[i + j + mid] = x - y;
                        w = w * wn;
                    }
                }
            }
        }
        void D_FFT(cp *a, cp *b, int N, int op){
            for(int i = 0; i < N; i++)    d[i] = a[i] + I * b[i];
            FFT(d, N, op);
            d[N] = d[0];
            for(int i = 0; i < N; i++){
                a[i] = (d[i] + d[N - i].conj()) / 2;
                b[i] = I * (-1) * (d[i] - d[N - i].conj()) / 2;
            }
            d[N] = cp(0, 0);
        }
        void mult(cp *a, cp *b, cp *c, int M){
            int N = 1, len = 0;
            while(N < M) N <<= 1, len++;
            for(int i = 0; i < N; i++)
                wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
            D_FFT(a, b, N, 1);
            for(int i = 0; i < N; i++)    c[i] = a[i] * b[i];
            FFT(c, N, -1);
            for(int i = 0; i < N; i++)    c[i].x = c[i].x / N;
        }
    }PLE;
    int n, m;
    void main() {
        scanf("%d%d", &n, &m); n++; m++;
        for(int i = 0; i < n; i++) scanf("%lf", &a[i].x);
        for(int i = 0; i < m; i++) scanf("%lf", &b[i].x);
        PLE.mult(a, b, c, n + m - 1); 
        for(int i = 0; i < n + m - 1; i++)    printf("%d ", (int)round(c[i].x));
        return;
    }
}

NTT模板：

namespace NTT{
    typedef long long LL;
    const int mod = 998244353;
    const int g = 3;
    LL a[3000005], b[3000005], c[3000005];
    int n, m;
    LL qpow(LL a, LL b){
        LL ans = 1;
        while(b){
            if(b & 1)    ans = ans * a % mod;
            a = a * a % mod;
            b >>= 1;
        }
        return ans;
    }
    struct p_l_e{
        int wz[3000005];
        void NTT(LL *a, int N, int op) {
            for(int i = 0; i < N; i++) 
                if(i < wz[i]) swap(a[i], a[wz[i]]);
            for(int le = 2; le <= N; le <<= 1) {
                int mid = le >> 1;
                LL wn = qpow(g, (mod - 1) / le);
                if(op == -1) wn = qpow(wn, mod - 2); 
                for(int i = 0; i < N; i += le) {
                    int w = 1, x, y;
                    for(int j = 0; j < mid; j++) {
                        x = a[i + j]; 
                        y = a[i + j + mid] * w % mod; 
                        a[i + j] = (x + y) % mod;
                        a[i + j + mid] = (x - y + mod) % mod;
                        w = w * wn % mod;
                    }
                }
            }
        }
        void mult(LL *a, LL *b, LL *c, int M) {
            int N = 1, len = 0;
            while(N < M)    N <<= 1, len++;
            for(int i = 0; i < N; i++)    
                wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
            NTT(a, N, 1); NTT(b, N, 1);
            for(int i = 0; i < N; i++)    c[i] = a[i] * b[i] % mod;
            NTT(c, N, -1);
            LL t = qpow(N, mod - 2);
            for(int i = 0; i < N; i++)    c[i] = c[i] * t % mod;
        }
    }PLE;
    void main() {
        scanf("%d%d", &n, &m); n++; m++;
        for(int i = 0; i < n; i++)    scanf("%lld", &a[i]);
        for(int i = 0; i < m; i++)    scanf("%lld", &b[i]);
        PLE.mult(a, b, c, n + m - 1);
        for(int i = 0; i < n + m - 1; i++)    printf("%lld ", c[i]);
    }
}

三模NTT实现任模FFT：

为什么要用MTT：当不是NTT模数或者多项式长度大于模数限制时，就要使用MTT。

MTT的使用原理：我们对初始多项式取模，那么如果在不取模卷积情况下，答案不会超过。我们取三个NTT模数，分别做多项式乘法，得到分别的答案，通过CRT合并可以得到的答案，如果那么就可以得到准确的答案，再对取模即可。

CRT合并的小优化：

初始式子

把一式二式合并(LL范围内)。

再次合并(不需要 快速乘)。

常用NTT模数：

以下模数的共同

拆系数FFT(CFFT)实现任模FFT：

实现原理：运用实数FFT不取模做乘法，然后取模回归到整数。但是由于误差较大（值域是），我们令把系数，对交叉做四遍卷积，求出答案按系数贡献取模加入。

可按合并DFT的方法优化DFT次数。

算法实现任长FFT：

当不是的幂次的时候，我们从式子入手：

令

喜闻乐见的模板：

三模NTT模板（注意：不可以MTT回来，因为系数会取模）

namespace MTT{
    typedef long long LL;
    int n, m;
    LL p, mod;
    const LL p1 = 998244353;
    const LL p2 = 1004535809;
    const LL p3 = 104857601;
    const int g = 3189;
    LL a[300005], b[300005], c[300005], cpa[300005], cpb[300005];
    LL c3[300005], c1[300005], c2[300005];
    LL qpow(LL a, LL b, LL mod) {
        LL ans = 1;
        while(b) {
            if(b & 1)    ans = ans * a % mod;
            a = a * a % mod;
            b >>= 1;
        }
        return ans;
    }
    const LL inv12 = qpow(p1, p2 - 2, p2);
    const LL inv123 = qpow(p1 * p2 % p3, p3 - 2, p3);
    struct p_l_e{
        int wz[300005];
        void MTT(LL *a, int N, int op) {
            for(int i = 0; i < N; i++)
                if(i < wz[i]) swap(a[i], a[wz[i]]);
            for(int le = 2; le <= N; le <<= 1) {
                int mid = le >> 1;
                LL wn = qpow(g, (mod - 1) / le, mod);
                if(op == -1) wn = qpow(wn, mod - 2, mod);
                for(int i = 0; i < N ;i += le) {
                    LL w = 1, x, y;
                    for(int j = 0; j < mid; j++) {
                        x = a[i + j];
                        y = a[i + j + mid] * w % mod;
                        a[i + j] = (x + y) % mod;
                        a[i + j + mid] = (x - y + mod) % mod;
                        w = w * wn % mod;
                    }
                }
            }
        }
        void mult(LL *a, LL *b, LL *c, int M) {
            int N = 1, len = 0;
            while(N < M) N <<= 1, len++;
            for(int i = 0; i < N; i++)
                wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
            MTT(a, N, 1); MTT(b, N, 1);
            for(int i = 0; i < N; i++)    c[i] = a[i] * b[i] % mod;
            MTT(c, N, -1);
            LL t = qpow(N, mod - 2, mod);
            for(int i = 0; i < N; i++)    c[i] = c[i] * t % mod;
        }

    }PLE;
    LL CRT(LL c1, LL c2, LL c3) {
        LL x = (c1 + p1 * ((c2 - c1 + p2) % p2 * inv12 % p2));
        LL y = (x % p + p1 * p2 % p * ((c3 - x % p3 + p3) % p3 * inv123 % p3) % p) % p;
        return y;
    }
    void merge(LL *c1, LL *c2, LL *c3, LL *c, int N) {
        for(int i = 0; i < N; i++)
            c[i] = CRT(c1[i], c2[i], c3[i]);
        return;
    }
    void main() {
        scanf("%d%d%lld", &n, &m, &p); n++; m++;
        for(int i = 0; i < n; i++)    scanf("%lld", &a[i]);
        for(int i = 0; i < m; i++)    scanf("%lld", &b[i]);
        mod = p1; memcpy(cpa, a, sizeof(a)); memcpy(cpb, b, sizeof(b)); PLE.mult(cpa, cpb, c1, n + m - 1);
        mod = p2; memcpy(cpa, a, sizeof(a)); memcpy(cpb, b, sizeof(b)); PLE.mult(cpa, cpb, c2, n + m - 1);
        mod = p3; memcpy(cpa, a, sizeof(a)); memcpy(cpb, b, sizeof(b)); PLE.mult(cpa, cpb, c3, n + m - 1);
        merge(c1, c2, c3, c, n + m - 1);
        for(int i = 0; i < n + m - 1; i++)    printf("%lld ", (c[i] % p + p) % p);
        return;
    }
}

拆系数FFT模板（注意：相同系数的两项可以合并一起IDFT。采用共轭优化法，只进行四次DFT）

namespace CFFT{
    typedef long long LL;
    int n, m, p ,sqrp; 
    int a[300005], b[300005];
    const long double pi = acos(-1);
    struct cp{
        long double x, y;
        cp() {x = y = 0;}
        cp(long double X,long double Y) {x = X; y = Y; }
        cp conj() {return (cp) {x, -y};}
    }ka[300005], kb[300005], ta[300005], tb[300005], kk[300005], kt[300005], tt[300005], c[300005], I(0, 1), d[300005];

    cp operator+ (const cp &a, const cp &b) {return (cp){a.x + b.x, a.y + b.y}; }
    cp operator- (const cp &a, const cp &b) {return (cp){a.x - b.x, a.y - b.y}; }
    cp operator* (const cp &a, const cp &b) {return (cp){a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x};}
    cp operator* (const cp &a, long double b) {return (cp){a.x * b, a.y * b};}
    cp operator/ (const cp &a, long double b) {return (cp){a.x / b, a.y / b};}    
    struct p_l_e{
        int wz[300005];
        void FFT(cp *a, int N, int op){
            for(int i = 0; i < N; i++)
                if(i < wz[i])    swap(a[i], a[wz[i]]);
            for(int le = 2; le <= N; le <<= 1){
                int mid = le >> 1;
                cp x, y, w, wn = (cp){cos(op * 2 * pi / le), sin(op * 2 * pi / le)};
                for(int i = 0; i < N; i += le){
                    w = (cp){1, 0};
                    for(int j = 0; j < mid; j++){
                        x = a[i + j];
                        y = a[i + j + mid] * w;
                        a[i + j] = x + y;
                        a[i + j + mid] = x - y;
                        w = w * wn;
                    }
                }
            } 
        }
        void D_FFT(cp *a, cp *b, int N, int op){
            for(int i = 0; i < N; i++)    d[i] = a[i] + I * b[i];
            FFT(d, N, op);
            d[N] = d[0];
            if(op == 1){
                for(int i = 0; i < N; i++){
                    a[i] = (d[i] + d[N - i].conj()) / 2;
                    b[i] = I * (-1) * (d[i] - d[N - i].conj()) / 2;
                }
            } else {
                for(int i = 0; i < N; i++){
                    a[i] = cp(d[i].x, 0);
                    b[i] = cp(d[i].y, 0);
                }
            }
            d[N] = cp(0, 0);
        }
        void mult(int *a, int *b, int M){
            int N = 1, len = 0;
            while(N < M) N <<= 1, len++;
            for(int i = 0; i < N; i++)
                wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
            for(int i = 0; i < N; i++){
                ka[i].x = a[i] >> 15;
                kb[i].x = b[i] >> 15;
                ta[i].x = a[i] & 32767;
                tb[i].x = b[i] & 32767;
            }
            D_FFT(ta, ka, N, 1); D_FFT(tb, kb, N, 1);
            for(int i = 0; i < N; i++){
                kk[i] = ka[i] * kb[i];
                kt[i] = ka[i] * tb[i] + ta[i] * kb[i];
                tt[i] = ta[i] * tb[i];
            }
            D_FFT(tt, kk, N, -1); FFT(kt, N, -1);
            for(int i = 0; i < N; i++){
                tt[i] = tt[i] / N;
                kt[i] = kt[i] / N;
                kk[i] = kk[i] / N;
            }
        }
    }PLE;
    void main() {
        scanf("%d%d%d", &n, &m, &p); n++; m++;
        for(int i = 0; i < n; i++)    scanf("%d", &a[i]),a[i] = a[i] % p;
        for(int i = 0; i < m; i++)    scanf("%d", &b[i]),b[i] = b[i] % p;
        PLE.mult(a, b, n + m - 1);
        for(int i = 0; i < n + m - 1; i++)
            printf("%lld ",(((((LL)round(kk[i].x)) % p) << 30) + ((((LL)round(kt[i].x)) % p) << 15) + ((LL)round(tt[i].x)) % p) % p);
    }
}

模板：

struct polynie {
    CP getw(int m, int k, int op) {
        return CP(cos(2 * pi * k / m), op * sin(2 * pi * k / m));
    }
    int wz[MAXN];
    CP A[MAXN], B[MAXN], C[MAXN];
    void FFT(CP *a, int N, int op) {
        rop(i, 0, N) if(i < wz[i]) swap(a[i], a[wz[i]]);
        for(int l = 2; l <= N; l <<= 1) {
            int mid = l >> 1;
            CP x, y, w, wn = CP(cos(pi / mid), sin(op * pi / mid));
            for(int i = 0; i < N; i += l) {
                w = CP(1, 0);
                rop(j, 0, mid) {
                    x = a[i + j];
                    y = w * a[i + j + mid];
                    a[i + j] = x + y;
                    a[i + j + mid] = x - y;
                    w = w * wn;
                }
            }
        }
    }
    void mult(CP *a, CP *b, CP *c, int M) {
        int N = 1, len = 0;
        while(N < M) N <<= 1, len++;
        rop(i, 0, N) wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
        FFT(a, N, 1); FFT(b, N, 1);
        rop(i, 0, N) c[i] = a[i] * b[i];
        FFT(c, N, -1);
        rop(i, 0, N) c[i].x = c[i].x / N, c[i].y = c[i].y / N;
    }
    void blue_stein(CP *a, int M, int op) {
        int M2 = M << 1;
        memset(A, 0, sizeof(A));
        memset(B, 0, sizeof(B));
        memset(C, 0, sizeof(C));
        rop(i, 0, M) A[i] = a[i] * getw(M2, 1ll * i * i % M2, op);
        rop(i, 0, M2) B[i] = getw(M2, 1ll * (i - M) * (i - M) % M2, -op);
        mult(A, B, C, M2 + M - 1);
        rop(i, 0, M) a[i] = C[i + M] * getw(M2, 1ll * i * i % M2, op);
        if(op == -1) rop(i, 0, M) a[i].x = a[i].x / M, a[i].y = a[i].y / M;
    }
}PLE;

多项式求逆：

问题描述：

已知，且，求

推导过程：

设

由于

所以

那么

两边平方，得：

由于的第项为

一定有一项，所以

两边同乘，得：

喜闻乐见的模板：

namespace INV{
    typedef long long LL;
    int n, a[300005], b[300005];
    const int mod = 998244353;
    const int g = 3189;
    int qpow(int a, int b){
        int ans = 1;
        while(b){
            if(b & 1)    ans = 1ll * ans * a % mod;
            a = 1ll * a * a % mod;
            b >>= 1;
        }
        return ans;
    }
    struct p_l_e{
        int wz[300005], i_c[300005];
        void NTT(int *a, int N, int op){
            for(int i = 0; i < N; i++)
                if(i < wz[i]) swap(a[i], a[wz[i]]);
            for(int le = 2; le <= N; le <<= 1){
                int mid = le >> 1, wn = qpow(g, (mod - 1) / le);
                if(op == -1) wn = qpow(wn, mod - 2);
                for(int i = 0; i < N; i += le){
                    LL w = 1; int x, y;
                    for(int j = 0; j < mid; j++){
                        x = a[i + j];
                        y = w * a[i + j + mid] % mod;
                        a[i + j] = (x + y) % mod;
                        a[i + j + mid] = (x - y + mod) % mod;
                        w = w * wn % mod;
                    }
                }
            }
        }
        int init(int M){
            int N = 1, len = 0;
            while(N < M) N <<= 1, len++;    
            for(int i = 0; i < N; i++)
                wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
            return N;
        }
        void INV(int *a, int *b, int deg){
            if(deg == 1){b[0] = qpow(a[0], mod - 2); return;}
            INV(a, b, (deg + 1) >> 1);
            int N = init(deg + deg - 1);
            for(int i = 0; i < deg; i++) i_c[i] = a[i];
            for(int i = deg; i < N; i++) i_c[i] = 0;
            NTT(b, N, 1);NTT(i_c, N, 1);
            for(int i = 0; i < N; i++) b[i] = 1ll * b[i] * (2 - 1ll * b[i] * i_c[i] % mod + mod) % mod;
            NTT(b, N, -1);
            int t = qpow(N, mod - 2);
            for(int i = 0; i < N; i++) b[i] = 1ll * b[i] * t % mod;
            for(int i = deg; i < N; i++) b[i] = 0;
        }
    }PLE;

    void main(){
        scanf("%d", &n);
        for(int i = 0; i < n; i++)    scanf("%d", &a[i]);
        PLE.INV(a, b, n);
        for(int i = 0; i < n; i++)    printf("%d ",b[i]);
    }
}

做法：

设

两边求导得

积分回去即可。

应用：

这个的组合意义是：无序组合。

设，表示一些东西，那么这些东西有序组合的方案数为

而无序组成的方案数为：

如果无序组合方案数好求，那么求就能得到。

例题

喜闻乐见的代码：

多项式:

namespace PLE_ln{
  struct polyme {
      int li[SZ], wz[SZ];
      void NTT(int *a, int N, int op) {
          rop(i, 0, N) if(i < wz[i]) swap(a[i], a[wz[i]]);
          for(int l = 2; l <= N; l <<= 1) {
              int mid = l >> 1;
              int x, y, w, wn = qpow(g, (mod - 1) / l);
              if(op) wn = qpow(wn, mod - 2);
              for(int i = 0; i < N; i += l) {
                  w = 1;
                  for(int j = 0; j < mid; ++j) {
                      x = a[i + j]; y = 1ll * w * a[i + j + mid] % mod;
                      a[i + j] = (x + y) % mod;
                      a[i + j + mid] = (x - y + mod) % mod;
                      w = 1ll * w * wn % mod;
                  }
              }
          }
      }
      void qd(int *a, int *b, int n) {
          rop(i, 0, n) b[i] = 1ll * a[i + 1] * (i + 1) % mod;
      }
      void jf(int *a, int *b, int n) {
          rop(i, 1, n) b[i] = 1ll * a[i - 1] * qpow(i, mod - 2) % mod;
      }
      void mult(int *a, int *b, int *c, int M) {
          int N = 1, len = 0;
          while(N < M) N <<= 1, len ++;
          rop(i, 0, N) wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
          NTT(a, N, 0); NTT(b, N, 0);
          rop(i, 0, N) c[i] = 1ll * a[i] * b[i] % mod;
          NTT(c, N, 1);
          int t = qpow(N, mod - 2);
          rop(i, 0, N) c[i] = 1ll * c[i] * t % mod;
      }
      void inv(int *a, int *b, int deg) {
          if(deg == 1) {b[0] = qpow(a[0], mod - 2) % mod; return;}
          inv(a, b, (deg + 1) >> 1);
          rop(i, 0, deg) li[i] = a[i];
          int N = 1, len = 0;
          while(N < deg + deg - 1) N <<= 1, len ++;
          rop(i, 0, N) wz[i] = (wz[i >> 1] >> 1) | ((i & 1) << (len - 1));
          rop(i, deg, N) li[i] = 0;
          NTT(li, N, 0); NTT(b, N, 0);
          rop(i, 0, N) b[i] = 1ll * b[i] * (2 - 1ll * li[i] * b[i] % mod + mod) % mod;
          NTT(b, N, 1);
          int t = qpow(N, mod - 2);
          for(int i = 0; i < N; i++) b[i] = 1ll * b[i] * t % mod;
          rop(i, deg, N) b[i] = 0;
      }
  }PLE;
  int a[SZ], da[SZ], ia[SZ], dla[SZ], la[SZ], n;

  void main() {

      scanf("%d", &n);
      rop(i, 0, n) scanf("%d", &a[i]);
      PLE.qd(a, da, n);
      PLE.inv(a, ia, n);
      PLE.mult(ia, da, dla, n + n - 1);
      PLE.jf(dla, la, n);
      rop(i, 0, n) printf("%d ", la[i]);
  }
}
全部评论
如果能安利一些练手题就更好了
1 回复 分享
发布于 2019-04-17 19:35
1 回复 分享
发布于 2019-04-17 16:27
讲的很有条理了
点赞 回复 分享
发布于 2022-03-02 15:58
点赞 回复 分享
发布于 2019-04-15 15:13

相关推荐

头像
11-14 09:57
已编辑
南京邮电大学 Java
华为OD面试全流程：从机考到入职，新手也能看懂！！
嘿，我最近在招聘网站遇到好些小朋友面试中了，还不怎么清楚面试的流程，我给总结下哈，经供参考哦。1、机考：无固定准备周期，按自身节奏来就好不用纠结“别人准备多久”，有人一周集中刷题通关，也有人花数月扎实打基础，准备时间长不代表效率低，放宽心按自己的进度备考，别陷入焦虑。2、综测：立好“一致人设”，不用追求“完人”给自己立一个人设，注意前后一致性，在一道道咄咄逼人的问题冲刷下，真的很容易找不到北，所以你就突出部分特质就够了，比如团结就是大于创新，别老想着自己是个完人3、HR面试：看似“聊家常”，实则藏细节大多时候会问个人情况、求职意向等家常问题，难度不高，但别掉以轻心——部分HR也会穿插技术问题，...
点赞 评论 收藏
分享
11-13 16:07
江苏网商精益管理软件有限公司_工程部_后端开发(实习员工)
郑州-超聚变-一面-技术面
自我介绍是否在实习呢？本科论文进度怎么样了？实习拷打：数据预热是什么？QPS是多少？收单接口迁移是什么？切量逻辑是什么意思？用户是如何跟百分比关联上的呢？Java&nbsp;语言的优缺点？Java&nbsp;是否会出现内存泄漏？什么样的场景会出现呢？Java&nbsp;出现了内存泄露了，如果去定位呢？jdk&nbsp;最新版本是什么==&nbsp;和&nbsp;equals&nbsp;有什么区别？try-finally&nbsp;try&nbsp;中return&nbsp;a;&nbsp;final中&nbsp;return&nbsp;b;&nbsp;返回什么值？为什么？算法编写：使用List存储student对象，对List进行排序，先按照分数进行排序，再按照学号进行排序。Linux&nbsp;常用命令，查看某个文件内容中是否有某个单词，...
点赞 评论 收藏
分享
头像
09-22 11:46
杭州电子科技大学 大数据开发工程师
点赞 评论 收藏
分享
11-03 14:57
西北大学 营销
出现好几次了&nbsp;选啥
Belltrix：其实就是每根转动一定的角度
点赞 评论 收藏
分享
11-14 10:15
海康威视_技术支持部_云存储开发工程师(准入职员工)
海康威视内推，海康威视内推码
真实工作体验！【工作时间】&nbsp;海康实行弹性工作制，一般九点半之前到公司就可以。对于实习生来说，一般只要打够八个半小时的卡就好了。这点还是不错的，早点上班就可以早点下班。正式工可能需要大小周，具体看部门要求。实习生应该都是双休的，不过周末去的话也会给你发工资。中午休息一个半小时，大部分员工都会自己买午休床。&nbsp;【公司环境】&nbsp;实习报到的时候会给你分配一台电脑，一般都是无盘机，配置很普通，不允许自己带电脑。海康对网络管控比较严格，很多网站不能访问。想要访问外网的话只能通过虚拟机，然后通过公司内部的文件传输工具传到红网，这点还是比较麻烦的。&nbsp;海康食堂还行，样式挺丰富的，价格也不贵。早餐我一般在5-10r，...
海康威视公司福利 1235人发布
点赞 评论 收藏
分享
评论
13
9
分享

全站热榜

更多

创作者周榜

更多
正在热议
更多
# 互联网行业现在还值得去吗 #
36592次浏览 261人参与
# 落户对你的求职选择影响有多大 #
29229次浏览 101人参与
# 虾皮开奖 #
42476次浏览 202人参与
# 你小时候最想从事什么职业 #
132399次浏览 1971人参与
# 第一次找实习，我建议__ #
27816次浏览 348人参与
# 非技术2024笔面经 #
435283次浏览 4881人参与
# 参加完秋招的机械人，还参加春招吗？ #
80429次浏览 614人参与
# 机械人的工作环境真的很差吗 #
35764次浏览 132人参与
# 牛友的志愿填报指南 #
41589次浏览 196人参与
# 韶音科技求职进展汇总 #
62257次浏览 506人参与
# 从mentor身上学到了__ #
23456次浏览 386人参与
# 你怎么评价今年的春招？ #
144143次浏览 1392人参与
# 外出实习被同学举报 #
6146次浏览 39人参与
# 除了主业以外，你还有哪些其他收入？ #
36458次浏览 303人参与
# 打工人的至爽时刻or至暗时刻 #
42989次浏览 223人参与
# 材料进Fab厂真的劝退吗？ #
60829次浏览 209人参与
# 你认为工作的意义是什么 #
206313次浏览 1309人参与
# 华为海思工作体验 #
36182次浏览 146人参与
# 秋招暂停，我将对以下公司做出处罚__ #
32069次浏览 147人参与
# 如果今天是你的last day，你会怎么度过？ #
49868次浏览 304人参与
牛客网
牛客网在线编程
牛客网题解
牛客企业服务