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

目录

数据结构

1 字典树

图论

1 网络流dinic

2 zkw费用流

3 无向图的强联通分量

数论

1 中国剩余定理

2 大质数判定

3 约瑟夫环

其他

1 祖传头文件

2 大数

数据结构

1.字典树

使用时记得先初始化第一个点

const int MAXN = 1e2 + 5;
int Maxlen, Maxnum;
int T, K;

struct node {
    int next[27];
    int v, num;
    void init() {
        v=-1;
        num = 0;
        memset(next,-1,sizeof(next));
    }
};
struct node L[1000000];
int tot=0;

void add(char a[]) {
    int now=0;
    int len = strlen(a);
    for(int i=0; i<len; i++) {
        int tmp=a[i]-‘a‘;
        int next=L[now].next[tmp];
        if(next==-1) {
            next=++tot;
            L[next].init();
            L[now].next[tmp]=next;
        }
        now=next;
        L[now].num ++;
        if(L[now].num >= 3) {
            if(Maxlen < i + 1) {
                Maxlen = i + 1;
                Maxnum = L[now].num;
            } else if(Maxnum < L[now].num && Maxlen <= i + 1) {
                Maxnum = L[now].num;
            }
        }
    }
    L[now].v=0;
}

int query(char s2[]) {
    int len = strlen(s2);
    int now = 0;
    for(int i = 0; i < len; i++) {
        int temp = s2[i] - ‘a‘;
        int next = L[now].next[temp];
        if(next == -1) return 0;
        now = next;
    }
    return L[now].num;
}

int main()
{
    L[0].init();

    return 0;
}

　

图论　

1.网络流Dinic

const int maxn = 405;    //开四倍
const int maxe = 4*maxn*maxn;
const int inf = 0x3f3f3f3f;
struct MaxFlow {
    struct Edge {
        int v, w, nxt;
    } edge[maxe];
    int head[maxn], tot, level[maxn];
    void init(){
        memset(head,-1,sizeof(head));
        tot=0;
    }
    void add(int u, int v, int w) {
        edge[tot].v = v;
        edge[tot].w = w;
        edge[tot].nxt = head[u];
        head[u] = tot++;  

        edge[tot].v = u;
        edge[tot].w = 0;
        edge[tot].nxt = head[v];
        head[v] = tot++;
    }
    bool bfs(int s, int t) {
        memset(level, -1, sizeof(level));
        queue<int>q;
        q.push(s);
        level[s] = 0;
        while(!q.empty()) {
            int u = q.front(); q.pop();
            for(int i = head[u]; ~i; i = edge[i].nxt) {
                if(edge[i].w > 0 && level[edge[i].v] < 0) {
                    level[edge[i].v] = level[u] + 1;
                    q.push(edge[i].v);
                }
            }
        }
        return level[t] > 0;
    }
    int dfs(int u, int t, int f) {
        if(u == t) return f;
        for(int i = head[u]; ~i; i = edge[i].nxt) {
            int v = edge[i].v;
            if(edge[i].w > 0 && level[v] > level[u]) {
                int d = dfs(v, t, min(f, edge[i].w));
                if(d > 0) {
                    edge[i].w -= d;
                    edge[i ^ 1].w += d;
                    return d;
                }
            }
        }
        level[u] = -1; //不太确定,如果WA了把这句删掉试试
        return 0;
    }
    int solve(int s, int t) {
        int flow = 0, f;
        while(bfs(s, t)) {  

            while(f = dfs(s, t, inf)) flow += f;  

        }
        return flow;
    }
}F;

2.

zkw费用流

const int MX = 80000;
const int MXE = 4 * MX * MX;
const int ME = 4e5 + 5;//边的数量

struct MCMF {
    int S, T;//源点，汇点
    int tot, n;
    int st, en, maxflow, mincost;
    bool vis[MX];
    int head[MX], cur[MX], dis[MX];
    int roade[MX], roadv[MX], rsz; //用于打印路径

    queue <int> Q;
    struct Edge {
        int v, cap, cost, nxt, flow;
        Edge() {}
        Edge(int a, int b, int c, int d) {
            v = a, cap = b, cost = c, nxt = d, flow = 0;
        }
    } E[ME], SE[ME];

    void init(int _n) {
        n = _n, tot = 0;
        for(int i = 0; i <= n; i++) head[i] = -1;
    }
    void edge_add(int u, int v, int cap, int cost) {
        E[tot] = Edge(v, cap, cost, head[u]);
        head[u] = tot++;
        E[tot] = Edge(u, 0, -cost, head[v]);
        head[v] = tot++;
    }
    bool adjust() {
        int v, min = INF;
        for(int i = 0; i <= n; i++) {
            if(!vis[i]) continue;
            for(int j = head[i]; ~j; j = E[j].nxt) {
                v = E[j].v;
                if(E[j].cap - E[j].flow) {
                    if(!vis[v] && dis[v] - dis[i] + E[j].cost < min) {
                        min = dis[v] - dis[i] + E[j].cost;
                    }
                }
            }
        }
        if(min == INF) return false;
        for(int i = 0; i <= n; i++) {
            if(vis[i]) {
                cur[i] = head[i];
                vis[i] = false;
                dis[i] += min;
            }
        }
        return true;
    }
    int augment(int i, int flow) {
        if(i == en) {
            mincost += dis[st] * flow;
            maxflow += flow;
            return flow;
        }
        vis[i] = true;
        for(int j = cur[i]; j != -1; j = E[j].nxt) {
            int v = E[j].v;
            if(E[j].cap == E[j].flow) continue;
            if(vis[v] || dis[v] + E[j].cost != dis[i]) continue;
            int delta = augment(v, std::min(flow, E[j].cap - E[j].flow));
            if(delta) {
                E[j].flow += delta;
                E[j ^ 1].flow -= delta;
                cur[i] = j;
                return delta;
            }
        }
        return 0;
    }
    void spfa() {
        int u, v;
        for(int i = 0; i <= n; i++) {
            vis[i] = false;
            dis[i] = INF;
        }
        Q.push(st);
        dis[st] = 0; vis[st] = true;
        while(!Q.empty()) {
            u = Q.front(), Q.pop(); vis[u] = false;
            for(int i = head[u]; ~i; i = E[i].nxt) {
                v = E[i].v;
                if(E[i].cap == E[i].flow || dis[v] <= dis[u] + E[i].cost) continue;
                dis[v] = dis[u] + E[i].cost;
                if(!vis[v]) {
                    vis[v] = true;
                    Q.push(v);
                }
            }
        }
        for(int i = 0; i <= n; i++) {
            dis[i] = dis[en] - dis[i];
        }
    }
    int zkw(int s, int t) {
        st = s, en = t;
        spfa();
        mincost = maxflow = 0;
        for(int i = 0; i <= n; i++) {
            vis[i] = false;
            cur[i] = head[i];
        }
        do {
            while(augment(st, INF)) {
                memset(vis, false, n * sizeof(bool));
            }
        } while(adjust());
        return mincost;
    }
} M;

3.无向图的强联通分量

const int MX = 1e5 + 10;

struct Edge {
    int u, v, nxt;
} E[MX];
int Head[MX], erear;
void edge_init() {
    erear = 0;
    memset(Head, -1, sizeof(Head));
}
void edge_add(int u, int v) {
    E[erear].u = u;
    E[erear].v = v;
    E[erear].nxt = Head[u];
    Head[u] = erear++;
}
int n, m, IN[MX], cnt[MX], val[MX];
int bsz, ssz, dsz;
int Low[MX], DFN[MX];
void Init_tarjan(int n) {
    bsz = ssz = dsz = 0;
    for(int i = 1; i <= n; ++i) Low[i] = DFN[i] = 0;
}

int Stack[MX], inStack[MX], Belong[MX];
void trajan(int u, int e) {
    inStack[u] = 1;
    Stack[++ssz] = u;
    DFN[u] = Low[u] = ++dsz;
    for(int i = Head[u]; ~i; i = E[i].nxt) {
        int v = E[i].v;
        if((i ^ 1) == e) continue;
        if(!DFN[v]) {
            trajan(v, i);
            Low[u] = min(Low[u], Low[v]);
        } else if(inStack[v]) {
            Low[u] = min(Low[u], Low[v]);
        }
    }
    if(DFN[u] == Low[u]) {
        bsz++; int v;
        do {
            v = Stack[ssz--];
            inStack[v] = 0;
            Belong[v] = bsz;
        } while(ssz && v != u);
    }
}
void tarjan_solve(int n) {
    dsz = bsz = ssz = 0;
    memset(DFN, 0, sizeof(DFN));
    for(int i = 1; i <= n; i++) {
        if(!DFN[i]) trajan(i, -1);
    }
    /*缩点*/
    edge_init();
    for(int i = 0; i < 2 * m; i += 2) {
        int u = E[i].u, v = E[i].v;
        u = Belong[u]; v = Belong[v];
        if(u == v) continue;
        edge_add(u, v);
        edge_add(v, u);
    }
}

　　

数论

1.中国剩余定理

LL gcd(LL a, LL b, LL &x, LL &y) {
    if(b == 0) {
        x =1, y = 0;
        return a;
    }
    LL r = gcd(b, a % b, x, y);
    LL t  = y;
    y = x - a / b * y;
    x = t;
    return r;
}  

LL multi(LL a, LL b, LL mod) {
    LL ret = 0;
    while(b) {
        if(b & 1) {
            ret = ret + a;
            if(ret >= mod) ret -= mod;
        }
        a = a + a;
        if(a >= mod) a -= mod;
        b >>= 1;
    }
    return ret;
}  

LL crt(int n, LL m[], LL a[]) {
    LL M = 1, d, y, x = 0;
    for(int i = 0; i < n; i++) M *= m[i];
    for(int i = 0; i < n; i++) {
        LL w = M / m[i];
        d = gcd(m[i], w, d, y);
        y = (y % m[i] + m[i]) % m[i];
        x = ((x + multi(multi(a[i], w, M), y, M)) % M + M) % M;
    }
    return x;
}

　　

2.大质数判定

LL multi(LL a, LL b, LL mod) {
    LL ret = 0;
    while(b) {
        if(b & 1) ret = ret + a;
        if(ret >= mod) ret -= mod;
        a = a + a;
        if(a >= mod) a -= mod;
        b >>= 1;
    }
    return ret;
}
LL power(LL a, LL b, LL mod) {
    LL ret = 1;
    while(b) {
        if(b & 1) ret = multi(ret, a, mod);
        a = multi(a, a, mod);
        b >>= 1;
    }
    return ret;
}
bool Miller_Rabin(LL n) {
    LL u = n - 1, pre, x;
    int i, j, k = 0;
    if(n == 2 || n == 3 || n == 5 || n == 7 || n == 11) return true;
    if(n == 1 || (!(n % 2)) || (!(n % 3)) || (!(n % 5)) || (!(n % 7)) || (!(n % 11))) return
            false;
    for(; !(u & 1); k++, u >>= 1);
    for(i = 0; i < 5; i++) {
        x = rand() % (n - 2) + 2;
        x = power(x, u, n);
        pre = x;
        for(j = 0; j < k; j++) {
            x = multi(x, x, n);
            if(x == 1 && pre != 1 && pre != (n - 1))
                return false;
            pre = x;
        }
        if(x != 1) return false;
    }
    return true;
}

3.约瑟夫环

/*
F[n] = (F[n - 1] + m) % n, F[1] = 0
返回的下标从0 开始，复杂度大约为O(m)
*/
int Joseph(int n, int m) {
    if(n == 1) return 0;
    if(m == 1) return n - 1;
    LL pre = 0; int now = 2;
    while(now <= n) {
        if(pre + m >= now) {
            pre = (pre + m) % now;
            now++;
        } else {
            int a = now - 1 - pre, b = m - 1;
            int k = a / b + (a % b != 0);
            if(now + k > n + 1) k = n + 1 - now;
            pre = (pre + (LL)m * k) % (now + k - 1);
            now += k;
        }
    }
    return pre;
}

　　

　　

其他

1.祖传头文件

#include <iostream>
#include <cstring>
#include <stdio.h>
#include <algorithm>
#include <queue>
#include <vector>
#include <iomanip>
#include <math.h>
#include <map>
using namespace std;
#define FIN     freopen("input.txt","r",stdin);
#define FOUT    freopen("output.txt","w",stdout);
#define INF     0x3f3f3f3f
#define INFLL   0x3f3f3f3f3f3f3f
#define lson    l,m,rt<<1
#define rson    m+1,r,rt<<1|1
typedef long long LL;
typedef pair<int, int> PII;

　　

2.大数

const int MX = 2500;
const int MAXN = 9999;
const int DLEN = 4;
/*已重载>+-  % 和print*/
class Big {
public:
    int a[MX], len;
    Big(const int b = 0) {
        int c, d = b;
        len = 0;
        memset(a, 0, sizeof(a));
        while(d > MAXN) {
            c = d - (d / (MAXN + 1)) * (MAXN + 1);
            d = d / (MAXN + 1);
            a[len++] = c;
        }
        a[len++] = d;
    }
    Big(const char *s) {
        int t, k, index, L, i;
        memset(a, 0, sizeof(a));
        L = strlen(s);
        len = L / DLEN;
        if(L % DLEN) len++;
        index = 0;
        for(i = L - 1; i >= 0; i -= DLEN) {
            t = 0;
            k = i - DLEN + 1;
            if(k < 0) k = 0;
            for(int j = k; j <= i; j++) {
                t = t * 10 + s[j] - ‘0‘;
            }
            a[index++] = t;
        }
    }
    Big operator/(const int &b)const {
        Big ret;
        int i, down = 0;
        for(int i = len - 1; i >= 0; i--) {
            ret.a[i] = (a[i] + down * (MAXN + 1)) / b;
            down = a[i] + down * (MAXN + 1) - ret.a[i] * b;
        }
        ret.len = len;
        while(ret.a[ret.len - 1] == 0 && ret.len > 1) ret.len--;
        return ret;
    }
    bool operator>(const Big &T)const {
        int ln;
        if(len > T.len) return true;
        else if(len == T.len) {
            ln = len - 1;
            while(a[ln] == T.a[ln] && ln >= 0) ln--;
            if(ln >= 0 && a[ln] > T.a[ln]) return true;
            else return false;
        } else return false;
    }
    Big operator+(const Big &T)const {
        Big t(*this);
        int i, big;
        big = T.len > len ? T.len : len;
        for(i = 0; i < big; i++) {
            t.a[i] += T.a[i];
            if(t.a[i] > MAXN) {
                t.a[i + 1]++;
                t.a[i] -= MAXN + 1;
            }
        }
        if(t.a[big] != 0) t.len = big + 1;
        else t.len = big;
        return t;
    }
    Big operator-(const Big &T)const {
        int i, j, big;
        bool flag;
        Big t1, t2;
        if(*this > T) {
            t1 = *this;
            t2 = T;
            flag = 0;
        } else {
            t1 = T;
            t2 = *this;
            flag = 1;
        }
        big = t1.len;
        for(i = 0; i < big; i++) {
            if(t1.a[i] < t2.a[i]) {
                j = i + 1;
                while(t1.a[j] == 0) j++;
                t1.a[j--]--;
                while(j > i) t1.a[j--] += MAXN;
                t1.a[i] += MAXN + 1 - t2.a[i];
            } else t1.a[i] -= t2.a[i];
        }
        t1.len = big;
        while(t1.a[t1.len - 1] == 0 && t1.len > 1) {
            t1.len--;
            big--;
        }
        if(flag) t1.a[big - 1] = 0 - t1.a[big - 1];
        return t1;
    }
    int operator%(const int &b)const {
        int i, d = 0;
        for(int i = len - 1; i >= 0; i--) {
            d = ((d * (MAXN + 1)) % b + a[i]) % b;
        }
        return d;
    }
    Big operator*(const Big &T) const {
        Big ret;
        int i, j, up, temp, temp1;
        for(i = 0; i < len; i++) {
            up = 0;
            for(j = 0; j < T.len; j++) {
                temp = a[i] * T.a[j] + ret.a[i + j] + up;
                if(temp > MAXN) {
                    temp1 = temp - temp / (MAXN + 1) * (MAXN + 1);
                    up = temp / (MAXN + 1);
                    ret.a[i + j] = temp1;
                } else {
                    up = 0;
                    ret.a[i + j] = temp;
                }
            }
            if(up != 0) {
                ret.a[i + j] = up;
            }
        }
        ret.len = i + j;
        while(ret.a[ret.len - 1] == 0 && ret.len > 1) ret.len--;
        return ret;
    }
    void print() {
        printf("%d", a[len - 1]);
        for(int i = len - 2; i >= 0; i--) printf("%04d", a[i]);
    }
};

　　

时间： 2024-10-11 02:29:01

模板整理 (施工中 2017.8.21更新)的相关文章

常用STL整理 (施工中)

1.vector 构造 vector <int> v; 基本操作 v.begin() //指向迭代器中第一个元素. v.end() //指向迭代器中末端元素的下一个,指向一个不存在元素. v.push_back(elem) //在尾部加入一个数据. v.pop_back() //删除最后一个数据. v.capacity() //vector可用空间的大小. v.size() //返回容器中数据个数. v.empty() //判断容器是否为空. v.front() //传回第一个数据. v.ba

2017.1.21总结

---恢复内容开始--- 今天写了2道题,一道p1227 一道p1919 p1227原题: 给出一有向图,图中每条边都被标上了关系运算符'<','>','='.现在要给图中每个顶点标上一个大于等于0,小于等于k的某个整数使所有边上的符号得到满足.若存在这样的k,则求最小的k,若任何k都无法满足则输出NO. 例如下表中最小的k为2. 结点1>结点2结点2>结点3结点2>结点4结点3=结点4 如果存在这样的k,输出最小的k值:否则输出'NO'. 这道题是差分约束+拓扑排序题目,需

【我的书】Unity Shader的书 — 文件夹（2015.12.21更新）

写在前面 感谢全部点进来看的朋友.没错.我眼下打算写一本关于Unity Shader的书. 出书的目的有以下几个: 总结我接触Unity Shader以来的历程,给其它人一个借鉴.我非常明确学Shader的艰难,在群里也见了非常多人提出的问题. 我认为学习Shader还是一件有规律可循的事情,但问题是中文资料难觅,而大家又不愿意去看英文...这对我有什么优点呢?强迫我对知识进行梳理,对细节问题把握更清楚. 第二个原因你懂的. 关于本书的定位问题: 面向Unity Shader刚開始学习的人,但要

Exchange Server 服务器2017年最新更新

2017年3月20日Exchange 2007--2016各个版本已经发布的更新补丁. 具体的各个版本的下载路径如下: Exchange Server 2016 Cumulative Update 5 (KB4012106), Download, UM Lang Packs Exchange Server 2013 Cumulative Update 16 (KB4012112), Download, UM Lang Packs Exchange Server 2010 Service Pack

Kubernetes集群中Service的滚动更新

Kubernetes集群中Service的滚动更新 二月 9, 2017 0 条评论 在移动互联网时代,消费者的消费行为已经"全天候化",为此,商家的业务系统也要保持7×24小时不间断地提供服务以满足消费者的需求.很难想像如今还会有以"中断业务"为前提的服务系统更新升级.如果微信官方发布公告说:每周六晚23:00~次日凌晨2:00进行例行系统升级,不能提供服务,作为用户的你会怎么想.怎么做呢?因此,各个平台在最初设计时就要考虑到服务的更新升级问题,部署在Kubern

母函数入门笔记（施工中&hellip;

定义:对于一个数列,它的母函数(即生成函数)为   为了对这个准确求值,我们设    举一个简单的例子 例1 对于数列 他的生成函数为 ,那么应用一下等比数列求和公式 这里由于 所以当时 那么   例2 对于数列 生成函数 就是上面那个的比例系数放大到b 那么就是 例3 对于数列 生成函数 就是比例系数放大到 可以得出 类比可以得到   例4 然后是一个很鬼的 对于数列求生成函数 我们考虑这个东西是在无限定义下的 所以等价于 例5 然后是一个稍微麻烦点的 对于数列求生成函数   然后为了把这个东

The C Programming Language(K&R) 扣细节随记（施工中...

各种糟糕,入坑这么久才开始看K&R的The C Programming Language学C,而且还是为了应付开学某场滚回本体的考试(虽然觉着即使复习了还会被各种吊打),废话不多说,开始施工.? ? |--> 导言 整数除法会执行舍位,故要先乘后除. 数据类型: 关键字 位长(字节) 范围 格式化字符串 char 1 bytes -128..127(或0..255,与体系结构相关) ?%c unsigned char 1bytes 0..255 ?%c,?%hhu signed char 1

C++的标准模板库STL中实现的数据结构之顺序表vector的分析与使用

摘要 本文主要借助对C++的标准模板库STL中实现的数据结构的学习和使用来加深对数据结构的理解.即联系数据结构的理论分析和详细的应用实现(STL),本文是系列总结的第一篇,主要针对线性表中的顺序表(动态数组)STL vector进行分析和总结. 引言 因为前段时间对台大的机器学习基石和技法课程进行了学习,发如今详细的实现中经常涉及到各种类型的数据结构,比方线性表.二叉树.图等,在使用这些数据结构时感到有些吃力.主要是对一些主要的数据结构理解的不够.所以趁着暑假假期.近期一段时间总会抽出时间复习一

2017/1/21 上午活动

2017/1/21 上午       from高嘉怡 用开源飞控套件做一架Mini四轴飞行器 http://www.chuangkoo.com/project/48 材料清单 1.MWC飞控)*1                    82元/件 https://item.taobao.com/item.htm?spm=a1z10.3-c-s.w4002-2963753174.64.yQPiw8&id=18839984356 2.720空心杯电机  黑白线*4     5.5元/个 红蓝线*4