模板整理計劃

阿新 • • 發佈：2019-01-10

“是時候了”
“好”
“我來了” “NOIp”

這裡寫圖片描述

全排列

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAXN (100)
int n;
int num[MAXN];
bool vis[MAXN];

void print()
{
    for(int i = 1; i <= n; ++ i)
        printf("%d ", num[i]);
    cout 
 << '\n';
}

void dfs(int x)
{
    if(x > n)
    {
        print();
        return;
    }
    for(int i = 1; i <= n; ++ i)
    {
        if(!vis[i])
        {
            num[x] = i;
            vis[i] = 1;
            dfs(x+1);
            vis[i] = 0;
        }
    }

}

int main()
{
    cin 
 >> n;
    dfs(1);
    return 0;
}

選數半排列

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAXN (100)
int n, k;
int num[MAXN], ans[MAXN];

void print()
{
    for(int i = 1; i <= k; ++ i)
        printf("%d ", ans[i]);
    cout 
 << '\n';
}

void dfs(int x, int last)
{
    if(x > k)
    {
        print();
        return;
    }
    for(int i = last+1; i <= n; ++ i)
    {
        ans[x] = num[i];
        dfs(x+1, i);
    }
}

int main()
{
    cin >> n >> k;
    for(int i = 1; i <= n; ++ i)
        scanf("%d", &num[i]);
    dfs(1,0);
    return 0;
}

這裡寫圖片描述

DFS子集列舉

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAXN (100)
int n;
bool vis[MAXN];

void print()
{
    for(int i = 1; i <= n; ++ i)
        printf("%d ", vis[i]);
    cout << '\n';
}

void dfs(int x)
{
    if(x > n)
    {
        print();
        return;
    }
    vis[x] = 0;
    dfs(x+1);
    vis[x] = 1;
    dfs(x+1);
    vis[x] = 0;
}

int main()
{
    cin >> n;
    dfs(1);
    return 0;
}

二進位制子集列舉

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
    int n;
    cin >> n;
    for(int s = 0; s < (1<<n); ++ s)
    {
        for(int j = n-1; j >= 0; -- j)
            cout << (bool)(s&(1<<j)) << " ";
        cout << '\n';
    }
    return 0;
}

這裡寫圖片描述

gcd

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

int gcd(int a, int b)
{
    if(!b) return a;
    return gcd(b,a%b);
}

int main()
{
    int a, b;
    cin >> a >> b;
    cout << gcd(max(a,b),min(a,b));
    return 0;
}

exgcd

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

int exgcd(int a, int b, int &x, int &y)
{
    if(!b) 
    {
        x = 1; y = 0;
        return a;
    }
    int ans = gcd(b,a%b,x,y);
    int t = x;
    x = y;
    y = t-a/b*y;
    return ans;
}

int main()
{
    int a, b, x, y;
    cin >> a >> b;
    cout << gcd(max(a,b),min(a,b),x,y) << " " << x << " " < y << '\n';
    return 0;
}

這裡寫圖片描述

埃氏篩法

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAXN (100000)
bool vis[MAXN];

int main()
{
    int n;
    cin >> n;
    for(int i = 2; i <= n; ++ i)
        if(!vis[i])
            for(int j = i+i; j <= n; j += i)
                vis[j] = 1;
    for(int i = 2; i <= n; ++ i)
        if(!vis[i])
            printf("%d ", i);
    printf("\n");
    return 0;
}

尤拉篩法-線性篩

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAXN (100000)
bool vis[MAXN];
int prime[MAXN];

int main()
{
    int n, cnt = 0;
    cin >> n;

    fill(vis+1, vis+n+1, 1);
    for(int i = 2; i <= n; ++ i)
    {
        if(vis[i]) prime[++cnt] = i;
        for(int j = 1; j <= cnt && prime[j]*i <= n; ++ j)
        {
            vis[prime[j]*i] = 0;
            if(i%prime[j] == 0) break;
        }
    }

    for(int i = 1; i <= cnt; ++ i)
        printf("%d ", prime[i]);
    printf("\n");
    return 0;
}

這裡寫圖片描述

快速冪（非遞迴）

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;
typedef long long LL;

LL ksm(LL a, LL p, LL k)
{
    LL ans = 1;
    for(; p; p >>= 1, a = ((a%k)*(a%k))%k)
        if(p&1)
            ans = ((ans%k)*(a%k))%k;
    return ans%k;
}

int main()
{
    LL a, b, c;
    cin >> a >> b >> c;
    printf("%lld^%lld mod %lld=%lld\n",a, b, c, ksm(a,b,c));
    return 0;
}

這裡寫圖片描述

暴力LCA（帶DFS+邊權）

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAX_V (500000)
#define MAX_E (MAX_V)
int V, tot = 0;
int first[MAX_V], nxt[MAX_E<<1], deep[MAX_V], fa[MAX_V], dis[MAX_V];
struct edge{
    int from, to, cost;
}es[MAX_E<<1];

void build(int ff, int tt, int dd)
{
    es[++tot] = (edge){ff,tt,dd};
    nxt[tot] = first[ff];
    first[ff] = tot;
}

void dfs(int x, int f)
{
    fa[x] = f;
    deep[x] = deep[f]+1;
    for(int i = first[x]; i != -1; i = nxt[i])
    {
        int v = es[i].to;
        if(v == f) continue;
        dis[v] = es[i].cost;
        dfs(v,x);
    }
}

int lca(int x, int y)
{
    int ans = 0;
    if(deep[x] > deep[y]) swap(x,y);
    while(deep[y] != deep[x])
    {
        ans += dis[y];
        y = fa[y];
    }
    while(x != y)
    {
        ans += dis[x];
        x = fa[x];
        ans += dis[y];
        y = fa[y];
    }
    return ans;
}

int main()
{
    cin >> V;
    memset(first,-1,sizeof(first));
    for(int i = 1; i < V; ++ i)
    {
        int f, t, d;
        scanf("%d%d%d", &f, &t, &d);
        build(f,t,d); build(t,f,d);
    }
    deep[1] = 0; dis[1] = 0;
    dfs(1,1);
    int Q;
    cin >> Q;
    while(Q --)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        printf("%d\n", lca(x,y));
    }
    return 0;
}

這裡寫圖片描述

並查集

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAXN (10010)
int fa[MAXN];

int find(int x)
{
    int t, r = x;
    while(r != fa[r]) r = fa[r];
    while(x != r) {t=fa[x];fa[x]=r;x=t;}
    return r;
}

void lianjie(int x, int y)
{
    int fx = find(x), fy = find(y);
    if(fx != fy) fa[fx] = fy;
}

void check(int x, int y)
{
    int fx = find(x), fy = find(y);
    if(fx != fy) puts("N"); 
    else puts("Y");
}

int main()
{
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; ++ i) fa[i] = i;
    for(int i = 1; i <= m; ++ i)
    {
        int t, x, y;
        scanf("%d%d%d", &t, &x, &y);
        if(t == 1) lianjie(x,y);
        else check(x,y);
    }
    return 0;
}

這裡寫圖片描述

最小生成樹Kruskal

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

#define MAX_V (5050)
#define MAX_E (200200)
int V, E;
int fa[MAX_V];
struct edge{
    int from, to, cost;
}es[MAX_E];

bool cmp(edge a, edge b) {return a.cost < b.cost;}

int find(int x)
{
    int t, r = x;
    while(r != fa[r]) r = fa[r];
    while(x != r){t=fa[x];fa[x]=r;x=t;}
    return r;
}

int kruskal()
{
    int ans = 0;
    for(int i = 1; i <= V; ++ i) fa[i] = i;
    sort(es+1, es+E+1, cmp);
    for(int i = 1; i <= E; ++ i)
    {
        int fu = find(es[i].from);
        int fv = find(es[i].to);
        if(fu != fv)
        {
            fa[fu] = fv;
            ans += es[i].cost;
        }
    }
    return ans;
}

int main()
{
    cin >> V >> E;
    for(int i = 1; i <= E; ++ i)
    {
        int f, t, d;
        scanf("%d%d%d", &f, &t, &d);
        es[i] = (edge){f,t,d};
    }
    cout << kruskal() << '\n';
    return 0;
}

這裡寫圖片描述

最短路floyd

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

#define MAXN (110)
int V; 
int dis[MAXN][MAXN];

void floyd()
{
    for(int k = 1; k <= V; ++ k)
        for(int i = 1; i <= V; ++ i)
            for(int j = 1; j <= V; ++ j)
                dis[i][j] = min(dis[i][j], dis[i][k]+dis[k][j]);
}

int main()
{
    cin >> V;
    memset(dis,63,sizeof(dis));
    for(int i = 1; i <= V; ++ i)
        for(int j = 1; j <= V; ++ j)
            scanf("%d", &dis[i][j]), dis[j][i] = dis[i][j];
    floyd();
    int Q; cin >> Q;
    while(Q--)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", dis[a][b]);
    }
    return 0;
}

這裡寫圖片描述

最短路spfa

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <queue> 
using namespace std;

#define MAX_V (2525)
#define MAX_E (6262)
int V, E, tot = 0;
int first[MAX_V], nxt[MAX_E<<1], dis[MAX_V];
bool used[MAX_V];
struct edge{
    int from, to, cost;
}es[MAX_E<<1];

void build(int ff, int tt, int dd)
{
    es[++tot] = (edge){ff,tt,dd};
    nxt[tot] = first[ff];
    first[ff] = tot;
}

#define INF (1e9)
queue <int> q;
void spfa(int s)
{
    fill(dis+1,dis+V+1,INF);
    dis[s] = 0;
    q.push(s);
    used[s] = 1;
    while(q.size())
    {
        int x = q.front();
        q.pop();
        used[x] = 0;
        for(int i = first[x]; i != -1; i = nxt[i])
        {
            int v = es[i].to;
            if(dis[v] > dis[x] + es[i].cost)
            {
                dis[v] = dis[x] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
        }
    }
}

int main()
{
    int Ts, Te;
    cin >> V >> E >> Ts >> Te;
    memset(first,-1,sizeof(first));
    for(int i = 1; i <= E; ++ i)
    {
        int f, t, d;
        scanf("%d%d%d", &f, &t, &d);
        build(f,t,d); build(t,f,d);
    }
    spfa(Ts);
    cout << dis[Te] << '\n';
    return 0;
}

最短路spfa_slf優化

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <queue> 
using namespace std;

#define MAX_V (2525)
#define MAX_E (6262)
int V, E, tot = 0;
int first[MAX_V], nxt[MAX_E<<1], dis[MAX_V];
bool used[MAX_V];
struct edge{
    int from, to, cost;
}es[MAX_E<<1];

void build(int ff, int tt, int dd)
{
    es[++tot] = (edge){ff,tt,dd};
    nxt[tot] = first[ff];
    first[ff] = tot;
}

#define INF (1e9)
deque <int> q;
void spfa_slf(int s)
{
    fill(dis+1,dis+V+1,INF);
    dis[s] = 0;
    q.push_back(s);
    used[s] = 1;
    while(q.size())
    {
        int x = q.front();
        q.pop_front();
        used[x] = 0;
        for(int i = first[x]; i != -1; i = nxt[i])
        {
            int v = es[i].to;
            if(dis[v] > dis[x] + es[i].cost)
            {
                dis[v] = dis[x] + es[i].cost;
                if(!used[v])
                {
                    if(q.empty()) q.push_back(v);
                    else if(dis[v] <= dis[q.front()]) q.push_front(v);
                    else q.push_back(v);
                    used[v] = 1;
                }
            }
        }
    }
}

int main()
{
    int Ts, Te;
    cin >> V >> E >> Ts >> Te;
    memset(first,-1,sizeof(first));
    for(int i = 1; i <= E; ++ i)
    {
        int f, t, d;
        scanf("%d%d%d", &f, &t, &d);
        build(f,t,d); build(t,f,d);
    }
    spfa_slf(Ts);
    cout << dis[Te] << '\n';
    return 0;
}

最短路spfa判負環

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <queue> 
using namespace std;

#define MAX_V (2525)
#define MAX_E (6262)
int V, E, EE, tot = 0;
int first[MAX_V], nxt[MAX_E<<1], dis[MAX_V];
bool used[MAX_V];
struct edge{
    int from, to, cost;
}es[MAX_E<<1];

void build(int ff, int tt, int dd)
{
    es[++tot] = (edge){ff,tt,dd};
    nxt[tot] = first[ff];
    first[ff] = tot;
}

#define INF (1e9)
queue <int> q;
int tim[MAX_V];
string spfa(int s)
{
    fill(dis+1,dis+V+1,INF);
    dis[s] = 0;
    q.push(s);
    used[s] = 1;
    while(q.size())
    {
        int x = q.front();
        q.pop();
        used[x] = 0;
        if(++tim[x] > V) return "YES";
        for(int i = first[x]; i != -1; i = nxt[i])
        {
            int v = es[i].to;
            if(dis[v] > dis[x] + es[i].cost)
            {
                dis[v] = dis[x] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
        }
    }
    return "NO";
}

int main()
{
    int T;
    cin >> T;
    while(T --)
    {
        tot = 0;
        memset(first,-1,sizeof(first));
        memset(nxt,0,sizeof(nxt));
        memset(used,0,sizeof(used));
        memset(es,0,sizeof(es));
        memset(tim,0,sizeof(tim));
        while(q.size()) q.pop();

        scanf("%d%d%d", &V, &E, &EE);
        for(int i = 1; i <= E; ++ i)
        {
            int f, t, d;
            scanf("%d%d%d", &f, &t, &d);
            build(f,t,d); build(t,f,d);
        }
        for(int i = 1; i <= EE; ++ i)
        {
            int f, t, d;
            scanf("%d%d%d", &f, &t, &d);
            build(f,t,-d);
        }
        cout << spfa(1) << '\n';
    }
    return 0;
}

這裡寫圖片描述

最短路 Dijsktra堆優化

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <queue> 
using namespace std;

#define MAX_V (2525)
#define MAX_E (6262)
int V, E, tot = 0;
int first[MAX_V], nxt[MAX_E<<1], dis[MAX_V];
bool done[MAX_V];
struct edge{
    int from, to, cost;
}es[MAX_E<<1];

void build(int ff, int tt, int dd)
{
    es[++tot] = (edge){ff,tt,dd};
    nxt[tot] = first[ff];
    first[ff] = tot;
}

struct zt{
    int u, d;
};

bool operator < (zt a, zt b)
{
    return a.d > b.d;
}

priority_queue <zt> q;

#define INF (1e9)
void Dijkstra(int s)
{
    fill(dis+1,dis+V+1,INF);
    dis[s] = 0;
    q.push((zt){s,0});
    while(q.size())
    {
        int x = q.top().u;
        q.pop();
        if(done[x]) continue;
        done[x] = 1;
        for(int i = first[x]; i != -1; i = nxt[i])
        {
            int v = es[i].to;
            if(dis[v] > dis[x] + es[i].cost)
            {
                dis[v] = dis[x] + es[i].cost;
                q.push((zt){v,dis[v]});
            }
        }
    }
}
int main()
{
    int Ts, Te;
    cin >> V >> E >> Ts >> Te;
    memset(first,-1,sizeof(first));
    for(int i = 1; i <= E; ++ i)
    {
        int f, t, d;
        scanf("%d%d%d", &f, &t, &d);
        build(f,t,d); build(t,f,d);
    }
    Dijkstra(Ts);
    cout << dis[Te] << '\n';
    return 0;
}

這裡寫圖片描述

次短路_sub_spfa

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <queue>
using namespace std;

#define MAXN (100100)
int V, E, tot = 0;
int first[MAXN], nxt[MAXN<<1], dis1[MAXN], dis2[MAXN];
bool used[MAXN];
struct edge{
    int from, to, cost;
}es[MAXN<<1];

void build(int ff, int tt, int dd)
{
    es[++tot] = (edge){ff,tt,dd};
    nxt[tot] = first[ff];
    first[ff] = tot;
}

#define INF (1e9)
queue <int> q;
void sub_spfa(int s)
{
    fill(dis1+1,dis1+V+1,INF); fill(dis2+1,dis2+V+1,INF);
    dis1[s] = 0;
    q.push(s);
    used[s] = 1;
    while(q.size())
    {
        int x = q.front();
        q.pop();
        used[x] = 0;
        for(int i = first[x]; i != -1; i = nxt[i])
        {
            int v = es[i].to;
            if(dis1[v] > dis1[x] + es[i].cost)
            {
                dis2[v] = dis1[v];
                dis1[v] = dis1[x] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
            else if((dis1[v] < dis1[x]+es[i].cost) && (dis2[v] > dis1[x]+es[i].cost))
            {
                dis2[v] = dis1[x] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
            else if(dis2[v] > dis2[x] + es[i].cost)
            {
                dis2[v] = dis2[x] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            } 
        }
    }
}

int main()
{
    cin >> V >> E;
    memset(first,-1,sizeof(first));
    for(int i = 1; i <= E; ++ i)
    {
        int f,t,d;
        scanf("%d%d%d", &f, &t, &d);
        build(f,t,d);
    }
    sub_spfa(1);
    if(dis2[V] < INF) cout << dis2[V] << '\n';
    else puts("-1");
    return 0;
}

這裡寫圖片描述

線段樹

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
#define L(x) (x<<1)
#define R(x) (x<<1|1)
#define SZ(x) (tree[x].r-tree[x].l+1)
using namespace std;
typedef long long LL;

#define MAXN (200020)
int xl[MAXN];
struct TREE{
    int l, r, add;
    LL sum;
}tree[MAXN<<2];

void update(int p)
{
    tree[p].sum = tree[L(p)].sum + tree[R(p)].sum;
    return;
}

void build(int l, int r, int p)
{
    tree[p].l = l; tree[p].r = r;
    if(l == r)
    {
        tree[p].sum = xl[l];
        return;
    }
    int mid = (tree[p].l+tree[p].r)>>1;
    build(l,mid,L(p)); build(mid+1,r,R(p));
    update(p);
    return;
}

void spread(int p)
{
    if(tree[p].add)
    {
        tree[L(p)].add += tree[p].add;
        tree[R(p)].add += tree[p].add;
        tree[L(p)].sum += (SZ(L(p))*tree[p].add);
        tree[R(p)].sum += (SZ(R(p))*tree[p].add);
        tree[p].add = 0;
        update(p);
        return;
    }
}

void change(int l, int r, int p, int x)
{
    if(l <= tree[p].l && r >= tree[p].r)
    {
        tree[p].add += x;
        tree[p].sum += (SZ(p)*x);
        return;
    }
    spread(p);
    int mid = (tree[p].l+tree[p].r)>>1;
    if(l <= mid) change(l,r,L(p),x);
    if(r > mid) change(l,r,R(p),x);
    update(p);
    return;
}

LL ask(int l, int r, int p)
{
    if(l <= tree[p].l && r >= tree[p].r)
        return tree[p].sum;
    spread(p);
    LL ans = 0;
    int mid = (tree[p].l+tree[p].r)>>1;
    if(l <= mid) ans += ask(l,r,L(p));
    if(r > mid) ans += ask(l,r,R(p));
    update(p);
    return ans;
}

int main()
{
    int n;
    cin >> n;
    for(int i = 1; i <= n; ++ i) scanf("%d", &xl[i]);
    build(1,n,1);
    int Q;
    cin >> Q;
    while(Q--)
    {
        int t, a, b, x;
        scanf("%d", &t);
        if(t == 1)
        {
            scanf("%d%d%d", &a, &b, &x);
            change(a,b,1,x);
        }
        else{
            scanf("%d%d", &a, &b);
            printf("%lld\n", ask(a,b,1));
        }
    }
    return 0;
}

這裡寫圖片描述

高精度

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>
using namespace std;

#define MAXN (100000)
struct Big{
    int a[MAXN];
    int len;
    void print()
    {
        while(!a[this->len] && this->len) --this->len;
        for(int i = this->len; i >= 1; -- i)
            printf("%d", this->a[i]);
        if(!this->len) puts("0");
        else puts("");
    }
};

Big operator + (Big A, Big B)
{
    A.len = max(A.len, B.len)+1;
    for(int i = 1; i <= A.len; ++ i)
    {
        A.a[i] += B.a[i];
        A.a[i+1] += (A.a[i]/10);
        A.a[i] %= 10;
    }
    return A;
}

bool operator < (Big A, Big B)
{
    if(A.len != B.len) return A.len < B.len;
    for(int i = A.len; i >= 1; -- i)
        return A.a[i] < B.a[i];
    return true;
}

Big t;
void swap(Big &A, Big &B) {t = A; A = B; B = t;}

Big operator - (Big A, Big B)
{
    if(A < B) swap(A, B), putchar('-');
    for(int i = 1; i <= A.len; ++ i)
    {
        A.a[i] -= B.a[i];
        if(A.a[i] < 0)
        {
            A.a[i] += 10;
            -- A.a[i+1];
        }
    }
    return A;
}

Big T;
Big operator * (Big A, Big B)
{
    T.len = A.len+B.len;
    for(int i = 1; i <= A.len; ++ i)
        for(int j = 1; j <= B.len; ++ j)
        {
            T.a[i+j-1] += (A.a[i]*B.a[j]);
            T.a[i+j] += (T.a[i+j-1]/10);
            T.a[i+j-1] %= 10;
        }
    return T;
}

char s[MAXN];
void read(Big &A)
{
    scanf("%s", s+1);
    A.len = strlen(s+1);
    for(int i = 1; i <= A.len; ++ i)
        A.a[A.len-i+1] = (int)(s[i]-'0');
}

Big A, B, C;
int main()
{
    read(A); read(B);
    C = A+B;
//  C = A-B;
//  C = A*B;
    C.print();
    return 0;
}

BLESS ALL.

這裡寫圖片描述

（圖侵刪，圖雜）

這裡寫圖片描述

模板整理計劃

“是時候了” “好” “我來了” “NOIp” 全排列 #include <cstdio> #include <cstring> #include <iostream> #include <cst

模板整理 (施工中 2017.8.21更新)

中國剩余定理復雜度更新一個點 mod tarjan iomanip push man 目錄數據結構 1 字典樹圖論 1 網絡流dinic 2 zkw費用流 3 無向圖的強聯通分量數論 1 中國剩余定理

manacher模板整理

//p[]為最長迴文半徑長度，id為當前最靠右端迴文串的中心點(多個取最靠左)，mx為id對應的迴文串的最右端座標+1void manacher(char *s,int len){ p[0] = 1; int mx = 0 , id = 0; for(int i = 1

多項式模板整理

多項式求逆簡單的 pac 積分常用 n) code max text 多項式乘法 FFT模板時間復雜度\(O(n\log n)\)。模板： void FFT(Z *a,int x,int K){ static int rev[N],lst; int

Effictive C++條款整理計劃（21-30）

21. 必須返回物件時，別妄想返回其reference 該條表達的意思是：在需要返回一個新物件的時候，我們不應返回一個棧上（記憶體被釋放，reference無效）、堆上（極易資源洩露）、或者static（多執行緒不安全）上面的reference，而是應該返回這個新物件。 22.

Effictive C++條款整理計劃（11-20）

11. 在operator=中處理自我賦值該條款說的是，在operator函式中，應該先判斷是否在進行自賦值，如果是自賦值，應該直接返回*this，而不是繼續進行自我賦值 class Student { public: Student(int age):m_age(age)

Effictive C++條款整理計劃（1-10）

第一條：視C++為一個語言聯邦該條款的理解是，把c++看成一個由相關語言組成的聯邦，而非單一的語言，在運用某個次語言的時候，應該遵守各個次語言的約定和規則，保證其簡單，直觀易懂。 c++次語言有以下四種： C語言 c++是C語言的超集 Object-Oriented C++

【演算法總結】01揹包與完全揹包模板整理

三種揹包的概念區分 01揹包（ZeroOnePack）: 有N件物品和一個容量為V的揹包。每種物品均只有一件。第i件物品的費用是c[i]，價值是w[i]。求解將哪些物品裝入揹包可使價值總和最大。完全揹

最小費用最大流(spfa增廣)——模板整理

這個演算法好像沒名字。。就是每次spfa增廣。時間複雜度O(n*m^2*3)？ #include<cstdio> #include<cstring> #include<

考前模板整理

考前整理了一下模板，供自己複習。（雖說考試已經過去了，不過明年你還可以用啊，已退役的OIer當我沒說）考前模板彙總快速冪 #define ll long long #include<bits/stdc++.h> using namespace std; ll power(

凸包之Andrew演算法——模板整理

是Graham的變種。水平掃描，分別構造上下凸殼，然後把兩者接起來。感覺比Graham好用。複雜度O(nlog2n) (排序) #include<cmath> #include&l

線段樹模板整理

綜述線段樹的原理：將[1,n]分解成若干特定的子區間(數量不超過4*n),然後，將每個區間[L,R]都分解為少量特定的子區間，通過對這些少量子區間的修改或者統計，來實現快速對[L,R]的修改或者統計

模板整理慢慢更新

數論矩陣快速冪斐波那契第n項和 #include <bits/stdc++.h> using namespace std; #define ne 2 #define INF 1000000009 struct node { l

k短路模板整理

總結：除了第一題，其他的都是很裸的模板題，所以只介紹第一題。其中第2題是求1-n次短路，且是雙向邊第2題直接求k短路，沒有的話輸出-1，單向邊第4題判斷k短路是否小於等於T，單向邊第一題題意：給定n條邊每條邊（co

【POJ 3241】曼哈頓最小生成樹（模板整理）

關於曼哈頓最小生成樹的證明見：http://www.2cto.com/kf/201505/399861.html 模板： #include<cmath> #include<cstdio> #include<cstring> #incl

(最短路徑算法整理)dijkstra、floyd、bellman-ford、spfa算法模板的整理與介紹

void empty borde fast 默認 grand else 理解 scan 這一篇博客以一些OJ上的題目為載體。整理一下最短路徑算法。會陸續的更新。。。一、多源最短路算法——floyd算法 floyd算法主要用於求隨意兩點間的最短路徑。也成

自己定義微信圖文模板註意事項整理

查詢 popu bsp 不支持支持 -m 均可實現文章自己定義模板，要把css寫在html style中，在網頁打開復制整個文章，復制的時候會把樣式一起復制進去，粘貼到微信素材管理-》後臺編輯器中預覽就可以實現。 1，html復制到後臺編輯器之後編輯器會把

noip考前模板大整理

stream 最長回文串 ring 分解質 prior nio check logs sca //歸並排序求逆序對 #include<bits/stdc++.h> #define ll long long using namespace std; i

性能測試計劃模板

性能測試計劃模板1. 簡介1.1. 編寫目的簡述編寫此計劃的目的編寫本文檔的目的是用於指導sinamail4.0系統的性能測試。主要從測試環境、測試工具、測試策略、測試具體執行方法、任務與進度表等事先計劃和設計。1.2. 項目背景簡述本項目的背景針對迎接2008奧運，對用戶新開發的帶有2008域名的免

Linux crontab 計劃任務整理

linux centos crontab Linux crontab 計劃任務整理安裝 yum install -y vixie-cron # 安裝常用命令 crontab -e # 編輯 crontab -l # 查看 crontab -u

模板整理計劃

全排列

選數半排列

DFS子集列舉

二進位制子集列舉

埃氏篩法

尤拉篩法-線性篩

快速冪（非遞迴）

暴力LCA（帶DFS+邊權）

並查集

最小生成樹Kruskal

最短路floyd

最短路spfa

最短路spfa_slf優化

最短路spfa判負環

最短路 Dijsktra堆優化

次短路_sub_spfa

線段樹

高精度

BLESS ALL.

相關推薦