维护一个序列，初始全为\(1\)

支持两种操作：

1.对于所有的位置\(i\)，将它的值乘上\(i + a\)

2.询问\(a\)处的值

\(q=120000\) 20s 512M

——————

如果把第一个操作看成乘上一个\(x + a_i\)，第二个操作看成询问\(x = a_i\)处多项式的值，那么这是一个裸的动态多点求值

首先暴力是可以AC的……恩，开个O2就行……

直接上CDQ＋静态多点求值的话是\(O(n \log ^3 n)\)的，只能跑过60分

#pragma GCC optimize(2)

#include <bits/stdc++.h>

using namespace std;

const int N = ;

const int MOD = ;

const int G = ;

int powi(int a, int b)

{

    int c = ;

    for (; b; b >>= , a = 1ll * a * a % MOD)

        if (b & ) c = 1ll * c * a % MOD;

    return c;

}

void NTT(int A[], int n, int f)

{

    for (int i = ; i < n; ++ i)

    {

        int j = ;

        for (int p = , q = n >> ; p < n; p <<= , q >>= )

            if (i & p) j |= q;

        if (i < j) swap(A[i], A[j]);

    }

    for (int i = ; i <= n; i <<= )

    {

        int w1 = powi(G, (MOD - ) / i);

        if (f < ) w1 = powi(w1, MOD - );

        for (int j = ; j < n; j += i)

        {

            int w = ;

            for (int k = j; k < j + (i >> ); ++ k)

            {

                int u = A[k], v = 1ll * A[k + (i >> )] * w % MOD;

                A[k] = (u + v) % MOD;

                A[k + (i >> )] = (u - v + MOD) % MOD;

                w = 1ll * w * w1 % MOD;

            }

        }

    }

    int p = powi(n, MOD - );

    if (f < ) for (int i = ; i < n; ++ i) A[i] = 1ll * A[i] * p % MOD;

}

int Rev_tmp1[N], Rev_tmp2[N];

void Rev(int A[], int G[], int n)

{

    if (n == )

    {

        G[] = powi(A[], MOD - );

    }

    else

    {

        Rev(A, G, n / );

        for (int i = ; i < n; ++ i) Rev_tmp1[i] = A[i];

        for (int i = n; i < (n << ); ++ i) Rev_tmp1[i] = ;

        for (int i = ; i < (n >> ); ++ i) Rev_tmp2[i] = G[i];

        for (int i = (n >> ); i < (n << ); ++ i) Rev_tmp2[i] = ;

        NTT(Rev_tmp1, n << , );

        NTT(Rev_tmp2, n << , );

        for (int i = ; i < (n << ); ++ i) Rev_tmp1[i] = (( - 1ll * Rev_tmp1[i] * Rev_tmp2[i]) % MOD + MOD) * Rev_tmp2[i] % MOD;

        NTT(Rev_tmp1, n << , -);

        for (int i = ; i < n; ++ i) G[i] = Rev_tmp1[i];

    }

}

int Mod_tmp1[N], Mod_tmp2[N], Mod_tmp3[N], Mod_tmp4[N];

void Mod(int A[], int B[], int D[], int n, int m)

{

    if (n < m)

    {

        for (int i = ; i < n; ++ i) D[i] = A[i];

        return;

    }

    int nn = ;

    while (nn < (n - m + )) nn <<= ;

    for (int i = ; i < n; ++ i) Mod_tmp3[i] = A[i];

    for (int i = ; i < m; ++ i) Mod_tmp4[i] = B[i];

    for (int i = , j = n - ; i < j; ++ i, -- j) swap(Mod_tmp3[i], Mod_tmp3[j]);

    for (int i = , j = m - ; i < j; ++ i, -- j) swap(Mod_tmp4[i], Mod_tmp4[j]);

    for (int i = m; i < nn; ++ i) Mod_tmp4[i] = ;

    Rev(Mod_tmp4, Mod_tmp2, nn);

    for (int i = ; i < n - m + ; ++ i) Mod_tmp1[i] = Mod_tmp3[i];

    for (int i = n - m + ; i < (nn << ); ++ i) Mod_tmp1[i] = ;

    for (int i = n - m + ; i < (nn << ); ++ i) Mod_tmp2[i] = ;

    NTT(Mod_tmp1, nn << , );

    NTT(Mod_tmp2, nn << , );

    for (int i = ; i < (nn << ); ++ i) Mod_tmp1[i] = 1ll * Mod_tmp1[i] * Mod_tmp2[i] % MOD;

    NTT(Mod_tmp1, nn << , -);

    while (nn < n) nn <<= ;

    for (int i = , j = n - m; i < j; ++ i, -- j) swap(Mod_tmp1[i], Mod_tmp1[j]);

    for (int i = n - m + ; i < (nn << ); ++ i) Mod_tmp1[i] = ;

    for (int i = ; i < m; ++ i) Mod_tmp2[i] = B[i];

    for (int i = m; i < (nn << ); ++ i) Mod_tmp2[i] = ;

    NTT(Mod_tmp1, nn << , );

    NTT(Mod_tmp2, nn << , );

    for (int i = ; i < (nn << ); ++ i) Mod_tmp1[i] = 1ll * Mod_tmp1[i] * Mod_tmp2[i] % MOD;

    NTT(Mod_tmp1, nn << , -);

    for (int i = ; i < m - ; ++ i) D[i] = (A[i] - Mod_tmp1[i] + MOD) % MOD;

}

int AAA[N];

int Mul_tmp[][N], Mul_tmp1[N], Mul_tmp2[N];

void Mul(int x, int l, int r)

{

    if (r - l == )

    {

        Mul_tmp[x][l *  + ] = ;

        Mul_tmp[x][l * ] = AAA[l];

        return;

    }

    int m = (l + r) / ;

    Mul(x + , l, m);

    Mul(x + , m, r);

    for (int i = ; i < ((m - l) << ); ++ i) Mul_tmp1[i] = Mul_tmp[x + ][i + l * ];

    for (int i = ; i < ((r - m) << ); ++ i) Mul_tmp2[i] = Mul_tmp[x + ][i + m * ];

    int nn = ;

    while (nn < (r - l) * ) nn <<= ;

    for (int i = ((m - l) << ); i < nn; ++ i) Mul_tmp1[i] = ;

    for (int i = ((r - m) << ); i < nn; ++ i) Mul_tmp2[i] = ;

    NTT(Mul_tmp1, nn, );

    NTT(Mul_tmp2, nn, );

    for (int i = ; i < nn; ++ i) Mul_tmp1[i] = 1ll * Mul_tmp1[i] * Mul_tmp2[i] % MOD;

    NTT(Mul_tmp1, nn, -);

    for (int i = ; i < ((r - l) << ); ++ i) Mul_tmp[x][i + l * ] = Mul_tmp1[i];

}

int get_val_tmp[][N];

void get_val(int fin[], int x, int l, int r)

{

    if (r - l == )

    {

        fin[l] = get_val_tmp[x][l * ];

        return;

    }

    int m = (l + r) / ;

    Mod(get_val_tmp[x] + l * , Mul_tmp[x + ] + l * , get_val_tmp[x + ] + l * , (r - l) * , (m - l) + );

    Mod(get_val_tmp[x] + l * , Mul_tmp[x + ] + m * , get_val_tmp[x + ] + m * , (r - l) * , (r - m) + );

    for (int i = m + l; i < m * ; ++ i) get_val_tmp[x + ][i] = ;

    for (int i = r + m; i < r * ; ++ i) get_val_tmp[x + ][i] = ;

    get_val(fin, x + , l, m);

    get_val(fin, x + , m, r);

}

void GGG(int A[], int B[], int D[], int n, int m)

{

    for (int i = ; i < m * ; ++ i) get_val_tmp[][i] = ;

    for (int i = ; i < m; ++ i) AAA[i] = MOD - B[i];

    Mul(, , m);

    Mod(A, Mul_tmp[], get_val_tmp[], n, m + );

    get_val(D, , , m);

}

int typ[N], val[N], ans[N];

int solve_tmp1[N], solve_tmp2[N], solve_tmp3[N];

void solve(int l, int r)

{

    if (r - l == ) return;

    int m = (l + r) / ;

    solve(l, m);

    solve(m, r);

    int tot1 = , tot2 = , tot3 = ;

    for (int i = l; i < m; ++ i) if (typ[i] == ) AAA[tot1 ++] = val[i];

    for (int i = m; i < r; ++ i) if (typ[i] == ) solve_tmp2[tot2 ++] = val[i];

    if (!tot1 || !tot2) return;

    Mul(, , tot1);

    for (int i = ; i < tot1 + ; ++ i) solve_tmp1[i] = Mul_tmp[][i];

    for (int i = tot1 + ; i < tot1 * ; ++ i) solve_tmp1[i] = ;

    GGG(solve_tmp1, solve_tmp2, solve_tmp3, tot1 + , tot2);

    for (int i = m; i < r; ++ i) if (typ[i] == ) ans[i] = 1ll * ans[i] * solve_tmp3[tot3 ++] % MOD;

}

int main()

{

    int a, b, c, n;

    scanf("%d%d%d", &a, &b, &c); n = b + c;

    for (int i = ; i < n; ++ i)

    {

        scanf("%d%d", &typ[i], &val[i]); ans[i] = ;

        val[i] = ((val[i]) % MOD + MOD) % MOD;

    }

    solve(, n);

    for (int i = ; i < n; ++ i)

        if (typ[i] == ) printf("%d\n", ans[i]);

}

令第\(i-1\)次询问到第\(i\)次询问之间的多项式之积为\(A_i(x)\)

那么显然有 \(ans_i = (\prod_{p=1}^{i} A_p(x)) \mod (x - a_i)\)

令\(f_{l,r}=(\prod_{p=1}^{l} A_p(x)) \mod (\prod_{p = l}^{r-1} (x - a_p)) \)

于是\(ans_i = f_{i,i+1}\)

注意到

\(f_{l,mid} = f_{l,r} \mod (\prod_{p = l}^{mid-1} (x - a_p)) \)

\(f_{mid,r} =( f_{l,r} \prod_{p=l+1}^{mid} A_p(x))  \mod (\prod_{p = mid}^{r-1} (x - a_p)) \)

\(f_{1,q}=A_1(x) \)

预处理 需要用的 \(x-a_i\)的积 和 需要用的 \(A_i(x) \) 的积（就是一个多项式分治乘法啦

一次递归只需要跑一次多项式乘法和两次多项式取膜，多项式的度数是\(O(len)\)的，因此一次递归的复杂度是\(O(len \log len)\)的

\(T(n) = 2 T(\frac{n}{2})  + O(n \log n))\)

最终复杂度\(O(n \log ^2 n)\)

代码写的和上面的分析有些不同，所以有点萎（捂脸

#pragma GCC optimize(2)

#include <bits/stdc++.h>

using namespace std;

const int N = ;

const int MOD = ;

const int G = ;

int powi(int a, int b)

{

    int c = ;

    for (; b; b >>= , a = 1ll * a * a % MOD)

        if (b & ) c = 1ll * c * a % MOD;

    return c;

}

void NTT(int A[], int n, int f)

{

    for (int i = , j = ; i < n; ++ i)

    {

        if (i > j) swap(A[i], A[j]);

        for (int l = n >> ; (j ^= l) < l; l >>= );

    }

    for (int i = ; i <= n; i <<= )

    {

        int w1 = powi(G, (MOD - ) / i);

        if (f < ) w1 = powi(w1, MOD - );

        for (int j = ; j < n; j += i)

        {

            int w = ;

            for (int k = j; k < j + (i >> ); ++ k)

            {

                int u = A[k], v = 1ll * A[k + (i >> )] * w % MOD;

                A[k] = (u + v >= MOD? u + v - MOD: u + v);

                A[k + (i >> )] = (u - v < ? u - v + MOD: u - v);

                w = 1ll * w * w1 % MOD;

            }

        }

    }

    int p = powi(n, MOD - );

    if (f < ) for (int i = ; i < n; ++ i) A[i] = 1ll * A[i] * p % MOD;

}

int Rev_tmp1[N], Rev_tmp2[N];

void Rev(int A[], int G[], int n)

{

    if (n == )

    {

        G[] = powi(A[], MOD - );

    }

    else

    {

        Rev(A, G, n / );

        for (int i = ; i < n; ++ i) Rev_tmp1[i] = A[i];

        for (int i = n; i < (n << ); ++ i) Rev_tmp1[i] = ;

        for (int i = ; i < (n >> ); ++ i) Rev_tmp2[i] = G[i];

        for (int i = (n >> ); i < (n << ); ++ i) Rev_tmp2[i] = ;

        NTT(Rev_tmp1, n << , );

        NTT(Rev_tmp2, n << , );

        for (int i = ; i < (n << ); ++ i) Rev_tmp1[i] = (( - 1ll * Rev_tmp1[i] * Rev_tmp2[i]) % MOD + MOD) * Rev_tmp2[i] % MOD;

        NTT(Rev_tmp1, n << , -);

        for (int i = ; i < n; ++ i) G[i] = Rev_tmp1[i];

    }

}

int Mod_tmp1[N], Mod_tmp2[N], Mod_tmp3[N], Mod_tmp4[N];

void Mod(int A[], int B[], int D[], int n, int m)

{

    while (B[m - ] == ) m --;

    if (n < m)

    {

        for (int i = ; i < n; ++ i) D[i] = A[i];

        return;

    }

    int nn = ;

    while (nn < (n - m + )) nn <<= ;

    for (int i = ; i < n; ++ i) Mod_tmp3[i] = A[i];

    for (int i = ; i < m; ++ i) Mod_tmp4[i] = B[i];

    for (int i = , j = n - ; i < j; ++ i, -- j) swap(Mod_tmp3[i], Mod_tmp3[j]);

    for (int i = , j = m - ; i < j; ++ i, -- j) swap(Mod_tmp4[i], Mod_tmp4[j]);

    for (int i = m; i < nn; ++ i) Mod_tmp4[i] = ;

    Rev(Mod_tmp4, Mod_tmp2, nn);

    for (int i = ; i < n - m + ; ++ i) Mod_tmp1[i] = Mod_tmp3[i];

    for (int i = n - m + ; i < (nn << ); ++ i) Mod_tmp1[i] = ;

    for (int i = n - m + ; i < (nn << ); ++ i) Mod_tmp2[i] = ;

    NTT(Mod_tmp1, nn << , );

    NTT(Mod_tmp2, nn << , );

    for (int i = ; i < (nn << ); ++ i) Mod_tmp1[i] = 1ll * Mod_tmp1[i] * Mod_tmp2[i] % MOD;

    NTT(Mod_tmp1, nn << , -);

    while (nn < n) nn <<= ;

    for (int i = , j = n - m; i < j; ++ i, -- j) swap(Mod_tmp1[i], Mod_tmp1[j]);

    for (int i = n - m + ; i < (nn << ); ++ i) Mod_tmp1[i] = ;

    for (int i = ; i < m; ++ i) Mod_tmp2[i] = B[i];

    for (int i = m; i < (nn << ); ++ i) Mod_tmp2[i] = ;

    NTT(Mod_tmp1, nn << , );

    NTT(Mod_tmp2, nn << , );

    for (int i = ; i < (nn << ); ++ i) Mod_tmp1[i] = 1ll * Mod_tmp1[i] * Mod_tmp2[i] % MOD;

    NTT(Mod_tmp1, nn << , -);

    for (int i = ; i < m - ; ++ i) D[i] = (A[i] - Mod_tmp1[i] + MOD) % MOD;

}

int AAA[N], BBB[N];

int Mul1[][N], Mul2[][N], Mul_tmp1[N], Mul_tmp2[N];

void Mul(int Mul_tmp[][N], int x, int l, int r)

{

    if (r - l == )

    {

        if (!BBB[l])

        {

            Mul_tmp[x][l *  + ] = ;

            Mul_tmp[x][l * ] = AAA[l];

        }

        else

        {

            Mul_tmp[x][l *  + ] = ;

            Mul_tmp[x][l * ] = ;

        }

        return;

    }

    int m = (l + r) / ;

    Mul(Mul_tmp, x + , l, m);

    Mul(Mul_tmp, x + , m, r);

    for (int i = ; i < ((m - l) << ); ++ i) Mul_tmp1[i] = Mul_tmp[x + ][i + l * ];

    for (int i = ; i < ((r - m) << ); ++ i) Mul_tmp2[i] = Mul_tmp[x + ][i + m * ];

    int nn = ;

    while (nn < (r - l) * ) nn <<= ;

    for (int i = ((m - l) << ); i < nn; ++ i) Mul_tmp1[i] = ;

    for (int i = ((r - m) << ); i < nn; ++ i) Mul_tmp2[i] = ;

    NTT(Mul_tmp1, nn, );

    NTT(Mul_tmp2, nn, );

    for (int i = ; i < nn; ++ i) Mul_tmp1[i] = 1ll * Mul_tmp1[i] * Mul_tmp2[i] % MOD;

    NTT(Mul_tmp1, nn, -);

    for (int i = ; i < ((r - l) << ); ++ i) Mul_tmp[x][i + l * ] = Mul_tmp1[i];

}

int cnt1[N], cnt2[N];

int ans[N], typ[N], val[N];

int solve_tmp[][N], solve_tmp1[N], solve_tmp2[N];

void solve(int x, int l, int r)

{

    if (r - l == )

    {

        ans[l] = solve_tmp[x][l * ];

        return;

    }

    if (cnt1[r] - cnt1[l] == ) return;

    int m = (l + r) / ;

    Mod(solve_tmp[x] + l * , Mul1[x + ] + l * , solve_tmp[x + ] + l * , (r - l) * , (m - l) * );

    int nn = ;

    while (nn < (r - l) * ) nn *= ;

    for (int i = ; i < (r - l) * ; ++ i) solve_tmp1[i] = solve_tmp[x][i + l * ];

    for (int i = (r - l) * ; i < nn; ++ i) solve_tmp1[i] = ;

    for (int i = ; i < (m - l) * ; ++ i) solve_tmp2[i] = Mul2[x + ][i + l * ];

    for (int i = (m - l) * ; i < nn; ++ i) solve_tmp2[i] = ;

    NTT(solve_tmp1, nn, );

    NTT(solve_tmp2, nn, );

    for (int i = ; i < nn; ++ i) solve_tmp1[i] = 1ll * solve_tmp1[i] * solve_tmp2[i] % MOD;

    NTT(solve_tmp1, nn, -);

    Mod(solve_tmp1, Mul1[x + ] + m * , solve_tmp[x + ] + m * , (r - l) * , (r - m) * );

    solve(x + , l, m);

    solve(x + , m, r);

}

namespace IO {

    const int SIZE=(int)(1e6);

    char buf[SIZE];

    FILE *in,*out;

    int cur;

    inline void init() {

        cur=SIZE;in=stdin;out=stdout;

    }

    inline char nextChar() {

        if(cur==SIZE) {

            fread(buf,SIZE,,in);cur=;

        } return buf[cur++];

    }

    inline int nextInt() {

        bool st=,neg=;

        char c;int num=;

        while((c=nextChar())!=EOF) {

            if(c=='-') st=neg=;

            else if(c>='' && c<='') {

                st=;num=num*+c-'';

            } else if(st) break;

        } if(neg) num=-num;

        return num;

    }

    inline void printChar(char c) {

        buf[cur++]=c;

        if(cur==SIZE) {

            fwrite(buf,SIZE,,out);cur=;

        }

    }

    inline void printInt(int x) {

        if(x<) {

            printChar('-');printInt(-x);

            return;

        }

        if(x>=) printInt(x/);printChar(''+x%);

    }

    inline void close() {

        if(cur>) fwrite(buf,cur,,out);cur=;

    }

}

int main()

{

    using namespace IO;

    int a, b, c, n;

    init();

    a = nextInt();

    b = nextInt();

    c = nextInt();

    n = b + c;

    for (int i = ; i < n; ++ i)

    {

        typ[i] = nextInt();

        val[i] = nextInt();

        ans[i] = ;

        cnt1[i + ] = cnt1[i] + (typ[i] == );

        cnt2[i + ] = cnt2[i] + (typ[i] == );

        val[i] = ((val[i]) % MOD + MOD) % MOD;

    }

    for (int i = ; i < n; ++ i) if (typ[i] == ) BBB[i] = , AAA[i] = val[i]; else BBB[i] = ;

    Mul(Mul2, , , n);

    for (int i = ; i < n; ++ i) if (typ[i] == ) BBB[i] = , AAA[i] = MOD - val[i]; else BBB[i] = ;

    Mul(Mul1, , , n);

    solve_tmp[][] = ;

    solve(, , n);

    cur = ;

    for (int i = ; i < n; ++ i)

        if (typ[i] == ) printInt(ans[i]), printChar('\n');

    close();

}

换了一个NTT板子，终于跑的比暴力快了QAQ

学会了多项式技巧（划去

xjoi 2082: 小明的序列的更多相关文章

  1. 小明系列问题――小明序列(LIS)

    小明系列问题――小明序列 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit ...

  2. hdu----(4521)小明系列问题——小明序列

    小明系列问题——小明序列 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)Tota ...

  3. 小明系列问题——小明序列(Lis 相距大于d的单调上升子序列)

    小明系列问题——小明序列 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Tot ...

  4. hdu4521 小明系列的问题——小明序列(LIS变种 （段树+单点更新解决方案）)

    链接: huangjing 题目:中文题目 思路: 1:这个题目假设去掉那个距离大于d的条件,那么必定是一个普通的LIS.可是加上那个条件后就变得复杂了.我用的线段树的解法. . .就是採用延迟更新的 ...

  5. hdu 4521 小明系列问题——小明序列 线段树+二分

    小明系列问题——小明序列 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Pro ...

  6. 2018.07.08 hdu4521 小明系列问题——小明序列（线段树+简单dp）

    小明系列问题--小明序列 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others) Proble ...

  7. HDU 4521 小明系列问题——小明序列 （线段树 单点更新）

    题目连接 Problem Description 大家都知道小明最喜欢研究跟序列有关的问题了,可是也就因为这样,小明几乎已经玩遍各种序列问题了.可怜的小明苦苦地在各大网站上寻找着新的序列问题,可是找来 ...

  8. hdu 4521 小明系列问题——小明序列(线段树+DP或扩展成经典的LIS)

    小明系列问题--小明序列 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Tot ...

  9. hdu4521 小明系列问题——小明序列

    Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission ...

随机推荐

  1. 浩哥解析MyBatis源码（八）——Type类型模块之TypeAliasRegistry（类型别名注册器）

    原创作品,可以转载,但是请标注出处地址:http://www.cnblogs.com/V1haoge/p/6705769.html 1.回顾 前面几篇讲了数据源模块,这和之前的事务模块都是enviro ...

  2. Spring Boot 整合 Redis 实现缓存操作

    摘要: 原创出处 www.bysocket.com 「泥瓦匠BYSocket 」欢迎转载,保留摘要,谢谢!   『 产品没有价值,开发团队再优秀也无济于事 – <启示录> 』   本文提纲 ...

  3. C++ 窗口可改风格

    SetWindowLong(m_hWnd,GWL_STYLE,::GetWindowLong(m_hWnd,GWL_STYLE)& ~WS_MAXIMIZEBOX);//去掉最大化 GWL_S ...

  4. webstorm配置编译sass的输出目录

    关于这个的问题,虽说不是很难,但还是踩了点小坑,下面就来介绍下如何使用webstorm配置编译sass的输出目录. 1.下载Ruby 2.使用Ruby安装sass 3.检测是否安装成功. 前面的几步很 ...

  5. MongoDB基础教程系列--第九篇 MongoDB 分片

    1.分片介绍 分片(sharding)是将数据拆分,将其分散存到不同机器上的过程.MongoDB 支持自动分片,可以使数据库架构对应用程序不可见.对于应用程序来说,好像始终在使用一个单机的 Mongo ...

  6. bootstrap快速入门笔记（九）-响应式工具

    一,可用的类   超小屏幕手机 (<768px) 小屏幕平板 (≥768px) 中等屏幕桌面 (≥992px) 大屏幕桌面 (≥1200px) .visible-xs-* 可见 隐藏 隐藏 隐藏 ...

  7. [CTSC2008] 网络管理

    题目描述 Description M公司是一个非常庞大的跨国公司,在许多国家都设有它的下属分支机构或部门.为了让分布在世界各地的N个部门之间协同工作,公司搭建了一个连接整个公司的通信网络.该网络的结构 ...

  8. 自定义list排序

    使用扩展方法OrderBy,OrderByDescending,效果优良. 实现代码如下: private static void SortByExtensionMethod() { List< ...

  9. 整合最优雅SSM框架：SpringMVC + Spring + MyBatis

    我们看招聘信息的时候,经常会看到这一点,需要具备SSH框架的技能:而且在大部分教学课堂中,也会把SSH作为最核心的教学内容. 但是,我们在实际应用中发现,SpringMVC可以完全替代Struts,配 ...

  10. OD常用断点之CC断点

    在做Windows平台软件逆向时,Ollydbg是极其常用的逆向工具,动态调试功能非常强大.在调试过程中,断点的使用有助于确定关键的破解位置,今天讲解的内容是OD常用断点中的CC断点. CC断点有很多 ...