liu_jiangwen
liu_jiangwen

ACM模板

动态规划

背包

01背包

//物品数量为n 背包容量为v
//第i个物品的价值为val[i] 体积为vol[i]
//最终结果为dp[v]
const int maxn = 1010;
int dp[maxn];
int vol[maxn];
int val[maxn];
int n, v;

void solve() {
    memset(dp, 0, sizeof(dp));
    for(int i = 0; i < n; i++) {
        for(int j = v; j >= vol[i]; j--) {
            dp[j] = max(dp[j], dp[j - vol[i]] + val[i]);
        }
    }
}

完全背包

const int maxn = 1010;
int dp[maxn];
int vol[maxn];
int val[maxn];
int n, v;

void solve() {
    memset(dp, 0, sizeof(dp));
    for(int i = 0; i < n; i++) {
        for(int j = vol[i]; j <= v; j++) {
            dp[j] = max(dp[j], dp[j - vol[i]] + val[i]);
        }
    }
}

多重背包

//恰好装满 hdu2844
#include
#include
#include
#include
#include
using namespace std;

const int maxn = 110;
const int maxm = 100010;
int val[maxn];
int num[maxn];
int dp[maxm];
int n, m;

void solve() {
    memset(dp, -1, sizeof(dp));
    dp[0] = 0;
    for(int i = 0; i < n; i++) {
        if(val[i] * num[i] >= m) {
            for(int j = val[i]; j <= m; j++) {
                if(dp[j - val[i]] != -1) {
                    dp[j] = max(dp[j], dp[j - val[i]] + val[i]);
                }
            }
        }
        else {
            int cnt = 1;
            int totVal = val[i];
            while(num[i] > cnt) {
                for(int j = m; j >= totVal; j--) {
                    if(dp[j - totVal] != -1) {
                        dp[j] = max(dp[j], dp[j - totVal] + totVal);
                    }
                }
                num[i] -= cnt;
                cnt <<= 1;
                totVal <<= 1;
            }
            totVal = num[i] * val[i];
            for(int j = m; j >= totVal; j--) {
                if(dp[j - totVal] != -1) {
                    dp[j] = max(dp[j], dp[j - totVal] + totVal);
                }
            }
        }
    }
    int ans = 0;
    for(int i = 1; i <= m; i++) {
        if(dp[i] == i) {
            ans++;
        }
    }
    printf("%d\n", ans);
}

int main() {
    while(scanf("%d%d", &n, &m) && (n || m)) {
        for(int i = 0; i < n; i++) {
            scanf("%d", val + i);
        }
        for(int i = 0; i < n; i++) {
            scanf("%d", num + i);
        }
        solve();
    }
    return 0;
}

多重背包判断可行性

//每种有若干件的物品能否填满给定容量的背包
//O(NV)
// hdu2844
#include
#include
#include
#include
#include
using namespace std;

const int maxn = 101;
const int maxm = 100001;
int val[maxn];
int num[maxn];
int dp[maxm];
int n, m;

void solve() {
    for(int i = 1; i <= m; i++) {
        dp[i] = -1;
    }
    dp[0] = 0;
    for(int i = 1; i <= n; i++) {
        for(int j = 0; j <= m; j++) {
            dp[j] = dp[j] >= 0 ? num[i] : -1;
        }
        for(int j = 0; j <= m - val[i]; j++) {
            if(dp[j] > 0) {
                dp[j + val[i]] = max(dp[j + val[i]], dp[j] - 1);
            }
        }
    }
    int ans = 0;
    for(int i = 1; i <= m; i++) {
        if(dp[i] != -1) {
            ans++;
        }
    }
    printf("%d\n", ans);
}

int main() {
    while(scanf("%d%d", &n, &m) && (n || m)) {
        for(int i = 1; i <= n; i++) {
            scanf("%d", val + i);
        }
        for(int i = 1; i <= n; i++) {
            scanf("%d", num + i);
        }
        solve();
    }
    return 0;
}

数论

组合数求模

卢卡斯定理

//FZU 2020
//要求p为素数
//适合使用的场景：
//1 <= m <= n <= 1e18 , p <= 1e5
typedef long long LL;
LL quickPowMod(LL n, LL r, LL mod) {
    LL res = 1;
    n %= mod;
    while(r) {
        if(r & 1) {
            res = (res * n) % mod;
        }
        n = (n * n) % mod;
        r >>= 1;
    }
    return res;
}

LL inverse(LL n, LL mod) {
    return quickPowMod(n, mod - 2, mod);
}

LL C(LL n, LL m, LL mod) {
    if(m > n) {
        return 0;
    }
    LL res = 1;
    LL a, b;
    for(int i = 1; i <= m; i++) {
        a = (n + i - m) % mod;
        b = inverse(i, mod);
        res = (((res * a) % mod)* b) % mod;
    }
    return res;
}

LL lucas(LL n, LL m, LL mod) {
    if(m == 0) {
        return 1;
    }
    return C(n % mod, m % mod, mod) * lucas(n / mod, m / mod, mod) % mod;
}

int main() {
    int t;
    LL n, m, mod;
    cin >> t;
    while(t--) {
        cin >> n >> m >> mod;
        cout << lucas(n, m, mod) << endl;
    }
    return 0;
}

扩展卢卡斯定理

C n m % p      1 ≤ m ≤ n ≤ 1 0 18      2 ≤ p ≤ 1000000      且 p 不 保 证 为 质 数 C_n^m \% p\;\;1\leq m \leq n \leq 10^{18}\;\;2\leq p \leq 1000000\;\;且p不保证为质数 Cnm​%p1≤m≤n≤10182≤p≤1000000且p不保证为质数

//洛谷4720模板
//Gym - 100633J
#include
#include
#include
#include
#include
#include
#include
using namespace std;
typedef long long LL;

LL quickPowerMod(LL n, LL r, LL p) {
    LL res = 1;
    n %= p;
    while(r) {
        if(r & 1) {
            res = res * n % p;
        }
        r >>= 1;
        n = n * n % p;
    }
    return res;
}

LL exgcd(LL a, LL b, LL &x, LL &y) {
    if(b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    LL res = exgcd(b, a % b, x, y);
    LL temp = x;
    x = y;
    y = temp - a / b * y;
    return res;
}

LL inverse(LL a, LL m) {
    LL x1, x2;
    LL d = exgcd(a, m, x1, x2);
    if(d != 1) {
        return -1;
    }
    return (x1 % m + m) % m;
}

LL CRT(vector &b, vector &m) {
    LL n = m.size();
    LL ans = 0;
    LL M = 1;
    LL Mi;
    LL x, y;
    for(LL temp : m) {
        M *= temp;
    }
    for(LL i = 0; i < n; i++) {
        Mi = M / m[i];
        //exgcd(Mi, m[i], x, y);
        ans = (ans + b[i] * Mi * inverse(Mi, m[i])) % M;
    }
    ans = (ans + M) % M;
    return ans;
}

//计算n!中因子p的个数
LL calculateExp(LL n, LL p) {
    LL res = 0;
    while(n) {
        res += n / p;
        n /= p;
    }
    return res;
}

//计算n!中除去所有因子p之后模mod(p^x)的值
LL facModP(LL n, LL mod, LL p) {
    if(n == 0) {
        return 1;
    }
    LL res = 1;
    if(n / mod) {
        for(LL i = 2; i <= mod; i++) {
            if(i % p != 0) {
                res = res * i % mod;
            }
        }
        res = quickPowerMod(res, n / mod, mod);
    }
    LL temp = n % mod;
    for(LL i = 2; i <= temp; i++) {
        if(i % p != 0) {
            res = res * i % mod;
        }
    }
    return res * facModP(n / p, mod, p) % mod;
}

//计算C(n, m) % p^x 的值
LL CmodP(LL n, LL m, LL mod, LL p) {
    LL res, inv1, inv2;
    LL cnt = 0;
    cnt += calculateExp(n, p);
    cnt -= calculateExp(m, p);
    cnt -= calculateExp(n - m, p);

    res = facModP(n, mod, p);
    inv1 = facModP(m, mod, p);
    inv2 = facModP(n - m, mod, p);
    inv1 = inverse(inv1, mod);
    inv2 = inverse(inv2, mod);
    res = (res * inv1 % mod) * inv2 % mod;
    res = res * quickPowerMod(p, cnt, mod) % mod;
    return res;
}

//计算C(n, m) % mod(合数)的值
LL CmodX(LL n, LL m, LL mod) {
    vector b, md;
    LL temp;
    for(LL i = 2; i * i <= mod; i++) {
        if(mod % i == 0) {
            temp = 1;
            while(mod % i == 0) {
                temp *= i;
                mod /= i;
            }
            md.push_back(temp);
            b.push_back(CmodP(n, m, temp, i));
        }
    }
    if(mod > 1) {
        md.push_back(mod);
        b.push_back(CmodP(n, m, mod, mod));
    }
    return CRT(b, md);
}

int main() {
    LL n, m, p;
    while(cin >> n >> m >> p) {
        cout << CmodX(n, m, p) << endl;
    }
    return 0;
}

模线性方程组

中国剩余定理

typedef long long LL;
const int maxn = 1000;
LL b[maxn];
LL m[maxn];

LL extendGcd(LL a, LL b, LL &x, LL &y) {
    if(b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    LL res = extendGcd(b, a % b, x, y);
    LL temp = x;
    x = y;
    y = temp - a/b*y;
    return res;
}

LL CRT(LL *b, LL *m, int n) {
    LL ans = 0;
    LL M = 1;
    LL Mi;
    LL x, y;
    for(int i = 0; i < n; i++) {
        M *= m[i];
    }
    for(int i = 0; i < n; i++) {
        Mi = M / m[i];
        extendGcd(Mi, m[i], x, y);
        ans = (ans + b[i] * Mi * x) % M;
    }
    ans = (ans + M) % M;
    return ans;
}

扩展中国剩余定理

//模板验证POJ2891

typedef long long LL;
const int maxn = 1000;
LL b[maxn];
LL m[maxn];

LL exGcd(LL a, LL b, LL &x, LL &y) {
    if(b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    LL res = exGcd(b, a % b, x, y);
    LL temp = x;
    x = y;
    y = temp - a/b*y;
    return res;
}

LL gcd(LL a, LL b) {
    return b == 0 ? a : gcd(b, a % b);
}

LL inverse(LL a, LL m) {
    LL x1, x2;
    LL d = exGcd(a, m, x1, x2);
    if(d != 1) {
        return -1;
    }
    return x1 % m;
}

bool merge(LL m1, LL b1, LL m2, LL b2, LL &m3, LL &b3) {
    LL d = gcd(m1, m2);
    LL b = b2 - b1;
    if(b % d) {
        return false;
    }
    b = (b % m2 + m2) % m2;
    m1 /= d;
    m2 /= d;
    b /= d;
    b *= inverse(m1, m2);
    b %= m2;
    b *= m1 * d;
    b += b1;
    m3 = m1 * m2 * d;
    b3 = (b % m3 + m3) % m3;
    return true;
}

LL CRT(LL *b, LL *m, int n) {
    LL tempm, tempb;
    for(int i = 0; i < n - 1; i++) {
        if(merge(m[i], b[i], m[i + 1], b[i + 1], tempm, tempb)) {
            m[i + 1] = tempm;
            b[i + 1] = tempb;
        }
        else {
            return -1;
        }
    }
    return (b[n - 1] % m[n - 1] + m[n - 1]) % m[n - 1];
}

int main() {
    int n;
    while(cin >> n) {
        for(int i = 0; i < n; i++) {
            cin >> m[i] >> b[i];
        }
        cout << CRT(b, m, n) << endl;
    }
    return 0;
}

欧拉筛

欧拉筛筛选素数

const int maxn = 100000;
bool isPrim[maxn];
int primes[maxn];
int countPrim;
void sieve() {
    int temp;
    memset(isPrim, -1, sizeof(isPrim));
    isPrim[1] = false;
    countPrim = 0;
    for(int i = 2; i < maxn; i++) {
        if(isPrim[i]) {
            primes[countPrim++] = i;
        }
        for(int j = 0; j < countPrim && (temp = i * primes[j]) < maxn; j++) {
            isPrim[temp] = false;
            if(i % primes[j] == 0) {
                break;
            }
        }
    }
}

欧拉筛计算欧拉函数

const int maxn = 100000;
bool isPrim[maxn];
int primes[maxn];
int phi[maxn];
int countPrim;
void sieve() {
    LL temp;
    memset(isPrim, -1, sizeof(isPrim));
    memset(phi, 0, sizeof(phi));
    phi[1] = 1;
    countPrim = 0;
    for(int i = 2; i < maxn; i++) {
        if(isPrim[i]) {
            primes[countPrim++] = i;
            phi[i] = i - 1;
        }
        for(int j = 0; j < countPrim && (temp = i * primes[j]) < maxn; j++) {
            isPrim[temp] = false;
            if(i % primes[j] == 0) {
                phi[temp] = phi[i]*primes[j];
                break;
            }
            else {
                phi[temp] = phi[i]*phi[primes[j]];
            }
        }
    }
}

欧拉筛计算莫比乌斯函数

const int maxn = 100000;
bool isPrim[maxn];
int primes[maxn];
int mu[maxn];
int countPrm;
void sieve() {
    memset(isPrim, -1, sizeof(isPrim));
    memset(mu, 0, sizeof(mu));
    memset(primes, 0, sizeof(primes));
    countPrim = 0;
    isPrim[1] = false;
    mu[1] = 1;
    LL temp;
    for(int i = 2; i < maxn; i++) {
        if(isPrim[i]) {
            primes[countPrim++] = i;
            mu[i] = -1;
        }
        for(int j = 0; j < countPrim && (temp = i * primes[j]) < maxn; j++) {
            isPrim[temp] = false;
            if(i % primes[j] == 0) {
                mu[temp] = 0;
                break;
            }
            else {
                mu[temp] = -mu[i];
            }
        }
    }
}

Gauss-Jordan消元

const double eps = 1e-8;
const int maxn = 110;
typedef double Matrix[maxn][maxn];

void guassJordan(Matrix A, int n) {
    int i, j, k, r;
    for(i = 0; i < n; i++) {
        r = i;
        for(j = i + 1; j < n; j++) {
            if(fabs(A[j][i]) > fabs(A[r][i])) {
                r = j;
            }
        }
        if(fabs(A[r][i]) < eps) {
            continue;
        }
        if(r != i) {
            for(j = 0; j <= n; j++) {
                swap(A[r][j], A[i][j]);
            }
        }
        for(k = 0; k < n; k++) {
            if(k != i) {
                for(j = n; j >= i; j--) {
                    A[k][j] -= A[k][i] / A[i][i] * A[i][j];
                }
            }
        }
    }
}

FFT NTT FWT

FFT

//模板验证 HDU1402 模拟大数乘法
#include
#include
#include
#include
#include
#include
using namespace std;

const int maxm = 17;
const int maxn = 1 << maxm;
complex buffer1[maxn];
complex buffer2[maxn];
complex omega[maxn];
complex conjOmega[maxn];
char number1[maxn];
char number2[maxn];
int sum[maxn];

void initOmega(int n) {
    double pi = acos(-1);
    for(int i = 0; i < n; i++) {
        omega[i] = complex(cos(2 * pi * i / n), sin(2 * pi * i / n));
        conjOmega[i] = conj(omega[i]);
    }
}

void inverse(int n, complex* buffer) {
    for(int i = 0, j = 0; i < n; i++) {
        if(i < j) {
            swap(buffer[i], buffer[j]);
        }
        for(int k = n >> 1; (j ^= k) < k; k >>= 1) {
            continue;
        }
    }
}

void fft(int n, complex* buffer, complex* omega) {
    inverse(n, buffer);
    for(int i = 2; i <= n; i <<= 1) {
        int m = i >> 1;
        int step = n / i;
        for(int j = 0; j < n; j += i) {
            for(int k = 0; k < m; k++) {
                complex temp = buffer[j + k];
                buffer[j + k] = buffer[j + k] + omega[step * k] * buffer[j + k + m];
                buffer[j + k + m] = temp - omega[step * k] * buffer[j + k + m];
            }
        }
    }
}

int main() {
    int len1, len2, len;
    while(scanf("%s%s", number1, number2) == 2) {
        len1 = strlen(number1);
        len2 = strlen(number2);
        for(len = 1; len < len1 * 2 || len < len2 * 2; len <<= 1) {
            continue;
        }
        for(int i = 0; i < len1; i++) {
            buffer1[i] = number1[len1 - i - 1] - '0';
        }
        for(int i = len1; i < len; i++) {
            buffer1[i] = 0;
        }
        for(int i = 0; i < len2; i++) {
            buffer2[i] = number2[len2 - i - 1] - '0';
        }
        for(int i = len2; i < len; i++) {
            buffer2[i] = 0;
        }
        initOmega(len);
        fft(len, buffer1, omega);
        fft(len, buffer2, omega);
        for(int i = 0; i < len; i++) {
            buffer1[i] *= buffer2[i];
        }
        fft(len, buffer1, conjOmega);
        for(int i = 0; i < len; i++) {
            sum[i] = (int)(buffer1[i].real() / len + 0.5);
        }
        for(int i = 0; i < len; i++) {
            sum[i + 1] += sum[i] / 10;
            sum[i] %= 10;
        }
        for(len = len1 + len2 - 1; len > 0 && sum[len] <= 0; len--) {
            continue;
        }
        for(int i = len; i >= 0; i--) {
            printf("%d", sum[i]);
        }
        putchar('\n');
    }
    return 0;
}

NTT

//模板验证 HDU1402 模拟大数乘法
#include
#include
#include
#include
#include
using namespace std;
typedef long long LL;

const LL MOD = 1004535809;
const LL gOfMod = 3;
const LL maxm = 17;
const LL maxn = 1 << maxm;
LL g[maxn];
LL invG[maxn];
LL buffer1[maxn];
LL buffer2[maxn];
char number1[maxn];
char number2[maxn];
LL sum[maxn];

LL quickPowerMod(LL n, LL r, LL mod) {
    LL res = 1;
    n %= mod;
    while(r) {
        if(r & 1) {
            res = res * n % mod;
        }
        n = n * n % mod;
        r >>= 1;
    }
    return res;
}

void initG(LL n) {
    g[0] = 1;
    g[1] = quickPowerMod(3, (MOD - 1) / n, MOD);
    invG[0] = 1;
    invG[1] = quickPowerMod(g[1], MOD - 2, MOD);
    for(LL i = 2; i < n; i++) {
        g[i] = g[i - 1] * g[1] % MOD;
        invG[i] = invG[i - 1] * invG[1] % MOD;
    }
}

void inverseBuffer(LL n, LL* buffer) {
    for(LL i = 0, j = 0; i < n; i++) {
        if(i > j) {
            swap(buffer[i], buffer[j]);
        }
        for(int k = n >> 1; (j ^= k) < k; k >>= 1) {
            continue;
        }
    }
}

void fft(LL n, LL* buffer, LL* g) {
    inverseBuffer(n, buffer);
    for(LL i = 2; i <= n; i <<= 1) {
        LL m = i / 2;
        LL step = n / i;
        for(int j = 0; j < n; j+= i) {
            for(int k = 0; k < m; k++) {
                LL temp = buffer[j + k];
                buffer[j + k] = (buffer[j + k] + g[k * step] * buffer[j + k + m] % MOD) % MOD;
                buffer[j + k + m] = ((temp - g[k * step] * buffer[j + k + m]) % MOD + MOD) % MOD;
            }
        }
    }
}

int main() {
    LL len1, len2, len;
    while(scanf("%s%s", number1, number2) == 2) {
        len1 = strlen(number1);
        len2 = strlen(number2);
        for(len = 1; len < len1 * 2 || len < len2 * 2; len <<= 1) {
            continue;
        }
        for(int i = 0; i < len1; i++) {
            buffer1[i] = number1[len1 - i - 1] - '0';
        }
        for(int i = len1; i < len; i++) {
            buffer1[i] = 0;
        }
        for(int i = 0; i < len2; i++) {
            buffer2[i] = number2[len2 - i - 1] - '0';
        }
        for(int i = len2; i < len; i++) {
            buffer2[i] = 0;
        }
        initG(len);
        fft(len, buffer1, g);
        fft(len, buffer2, g);
        for(int i = 0; i < len; i++) {
            buffer1[i] = buffer1[i] * buffer2[i] % MOD;
        }
        fft(len, buffer1, invG);
        LL invLen = quickPowerMod(len, MOD - 2, MOD);
        for(int i = 0; i < len; i++) {
            sum[i] = buffer1[i] * invLen % MOD;
        }
        for(int i = 0; i < len; i++) {
            sum[i + 1] += sum[i] / 10;
            sum[i] %= 10;
        }
        for(len = len1 + len2 - 1; len > 0 && sum[len] <= 0; len--) {
            continue;
        }
        while(len >= 0) {
            printf("%I64d", sum[len--]);
        }
        putchar('\n');
    }
    return 0;
}

数据结构

线段树

线段树单点更新

非递归建树

/*
模板验证 HDU1166
求区间和，题目给的区间描述是左闭右闭的，代码中全部使用左开右闭的区间
所有下标从0开始
非递归建树建立的是一颗满二叉树
*/
#include
#include
#include
#include

#define Add "Add"
#define Sub "Sub"
#define End "End"
#define Query "Query"

using namespace std;

const int maxn = 50050;
const int inf = 0x7fffffff;
int date[maxn * 4];
int leaves;	//叶子节点数量
int n;
char order[6];

void init() {
    leaves = 1;
    while(leaves < n) {
        leaves <<= 1;
    }
    memset(date, 0, sizeof(date));
}

void update(int index, int val) {
    index += leaves - 1;       //原数组中下标在线段树对应的数组中下标值的计算方法
    date[index] += val;
    while(index > 0) {
        index = (index - 1) / 2;
        date[index] += val;
    }
}

//要求查询的区间为[a, b)， 当前查询的区间为[l, r)，当前区间对应的节点为k
//在主函数中调用时调用方法为query(a, b, 0, 0, leaves);
int query(int a, int b, int k, int l, int r) {
    if(a >= r || b <= l) {
        return 0;
    }
    if(a <= l && b >= r) {
        return date[k];
    }
    return query(a, b, 2 * k + 1, l, (l + r)/2) + query(a, b, 2 * k + 2, (l + r) / 2, r);
}

int main() {
    int t, temp, index, l ,r;
    scanf("%d", &t);
    for(int cs = 1; cs <= t; cs++) {
        scanf("%d", &n);
        init();
        for(int i = 0; i < n; i++) {
            scanf("%d", &temp);
            update(i, temp);
        }
        printf("Case %d:\n", cs);
        while(scanf("%s", order)) {
            if(strcmp(order, End) == 0) {
                break;
            }
            else if(strcmp(order, Add) == 0) {
                scanf("%d%d", &index, &temp);
                update(index - 1, temp);
            }
            else if(strcmp(order, Sub) == 0) {
                scanf("%d%d", &index, &temp);
                update(index - 1, -temp);
            }
            else if(strcmp(order, Query) == 0) {
                scanf("%d%d", &l, &r);
                printf("%d\n", query(l - 1, r, 0, 0, leaves));
            }
        }
    }
    return 0;
}

递归建树

/*
模板验证 HDU1166
求区间和，题目给的区间描述是左闭右闭的，代码中全部使用左开右闭的区间
所有下标从0开始
*/
#include
#include
#include
#include

#define Add "Add"
#define Sub "Sub"
#define End "End"
#define Query "Query"

using namespace std;

const int maxn = 50050;
const int inf = 0x7fffffff;
int date[maxn * 4];
int sourceDate[maxn];
int n;
char order[6];

//当前节点为v，对应区间为[l, r)
void build(int v, int l, int r) {
    if(r - l == 1) {
        date[v] = sourceDate[l];
    }
    else {
        build(2 * v + 1, l, (l + r) / 2);
        build(2 * v + 2, (l + r) / 2, r);
        date[v] = date[2 * v + 1] + date[2 * v + 2];
    }
}

//需要修改原数组中下标为index的元素，变化的值为val
void update(int index, int val, int v, int l, int r) {
    if(r - l == 1) {
        date[v] += val;
    }
    else {
        if(index < (l + r) / 2) {
            update(index, val, v * 2 + 1, l, (l + r) / 2);
        }
        else {
            update(index, val, v * 2 + 2, (l + r) / 2, r);
        }
        date[v] = date[2 * v + 1] + date[2 * v + 2];
    }
}

int query(int a, int b, int v, int l, int r) {
    if(a >= r || b <= l) {
        return 0;
    }
    if(a <= l && b >= r) {
        return date[v];
    }
    return query(a, b, 2 * v + 1, l, (l + r) / 2) + query(a, b, 2 * v + 2, (l + r) / 2, r);
}

int main() {
    int t, index, val, l, r;
    scanf("%d", &t);
    for(int cs = 1; cs <= t; cs++) {
        scanf("%d", &n);
        for(int i = 0; i < n; i++) {
            scanf("%d", sourceDate + i);
        }
        build(0, 0, n);
        printf("Case %d:\n", cs);
        while(scanf("%s", order) == 1) {
            if(strcmp(order, End) == 0) {
                break;
            }
            else if(strcmp(order, Add) == 0) {
                scanf("%d%d", &index, &val);
                update(index - 1, val, 0, 0, n);
            }
            else if(strcmp(order, Sub) == 0) {
                scanf("%d%d", &index, &val);
                update(index - 1, -val, 0, 0, n);
            }
            else if(strcmp(order, Query) == 0) {
                scanf("%d%d", &l, &r);
                printf("%d\n", query(l - 1, r, 0, 0, n));
            }
        }
    }
    return 0;
}

线段树区间更新

/*
模板验证POJ3468
计算区间和 
*/
#include
#include
#include
#include
using namespace std;
typedef long long LL;

const int maxn = 100010;
LL sourceDate[maxn];	//原始数据
LL date[maxn << 2];	//存储线段树
LL mark[maxn << 2];	//懒惰标记

void build(int v, int l, int r) {
    mark[v] = 0;
    if(r - l == 1) {
        date[v] = sourceDate[l];
    }
    else {
        build(2 * v + 1, l, (l + r) / 2);
        build(2 * v + 2, (l + r) / 2, r);
        date[v] = date[2 * v + 1] + date[2 * v + 2];
    }
}

//下移懒惰标记
void pushDown(int v, int l, int r) {
    if(mark[v] != 0) {
        int chl = 2 * v + 1;
        int chr = 2 * v + 2;
        int mid = (l + r) / 2;
        mark[chl] += mark[v];
        mark[chr] += mark[v];
        date[chl] += (mid - l) * mark[v];
        date[chr] += (r - mid) * mark[v];
        mark[v] = 0;
    }
}

void update(int a, int b, int val, int v, int l, int r) {
    if(a >= r || b <= l) {
        return ;
    }
    else if(a <= l && b >= r) {
        mark[v] += val;
        date[v] += val * (r - l);
    }
    else {
        pushDown(v, l, r);
        update(a, b, val, 2 * v + 1, l, (l + r) / 2);
        update(a, b, val, 2 * v + 2, (l + r) / 2, r);
        date[v] = date[2 * v + 1] + date[2 * v + 2];
    }
}

LL query(int a, int b, int v, int l, int r) {
    if(a >= r || b <= l) {
        return 0;
    }
    else if(a <= l && b >= r) {
        return date[v];
    }
    else {
        pushDown(v, l, r);
        return query(a, b, 2 * v + 1, l, (l + r) / 2) + query(a, b, 2 * v + 2, (l + r) / 2, r);
    }
}

int main() {
    int n, m;
    char order;
    int a, b, v;
    while(scanf("%d%d", &n, &m) == 2) {
        for(int i = 0; i < n; i++) {
            scanf("%lld", sourceDate + i);
        }
        build(0, 0, n);
        for(int i = 0; i < m; i++) {
            scanf("\n%c", &order);
            if(order == 'Q') {
                scanf("%d%d", &a, &b);
                printf("%lld\n", query(a- 1, b, 0, 0, n));
            }
            else {
                scanf("%d%d%d", &a, &b, &v);
                update(a - 1, b, v, 0, 0, n);
            }
        }
    }
    return 0;
}

线段树+扫描线

HDU1542
//线段树 + 扫描线 + 离散化
//注意这里的区间是闭区间
#include
#include
#include
#include
using namespace std;
struct Edge {
    double xl;
    double xr;
    double h;
    int flag;
    bool operator<(const Edge &e) {
        return h < e.h;
    }
};

const int maxn = 110;
double len[maxn << 3];
int cover[maxn << 3];
Edge edge[maxn << 1];
double point[maxn << 1];

void build() {
    memset(len, 0, sizeof(len));
    memset(cover, 0, sizeof(cover));
}

void update(int a, int b, int val, int v, int l, int r) {
    if(a >= r || b <= l) {
        return ;
    }
    else if(a <= l && b >= r) {
        cover[v] += val;
        if(cover[v]) {
            len[v] = point[r] - point[l];
        }
        else if(r - l > 1) {
            len[v] = len[2 * v + 1] + len[2 * v + 2];
        }
        else {
            len[v] = 0;
        }
    }
    else {
        update(a, b, val, 2 * v + 1, l, (l + r) / 2);
        update(a, b, val, 2 * v + 2, (l + r) / 2, r);
        if(cover[v]) {
            len[v] = point[r] - point[l];
        }
        else {
            len[v] = len[2 * v + 1] + len[2 * v + 2];
        }
    }
}

int main() {
    int n;
    double x1, x2, y1, y2;
    int cnt;
    int cs = 0;
    double ans;
    int a, b;
    while(scanf("%d", &n) && n) {
        for(int i = 0; i < n; i++) {
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);

            edge[2 * i].xl = edge[2 * i + 1].xl = x1;
            edge[2 * i].xr = edge[2 * i + 1].xr = x2;
            edge[2 * i].flag = 1;
            edge[2 * i + 1].flag = -1;
            edge[2 * i].h = y1;
            edge[2 * i + 1].h = y2;

            point[2 * i] = x1;
            point[2 * i + 1] = x2;
        }
        sort(edge, edge + 2 * n);
        sort(point, point + 2 * n);
        cnt = 0;
        for(int i = 1; i < 2 * n; i++) {
            if(point[i] != point[cnt]) {
                point[++cnt] = point[i];
            }
        }
        build();
        ans = 0.0;
        for(int i = 0; i < 2 * n - 1; i++) {
            a = lower_bound(point, point + cnt + 1, edge[i].xl) - point;
            b = lower_bound(point, point + cnt + 1, edge[i].xr) - point;
            update(a, b, edge[i].flag, 0, 0, cnt);
            ans += len[0] * (edge[i + 1].h - edge[i].h);
            //printf("%f %f\n", len[0], edge[i + 1].h - edge[i].h);
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n", ++cs, ans);
    }
    return 0;
}

可持久化线段树 无更新

//模板验证 HDU2665
#include
#include
#include
#include
using namespace std;

struct Node {
    int ls;
    int rs;
    int val;
};

const int maxn = 100010;
Node date[maxn * 20];
int roots[maxn];
int sourceDate[maxn];
int sortDate[maxn];
int cntNode;
int sz;

void build(int &v, int l, int r) {
    v = cntNode++;
    date[v].val = 0;
    if(r - l == 1) {
        return ;
    }
    build(date[v].ls, l, (l + r) / 2);
    build(date[v].rs, (l + r) / 2, r);
}

void update(int pre, int &now, int l, int r, int val) {
    now = cntNode++;
    int mid = (l + r) / 2;
    date[now].ls = date[pre].ls;
    date[now].rs = date[pre].rs;
    date[now].val = date[pre].val + 1;
    if(r - l == 1) {
        return ;
    }
    if(val < mid) {
        update(date[pre].ls, date[now].ls, l, mid, val);
    }
    else {
        update(date[pre].rs, date[now].rs, mid, r, val);
    }
}

int query(int k, int lv, int rv, int l, int r) {
    if(r - l == 1) {
        return l;
    }
    int mid = (l + r) / 2;
    int res = date[date[rv].ls].val - date[date[lv].ls].val;
    if(k <= res) {
        return query(k, date[lv].ls, date[rv].ls, l, mid);
    }
    else {
        return query(k - res, date[lv].rs, date[rv].rs, mid, r);
    }
}

int main() {
    int t;
    int n, m;
    int l, r, k;
    int ans;
    int val;
    scanf("%d", &t);
    while(t--) {
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; i++) {
            scanf("%d", sourceDate + i);
            sortDate[i] = sourceDate[i];
        }
        sort(sortDate, sortDate + n);
        sz = unique(sortDate, sortDate + n) - sortDate;
        cntNode = 0;
        build(roots[0], 0, sz);
        for(int i = 0; i < n; i++) {
            val = lower_bound(sortDate, sortDate + sz, sourceDate[i]) - sortDate;
            update(roots[i], roots[i + 1], 0, sz, val);
        }
        for(int i = 0; i < m; i++) {
            scanf("%d%d%d", &l, &r, &k);
            ans = query(k, roots[l - 1], roots[r], 0, sz);
            printf("%d\n", sortDate[ans]);
        }
    }
    return 0;
}

可持久化线段树 单点更新

//ZOJ2112
#include
#include
#include
#include
#include
using namespace std;

struct Node {
    int ls;
    int rs;
    int val;
};

struct Operation {
    char order;
    int l;
    int r;
    int k;
};

const int maxn = 50050;
const int maxm = 10010;
Node date[(maxn + maxm) * 32];  //主席树上的节点
Operation op[maxm];             //存储操作
int roots[maxn];                //主席树各个版本的根节点
int bits[maxn];                 //使用树状数组维护的各个主席树的根节点
int sourceDate[maxn + maxm];    //原始序列
int sortDate[maxn + maxm];      //离散化之后的序列
vector li, ri;             //查询和修改时需要访问的主席树（使用树状数组维护的）的下标
char order[3];                  //暂时存储输入的命令'Q'和'C'
int cntNode;                    //统计所有的主席树的节点数量
int sz;                         //保存sortDate数组的大小
int n, m;

void build(int &v, int l, int r) {  //节点date[v]维护的区间为[l, r)
    v = cntNode++;
    date[v].val = 0;
    if(r - l == 1) {
        return ;
    }
    build(date[v].ls, l, (l + r) / 2);
    build(date[v].rs, (l + r) / 2, r);
}

void update(int pre, int &now, int l, int r, int k, int val) {
//now 是当前建立的节点，pre是前一棵树上与now对应的节点，date[now]维护的区间是[l, r)
//当前插入的值在离散化区间中对应的数字为k
//如果是向序列中插入k，则val = 1
//如果是将k替换为其它数字，则val = -1
    now = cntNode++;
    date[now].ls = date[pre].ls;
    date[now].rs = date[pre].rs;
    date[now].val = date[pre].val + val;
    if(r - l == 1) {
        return ;
    }
    int mid = (l + r) / 2;
    if(k < mid) {
        update(date[pre].ls, date[now].ls, l, mid, k, val);
    }
    else {
        update(date[pre].rs, date[now].rs, mid, r, k, val);
    }
}

void add(int index, int val) {
//当有修改操作时需要调用该函数
//index指的是被修改的数字在原序列中的下标（从1开始计数）
//我的下标是从0开始的，所以在计算离散化后它对应的数字的时候，使用index - 1
//如果当前的sourceDate[index - 1]是还没修改的数字，则val = -1；否则val = 1
    int k = lower_bound(sortDate, sortDate + sz, sourceDate[index - 1]) - sortDate;
    while(index <= n) {
        update(bits[index], bits[index], 0, sz, k, val);
        index += index & -index;
    }
}

int query(int sv, int ev, int l, int r, int k) {
//若查询的区间为[s + 1, e]，则在组函数中调用该函数时
//sv 为第s棵线段树的根节点下标
//ev 为第e棵线段树的根节点下标（从0开始计数）
//sv和ev所维护的区间为[l, r)
//函数询问的是区间[l, r)中第k小的数（从1开始计数）
    if(r - l == 1) {
        return l;
    }
    int res = 0;

//下面两个循环采用了树状数组的思维进行求和
    for(int i : ri) {
        res += date[date[i].ls].val;
    }
    for(int i : li) {
        res -= date[date[i].ls].val;
    }

    res += date[date[ev].ls].val - date[date[sv].ls].val;
    if(k <= res) {
        for(auto it = ri.begin(); it != ri.end(); it++) {
            *it = date[*it].ls;
        }
        for(auto it = li.begin(); it != li.end(); it++) {
            *it = date[*it].ls;
        }
        return query(date[sv].ls, date[ev].ls, l, (l + r) / 2, k);
    }
    else {
        for(auto it = ri.begin(); it != ri.end(); it++) {
            *it = date[*it].rs;
        }
        for(auto it = li.begin(); it != li.end(); it++) {
            *it = date[*it].rs;
        }
        return query(date[sv].rs, date[ev].rs, (l + r) / 2, r, k - res);
    }
}

int main() {
    int t;
    int k, ans, temp;
    scanf("%d", &t);
    while(t--) {
        scanf("%d%d", &n, &m);
        sz = 0;
        for(int i = 0; i < n; i++) {
            scanf("%d", sourceDate + i);
            sortDate[sz++] = sourceDate[i];
        }
        for(int i = 0; i < m; i++) {
            scanf("%s", order);
            op[i].order = order[0];
            if(order[0] == 'Q') {
                scanf("%d%d%d", &op[i].l, &op[i].r, &op[i].k);
            }
            else {
                scanf("%d%d", &op[i].l, &op[i].r);
                sortDate[sz++] = op[i].r;
            }
        }
        sort(sortDate, sortDate + sz);
        sz = unique(sortDate, sortDate + sz) - sortDate;
        cntNode = 0;
        build(roots[0], 0, sz);
        for(int i = 0; i < n; i++) {
            k = lower_bound(sortDate, sortDate + sz, sourceDate[i]) - sortDate;
            update(roots[i], roots[i + 1], 0, sz, k, 1);
        }
        for(int i = 0; i <= n; i++) {
            //注意这里是 <= ，树状数组维护的是n + 1棵线段树
            bits[i] = roots[0];
        }
        for(int i = 0; i < m; i++) {
            if(op[i].order == 'Q') {
                li.clear();
                ri.clear();

                //下面两个循环计算的是在query函数中
                //使用树状数组思维求和时
                //需要访问的线段树根节点下标
                temp = op[i].r;
                while(temp) {
                    ri.push_back(bits[temp]);
                    temp -= temp & -temp;
                }

                temp = op[i].l - 1;
                while(temp) {
                    li.push_back(bits[temp]);
                    temp -= temp & -temp;
                }
                ans = query(roots[op[i].l - 1], roots[op[i].r], 0, sz, op[i].k);
                printf("%d\n", sortDate[ans]);
            }
            else {
                add(op[i].l, -1);
                sourceDate[op[i].l - 1] = op[i].r;
                add(op[i].l, 1);
            }
        }
    }
    return 0;
}

树状数组

一维树状数组

一维树状数组单点更新

#include
#include
#include
#include
using namespace std;
typedef long long LL;

const int maxn = 500050;
LL bit[maxn];

void add(int k, int val) {
    while(k < maxn) {
        bit[k] += val;
        k += k & -k;
    }
}

LL sum(int k) {
    LL res = 0;
    while(k > 0) {
        res += bit[k];
        k -= k & -k;
    }
    return res;
}

int main() {
}

一维树状数组区间更新

//模板验证 HDU1556
#include
#include
#include
#include
using namespace std;

const int maxn = 100010;
int bit0[maxn];
int bit1[maxn];
int n;

void pointAdd(int *bit, int k, int val) {
    while(k <= n) {
        bit[k] += val;
        k += k & -k;
    }
}

int sum(int *bit, int k) {
    int res = 0;
    while(k > 0) {
        res += bit[k];
        k -= k & -k;
    }
    return res;
}

void rangeAdd(int l, int r, int val) {
    pointAdd(bit0, l, -val * (l - 1));
    pointAdd(bit1, l, val);
    pointAdd(bit0, r + 1, val * r);
    pointAdd(bit1, r + 1, -val);
}

int rangeSum(int l, int r) {
    return  sum(bit0, r) + r * sum(bit1, r) -
            sum(bit0, l - 1) - (l - 1) * sum(bit1, l - 1);
}

int main() {
    int l, r;
    while(scanf("%d", &n) && n) {
        memset(bit0, 0, sizeof(bit0));
        memset(bit1, 0, sizeof(bit1));
        for(int i = 0; i < n; i++) {
            scanf("%d%d", &l, &r);
            rangeAdd(l, r, 1);
        }
        for(int i = 1; i < n; i++) {
            printf("%d ", rangeSum(i, i));
        }
        printf("%d\n", rangeSum(n, n));
    }
    return 0;
}

二维树状数组

二维树状数组单点更新

const int maxn = 1000;
int bit[maxn][maxn];

void add(int x, int y, int val) {
    int memoryY = y;
    while(x <= maxn) {
        y = memoryY;
        while(y <= maxn) {
            bit[x][y] += val;
            y += y & -y;
        }
        x += x & -x;
    }
}

int sum(int x, int y) {
    int memoryY = y;
    int res = 0;
    while(x > 0) {
        y = memoryY;
        while(y > 0) {
            res += bit[x][y];
            y -= y & -y;
        }
        x -= x & -x;
    }
    return res;
}

字符串

KMP

#include
#include
#include
#include
using namespace std;

const int maxn = 400001;
char source[maxn];
char pattern[maxn];
int next[maxn];
/*
int violentMatch(char *s, char *p) {
    int slen = strlen(s);
    int plen = strlen(p);
    int si = 0;
    int pi = 0;
    while(si < slen && pi < plen) {
        if(s[si] == p[pi]) {
            si++;
            pi++;
        }
        else {
            si = si - pi + 1;
            pi = 0;
        }
    }
    if(pi == plen) {
        return si - pi;
    }
    else {
        return -1;
    }
}
*/
void setNext(char *p, int *nx) {
    int plen = strlen(p);
    nx[0] = -1;
    int k = -1;
    int j = 0;
    while(j < plen - 1) {
        if(k == -1 || p[j] == p[k]) {
            k++;
            j++;
            if(p[j] != p[k]) {
                next[j] = k;
            }
            else {
                next[j] = next[k];
            }
        }
        else {
            k = next[k];
        }
    }
}
//判断p是否在s中，使用的next数组是p的next数组
//返回p在s中第一次出现的位置(0开始) 若s中没有p，则返回-1
int KMP(char *s, char *p) {
    int slen = strlen(s);
    int plen = strlen(p);
    int si = 0;
    int pi = 0;
    while(si <= slen - (plen - pi) && pi < plen) {
        if(pi == -1 || s[si] == p[pi]) {
            si++;
            pi++;
        }
        else {
            pi = next[pi];
        }
    }
    if(pi == plen) {
        return si - pi;
    }
    else {
        return -1;
    }
}

int main() {
    return 0;
}

扩展KMP

#include
#include
#include
#include
using namespace sdt;

const int maxn = 1000;
char source[maxn];
char pattern[maxn];
int next[maxn];
int extend[maxn];

//求解setNext使用 abcabc 作为子串，自己手动使用该算法算一遍应该就懂了...
void setNext(char *str, int *nx) {
    int len = strlen(str);
    nx[0] = len;
    for(nx[1] = 0; nx[1] < n - 1 && str[nx[1]] == str[nx[1] + 1]; nx[1]++) {
        continue;
    }
    int p0 = 1, p = nx[1] + 1 - 1;
    for(int i = 2; i < len; i++) {
        if(nx[i - p0] + i - 1 < p) {
            nx[i] = nx[i - p0];
        }
        else {
            nx[i] = max(0, p - i + 1);
            while(i + nx[i] < len && str[nx[i]] == str[i + nx[i]]) {
                nx[i]++;
            }
            p0 = i;
            p = i + nx[i] - 1;
        }
    }
}

void exKMP(char *sc, char *pat) {
    setNext(pat, next);
    int sLen = strlen(sc);
    int pLen = strlen(pat);
    for(extend[0] = 0; extend[0] < sLen && extend[0] < pLen && sc[extend[0]] == pat[extend[0]]; extend[0]++) {
        continue;
    }
    int p0 = 0;
    int p = extend[0] - 1;
    for(int i = 1; i < sLen; i++) {
        if(next[i - p0] + i - 1 < p) {
            extend[i] = next[i - p0];
        }
        else {
            int j = p - i + 1;
            if(j < 0) {
                j = 0;
            }
            while(j < pLen && i + j < sLen && sc[i + j] == pat[j]) {
                j++;
            }
            p0 = i;
            p = i + j - 1;
        }
    }
}

Manacher

#include
#include
#include
#include
using namespace std;

const int maxn = 1000;
char source[maxn];          //原始字符串数据
char tempStr[maxn << 1];    //转换后的字符串
int maxLen[maxn << 1];      //maxLen[i]为以tempStr[i]为中心的最长回文子串最右边的位置到tempStr[i]的距离

int manacher() {
    int len = strlen(source);
    for(int i = 0; i < len; i++) {
        tempStr[2 * i] = '#';
        tempStr[2 * i + 1] = source[i];
    }
    tempStr[2 * len] = '#';
    tempStr[2 * len + 1] = '\0';
    len = 2 * len + 1;
    memset(maxLen, 0, sizeof(maxLen));
    maxLen[0] = 1;
    int p0 = 0, p = 0, ans = 0;     //p为当前匹配到了的最远的字符的下标，p0为取得该最远位置的中心的下标
    for(int i = 1; i < len; i++) {
        if(i < p) {
            if(i  + maxLen[2 * p0 - i] - 1 < p) {
                maxLen[i] = maxLen[2 * p0 - i];
            }
            else {
                maxLen[i] = p - i + 1;
                while(i - maxLen[i] >= 0 && i + maxLen[i] < len && tempStr[i - maxLen[i]] == tempStr[i + maxLen[i]]) {
                    maxLen[i]++;
                }
                if(i + maxLen[i] > p0 + maxLen[p0]) {
                    p0 = i;
                    p = i + maxLen[i] - 1;
                }
            }
        }
        else {
            maxLen[i] = 1;
            while(i - maxLen[i] >= 0 && i + maxLen[i] < len && tempStr[i - maxLen[i]] == tempStr[i + maxLen[i]]) {
                maxLen[i]++;
            }
            if(i + maxLen[i] > p0 + maxLen[p0]) {
                p0 = i;
                p = i + maxLen[i] - 1;
            }
        }
        ans = max(ans, maxLen[i] - 1);
    }
    return ans;
}

字典树

const alphNum = 26;
const int maxn = 1000;
int trie[maxn][alphNum];

void insert(const char *s) {
    int len = strlen(s);
    root = 0;
    int id;
    for(int i = 0; i < len; i++) {
        id = s[i] - 'a';
        if(tire[root][id] == 0) {
            trie[root][id] = ++tot;
        }
        root = trie[root][id];
    }
}

bool find(const char *s) {
    int len = strlen(s);
    int root = 0;
    int id;
    for(int i = 0; i < len; i++) {
        id = s[i] - 'a';
        if(trie[root][id] == 0) {
            return false;
        }
        root = trie[root][id];
    }
    return true;
}

AC自动机

//板子验证 HDU2222
#include
#include
#include
#include
#include
using namespace std;
class Node {
public:
    Node *next[26];
    Node *fail;
    int cnt;    //本来觉得用bool就好了，但是看了HDU2222之后，发现还是用int好一点
    Node() {
        for(int i = 0; i < 26; i++) {
            next[i] = NULL;
        }
        fail = NULL;
        cnt = 0;
    }
};

class ACauto {
public:
    Node *root;

    ACauto() {
        root = new Node;
    }

    ~ACauto() {
        clear();
        delete root;
    }

    void clear() {
        Node* temp;
        queue q;
        q.push(root);
        while(!q.empty()) {
            temp = q.front();
            q.pop();
            for(int i = 0; i < 26; i++) {
                if(temp->next[i]) {
                    q.push(temp->next[i]);
                }
            }
            if(temp != root) {
                delete temp;
            }
        }
        for(int i = 0; i < 26; i++) {
            root->next[i] = NULL;
        }
    }

    void insert(const char * s) {
        Node *p = root;
        int id;
        for(int i = 0; s[i]; i++) {
            id = s[i] - 'a';
            if(p->next[id] == NULL) {
                p->next[id] = new Node;
            }
            p = p->next[id];
        }
        p->cnt++;
    }

    void buildFail() {
        Node *father;
        Node *fatherFail;
        queue q;
        q.push(root);
        while(!q.empty()) {
            father = q.front();
            q.pop();
            for(int i = 0; i < 26; i++) {
                if(father->next[i]) {
                    fatherFail = father->fail;
                    while(fatherFail) {
                        if(fatherFail->next[i]) {
                            father->next[i]->fail = fatherFail->next[i];
                            break;
                        }
                        fatherFail = fatherFail->fail;
                    }
                    if(fatherFail == NULL) {
                        father->next[i]->fail = root;
                    }
                    q.push(father->next[i]);
                }
            }
        }
    }

    int find(const char *s) {
        int res = 0;
        Node *p = root;
        Node *temp;
        int id;
        for(int i = 0; s[i]; i++) {
            id = s[i] - 'a';
            while(p->next[id] == NULL && p != root) {
                p = p->fail;
            }
            p = p->next[id];
            if(p == NULL) {
                p = root;
            }
            temp = p;
            while(temp != root && temp->cnt != -1) {
                res += temp->cnt;
                temp->cnt = -1;
                temp = temp->fail;
            }
        }
        return res;
    }
};

const int maxKeyLen = 55;
const int maxTextLen = 1000010;
char key[maxKeyLen];
char str[maxTextLen];
ACauto ac;

int main() {
    int t;
    int n;
    scanf("%d", &t);
    while(t--) {
        ac.clear();
        scanf("%d", &n);
        for(int i = 0; i < n; i++) {
            scanf("%s", key);
            ac.insert(key);
        }
        ac.buildFail();
        scanf("%s", str);
        printf("%d\n", ac.find(str));
    }
    return 0;
}

AC自动机+矩阵快速幂

/*
模板测试 POJ2778
在建立失效指针的同时，统计安全节点的数量
以此减小矩阵的规模
测试数据
比如当输入的字符串为
ATCG
T
的时候，安全节点只有两个，为root和A
此时cntNode = 2
*/
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
typedef long long LL;

class Node {
public:
    Node *next[4];
    Node *fail;
    bool isTail;
    int tag;
    Node() {
        memset(next, 0, sizeof(next));
        fail = NULL;
        isTail = false;
        tag = -1;
    }
};

class ACauto {
private:
    Node *root;
    map trans;

public:
    int cntNode;    //统计安全节点的数量
    ACauto() {
        root = new Node();
        root->tag = 0;
        cntNode = 1;
        trans['A'] = 0;
        trans['C'] = 1;
        trans['T'] = 2;
        trans['G'] = 3;
    }

    ~ACauto() {
        clear();
        delete root;
    }

    void clear() {
        queue que;
        Node *temp;
        que.push(root);
        while(!que.empty()) {
            temp = que.front();
            que.pop();
            for(int i = 0; i < 4; i++) {
                if(temp->next[i] != NULL) {
                    que.push(temp->next[i]);
                }
            }
            if(temp != root) {
                delete temp;
            }
        }
        for(int i = 0; i < 4; i++) {
            root->next[i] = NULL;
        }
        cntNode = 1;
    }

    void insert(const char *s) {
        Node *p = root;
        int id;
        for(int i = 0; s[i]; i++) {
            id = trans[s[i]];
            if(p->next[id] == NULL) {
                if(p->isTail) {
                    return ;
                }
                p->next[id] = new Node();
            }
            p = p->next[id];
        }
        p->isTail = true;
    }

    void buildFail() {
        Node *father;
        Node *fatherFail;
        queue que;
        que.push(root);
        while(!que.empty()) {
            father = que.front();
            que.pop();
            for(int i = 0; i < 4; i++) {
                if(father->next[i] != NULL && !(father->next[i]->isTail)) {
                    fatherFail = father->fail;
                    while(fatherFail != NULL) {
                        if(fatherFail->next[i]) {
                            father->next[i]->fail = fatherFail->next[i];
                            break;
                        }
                        fatherFail = fatherFail->fail;
                    }
                    if(fatherFail == NULL) {
                        father->next[i]->fail = root;
                    }
                    if(father->next[i]->fail->isTail) {
                        father->next[i]->isTail = true;
                    }
                    else {
                        father->next[i]->tag = cntNode++;
                        que.push(father->next[i]);
                    }
                }
            }
        }
    }

    void buildMatrix(LL mat[][110]) {
        for(int i = 0; i < cntNode; i++) {
            for(int j = 0; j < cntNode; j++) {
                mat[i][j] = 0;
            }
        }
        queue que;
        Node *father, *temp;
        que.push(root);
        while(!que.empty()) {
            father = que.front();
            que.pop();
            for(int i = 0; i < 4; i++) {
                if(father->next[i] != NULL && !(father->next[i]->isTail)) {
                    que.push(father->next[i]);
                }
                temp = father;
                while(temp != NULL && temp->next[i] == NULL) {
                   temp = temp->fail;
                }
                if(temp == NULL) {
                    mat[father->tag][0]++;
                }
                else if(temp->next[i]->tag >= 0){
                    mat[father->tag][temp->next[i]->tag]++;
                }
            }
        }
    }
};

const LL MOD = 100000;
char str[20];
LL matrix1[110][110];
LL matrix2[110][110];
LL matrix3[110][110];
ACauto ac;

void mul(LL matrix1[110][110], LL matrix2[110][110], int len) {
    for(int i = 0; i < len; i++) {
        for(int j = 0; j < len; j++) {
            matrix3[i][j] = 0;
        }
    }
    for(int i = 0; i < len; i++) {
        for(int j = 0; j >= 1;
    }
    for(int i = 0; i < len; i++) {
        for(int j = 0; j < len; j++) {
            matrix1[i][j] = matrix2[i][j];
        }
    }
}


int main() {
    int m, n;
    LL ans;
    while(scanf("%d%d", &m, &n) == 2) {
        ac.clear();
        for(int i = 0; i < m; i++) {
            scanf("%s", str);
            ac.insert(str);
        }
        ac.buildFail();
        ac.buildMatrix(matrix1);
        power(matrix1, n, ac.cntNode);
        ans = 0;
        for(int j = 0; j < ac.cntNode; j++) {
            ans = (ans + matrix1[0][j]) % MOD;
        }
        printf("%lld\n", ans);
    }
    return 0;
}

后缀数组

//时间复杂度大约为(4~6)O(n * floor(log n))
#include
#include
#include
//#define DEBUG
using namespace std;

const int maxn = 1000;
char str[maxn];             //需要求后缀数组的字符串
int suffixArray[maxn];      //suffixArray[i]为排名第i的子串的起点
                            //在计算过程中，如果出现子串相等的情况，则起点靠前的子串排名靠前
int cnt[maxn];              //统计排名(_rank)为i的二元组的数量
int tempArray1[maxn];
int tempArray2[maxn];
int n;
int Rank[maxn];             //Rank[i]为后缀i的排名
int height[maxn];           //height[i]为后缀i和后缀i-1的最长公共前缀长度

#ifdef DEBUG
void show(int *a) {
    for(int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
}
#endif // DEBUG

void buildSa(int m) {
    int countKind;                      //统计二元组的种类
    int *_rank = tempArray1;            //_rank[i]为，以str[i]开头的长度为k的子串的排名
                                        //即刘汝佳《算法竞赛入门经典——训练指南》P220中每幅图最下面的一行
                                        //若子串相等，则排名相同

/* *************************************************************************************************** */
    memset(cnt, 0, sizeof(int) * m);
    for(int i = 0; i < n; i++) {        //cnt先暂时用来统计每种字符出现的数量
        cnt[(int)str[i]]++;
    }
    for(int i = 1; i < m; i++) {
        cnt[i] += cnt[i - 1];
    }
    for(int i = n - 1; i >= 0; i--) {   //计算名次为--cnt[str[i]]的子串的起点
        //1 获取字符串中第i个位置的字符
        //2 通过--cnt[str[i]]计算出以str[i]开头的长度为1的子串的排名
        //3 则排名为--cnt[str[i]]的子串的起点下标为i
        suffixArray[--cnt[(int)str[i]]] = i;
    }
    countKind = 0;
    for(int i = 0, preKey = -1; i < n; i++) {
        if(str[suffixArray[i]] == preKey) {
            _rank[suffixArray[i]] = countKind;
        }
        else {
            preKey = str[suffixArray[i]];
            _rank[suffixArray[i]] = ++countKind;
        }
    }
#ifdef DEBUG
    show(_rank);
    show(suffixArray);
#endif // DEBUG
    if(countKind == n) {
        return ;
    }
//到目前为止，都是为了计算出字串长度为1时的排名
//_rank在接下来会用于计算第一和第二关键字
//当前计算出的_rank就是下一次迭代中二元组的第一关键字
/* *************************************************************************************************** */
    for(int k = 1; k <= n; k <<= 1) {
        //每个子串的长度为2 * k
        int *firstKey = _rank;                                                  //上一重迭代中计算出的_rank就是当前迭代中二元组的第一关键字
        int *secondRankIndex = _rank == tempArray1 ? tempArray2 : tempArray1;   //secondRankIndex第二关键字排名第i的二元组的下标
        for(int i = 0; i < k; i++) {
            secondRankIndex[i] = n - k + i;
        }
        for(int i = 0, j = k; i < n; i++) {
            if(suffixArray[i] >= k) {
                secondRankIndex[j++] = suffixArray[i] - k;
            }
        }
        memset(cnt, 0, sizeof(int) * (countKind + 1));
        for(int i = 0; i < n; i++) {
            cnt[firstKey[i]]++;
        }
        for(int i = 1; i <= countKind; i++) {
            cnt[i] += cnt[i - 1];
        }
        for(int i = n - 1; i >= 0; i--) {
            //1 找到第二关键字排名第i的二元组的下标secondRankIndex[i]，令index = secondRankIndex[i]
            //2 找到该二元组的第一关键字firstKey[index]，令key = firstKey[index]
            //3 求出该二元组的排名--cnt[key]
            suffixArray[--cnt[firstKey[secondRankIndex[i]]]] = secondRankIndex[i];
        }
        //程序执行到这里的时候，_rank中保存的是上一重迭代的计算结果
        //_rank[i]即为firstKey[i]即为第i个二元组的第一关键字
        //当i>=k时，firstKey[i] = secondKey[i - k]即第i-k个二元组的第二关键字
        _rank = secondRankIndex;    //现在secondRankIndex用不上了，就把它的空间拿给_rank用
                                    //但是firstKey保持不变，依然是指向上一重迭代中计算出来的_rank
        int preFirstKey = -1, preSecondKey = -1;
        int curFirstKey, curSecondKey;
        countKind = 0;
        for(int i = 0; i < n; i++) {
            curFirstKey = firstKey[suffixArray[i]];
            curSecondKey = suffixArray[i] >= n - k ? 0 : firstKey[suffixArray[i] + k];
            if(curFirstKey == preFirstKey && curSecondKey == preSecondKey) {
                _rank[suffixArray[i]] = countKind;
            }
            else {
                preFirstKey = curFirstKey;
                preSecondKey = curSecondKey;
                _rank[suffixArray[i]] = ++countKind;
            }
        }
#ifdef DEBUG
        show(_rank);
        show(suffixArray);
#endif // DEBUG
        if(countKind >= n) {
            return ;
        }
    }
}

void getHeight() {
    /*
        通过h[i] >= h[i - 1] - 1线性计算height
        设suffix(k)是排在suffix(i - 1)前一名的后缀
        即Rank[k] = Rank[i - 1] - 1
        则它们的最长公共前缀的长度为h[i - 1]即height[Rank[i - 1]]
        那么suffix(k + 1)排在suffix(i)前面
        (当h[i - 1] <= 1时，原式显然成立，故下面均假设h[i - 1] > 1)
        并且suffix(k + 1)和suffix(i)的最长公共前缀为h[i - 1] - 1
        于是，suffix(i)与它前面一名的最长公共前缀至少为h[i - 1] - 1
    */
    for(int i = 0; i < n; i++) {
        Rank[suffixArray[i]] = i;
    }
    for(int i = 0, j, k = 0; i < n; i++) {
        if(k > 0) {
            k--;
        }
        if(Rank[i] == 0) {
            height[Rank[i]] = 0;
            k = 0;
            continue;
        }
        j = suffixArray[Rank[i] - 1];
        while(i + k < n && j + k < n && str[i + k] == str[j + k]) {
            k++;
        }
        height[Rank[i]] = k;
    }
}

int main() {
    while(cin >> str) {
        n = strlen(str);
        buildSa('z' + 1);
    }
    return 0;
}

回文树（回文自动机）

指针版(性能较数组版低)

//HDU3948
//249ms	22.9MB	2544B	
//计算不同回文子串的数量
//注意使用时字符串下标从1开始
//输入时需要scanf("%s", str + 1);
#include
#include
#include
#include
#include
using namespace std;

class Node {
public:
    enum{SIZE = 26};
    int len;
    int failLen;
    Node* next[SIZE];
    Node* fail;

    Node(int _len = 0, int _failLen = -1, Node *f = NULL) {
        len = _len;
        failLen = _failLen;
        for(int i = 0; i < SIZE; i++) {
            next[i] = NULL;
        }
        fail = len == -1 ? this : f;
    }
};

class PalindromeTree{
public:
    Node* odd;
    Node* even;
    int countNode;

    PalindromeTree() {
        odd = new Node(-1);
        even = new Node(0, -1, odd);
        countNode = 0;
    }

    void build(const char *s) {
        clear();
        Node *p = odd;
        for(int i = 1; s[i]; i++) {
            while(s[i - p->len - 1] != s[i]) {
                p = p->fail;
            }
            int id = s[i] - 'a';
            if(p->next[id] != NULL) {
                p = p->next[id];
            }
            else {
                countNode++;
                Node *temp = p;
                p->next[id] = new Node(p->len + 2, p->failLen + 1);
                p = p->next[id];
                if(temp->len == -1) {
                    p->fail = even;
                }
                else {
                    temp = temp->fail;
                    while(s[i - temp->len - 1] != s[i]) {
                        temp = temp->fail;
                    }
                    p->fail = temp->next[id];
                }
            }
        }
    }

    void clear() {
        queue que;
        que.push(odd);
        que.push(even);
        Node *temp;
        while(!que.empty()) {
            temp = que.front();
            que.pop();
            for(int i = 0; i < Node::SIZE; i++) {
                if(temp->next[i] != NULL) {
                    que.push(temp->next[i]);
                }
            }
            if(temp == odd || temp == even) {
                continue;
            }
            delete temp;
        }
        for(int i = 0; i < Node::SIZE; i++) {
            odd->next[i] = NULL;
            even->next[i] = NULL;
        }
        countNode = 0;
    }

    ~PalindromeTree() {
        clear();
        delete odd;
        delete even;
    }
};

const int maxn = 110000;
char str[maxn];
PalindromeTree pt;

int main() {
    int t;
    int cs = 0;
    scanf("%d", &t);
    while(t--) {
        scanf("%s", str + 1);
        pt.build(str);
        printf("Case #%d: %d\n", ++cs, pt.countNode);
        pt.clear();
    }
    return 0;
}

数组版

//板子验证同上
//78ms	11.3MB	1586B	
#include
#include
#include
#include
#include
#include
using namespace std;

struct Node {
    enum{SIZE = 26};
    int len;
    int next[Node::SIZE];
    int fail;

    void init(int _len = 0, int _fail = -1) {
        len = _len;
        for(int i = 0; i < SIZE; i++) {
            next[i] = -1;
        }
        fail = len == -1 ? 0 : _fail;
    }
};

const int maxn = 100010;
Node tree[maxn];
char str[maxn];
int countNode;

void clear() {
    tree[0].init(-1, 0);
    tree[1].init(0, 0);
    countNode = 2;
}

void build(const char *s) {
    clear();
    int p = 0;
    for(int i = 1; s[i]; i++) {
        while(s[i - tree[p].len - 1] != s[i]) {
            p = tree[p].fail;
        }
        int id = s[i] - 'a';
        if(tree[p].next[id] != -1) {
            p = tree[p].next[id];
        }
        else {
            int temp = p;
            tree[p].next[id] = countNode;
            tree[countNode].init(tree[p].len + 2);
            p = tree[p].next[id];
            if(temp == 0) {
                tree[p].fail = 1;
            }
            else {
                temp = tree[temp].fail;
                while(s[i - tree[temp].len - 1] != s[i]) {
                    temp = tree[temp].fail;
                }
                tree[p].fail = tree[temp].next[id];
            }
            countNode++;
        }
    }
}

int main() {
    int t;
    int cs = 0;
    scanf("%d", &t);
    while(t--) {
        scanf("%s", str + 1);
        build(str);
        printf("Case #%d: %d\n",++cs, countNode - 2);
    }
    return 0;
}

后缀自动机

1、两个串的最长公共子串
2、统计出现次数最多的长度为n的串一共出现了多少次，使用基数排序
3、
4、

两个串的最长公共子串

//两个串的最长公共子串
//https://www.spoj.com/problems/LCS/en/
#include
#include
#include
#include
using namespace std;

const int SIZE = 26;
const int START = int('a');
const int maxn = 260000;
char str1[maxn];
char str2[maxn];
struct State {
    int len;
    int next[SIZE];
    int link;
}st[maxn * 2];
int sz;
int last;

void initSa() {
    sz = 1;
    last = 0;
    st[0].len = 0;
    st[0].link = -1;
    for(int i = 0; i < SIZE; i++) {
        st[0].next[i] = -1;
    }
}

void addChar(char c) {
    int cur = sz++;
    st[cur].len = st[last].len + 1;
    for(int i = 0; i < SIZE; i++) {
        st[cur].next[i] = -1;
    }
    int id = c - START;
    int p = last;
    for(; p != -1 && st[p].next[id] == -1; p = st[p].link) {
        st[p].next[id] = cur;
    }
    if(p == -1) {
        st[cur].link = 0;
    }
    else {
        int q = st[p].next[id];
        if(st[p].len + 1 == st[q].len) {
            st[cur].link = q;
        }
        else {
            int clone = sz++;
            st[clone].len = st[p].len + 1;
            st[clone].link = st[q].link;
            for(int i = 0; i < SIZE; i++) {
                st[clone].next[i] = st[q].next[i];
            }
            for(; p != -1 && st[p].next[id] == q; p = st[p].link) {
                st[p].next[id] = clone;
            }
            st[q].link = st[cur].link = clone;
        }
    }
    last = cur;
}

int lcs() {
    initSa();
    for(int i = 0; str1[i]; i++) {
        addChar(str1[i]);
    }
    int p = 0;
    int ans = 0;
    int curLen = 0;
    int id;
    for(int i = 0; str2[i]; i++) {
        id = str2[i] - START;
        while(p && st[p].next[id] == -1) {
            p = st[p].link;
            curLen = st[p].len;
        }
        if(st[p].next[id] != -1) {
            p = st[p].next[id];
            curLen++;
        }
        ans = max(ans, curLen);
    }
    return ans;
}

int main() {
    while(scanf("%s%s", str1, str2) == 2) {
        printf("%d\n", lcs());
    }
    return 0;
}

多个串的最长公共子串

//LCS2 - Longest Common Substring II 
//https://www.spoj.com/problems/LCS2/en/
#include
#include
#include
#include
#include
using namespace std;

const int maxn = 110000;
const int SIZE = 26;
struct State {
    int len;
    int matcheLen;
    int link;
    int next[SIZE];
}st[maxn * 2];
int sz;
int last;
char str[maxn];
int bucket[maxn];
int Rank[maxn * 2];

void initSa() {
    sz = 1;
    last = 0;
    st[0].len = 0;
    st[0].link = -1;
    st[0].matcheLen = 0;
    for(int i = 0; i < SIZE; i++) {
        st[0].next[i] = -1;
    }
}

void addChar(int c) {
    int cur = sz++;
    st[cur].len = st[last].len + 1;
    st[cur].matcheLen = 0;
    for(int i = 0; i < SIZE; i++) {
        st[cur].next[i] = -1;
    }
    int p = last;
    for(; p != -1 && st[p].next[c] == -1; p = st[p].link) {
        st[p].next[c] = cur;
    }
    if(p == -1) {
        st[cur].link = 0;
    }
    else {
        int q = st[p].next[c];
        if(st[p].len + 1 == st[q].len) {
            st[cur].link = q;
        }
        else {
            int clone = sz++;
            st[clone].len = st[p].len + 1;
            st[clone].link = st[q].link;
            st[clone].matcheLen = 0;
            for(int i = 0; i < SIZE; i++) {
                st[clone].next[i] = st[q].next[i];
            }
            st[q].link = st[cur].link = clone;
            for(; p != -1 && st[p].next[c] == q; p = st[p].link) {
                st[p].next[c] = clone;
            }
        }
    }
    last = cur;
}

void match(const char* s) {
    int cur = 0;
    int curLen = 0;
    int id;
    for(int i = 0; s[i]; i++) {
        id = s[i] - 'a';
        while(cur && st[cur].next[id] == -1) {
            cur = st[cur].link;
            st[cur].matcheLen = curLen = st[cur].len;
        }
        if(st[cur].next[id] != -1) {
            curLen++;
            cur = st[cur].next[id];
            st[cur].matcheLen = max(st[cur].matcheLen, curLen);
        }
    }
    for(int i = 0; i < sz; i++) {
        if(st[Rank[i]].matcheLen) {
            st[st[Rank[i]].link].matcheLen = st[st[Rank[i]].link].len;
        }
        st[Rank[i]].len = min(st[Rank[i]].len, st[Rank[i]].matcheLen);
        st[Rank[i]].matcheLen = 0;
    }
}

void radixSort(int len) {
    for(int i = 0; i < sz; i++) {
        ++bucket[st[i].len];
    }
    for(int i = len - 1; i >= 0; i--) {
        bucket[i] += bucket[i + 1];
    }
    for(int i = 0; i < sz; i++) {
        Rank[--bucket[st[i].len]] = i;
    }
}

int main() {
    //freopen("wa.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    initSa();
    scanf("%s", str);
    int len;
    for(len = 0; str[len]; len++) {
        addChar(str[len] - 'a');
    }
    radixSort(len);
    while(scanf("%s", str) == 1) {
        match(str);
    }
    int ans = 0;
    for(int i = 0; i < sz; i++) {
        ans = max(ans, st[i].len);
    }
    printf("%d\n", ans);
    return 0;
}

出现次数查询

//Substrings SPOJ - NSUBSTR 
//https://www.spoj.com/problems/NSUBSTR/en/
//使用基数排序
#include
#include
#include
#include
using namespace std;

const int maxn = 260000;
const int SIZE = 26;
struct {
    int len;
    int next[SIZE];
    int link;
    int cnt;
}st[maxn * 2];
int bucket[maxn];
int Rank[maxn * 2];
int ans[maxn];
char str[maxn];
int sz;
int last;

void initSa() {
    last = 0;
    sz = 1;
    st[0].cnt = 0;
    st[0].len = 0;
    st[0].link = -1;
    for(int i = 0; i < SIZE; i++) {
        st[0].next[i] = -1;
    }
}

void addChar(int c) {
    int cur = sz++;
    st[cur].len = st[last].len + 1;
    st[cur].cnt = 1;
    for(int i = 0; i < SIZE; i++) {
        st[cur].next[i] = -1;
    }
    int p = last;
    for(; p != -1 && st[p].next[c] == -1; p = st[p].link) {
        st[p].next[c] = cur;
    }
    if(p == -1) {
        st[cur].link = 0;
    }
    else {
        int q = st[p].next[c];
        if(st[p].len + 1 == st[q].len) {
            st[cur].link = q;
        }
        else {
            int clone = sz++;
            st[clone].len = st[p].len + 1;
            st[clone].cnt = 0;
            st[clone].link = st[q].link;
            for(int i = 0; i < SIZE; i++) {
                st[clone].next[i] = st[q].next[i];
            }
            st[q].link = st[cur].link = clone;
            for(; p != -1 && st[p].next[c] == q; p = st[p].link) {
                st[p].next[c] = clone;
            }
        }
    }
    last = cur;
}

void radixSort(int len) {
    memset(bucket, 0, sizeof(bucket));
    for(int i = 0; i < sz; i++) {
        bucket[st[i].len]++;
    }
    for(int i = len - 1; i >= 0; i--) {
        bucket[i] += bucket[i + 1];
    }
    for(int i = 0; i < sz; i++) {
        Rank[--bucket[st[i].len]] = i;
    }
}

void solve() {
    initSa();
    int len;
    for(len = 0; str[len]; len++) {
        addChar(str[len] - 'a');
    }
    radixSort(len);
    for(int i = 0; i < sz; i++) {
        st[st[Rank[i]].link].cnt += st[Rank[i]].cnt;
    }
    memset(ans, 0, sizeof(ans));
    for(int i = 0; i < sz; i++) {
        ans[st[i].len] = max(ans[st[i].len], st[i].cnt);
    }
    for(int i = 1; i <= len; i++) {
        printf("%d\n", ans[i]);
    }
}

int main() {
    while(scanf("%s", str) == 1) {
        solve();
    }
    return 0;
}

你可能感兴趣的:(ACM竞赛,模板)

  • ES-LTR粗排模块 poins jenkins运维
    ES-LTR粗排模块官方资源：https://github.com/HeiBoWang/elasticsearch-learning-to-rankElasticsearch学习排名插件使用机器学习提高搜索相关性排名。它为维基媒体基金会和Snagajob等地方的搜索提供了动力！这个插件有什么功能此插件：允许您在Elasticsearch中存储特征（Elasticsearch查询模板）记录特征得分（
  • k8s入门到实战（十）—— CronJob详细介绍及使用示例 一弓虽 k8s学习kubernetes容器云原生
    CronJob什么是CronJob在k8s中，CronJob是一种用于定期执行任务的资源对象。它基于Cron表达式，允许您在指定的时间间隔内自动运行容器化的任务。CronJob可以定义以下属性：schedule：指定任务执行的时间表，使用标准的Cron表达式语法。例如，“0****”表示每小时执行一次任务。jobTemplate：定义要执行的任务的模板，通常是一个Pod模板。这个模板包含了任务所需
  • C++ 如何去认识模板 SuhyOvO C++c++开发语言
    引言:C++模板是泛型编程的基石,允许程序员定义可与任何数据类型协作的函数和类。这种机制极大地增加了代码的灵活性和复用性,是C++最强大的特性之一。本文将深入探讨C++模板的概念、优势以及使用方法,帮助读者掌握这一重要的编程工具。文章目录模板简介模板的优势一、模板基础1.1模板的概念1.2函数模板1.3类模板二、模板进阶2.1模板的实例化2.2模板的特化2.3模板的默认参数2.4模板的嵌套三、模板
  • Vue：为什么要使用v-cloak 刻刻帝的海角 vue.js前端javascript
    Vue.js是一种流行的JavaScript框架，它使我们能够构建交互性强大的用户界面。在Vue.js中，v-cloak是一个指令，用于解决在页面加载时出现的闪烁问题。本文将介绍如何使用v-cloak及代码来优化Vue.js应用程序的渲染效果。引言当我们使用Vue.js构建应用程序时，有时会遇到一个问题：在页面加载时，由于Vue.js需要一定的时间来解析和渲染模板，会导致页面上显示出未经处理的Mu
  • P5963 [BalticOI ?] Card 卡牌游戏 贪心 golemon. 算法题游戏算法
    [P5963BalticOI?]Card卡牌游戏【来源请求】-洛谷|计算机科学教育新生态(luogu.com.cn)贪心模板题。存在(x1,y1)(x_1,y_1)(x1,y1)，(x2,y2)(x_2,y_2)(x2,y2)，假设xi>yix_i>y_ixi>yi，显然得认为：−x1+y2-x_1+y_2−x1+y2是最优得的，那么有：−x1+y2≤−x2+y1-x_1+y_2\le-x_2+y
  • 突破编程_C++_C++11新特性（type_traits的概念以及核心类型特性） breakthrough_01 c++开发语言
    1type_traits的概述type_traits是C++标准模板库（STL）中的一个头文件，它定义了一系列模板类，这些模板类在编译期获取某一参数、某一变量、某一个类等的类型信息，主要用于进行静态检查。通过使用type_traits，程序员可以在编译时就获得关于类型的详细信息，从而可以在不实际运行程序的情况下进行类型相关的优化和检查。type_traits中的内容主要可以分为以下几类：辅助基类：
  • JS的设计模式（23种） 是个车迷 JavaScriptjavascript设计模式开发语言
    JavaScript设计模式是指在JavaScript编程中普遍应用的一系列经过验证的最佳实践和可重用的解决方案模板，它们用来解决在软件设计中频繁出现的问题，如对象的创建、职责分配、对象间通信以及系统架构等。设计模式并不特指某个具体的代码片段，而是一种描述在特定上下文中如何组织程序结构和对象交互的通用指导原则。JavaScript设计模式涵盖了创建型模式（处理对象创建的方式）、结构型模式（关注对象
  • 有趣的DNA聚合酶 临窗听风雨
    UniPort数据库登记的DNA聚合酶被实验证实的都有1000多种，想要都介绍恐怕得写一本书。我选择了三个比较有趣的来聊一聊：它可以不依赖引物，仅在一种叫做末端蛋白的辅助下，起始DNA的复制。可以不依赖模板进行DNA合成的聚合酶。能够在无引物情况下进行DNA合成的聚合酶。Phi29DNAPolymerasePhi29DNAPolymerase（后面简称Phi29）是从枯草芽孢杆菌phi29噬菌体基
  • 洛谷 1853.投资的最大效益 是小Y啦 算法c++动态规划
    思路：完全背包。首先从题目的分析中我们可以知道，这里的债卷是可以无限次购买的，所以我们可以认定，这是个在选与不选的问题中，而且各个选项都是可以无限次选择的。确定了做法之后，我们需要看到这道题和普通的背包问题不同的地方，那就是我们如果只是写出模板的话，只能得到第一年的最大利润加资产。但是这里有要求说是多少年的。所以我们需要把第一次的数据存储到另一个数组当中，然后再还给他进行更新操作，这样才能在保证第
  • 突破编程_C++_面试（STL 编程 stack） breakthrough_01 突破编程_C++_面试c++面试
    1请简述std::stack在C++STL中的基本功能和使用场景std::stack在C++STL（标准模板库）中是一个容器适配器，专门用于实现后进先出（LIFO，Last-In-First-Out）的数据结构。其基本功能和使用场景如下：基本功能：push(element)：向栈顶添加元素。pop()：移除栈顶元素。如果栈为空，则此操作可能会导致未定义行为。top()：返回栈顶元素的引用，但不移除
  • 春招面试高频题目总结 小杰312 面试笔试面试c++职场和发展学习
    面试问题redis可以用于进程间通信吗？Why？How?--->延展一下有哪些进程间通信技术,优劣如何？有大量的插入sql语句，一条条的插入性能很差，如何通过事务进行优化？保证线程安全的策略有哪些？你知道哪些设计模式？有什么理解？单例、工厂方法、责任链、模板方法、策略模式都是基类抽象固定方法。子类提供具体实现。如何实现服务端与客户端的即时通讯？消息队列如何保证这个消息一定执行？不会丢失？持久化消息
  • 第10讲_Spring对Dao的支持 吴国友
    Spring框架优秀就是在于MVC开发的时候一旦需要对底层的数据库操作，它可以很好的支持JDBC技术，还有现在主流的ORM框架（Hibernate,MyBatis）技术。重点先介绍Spring对JDBC支持。在Spring对JDBC支持中提供了一个模板JdbcTemplate，此模板封装了对JDBC操作的许多方法，且消除了忽视资源释放而引起的漏洞Spring对JDBC操作需要导入的jar（开发环境
  • react 和vue区别 小王学前端️ vue3react.jsvue.js前端
    React和Vue是两个非常流行的前端JavaScript框架，它们有许多相似之处，但也有一些关键的区别：设计理念：React更倾向于函数式编程，推崇组件的纯粹性和可预测性，而Vue则更倾向于易用性和灵活性，提供了更多的内置特性和语法糖。模板vsJSX：Vue使用基于HTML的模板语法，这使得开发者可以快速上手。而React使用JSX，它是JavaScript的语法扩展，允许在JavaScript
  • web学习笔记（三十六） shan33__ 笔记学习笔记html前端javascript
    目录1.解构1.1对象解构1.2字符串解构1.3函数解构1.4总结2.模板字符串3.实例方法：startsWith()和endsWith()4.箭头函数4.1箭头函数的格式4.2箭头函数可以省略的部分4.3箭头函数总结5.剩余参数rest参数1.解构1.1对象解构在解构对象时要求变量名和对象的属性名保持一致，顺序不需要一致，可以随便写，但变量名和属性名一定要保持一致否则会输出undefined。当
  • C++面试：STL篇 葛雨龙 c++面试
    STL个人小结：stl是c++的标准模板库，stl6大组件：容器：存储数据，本质是类模板vector：底层是动态数组，连续内存支持随机存取，尾部增删效率高，内部增删O(n)list：底层是双链表，内存不连续，只能顺序访问，任意位置增删都是O(1)deque:整体连续，支持随机存取，首尾增删效率高，但是迭代器太复杂，所以一般只有当既要随机存取又要首尾增删采用deque。unordered_set:无
  • 云原生周刊：Istio 加入 Phippy 家族 ｜ 2024.3.18 KubeSphere 云原生 k8s容器平台kubesphere云计算
    开源项目推荐ko"ko"是一个用于构建和部署Go应用程序的简单、快速的容器镜像构建工具。它适用于那些镜像中只包含单个Go应用程序且没有或很少依赖于操作系统基础镜像的情况（例如没有cgo，没有操作系统软件包依赖）。"ko"在本地机器上通过执行"gobuild"的方式构建镜像，因此不需要安装Docker。这使得它非常适合轻量级的CI/CD场景。"ko"支持简单的YAML模板化，并且支持跨平台构建，还默
  • 每日推荐11.07 西瓜绿2020
    分享时下比较流行的优秀国外设计，每日开眼一下；数量四组，每日积累一点点，提高设计审美！#小程序#UI01.音乐播放器移动UI套件模板https://www.uplabs.com/posts/music-player-mobile-ui-kits-template-81dc5e4e-8750-4854-bb10-4f4a01ff94b202.游戏设备商店移动UI套件模板https://www.upl
  • 重拾C++之菜鸟刷算法第11篇---回溯算法（上） 阿卡西番茄酱 C++算法算法c++开发语言
    今天是个好日子，二月二龙抬头，龙年龙日龙抬头，顺风顺水好兆头，万事万物开好头，金银珠宝往家里走！offer往家走！回溯算法回溯法可以解决的问题组合问题：N个数里面按照一定规则找出k个数的集合切割问题：一个字符串按一定规则有几种切割方式子集问题：一个N个数的集合里有多少符合条件的子集排列问题：N个数按一定规则全排列，有几种排列方式棋盘问题：N皇后，解数独回溯三部曲回溯函数模板返回值以及参数回溯函数终
  • STL中pair对组的使用方法 李大爱 c++开发语言
    在STL（标准模板库）中，pair对组是一种将两个不同的数据类型封装在一起的容器。具体来说，pair对组提供了一种简单的方式来存储和访问两个元素。pair对组的用法非常简单，需要包含"utility"头文件。以下是一些常见的pair对组使用方法：创建pair对组：std::pairp1;//默认构造函数创建一个空的pair对组std::pairp2(1,"Hello");//使用两个参数创建pai
  • 【洛谷】P1886 滑动窗口 /【模板】单调队列 SSL_kyx #队列数据结构队列单调性ssl算法
    题目描述有一个长为nn的序列aa，以及一个大小为kk的窗口。现在这个从左边开始向右滑动，每次滑动一个单位，求出每次滑动后窗口中的最大值和最小值。例如：Thearrayis[1,3,−1,−3,5,3,6,7],and[1,3,-1,-3,5,3,6,7],and[1,3,−1,−3,5,3,6,7],andk=3k=3k=3。输入格式输入一共有两行，第一行有两个正整数n,k。第二行n个整数，表示序
  • Flask中session失效时间设置 忘了呼吸的那只猫
    最近需要使用Python开发web系统，主要用到的框架就是Flask，前端使用Jinja2模板引擎和Bootstrap，web容器使用Cherrypy，其中关于Login管理的使用了Flask-Login插件。基本上也是从零学起，前前后后花了有好几个月的时间，还是在借鉴了已有的一些项目基础上。在开发的过程中有很多的想法和体会，记录下来，有不对的地方欢迎大家指正。在处理登录管理的部分，在Flask-
  • 一个简单的微信小程序表单提交样式模板 w宇宙王 微信小程序小程序
    没什么东西，只是方便自己直接复制使用.wxml姓名：学校：职位选择：提交.,scss.box{padding:30rpx;}.form-item{display:flex;background-color:rgb(221,230,230);margin-bottom:10rpx;border-radius:30rpx;}.head{line-height:100rpx;margin-left:30
  • 对网站开发感兴趣？想要看顶级大佬是怎么做的？ CCSBRIDGE html5
    前言有的人喜欢造轮子，有的人讨厌重复造轮子。萝卜白菜，各有所好。我收集了一些一看就觉得很厉害的项目公主/王子请享用https://github.com/h5bp/html5-boilerplate简介：HTML5Boilerplate是一个专业的前端模板，用于构建快速、强大且适应性强的Web应用程序或网站。该项目是十多年迭代开发和社区知识的产物。它没有强加特定的开发理念或框架，因此您可以按照自己想
  • 认知的学习（工作记忆） Ginger_9193
    感觉记忆——工作记忆——长时记忆知觉————学习直接注意————提取与激活感觉记忆——内隐记忆——长时记忆感觉记忆——知识影响——长时记忆【辨析】工作记忆与短时记忆工作记忆是此刻你正在关注的信息短时记忆是记忆系统的组成部分，能保持约20秒【短时记忆的构成】1中央执行系统——监控、计划、提取、整合2语音环（1.5~2秒）——7位电话号码3视空间模板——将p旋转180度，得到的是b还是d?关联认知负荷
  • 代码随想录算法训练营三刷day24 | 回溯算法 之 理论基础 77. 组合 頔枫 算法训练营算法数据结构c++leetcode
    三刷day24理论基础77.组合递归函数的返回值以及参数回溯函数终止条件单层搜索的过程理论基础回溯法解决的问题都可以抽象为树形结构。因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。回溯三部曲回溯函数模板返回值以及参数在回溯算法中，我的习惯是函数起名字为backtracking，这个起名大家
  • 基于Python和OpenCV的产品码识别与验证案例 GT开发算法工程师 pythonopencv开发语言人工智能计算机视觉
    引言：本案例展示了如何使用Python结合OpenCV库来实现产品码的识别与验证。首先，通过图像预处理技术（如灰度化、二值化、降噪等）优化产品码图像，然后利用OpenCV中的模板匹配或机器学习算法（如SVM、神经网络等）来定位并识别产品码。目录原理：代码部分：注意：原理：产品码识别与验证的核心在于图像处理与模式识别技术。首先，通过图像处理技术提取出产品码区域，去除背景干扰，增强产品码的可识别性。然
  • C++变参模板 王健 C++模板笔记C++c++模板
    从c++11开始，模板可以接受一组数量可变的参数，这种技术称为变参模板。变参模板下面一个例子，通过变参模板打印一组数量和类型都不确定的参数。#include#includevoidprint(void){std::coutvoidprint(Targ1,Ts...args){std::coutvoidprint(Targ){std::coutvoidprint(Targ1,Ts...args){p
  • 粉嘟嘟的免费wordpress模板 podoor wordpresswordpress
    粉色好看的wordpress免费模板，用免费wordpress模板也可以搭建网站。https://www.wpniu.com/themes/11.html
  • 基础算法(一)#蓝桥杯 席万里 C/C++算法蓝桥杯c++
    文章目录1、模拟1.1、DNA序列修正1.2、无尽的石头2、递归2.1、带备忘录的斐波那契数列2.2、数的计算3、进制转换3.1、进制转换模板3.2、Alice和Bob的爱恨情仇4、前缀和4.1、前缀和模板4.2、区间次方和4.3、小郑的蓝桥平衡串4.4、大石头的搬运工4.5、最大数组和4.6、四元组问题**5、差分5.1、区间更新（一维差分）5.2、肖恩的投球游戏加强版5.4、泡澡6、离散化6.
  • 向ChatGPT高效提问模板 淘宝帝国 大数据人工智能
    PS:ChatGPT无限次数，无需魔法，登录即可使用,网页打开下面tj4.mnsfdx.net[点击跳转链接](http://tj4.mnsfdx.net/)我想请你XXXX，请问我应该如何向你提问才能得到最满意的答案，请提供全面、详细的建议，针对每一个建议请你提供具体的提问范例，注意这些范例都是关于如何向你提问获取做这件事的建议的，最后根据你所有的建议，再综合提供一个总的提问范例，注意这个范例必
  • TOMCAT在POST方法提交参数丢失问题 357029540 javatomcatjsp
    摘自http://my.oschina.net/luckyi/blog/213209 昨天在解决一个BUG时发现一个奇怪的问题，一个AJAX提交数据在之前都是木有问题的，突然提交出错影响其他处理流程。 检查时发现页面处理数据较多，起初以为是提交顺序不正确修改后发现不是由此问题引起。于是删除掉一部分数据进行提交，较少数据能够提交成功。 恢复较多数据后跟踪提交FORM DATA ，发现数
  • 在MyEclipse中增加JSP模板 删除-2008-08-18 ljy325 jspxmlMyEclipse
    在D:\Program Files\MyEclipse 6.0\myeclipse\eclipse\plugins\com.genuitec.eclipse.wizards_6.0.1.zmyeclipse601200710\templates\jsp  目录下找到Jsp.vtl，复制一份，重命名为jsp2.vtl,然后把里面的内容修改为自己想要的格式，保存。 然后在 D:\Progr
  • JavaScript常用验证脚本总结 eksliang JavaScriptjavaScript表单验证
         转载请出自出处：http://eksliang.iteye.com/blog/2098985        下面这些验证脚本，是我在这几年开发中的总结，今天把他放出来，也算是一种分享吧，现在在我的项目中也在用！包括日期验证、比较，非空验证、身份证验证、数值验证、Email验证、电话验证等等...! &nb
  • 微软BI（4） 18289753290 微软BI SSIS
    1） Q:查看ssis里面某个控件输出的结果：  A MessageBox.Show(Dts.Variables["v_lastTimestamp"].Value.ToString()); 这是我们在包里面定义的变量 2):在关联目的端表的时候如果是一对多的关系，一定要选择唯一的那个键作为关联字段。 3) Q：ssis里面如果将多个数据源的数据插入目的端一
  • 定时对大数据量的表进行分表对数据备份 酷的飞上天空 大数据量
    工作中遇到数据库中一个表的数据量比较大，属于日志表。正常情况下是不会有查询操作的，但如果不进行分表数据太多，执行一条简单sql语句要等好几分钟。。   分表工具：linux的shell + mysql自身提供的管理命令 原理：使用一个和原表数据结构一样的表，替换原表。   linux shell内容如下： =======================开始 
  • 本质的描述与因材施教 永夜-极光 感想随笔
             不管碰到什么事,我都下意识的想去探索本质,找寻一个最形象的描述方式。        我坚信,世界上对一件事物的描述和解释,肯定有一种最形象,最贴近本质,最容易让人理解        &
  • 很迷茫。。。 随便小屋 随笔
    小弟我今年研一，也是从事的咱们现在最流行的专业（计算机）。本科三流学校，为了能有个更好的跳板，进入了考研大军，非常有幸能进入研究生的行业（具体学校就不说了，怕把学校的名誉给损了）。   先说一下自身的条件，本科专业软件工程。主要学习就是软件开发，几乎和计算机没有什么区别。因为学校本身三流，也就是让老师带着学生学点东西，然后让学生毕业就行了。对专业性的东西了解的非常浅。就那学的语言来说
  • 23种设计模式的意图和适用范围 aijuans 设计模式
    Factory Method 意图 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。 　　适用性 当一个类不知道它所必须创建的对象的类的时候。 　　当一个类希望由它的子类来指定它所创建的对象的时候。 　　当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。 Abstr
  • Java中的synchronized和volatile aoyouzi javavolatilesynchronized
    说到Java的线程同步问题肯定要说到两个关键字synchronized和volatile。说到这两个关键字，又要说道JVM的内存模型。JVM里内存分为main memory和working memory。 Main memory是所有线程共享的，working memory则是线程的工作内存，它保存有部分main memory变量的拷贝，对这些变量的更新直接发生在working memo
  • js数组的操作和this关键字 百合不是茶 js数组操作this关键字
    js数组的操作;   一:数组的创建: 1、数组的创建 var array = new Array();　//创建一个数组 var array = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度 var arrayObj = new Array([element0[, element1[, ...[, elementN]]]
  • 别人的阿里面试感悟 bijian1013 面试分享工作感悟阿里面试
    原文如下：http://greemranqq.iteye.com/blog/2007170         一直做企业系统，虽然也自己一直学习技术，但是感觉还是有所欠缺，准备花几个月的时间，把互联网的东西，以及一些基础更加的深入透析，结果这次比较意外，有点突然，下面分享一下感受吧！    &nb
  • 淘宝的测试框架Itest Bill_chen springmaven框架单元测试JUnit
    Itest测试框架是TaoBao测试部门开发的一套单元测试框架，以Junit4为核心， 集合DbUnit、Unitils等主流测试框架，应该算是比较好用的了。 近期项目中用了下，有关itest的具体使用如下： 1.在Maven中引入itest框架： <dependency>   <groupId>com.taobao.test</groupId&g
  • 【Java多线程二】多路条件解决生产者消费者问题 bit1129 java多线程
    package com.tom; import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.locks.Condition; import java.util.concurrent.loc
  • 汉字转拼音pinyin4j 白糖_ pinyin4j
    以前在项目中遇到汉字转拼音的情况，于是在网上找到了pinyin4j这个工具包，非常有用，别的不说了，直接下代码：   import java.util.HashSet; import java.util.Set; import net.sourceforge.pinyin4j.PinyinHelper; import net.sourceforge.pinyin
  • org.hibernate.TransactionException: JDBC begin failed解决方案 bozch ssh数据库异常DBCP
    org.hibernate.TransactionException: JDBC begin failed:     at org.hibernate.transaction.JDBCTransaction.begin(JDBCTransaction.java:68)    at org.hibernate.impl.SessionImp
  • java-并查集（Disjoint-set）-将多个集合合并成没有交集的集合 bylijinnan java
    import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.ut
  • Java PrintWriter打印乱码 chenbowen00 java
    一个小程序读写文件，发现PrintWriter输出后文件存在乱码，解决办法主要统一输入输出流编码格式。 读文件： BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 通常，Reader 所作的每个读取请求都会导致对基础字符或字节流进行相应的读取请求。因
  • [天气与气候]极端气候环境 comsci 环境
          如果空间环境出现异变...外星文明并未出现,而只是用某种气象武器对地球的气候系统进行攻击,并挑唆地球国家间的战争,经过一段时间的准备...最大限度的削弱地球文明的整体力量,然后再进行入侵......      那么地球上的国家应该做什么样的防备工作呢?  &n
  • oracle order by与union一起使用的用法 daizj UNIONoracleorder by
    当使用union操作时，排序语句必须放在最后面才正确，如下： 只能在union的最后一个子查询中使用order by，而这个order by是针对整个unioning后的结果集的。So： 如果unoin的几个子查询列名不同，如 Sql代码  select supplier_id, supplier_name  from suppliers  UNI
  • zeus持久层读写分离单元测试 deng520159 单元测试
    本文是zeus读写分离单元测试,距离分库分表,只有一步了.上代码: 1.ZeusMasterSlaveTest.java package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Assert; import org.j
  • Yii 截取字符串(UTF-8) 使用组件 dcj3sjt126com yii
    1.将Helper.php放进protected\components文件夹下。 2.调用方法：   Helper::truncate_utf8_string($content,20,false);   //不显示省略号  Helper::truncate_utf8_string($content,20);  //显示省略号  &n
  • 安装memcache及php扩展 dcj3sjt126com PHP
    安装memcache    tar zxvf memcache-2.2.5.tgz     cd memcache-2.2.5/     /usr/local/php/bin/phpize (?)    ./configure --with-php-confi
  • JsonObject 处理日期 feifeilinlin521 javajsonJsonOjbectJsonArrayJSONException
        写这边文章的初衷就是遇到了json在转换日期格式出现了异常 net.sf.json.JSONException: java.lang.reflect.InvocationTargetException  原因是当你用Map接收数据库返回了java.sql.Date 日期的数据进行json转换出的问题话不多说  直接上代码  &n
  • Ehcache（06）——监听器 234390216 监听器listenerehcache
    监听器          Ehcache中监听器有两种，监听CacheManager的CacheManagerEventListener和监听Cache的CacheEventListener。在Ehcache中，Listener是通过对应的监听器工厂来生产和发生作用的。下面我们将来介绍一下这两种类型的监听器。  
  • activiti 自带设计器中chrome 34版本不能打开bug的解决 jackyrong Activiti
      在acitivti modeler中，如果是chrome 34，则不能打开该设计器，其他浏览器可以， 经证实为bug，参考 http://forums.activiti.org/content/activiti-modeler-doesnt-work-chrome-v34 修改为，找到 oryx.debug.js 在最头部增加 if (!Document.
  • 微信收货地址共享接口-终极解决 laotu5i0 微信开发
       最近要接入微信的收货地址共享接口，总是不成功，折腾了好几天，实在没办法网上搜到的帖子也是骂声一片。我把我碰到并解决问题的过程分享出来，希望能给微信的接口文档起到一个辅助作用，让后面进来的开发者能快速的接入，而不需要像我们一样苦逼的浪费好几天，甚至一周的青春。各种羞辱、谩骂的话就不说了，本人还算文明。    如果你能搜到本贴，说明你已经碰到了各种 ed
  • 关于人才 netkiller.github.com 工作面试招聘netkiller人才
    关于人才 每个月我都会接到许多猎头的电话，有些猎头比较专业，但绝大多数在我看来与猎头二字还是有很大差距的。 与猎头接触多了，自然也了解了他们的工作，包括操作手法，总体上国内的猎头行业还处在初级阶段。 总结就是“盲目推荐，以量取胜”。 目前现状 许多从事人力资源工作的人，根本不懂得怎么找人才。处在人才找不到企业，企业找不到人才的尴尬处境。 企业招聘，通常是需要用人的部门提出招聘条件，由人
  • 搭建 CentOS 6 服务器 - 目录 rensanning centos
    (1) 安装CentOS ISO（desktop/minimal）、Cloud（AWS/阿里云）、Virtualization（VMWare、VirtualBox） 详细内容 (2) Linux常用命令 cd、ls、rm、chmod...... 详细内容 (3) 初始环境设置 用户管理、网络设置、安全设置...... 详细内容 (4) 常驻服务Daemon
  • 【求助】mongoDB无法更新主键 toknowme mongodb
      Query query = new Query();          query.addCriteria(new Criteria("_id").is(o.getId()));                &n
  • jquery 页面滚动到底部自动加载插件集合 xp9802 jquery
    很多社交网站都使用无限滚动的翻页技术来提高用户体验，当你页面滑到列表底部时候无需点击就自动加载更多的内容。下面为你推荐 10 个 jQuery 的无限滚动的插件： 1. jQuery ScrollPagination jQuery ScrollPagination plugin 是一个 jQuery 实现的支持无限滚动加载数据的插件。 2. jQuery Screw S
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他