板子QWQ（考前复习）

最新推荐文章于 2024-05-11 18:26:23 发布
置顶 最新推荐文章于 2024-05-11 18:26:23 发布
阅读量372 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbbblzy/article/details/78495973
版权

LCA（倍增）

//LCA板子（倍增） 
//queue<int>q
//d[]表示深度 
//fa[i][j]表示i向上跳2^j步的节点 
void bfs()
{
    q.push(1);
    d[1]=1;
    while(q.size())
    {
        int x=q.front();q.pop();
        for(int i=link[x];i;i=e[i].next)
        {
            int y=e[i].y;
            if(d[y]) continue;
            d[y]=d[x]+1;
            fa[y][0]=x;
            for(int j=1;j<=17;++j) fa[y][j]=fa[fa[y][j-1]][j-1];
            q.push(y);
        }
    }
} 

int lca(int x,int y)
{
    if(d[x]<d[y]) swap(x,y);
        for(int i=0,h=d[x]-d[y];i<=18&&h;++i) if(h&(1<<i)) x=fa[x][i];

    if(x==y) return x;
    for(int i=17;i>=0;--i)
        if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}

SPFA

//SPFA板子QAQ
//dis[]表示单源点到各点的距离
// vis[]标记是否被访问过
//q[]用数组模拟队列
//st表示单源点
void SPFA()
{
    memset(dis,10,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[st]=0;vis[st]=1;q[1]=st;
    head=0;tail=1;
    while(head<tail)
    {
        int x=q[++head];vis[x]=0;
        for(int i=link[x];i;i=e[i].next)
        {
            int y=e[i].y;
            if(dis[x]+e[i].v<dis[y])
            {
                dis[y]=dis[x]+e[i].v;
                if(!vis[y])
                {
                    q[++tail]=y;
                    vis[y]=1;
                }
            }
        }
    }
}

快读0.0

int read()
{
    int sum=0,flag=1;
    char c;
    for(;c<'0'||c>'9';c=getchar())if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())sum=(sum<<1)+(sum<<3)+c-'0';
    return sum*flag;
}

并查集

for(int i=1;i<=n;++i) fa[i]=i;

int getfather(int v)
{
    if(fa[v]==v) return v;
    fa[v]=getfather(fa[v]);
    return fa[v];
}

bool unionn(int x,int y)
{
    int fx,fy;
    fx=getfather(x);
    fy=getfather(y);
    fa[fx]=fy;
}

bool judge(int x,int y)
{
    int fx,fy;
    fx=getfather(x);
    fy=getfather(y);
    return(fx==fy);
}

弗洛伊德

void floyed()
{
    for(int k=1;k<=n;++k)
    for(int i=1;i<=n;++i)
    for(int j=1;j<=n;++j)
        if(dis[i][k]+dis[k][j]<dis[i][j])
            dis[i][j]=dis[i][k]+dis[k][j];
}

dfs（邻接表）

void dfs(int k)
{
    for(int i=link[k];i;i=e[i].next)
    if(!vis[e[i].y])
    {
        vis[e[i].y]=1;
        dfs(e[i].y);
    }
}

bfs（邻接表）

void bfs(int k)
{
    int head=0,tail=1;
    q[1]=k;
    while(head++<tail)
    {
        for(int i=link[q[head]];i;i=e[i].next)
        if(!vis[e[i].y])
        {
            vis[e[i].y]=1;
            q[++tail]=e[i].y;
        }
    }
}

线性筛求素数

void getprime(int x)
{
    memset(isprime,true,sizeof(isprime));
    for(int i=2;i<=x;++i)
        if(isprime[i])
            for(int j=i+i;j<=x;j+=i)
                isprime[j]=false;
}

KMP（我压KMP）

void yuchuli()
{
    next[0]=-1;
    int j=-1;
    for(int i=0;i<b.size();++i)
    {
        while((j>=0)&&(b[j+1]!=b[i])) j=next[j];
        if(b[j+1]==b[i]) j++;
        next[i]=j;
    }
} 

void KMP()
{
    int j=-1;
    for(int i=0;i<a.size();++i)
    {
        while((j>-1)&&b[j+1]!=a[i]) j=next[j];
        if(b[j+1]==a[i]) j++;
        if(j==b.size()-1)
        {
            cout<<i-m;//输出位置
            tot++;//统计出现的次数
            j=next[j]; 
        }
    }
}

矩阵乘法(以斐波那契数列为例)

#include<bits/stdc++.h> 
using namespace std;
struct matrix
{
   int num[2][2];
matrix()
{
     num[0][0]=num[0][1]=num[1][0]=1;
     num[1][1]=0;
}
};
 //¾ØÕóµÄ³Ë·¨
matrix multi(matrix a,matrix b)
{
   matrix temp;
   for(int i = 0; i < 2; i++)
     for(int j = 0; j < 2; j++)
     {
       temp.num[i][j] = 0;
       for(int k = 0; k < 2;k++)
            temp.num[i][j] += a.num[i][k]*b.num[k][j]; 
       temp.num[i][j] %= 10000;//×¢ÊÍ1
     }
   return temp;
 }
 //¾ØÕóµÄn´ÎÃÝ
 matrix power(int n)
 {
   matrix temp,s;
   temp.num[1][0] = temp.num[0][1] = 0;
   temp.num[1][1] = 1;//°Ñtemp»¯³Éµ¥Î»¾ØÕó
   while(n != 0)
   {
     if(n & 1)
       temp = multi(temp,s);
     n = n /2;
     s = multi(s,s);
   }
   return temp;
 }
 int main()
 {
   int n;
   while(cin >> n && n != -1)
   {
     matrix ans = power(n);
     cout << ans.num[1][0] << endl;
   }
 }

拓扑排序

void topsort()
{
    head=0;tail=1;
    for(int i=1;i<=n;++i) if(in[i]==0) q[++tail]=i;
    while(head<tail)
    {
        head++;
        for(int i=1;i<=n;++i)
            if(a[q[head]][i])
            {
                in[i]--;
                if(in[i]==0) q[++tail]=i;
            }
    }
}

Dinic

//By Bibi
///                 .-~~~~~~~~~-._       _.-~~~~~~~~~-.
///             __.'              ~.   .~              `.__
///           .'//                  \./                  \\`.
///        .'//                     |                     \\`.
///       .'// .-~"""""""~~~~-._     |     _,-~~~~"""""""~-. \\`.
///     .'//.-"                 `-.  |  .-'                 "-.\\`.
///   .'//______.============-..   \ | /   ..-============.______\\`.
/// .'______________________________\|/______________________________`.
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define dep(i,a,b) for(int i=a;i>=b;--i)
using namespace std;
const int MAXN=500010;
const int INF=1<<29;
int read(){
    int sum=0,flag=1;
    char c;
    for(;c<'0'||c>'9';c=getchar())if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())sum=(sum<<1)+(sum<<3)+c-'0';
    return sum*flag;
}
int fd;
bool check=true;
struct edge{
    int y,next,v;
}e[MAXN<<1];
int link[MAXN];
int tot=1;
int n,m;
int d[MAXN];
int ans;
int head,tail,q[MAXN];
void insert(int x,int y,int z){
    e[++tot].next=link[x];e[tot].v=z;e[tot].y=y;link[x]=tot;
    e[++tot].next=link[y];e[tot].v=0;e[tot].y=x;link[y]=tot;
} 
void init(){
    m=read();n=read();
    int x,y,z; 
    for(int i=1;i<=m;++i){
        x=read();y=read();z=read();
        insert(x,y,z);
    }
}
void bfs(){
    memset(d,-1,sizeof(d));
    head=tail=0;
    q[++tail]=1;d[1]=0;
    while(head<tail){
        int k=q[++head];
        for(int i=link[k];i;i=e[i].next)
            if(e[i].v&&d[e[i].y]<0){
                d[e[i].y]=d[k]+1;
                q[++tail]=e[i].y;
            }
    }
    if(d[n]!=-1) check=true;
}
int dfs(int k,int l){
    if(k==n) return l;
    int maxl=0;
    for(int i=link[k];i&&maxl<l;i=e[i].next){
        if(d[e[i].y]==d[k]+1&&e[i].v){
            if(fd=dfs(e[i].y,min(e[i].v,l-maxl))){
            maxl+=fd;
            e[i].v-=fd;
            e[i^1].v+=fd;
            }
        }
    }
    if(!maxl) d[k]=-1;
    return maxl;
}
void dinic(){
    while(check){
    check=false;
    bfs();
    if(!check) break;
    while(fd=dfs(1,INF)) ans+=fd;
    }
}
int main(){
    init();
    dinic();
    printf("%d\n",ans );
    return 0;
}

zkw费用流

//By Bibi
///                 .-~~~~~~~~~-._       _.-~~~~~~~~~-.
///             __.'              ~.   .~              `.__
///           .'//                  \./                  \\`.
///        .'//                     |                     \\`.
///       .'// .-~"""""""~~~~-._     |     _,-~~~~"""""""~-. \\`.
///     .'//.-"                 `-.  |  .-'                 "-.\\`.
///   .'//______.============-..   \ | /   ..-============.______\\`.
/// .'______________________________\|/______________________________`.
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define dep(i,a,b) for(int i=a;i>=b;--i)
using namespace std;
const int INF=0x7ffffff;
const int MAXN=15010;
int read(){
    int sum=0,flag=1;
    char c;
    for(;c<'0'||c>'9';c=getchar())if(c=='-') flag=-1;
    for(;c>='0'&&c<='9';c=getchar())sum=(sum<<1)+(sum<<3)+c-'0';
    return sum*flag; 
}
int n,m;
int link[MAXN],tot=1;
int vis[MAXN];
int dis[MAXN];
int fd;
int ans1,ans2;
struct edge{
    int y,v,next,cost;
}e[MAXN<<1];
void insert(int x,int y,int v,int cost){
    e[++tot].next=link[x];e[tot].y=y;e[tot].v=v;e[tot].cost=cost;link[x]=tot;
    e[++tot].next=link[y];e[tot].y=x;e[tot].v=0;e[tot].cost=-cost;link[y]=tot;
}
void init(){
    n=read();m=read();
    int x,y,v,z;
    rep(i,1,m){
        x=read();y=read();v=read();z=read();
        insert(x,y,v,z);
    }
}
int q[MAXN],head,tail;
bool SPFA(){
    memset(vis,0,sizeof vis);
    memset(dis,0x7f,sizeof dis);
    dis[n]=0;vis[n]=1;
    head=tail=0;q[++tail]=n;
    while(head<tail){
        int x=q[++head];
        for(int i=link[x];i;i=e[i].next){
            int y=e[i].y;
            if(e[i^1].v&&dis[y]>dis[x]-e[i].cost){
                dis[y]=dis[x]-e[i].cost;
                if(!vis[y]){
                    vis[y]=1;
                    int t=head+1;
                    if(head<tail&&dis[y]<dis[t]) q[head--]=y;else q[++tail]=y;
                }
            }
        }
        vis[x]=0;
    }
    return dis[1]<INF;
}
int dfs(int x,int l){
    if(x==n) {vis[n]=1;return l;}
    int maxl=0;
    vis[x]=1;
    for(int i=link[x];i;i=e[i].next){
        int y=e[i].y;
        if(!vis[y]&&e[i].v&&dis[x]-e[i].cost==dis[y]){
            if(fd=dfs(y,min(e[i].v,l-maxl))){
                maxl+=fd;
                e[i].v-=fd;
                e[i^1].v+=fd;
                ans2+=fd*e[i].cost;
            }
            if(l==maxl) break;
        }
    }
    return maxl;
}
void costflow(){
    while(SPFA()){
        vis[n]=1;
        while(vis[n]){
            memset(vis,0,sizeof vis);
            ans1+=dfs(1,INF);
        }
    }
}
int main(){
    init();
    costflow();
    printf("%d %d\n",ans1,ans2 );
    return 0;
}

To be continued……

bbbblzy
关注
QwQ 嵌入式系统复习第四章
qq_42783498的博客
11-16 472
第一讲 ARM指令集与编程
QwQ嵌入式系统复习第二章
qq_42783498的博客
11-16 322
第一节 嵌入式系统硬件基础 第二节 嵌入式系统软件基础 第三节 嵌入式操作系统 第四节 嵌入式系统设计方法
LCA 板子（最近公共祖先）
m0_51448653的博客
07-27 317
3、遍历子节点时，如果depth大于更新，说明没有被搜索过，更新depth，放入队列，更新fa数组，fa[v][0]就是它的2^0也就是父节点，然后循环k[1,15]更新fa。4、否则，x和y一起往上跳，k[15,0]，结果是要一起跳到lca的下一层；如果x和y的2^k辈祖先不相同，则跳；2、x往上跳，k[15,0]，二进制拼凑，如果x跳了当前的k还是大于等于y的深度，就跳，否则不跳且continue。3、现在x和y同一深度了，如果x=y，说明y是x和y的lca，returnx。1、假设x是更深的那个。..
LCA板子
weixin_75192140的博客
10-23 63
【代码】LCA板子。
板子 lca
sophilex的博客
04-16 239
模板题 tarjan做法： #include<bits/stdc++.h> using namespace std; #define ll long long const ll N=500010; struct ty{ ll t,next; }edge[N<<1]; ll cnt1=0; ll head[N]; ll n,m,s; ll a,b; template<typename Type>inline void read(Type &xx) {
lca板子
qq_51379351的博客
08-06 292
#include<bits/stdc++.h> using namespace std; const int N=5e5+10; int head[N]; int n,m,s,f[N][30],lg[N],h[N]; ///该结点的深度 ///f[i][j]为i结点向上2^j的祖先 struct node { int to,ne; }bian[N*2]; int tot = 0; void add_edge(int x,int y) { tot++; bian[tot].to
操作系统复习的文件qwq
06-16
针对期末复习写的
QwQ 嵌入式系统复习第三章
qq_42783498的博客
11-16 304
第一节 嵌入式微处理器概述 第二节 ARM体系结构概览 第三节 ARM编程模型 第四节 ARM 异常处理
C#开发游戏程序设计大作业室内解谜qwq游戏源代码.zip
06-09
C#开发游戏程序设计大作业室内解谜qwq游戏源代码C#开发游戏程序设计大作业室内解谜qwq游戏源代码C#开发游戏程序设计大作业室内解谜qwq游戏源代码C#开发游戏程序设计大作业室内解谜qwq游戏源代码。C#开发游戏程序设计...
Tarjan----寻找最近公共祖先（LCA） 板子
最新发布
2301_77961281的博客
05-11 438
Tarjan算法的时间复杂度为O(N+Qα(N))，其中N是节点数，Q是查询数，α是Ackermann函数的反函数，通常可以认为是一个很小的常数。该算法通过深度优先搜索（DFS）遍历图，并使用并查集（Union-Find）数据结构来快速找到两个节点的最近公共祖先。否则，将其中一个节点的根节点的父节点设置为另一个节点的根节点，然后重复此过程直到找到它们的最近公共祖先。3. 对每一对查询的节点(u, v)，分别找到它们的根节点（即最终的祖先）。1. 对图进行深度优先搜索（DFS），记录每个节点的深度和父节点。
LCA板子+应用例题
谦的博客
07-21 281
来个板子 #include<iostream> #include<algorithm> #include<vector> #include<queue> #include<stack> #include<map> #include<stdio.h> #include<math.h> #include<algorithm> #include<string.h> #include<iom
LCA 板子
qq_53504307的博客
07-27 208
LCA
浅析LCA
热门推荐
夕弦
08-06 1万+
1.&amp;amp;amp;amp;nbsp;1.&amp;amp;amp;amp;nbsp;1. \ 定义 LCA（Least Common Ancestors），即最近公共祖先，指对于有根树 TTT 的两个结点 uuu 、vvv ，最近公共祖先 LCA(T,u,v)LCA(T,u,v)LCA(T, u, v) 表示一个结点 xxx, 满足 xxx 是 uuu、vvv 的祖先且 xxx 的深度尽可能大。 下面给出一个自己画的图，用来解释LCA及其算...
bzoj-1787-洛谷-4281（LCA板子题）
weixin_30904593的博客
03-23 167
传送门（bzoj） 传送门（洛谷） 可以说这道也是一个板子题 由于题中是三个人需经过的路径最短 就会有一点点不太一样 那么 就两两求LCA 这样之后就会出现两种状况 一、所得到的三个LCA是相等的 　　那毫无疑问真正的LCA的值就是这个值 二、若不是第二种情况 　　那必然会出现 　　有且仅有一个LCA的值与令两个LCA的值不同 第二种情况正确性（不严...
LCA的学习（DFS+LCA的简单板子）
永远鲜红の幼月的博客
09-05 922
最近碰到的一些题，主要问的就是LCA（最小公共祖先） 一开始是暴力，但是随着数据的增多，预感到不能继续暴力了，于是开始学习关于 最小公共祖先 的算法 网上有很多关于这方面的博客，但是很多的文章让我感觉看的云里雾里的（本人太菜），终于在浩如烟海的众多文章中找到了相对来说比较简单的一些，东拼西凑，最后总算稍微了解一点LCA算法了； 下面就介绍一下简单的LCA实现（个人觉得非常好理解）（目前我认为...
（详细）LCA板子以及入门题总结
李dayday
04-15 634
LCA算法总结 把lca题目记入下来！分享给你们 板子tarjan（离线） #define N 10005 #define M 1000005 // N 表示的树的节点 // M 表示的问题数 int cnt_e,cnt_q,head_e[N],head_q[N],vis[N],dis[N],t,ans[M],id[N],f[N]; // 边，问题数 struct node{ int ...
计算机网络选择题解析与复习重点
"计算机网络复习题" 计算机网络是信息技术领域中的核心组成部分，它涉及计算机之间的通信、数据交换以及资源共享。本资源提供了150道计算机网络的选择题，旨在帮助学习者复习和巩固相关知识。 1. 分布式系统与...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值