ACM个人零散知识点整理

杂项:

1.输入输出外挂

//读入优化 int 整数
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9') {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<= '9') {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x * f;
}

2.关闭c+++输入输出限制流

使用的时候一定放在所有cin,cout的开头,不然会导致输入的内容发生错乱

ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);

图论:

1.链式前向星模板

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6+5;
//init()
struct edgenode {
    int w,next,to;
    edgenode () {
        next=w=to=0;
    }
} edges[maxn];
int head[maxn];
int cnt=0;
//双向边调用两次即可
void addedge(int u, int v, int w) {
    edges[cnt].to=v;
    edges[cnt].w=w;
    edges[cnt].next=head[u];
    head[u]=cnt;
    cnt++;
}
//遍历
void ask(int x) {
    for(int i=head[x];i!=-1;i=edges[i].next) {

    }
}
void init() {
    memset(head,-1,sizeof(head));
}
int main() {

    return 0;
}

2.最近公共祖先

  • tarjan离线

    #include <bits/stdc++.h>
    using namespace std;
    const int maxn = 500001;
    const int maxm = 1000001;
    struct enode {
    int next,to;
    } edges[maxm];
    struct qnode {
    int next,id,to;//id第几次查询
    } que[maxm];
    int head_e[maxn];//前向星 edges
    int head_q[maxn];//前向星 查询
    int vis[maxn];
    int f[maxn];//并查集父亲数组
    int res[maxn];//结果
    int cnte=0;
    int cntq=0;
    int n,m,s;
    inline void addedge(int u, int v) {
    edges[cnte].to=v;
    edges[cnte].next=head_e[u];
    head_e[u]=cnte++;
    }
    inline void addque(int u, int v, int id) {
    que[cntq].to=v;
    que[cntq].id=id;
    que[cntq].next=head_q[u];
    head_q[u]=cntq++;
    }
    //并查集访问父亲
    int find(int x) {
    return x==f[x] ? x : f[x] = find(f[x]);//压缩
    }
    void tarjan(int s) {
    vis[s]=1;//先标记,不能在回溯时标记,因为双向边
    f[s]=s;
    for(int i=head_e[s]; i!=-1; i=edges[i].next) {
        if(!vis[edges[i].to]) {
            tarjan(edges[i].to);
            f[edges[i].to]=s;
        }
    }
    for(int i=head_q[s]; i!=-1; i=que[i].next) {
        if(vis[que[i].to]==1) {
            res[que[i].id]=find(que[i].to);
        }
    }
    }
    inline void init() {
    memset(vis,0,sizeof(vis));
    memset(head_e,-1,sizeof(head_e));
    memset(head_q,-1,sizeof(head_q));
    for(int i=1; i<=n; ++i) f[i]=i;
    }
    int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m>>s;
    init();
    int u,v;
    for(int i=1; i<n; ++i) {
        cin>>v>>u;
        addedge(v,u);
        addedge(u,v);
    }
    for(int i=1; i<=m; ++i) {
        cin>>v>>u;
        addque(u,v,i);
        addque(v,u,i);
    }
    tarjan(s);
    for(int i=1; i<=m; ++i) cout<<res[i]<<endl;
    return 0;
    }
  • ST倍增在线

    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    #include <math.h>
    using namespace std;
    const int maxn = 100005;
    struct node {
    int to,next;
    } edges[maxn<<1];
    //注意head[]数组初始化
    int head[maxn],cnt,dp[maxn][15],dep[maxn];
    void add(int u, int v) {
    edges[cnt].to=v;
    edges[cnt].next=head[u];
    head[u]=cnt++;
    }
    //节点 父亲节点
    void dfs(int s, int x) {
    dp[s][0]=x;
    dep[s]=dep[x]+1;
    int t;
    //跟新到根节点一路上的祖先
    for(int i=1; (1<<i)<=dep[x]; ++i) dp[s][i]=dp[dp[s][i-1]][i-1];
    for(int i=head[s]; i!=-1; i=edges[i].next) {
        t=edges[i].to;
        if(t==x) continue;
        dfs(t,s);
    }
    }
    int lca(int u, int v) {
    if(dep[v]>dep[u]) swap(u,v);
    for(int i=14; i>=0; --i) {
        if((dep[u]-dep[v])>=(1<<i)) {
            u=dp[u][i];
        }
    }
    //此时深度一定相同
    if(u==v) return u;
    for(int i=14; i>=0; --i) {
        if((1<<i)<=dep[u]&&dp[u][i]!=dp[v][i]) {
            u=dp[u][i];
            v=dp[v][i];
        }
    }
    //循环过程中不加判断可能会超过最近公共祖先,所以跟新到lca的儿子节点即可
    return dp[u][0];
    }
    int main() {
    int n,m,u,v;
    scanf("%d %d",&n,&m);
    cnt=0;
    memset(head,-1,sizeof(head));
    for(int i=1; i<n; ++i) {
        scanf("%d %d",&u,&v);
        add(u,v);
        add(v,u);
    }
    dep[0]=1;
    dfs(1,1);
    for(int i=1; i<=m; ++i) {
        scanf("%d %d",&u,&v);
        printf("%d\n",lca(u,v));
    }
    return 0;
    }

    数论:

    1.快速幂(矩阵快速幂略)

    int pow(int base,int num){
    int ans=1;
    while(num!=0){
        if(num&1!=0)
          ans*=base;
        base<<=1;
        b>>=1;
      }
    return ans;
    }

    2.位数公式

    x=log(n)+1//求n有多少位

    3.莫比乌斯函数

  • 在线

    ll mubi(ll n) {
    ll mu=1;
    for(ll i=2;i*i<=n;++i) {
        if(n%i==0) {
            mu*=-1;
            ll k=0;
            do {
                k++;
                if(k>1) {
                    mu=0;break;
                }
                n/=i;
            }while(n%i==0);
        }
    }
    if(n>1) mu*=-1;
    return mu;
    }
  • 离线

    mu[1]=1;
    for(i=2;i<=n;i++)
    {
    if(!not_prime[i])
    {
        prime[++tot]=i;
        mu[i]=-1;
    }
    for(j=1;prime[j]*i<=n;j++)
    {
        not_prime[prime[j]*i]=1;
        if(i%prime[j]==0)
        {
            mu[prime[j]*i]=0;
            break;
        }
        mu[prime[j]*i]=-mu[i];
    }
    }

    4.最小正整数逆元(ex_gcd)

    #include <bits/stdc++.h>
    using namespace std;
    typedef long long ll;
    ll exgcd(ll a, ll b, ll &x, ll &y) {
    if(!b) {
        x=1;y=0;return a;
    }
    ll ans=exgcd(b,a%b,x,y);
    ll temp=x;
    x=y;
    y=temp-a/b*y;
    return ans;
    }
    int main() {
    ios::sync_with_stdio(false);
    ll m,n;
    cin>>m>>n;
    ll x,y;
    exgcd(m,n,x,y);
    cout<<((x%n)+n)%n<<endl;
    return 0;
    }

ACM个人零散知识点整理的更多相关文章

  1. Android 零散知识点整理

    Android 零散知识点整理 为什么Android的更新试图操作必须在主线程中进行? 这是因为Android系统中的视图组件并不是线程安全的.通常应该让主线程负责创建.显示和更新UI,启动子线程,停 ...

  2. NDK开发-零散知识点整理

    JavaVM 标准Java平台下,每一个Process可以产生很多JavaVM对象,但在Android平台上,每一个Process只能产生一个Dalvik VM对象,也就是说在Android进程中是通 ...

  3. vue前端面试题知识点整理

    vue前端面试题知识点整理 1. 说一下Vue的双向绑定数据的原理 vue 实现数据双向绑定主要是:采用数据劫持结合发布者-订阅者模式的方式,通过 Object.defineProperty() 来劫 ...

  4. kafka知识点整理总结

    kafka知识点整理总结 只不过是敷衍 2017-11-22 21:39:59 kafka知识点整理总结,以备不时之需. 为什么要使用消息系统: 解耦 并行 异步通信:想向队列中放入多少消息就放多少, ...

  5. JSP页面开发知识点整理

    刚学JSP页面开发,把知识点整理一下. ----------------------------------------------------------------------- JSP语法htt ...

  6. JS知识点整理(二)

    前言 这是对平时的一些读书笔记和理解进行整理的第二部分,第一部分请前往:JS知识点整理(一).本文包含一些易混淆.遗漏的知识点,也会配上一些例子,也许不是很完整,也许还会有点杂,但也许会有你需要的,后 ...

  7. Android零散知识点积累

    本文仅在记录android开发中遇到的零散知识点,会不断更新... 目录 .隐藏系统标题栏 .图片尺寸及屏幕密度 3.获取顶部状态栏高度 1.隐藏系统标题栏 1)在资源文件styles.xml中定义样 ...

  8. css入门知识点整理

    css入门知识点整理 不要嘲笑我这个蒟蒻..例子来源:w3school css其实就分为两个东西,一个是选择器,另外一个是声明.声明定义了某个对象的属性的值,这都是html的内容.重点要关注的是选择器 ...

  9. activity生命周期知识点整理

    activity生命周期知识点整理 Activity: 是一个应用组件,用户可与其提供的屏幕进行交互.窗口通常会充满屏幕,但也可以小于屏幕并浮动在其他窗口之上. 一个activity的什么周期: 启动 ...

随机推荐

  1. Kotlin——最详细的接口使用、介绍

    在Kotlin中,接口(Interface)的使用和Java中的使用方式是有很大的区别.不管是接口中的属性定义,方法等.但是定义方式还是相同的. 目录 一.接口的声明 1.接口的声明 关键字:inte ...

  2. (function($){...})(jQuery)和$(document).ready(function(){}) 的区别

    (function($){...})(jQuery)  实际上是执行()(para)匿名函数,只不过是传递了jQuery对象.   立即执行函数:相当于先申明一个函数,声明完后直接调用: 用于存放开发 ...

  3. 基于Lua脚本解决实时数据处理流程中的关键问题

    摘要 在处理实时数据的过程中需要缓存的参与,由于在更新实时数据时并发处理的特点,因此在更新实时数据时经常产生新老数据相互覆盖的情况,针对这个情况调查了Redis事务和Lua脚本后,发现Redis事务并 ...

  4. SpringMVC自定义配置消息转换器踩坑总结

    问题描述 最近在开发时候碰到一个问题,springmvc页面向后台传数据的时候,通常我是这样处理的,在前台把数据打成一个json,在后台接口中使用@requestbody定义一个对象来接收,但是这次数 ...

  5. code force 401B. Game of Credit Cards

    B. Game of Credit Cards time limit per test 2 seconds memory limit per test 256 megabytes input stan ...

  6. 磁盘管理之 raid 文件系统 分区

    第1章 RAID 磁盘阵列 1.1 使用raid的目的 1)获得更大的容量 2)让数据更安全 3)读写速度更快 1.2 raid0.raid1.raid5.raid10对比 磁头 0磁道 1扇区 前4 ...

  7. ⑥bootstrap表单使用基础案例

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  8. JAVAscript学习笔记 jsDOM 第五节 (原创) 参考js使用表

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  9. PgSql on Docker with HaProxy 反向代理

    Run PgSql on Docker as Remote Db docker run -d -it \ --name pgdb \ -p 5432:5432 \ -e POSTGRES_USER=p ...

  10. 爱pia戏推出PC客户端,为您自动置顶窗口,方便查找

    爱pia戏推出PC客户端, 可以在无法使用插件的时候,使用PC客户端, 将为您自动置顶窗口,方便查看剧本. 百度网盘下载地址: 链接: http://pan.baidu.com/s/1pLpvn5p ...