xjoi 2082: 小明的序列

维护一个序列，初始全为\(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: 小明的序列的更多相关文章

小明系列问题――小明序列(LIS)
小明系列问题――小明序列 Time Limit:1000MS Memory Limit:32768KB 64bit IO Format:%I64d & %I64u Submit ...
hdu----(4521)小明系列问题——小明序列
小明系列问题——小明序列 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)Tota ...
小明系列问题——小明序列(Lis 相距大于d的单调上升子序列)
小明系列问题——小明序列 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others) Tot ...
hdu4521 小明系列的问题——小明序列(LIS变种（段树+单点更新解决方案）)
链接: huangjing 题目:中文题目思路: 1:这个题目假设去掉那个距离大于d的条件,那么必定是一个普通的LIS.可是加上那个条件后就变得复杂了.我用的线段树的解法. . .就是採用延迟更新的 ...
hdu 4521 小明系列问题——小明序列线段树+二分
小明系列问题——小明序列 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others) Pro ...
2018.07.08 hdu4521 小明系列问题——小明序列（线段树+简单dp）
小明系列问题--小明序列 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others) Proble ...
HDU 4521 小明系列问题——小明序列（线段树单点更新）
题目连接 Problem Description 大家都知道小明最喜欢研究跟序列有关的问题了,可是也就因为这样,小明几乎已经玩遍各种序列问题了.可怜的小明苦苦地在各大网站上寻找着新的序列问题,可是找来 ...
hdu 4521 小明系列问题——小明序列(线段树+DP或扩展成经典的LIS)
小明系列问题--小明序列 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others) Tot ...
hdu4521 小明系列问题——小明序列
Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others) Total Submission ...

随机推荐

我的iOS博客旅行开始了，欢迎光临！
期待您的关注!
js距离现在时间计算
<script language="javascript"> var biryear = 2015; var birmonth = 12; var birday = 1 ...
Linux配置tomcat (centos配置java环境 tomcat配置篇总结三)
♣下载安装tomcat7 ♣设置启动和关闭 ♣设置用户名和密码 ♣发布java web项目声明:这篇教程是建立在前两篇教程的基础上的,所以,还没安装工具和jdk,可以先看这个系列的前面两篇(去到文末 ...
(转载)Google的PageRank算法
本文由张洋(敲代码的张洋)投稿于伯乐在线. 本文转载于:http://blog.jobbole.com/23286/ 很早就对Google的PageRank算法很感兴趣,但一直没有深究,只有个轮廓性的 ...
Android系统--输入系统（八）Reader线程_使用EventHub读取事件
Android系统--输入系统(八)Reader线程_使用EventHub读取事件 1. Reader线程工作流程获得事件 size_t count = mEventHub->getEvent ...
尚学堂Java第一课
今天是北京尚学堂郑州分校开课的第一天,小班面授教学. 我很兴奋,是一个小白对IT大神渴求传道授业解惑的兴奋. 杨老师还是一贯耐心详细的手敲了第一堂课的完整大纲,必须给杨老师赞赞赞!!! 从幽默的制定班 ...
简谈-如何使用Python和R组合完成任务
概述和那些数据科学比赛不同,在真实的数据科学中,我们可能更多的时间不是在做算法的开发,而是对需求的定义和数据的治理.所以,如何更好的结合现实业务,让数据真正产生价值成了一个更有意义的话题. 数据科学 ...
图论算法-Dijkstra
原理 Dijkstra是一个神奇的最短路径算法,它的优点在于它可以稳定的时间内求出一张图从某点到另一点的距离.它的工作原理非常简单,思路类似于广搜.在搜索前,将每个点的颜色设为白色,第一次将源点Ins ...
[Cake] 0.C# Make自动化构建-简介
0.Cake是什么? Cake是C# Make的缩写,是一个基于C# DSL的自动化构建系统.它可以用来编译代码,复制文件以及文件夹,运行单元测试,压缩文件以及构建Nuget包等等. 熟悉大名鼎鼎的M ...
微信公众号开发笔记2(nodejs)
本篇主要记录调用微信各种api和功能实现一.始于access_token 无论调用微信的什么api,都需要一个查询参数,就是我们每隔1小时或者2小时获取的access_token,笔记1中已经保证了 ...

xjoi 2082: 小明的序列

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

随机推荐

热门专题