首页 > 其他 > 详细

Note_4.9

时间：2019-04-09 23:04:47      阅读：147      评论：0      收藏：0      [点我收藏+]

2019/4/9 奇奇怪怪的笔记



关于代码，基本上是现写的，可能连编译都过不了

因为是简单算法场，所以就很不走心了昂，/小纠结



图论相关?



最小生成树

  • prim,kruskal
  • 最小生成树的切割性质
  • 求次小生成树，动态mst
  • 根据Kruskal的贪心性质，任意两个联通块之间的最小边一定在mst中
  • 非mst一定可以通过一次换边得到权值更小的生成树。

最短路

dijkstra?

priority_queue是什么，我不知道

class dijkstra
{
    const ll MN=262144,inf=0x3f3f3f3f
    ll d[N];
    struct node{ll x;int id;}t[MN<<1];
    inline node Min(const node&x,const node&y){return x.x<y.x?x:y;}
    inline void rw(int k,ll x){for(t[k+=MN].x=x;k>>=1;)t[k]=Min(t[k<<1],t[k<<1|1]);}    inline void dij()
    {
        register int i,x;
        for(i=1;i<MN<<1;++i) t[i].x=inf;//init
        for(i=1;i<=n;++i) d[t[i+MN].id=i]=inf;//init
        for(rw(S,d[S]=0);t[1]!=inf;)
        {
            rw(x=t[1].id,inf);
            for(i=hr[x];i;i=e[i].nex)
                if(d[e[i].to]>d[x]+e[i].w) rw(e[i].to,d[e[i].to]=d[x]+e[i].w);
        }
    }
}



spfa

SLF优化是什么，我不知道

int dis[MN];
bool in[MN];
std::queue<int> q;
bool spfa()
{
    memset(dis,0x3f,sizeof dis);
    memset(in,0,sizeof in);
    reg int i,j;
    in[T]=true;q.push(T);dis[T]=0;
    while(!q.empty())
    {
        reg int u=q.front();q.pop();in[u]=false;
        for(i=hr[u];i;i=e[i].nex)
            if(dis[e[i].to]>dis[u]-e[i].c&&e[i^1].w)
            {
                dis[e[i].to]=dis[u]-e[i].c;
                if(!in[e[i].to]) in[e[i].to]=true,q.push(e[i].to);
            }   
    }
    return dis[S]!=inf;
}



floyd

复杂度\(O(n^3)\)，倍增floyd


图的联通



强联通分量

边/点双联通分量

割点、割边

圆方树

#define son e[i].to
int dfn[MN],low[MN],ind,st[MN],tp;
void tarjan(int x,int F=0)
{
    dfn[x]=low[x]=++ind;st[tp++]=x;
    reg int i;
    for(i=hr[x];i;i=e[i].nex)if(i^F^1)//防止重边的影响
        if(!dfn[son])
        {
            //如果两个点也算双联通分量的话，直接写(low[son]>=dfn[x])
            tj(son,i);low[x]=min(low[x],low[son]);
            if(dfn[x]==low[son])
            {
                ++num;ins(x,num,Hr);
                for(;st[tp]!=son;--tp) ins(num,st[tp-1],Hr);
            }
            else if(low[son]>dfn[x]) --tp,ins(x,son,Hr);
        }
        else low[x]=min(low[x],dfn[son]);
}
  • 两个圆点在圆方树上的路径，与路径上经过的方点相邻的圆点的集合，就等于原图中两点简单路径上的点集
  • 仙人掌上的最短路，圆方树上两个圆点之间权值不变，方点到子节点的边权等于父亲到它的最短路，求距离时，如果\(lca\)时方点，需要暴力转弯



网络流



dinic

\(O(EV^2)\)，显然跑不满，对于二分图求匹配这样的特殊情况，复杂度是\(O(E\sqrt V)\)

//懒得写了，反正很熟练了哇
int d[MN],q[MN],top;
bool bfs()
{
    memset(d,0,sizeof d);
    reg int i,j;
    for(d[q[i=top=1]=S]=1;i<=top;++i)
        for(j=hr[q[i]];i;i=e[i].nex)
            if(e[i].w&&!d[e[i].to])
                d[q[++top]=e[i].to]=d[q[i]]+1;
}
int dfs(int x,int f)
{
    if(x==T) return f;
    int used=0;
    for(int &i=cur[x];i;i=e[i].nex)
        if(d[e[i].to]==d[x]+1&&e[i].w)
        {
            int tmp=dfs(e[i].to,min(f-used,e[i].w));
            e[i].w-=tmp;e[i^1].w+=tmp;used+=tmp;
            if(used==f) return used;
        }
    return d[x]=-1,used;
}
int dinic()
{
    reg int maxflow=0;
    while(bfs())
    {
        memcpy(cur,hr,sizeof cur);
        maxflow+=dfs(S,inf);
    }
    return maxflow;
}



费用流spfa

\(O(\alpha VE)\)，据说\(\alpha\)平均不超过\(2\)？

//假设每条边的费用是时间，那么每次增广相当于增大走路的时间
int dis[MN];
bool in[MN];
std::queue<int> q;
bool spfa()
{
    memset(dis,0x3f,sizeof dis);
    memset(in,0,sizeof in);
    reg int i,j;
    in[T]=true;q.push(T);dis[T]=0;
    while(!q.empty())
        reg int u=q.front();q.pop();in[u]=false;
        for(i=hr[u];i;i=e[i].nex)
        {
            if(dis[e[i].to]>dis[u]-e[i].c&&e[i^1].w)
            {
                dis[e[i].to]=dis[u]-e[i].c;
                if(!in[e[i].to]) in[e[i].to]=true,q.push(e[i].to);
            }   
        }
    return dis[S]!=inf;
}
ll ans,maxflow,mincost;
bool vis[MN];
ll dfs(int x,int f)
{
    vis[x]=1;//一定要写！！！
    if(x==T) return f;
    ll used=0ll;
    reg int i;
    for(i=hr[x];i;i=e[i].nex)
        if(e[i].w&&dis[e[i].to]==dis[x]-e[i].c&&!vis[e[i].to])//!vis一定要写！！
        {
             ll w=dfs(e[i].to,min(e[i].w,f-used));
            mincost+=w*e[i].c;
             e[i].w-=w;e[i^1].w+=w;used+=w;
            if(used==f) return f;
        }
    return used;
}
void flow(int N,int K)
{
    for(;spfa();)
    {
        do{
            memset(vis,0,sizeof vis);//每次清0
            maxflow+=dfs(S,inf);
        }while(vis[T]);
    }
}



最小割树

//省去dinic部分
void clear(){for(reg int i=2;i<en;i+=2)e[i].w=e[i^1].w=(e[i].w+e[i^1].w)>>1;}
//因为是无向的图所有一开始正向反向边都有容量
void Build(int *id, int n)
{
    if(n==1) return;
    static int s[MN],t[MN];int cnts=0,cntt=0;
    int cut=dinic(id[0],id[1]);
    ins(id[0],id[1],cut,Hr,E,En);
    for(reg int i=0;i<n;++i)
        if(d[id[i]]) s[cnts++]=id[i];
        else t[cntt++]=id[i];
    memcpy(id,s,cnts<<2);
    memcpy(id+cnts,t,cntt<<2);
    if(cnts) Build(id,cnts);
    if(cntt) Build(id+cnts,cntt);
}



带上下界的网络流？

咕咕咕



树相关



树分治？

不会边分治的蒟蒻。。。

随便放几道题算了：1. 长链剖分 2. 点分治 3. 点分树



LCA?

树剖,倍增

RMQ

int pos[MN],fpos[MN<<2],st[MN<<2][20];//欧拉序,反欧拉序,st表
int dis(int x,int y)
{
    if(pos[x]>pos[y]) std::swap(x,y);
    reg int k=lg[pos[y]-pos[x]+1];
    return fpos[min(st[pos[x]][k],st[pos[y]-(1<<k)+1][k])];
}
void dfs(int x,int fa=0)
{
    pos[x]=++ind;fpos[ind]=x;st[ind][0]=ind;reg int i;
    for(i=hr[x];i;i=e[i].nex)if(e[i].to^fa)
        dfs(e[i].to,x),st[++ind][0]=pos[x];
}
inline void pre_work()
{
    reg int i,j;dfs(1);
    for(lg[0]=-1,i=1;i<(MN<<2);++i)lg[i]=lg[i>>1]+1;//注意是MN<<2
    for(j=1;j<20;++j)for(i-1;i+(1<<j)-1<=ind&&i<=ind;++i)
        st[i][j]=min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
}



动态树？ ，prufer编码？， 跳转到前天的笔记



欧拉回路

(偷偷把原来写的东西搬上来。。。)

  1. 判定

    有向图：所有点连通，且入度都等于出度
    无向图：所有点连通，且度数为偶数
    欧拉回路删掉一条边就是欧拉路径
    欧拉路径：有且只有两个不符合欧拉回路要求的点，并且相连后就满足了

  2. 算法

    求欧拉路径就把不满足的点连起来,求欧拉回路后删掉这条边就好了

    无向图

    dfs，标记走过的边以及反边，走过就不走

    每次回溯时记录边，这些边依次构成欧拉回路

    有向图

    边反向

    和无向图差不多

    然后可以当前弧优化

  3. 正确性

    除了第一个点外,其它的点dfs是一定是入边出边成对出现
    所以第一次加入答案的边一定是第一个点的入边
    回溯时这个点又会多走一条出边，那么下次加入的一定是又是这个点的入边
    归纳下去，一定会形成一条回路

namespace undir
{
    inline void ins(int u,int v);//略略略
    int de[MN],st[MN],top,mark[MN<<1]; 
    void dfs(int u)
    {
        for(int &i=hr[u];i;i=e[i].nex)if(!mark[i])
        {
            mark[i]=mark[i^1]=1;int j=i;dfs(e[i].to);//反边反边！
            st[++top]=j&1?((j-1)>>1):j>>1; 
        }
    }
    void solve();//包括读入，判定，略略略
}
namespace dir
{
    inline void ins(int u,int v);//略略略
    int ind[MN],outd[MN],st[MN],top,mark[MN];
    void dfs(int u)
    {
        for(int &i=hr[u];i;i=e[i].nex)if(!mark[i])
        {
            mark[i]=1;int j=i;
            dfs(e[i].to);st[++top]=j-1;
        }
    }
    void solve();
}



匈牙利算法

KM算法是什么，我不知道

核心是找到一个起点和终点都在同一个集合的增广路径，路径上相邻的两条边中恰有一个在匹配中

int ans,bel[MN];
bool vis[MN];
bool find(int x)
{
    for(int i=hr[x];i;i=e[i].nex)
        if(!vis[e[i].to])
        {
            vis[e[i].to]=true;
            if(bel[e[i].to]==-1||find(bel[e[i].to])) return bel[e[i].to]=x,1;
        }
    return 0;
}
void Main()
{
    for(int i=0;i<n;++i)
    {
        memset(vis,0,sizeof vis);
        if(find(i)) ++ans;
    }
}





字符串什么的



KMP

找到最大的前缀等于后缀，\(=\)最大的\(border\)

int nex[MN];
void KMP(char *s,int len)
{
    int i,k=0;
    for(nex[1]=0,i=2;i<=len;++i)
    {
        while(k&&s[k+1]!=s[i])k=nex[k];
        if(s[k+1]==s[i]) nex[i]=++k;
        else nex[i]=0;
    }
}
int March(char *s,int lens,char *t,int lent)
{
    int i,k=0,tot;
    for(i=1;i<=lent;++i)
    {
        while(k&&s[k+1]!=t[i]) k=nex[k];
        if(s[k+1]==t[i]) ++k;
        if(k==lens) ++tot,k=nex[k];//match!
    }
    return tot;
}



Z算法

和manacher类似的算法

\(z[i]\)表示\(s[i...]\)和原串的LCP

已知\(z[1...i-1]\)，求\(z[i]\)

定义\(r[i]=i+z[i]\)，即 \(i\) 后缀和原串的 LCP 在 \(i\) 后缀中的结束位置加\(1\)。

  • 考虑 \(1\) 到 \(i-1\) 中 \(r[k]\) 最大的 \(k\)，分成三种情况：
  1. \(i ≥ r[k]\)：令 \(z[i] = 0\)，往后暴力匹配，更新 \(k\) 为 \(i\)。
  2. \(i < r[k]\) 且 \(r[i-k+1] < z[k]\)：\(z[i] = z[i-k+1]\)。
  3. \(i < r[k]\) 且 \(r[i-k+1] ≥ z[k]\)：令 \(z[i] = r[k] - i\)，往后暴力匹配，更新 \(k\) 为 \(i\)。

均摊 \(O(n)\)。

考虑做字符串匹配，令\(C=B+\)‘#‘\(+A\)，求\(z\)数组，看哪些后缀的\(z\)值等于\(len_B\)

void Z()
{
    z[1]=0;r[1]=1;
    int i,k=1;
    for(i=2;i<=N;++i)
    {
        if(r[k]<=i) z[i]=1;
        else z[i]=min(r[k]-i,z[i-z[k]+1]);
        while(i+z[i]<=N&&s[1+z[i]]==s[i+z[i]]) ++z[i];
        r[i]=i+z[i];
        if(r[i]>=r[k]) k=i;
    }
}



AC自动机

class AC_automaton{
    private:
        int tr[N][26],cnt,e[N],fail[N];
    public:
        void insert(char *s)
        {
            int p=0;
            for(int i=0;s[i];i++)
            {
                int k=s[i]-'a';
                if(!tr[p][k])tr[p][k]=++cnt;
                p=tr[p][k];
            }
            e[p]++;
        }
        void build()
        {
            queue<int>q;
            memset(fail,0,sizeof(fail));
            for(int i=0;i<26;i++)if(tr[0][i])q.push(tr[0][i]);
            while(!q.empty())
            {
                int k=q.front();q.pop();
                for(int i=0;i<26;i++)
                    if(tr[k][i])
                        fail[tr[k][i]]=tr[fail[k]][i],q.push(tr[k][i]);
                    else tr[k][i]=tr[fail[k]][i];
            }
        }
        int query(char *t)
        {
            int p=0,res=0;
            for(int i=0;t[i];i++)
            {
                p=tr[p][t[i]-'a'];
                for(int j=p;j&&~e[j];j=fail[j])res+=e[j],e[j]=-1;
            }
            return res;
        }
}ac;



SA

为什么我的\(SA\)这么长啊啊啊

class SA
{
    private:
        int height[MN][19],p,q,sa[2][MN],rk[2][MN],num[MN];
    public:
        SA(){M(height);M(sa);M(rk);M(num);}
        inline void init(){M(height);M(sa);M(rk);M(num);}
        inline void build_sa()
        {
            register int i,j,k,mx;
            for(i=1;i<=n;++i) num[s[i]-'a'+1]++;
            for(i=1;i<=26;++i) num[i]+=num[i-1];
            for(i=1;i<=n;++i) sa[1][num[s[i]-'a'+1]--]=i;
            for(i=1;i<=n;++i) rk[1][sa[1][i]]=rk[1][sa[1][i-1]]+(s[sa[1][i-1]]!=s[sa[1][i]]);
            mx=rk[1][sa[1][n]];
            for(p=1,q=0,k=1;k<=n;k<<=1,p^=1,q^=1)
            {
                if(mx==n) break;
                for(i=1;i<=n;++i) num[rk[p][sa[p][i]]]=i;
                for(i=n;i;--i) if(sa[p][i]>k) sa[q][num[rk[p][sa[p][i]-k]]--]=sa[p][i]-k;
                for(i=n-k+1;i<=n;++i) sa[q][num[rk[p][i]]--]=i;
                for(i=1;i<=n;++i)
                    rk[q][sa[q][i]]=rk[q][sa[q][i-1]]+(rk[p][sa[q][i]]!=rk[p][sa[q][i-1]]||rk[p][sa[q][i]+k]!=rk[p][sa[q][i-1]+k]);
                mx=rk[q][sa[q][n]];
            }
            for(i=k=1;i<=n;++i)
            {
                if(rk[p][i]==1) continue;if(k) k--;
                for(j=sa[p][rk[p][i]-1];j+k<=n&&i+k<=n&&s[i+k]==s[j+k];++k);
                height[rk[p][i]][0]=k;
            }
            for(i=1;i<=18;++i)for(j=n;j>=1&&j>(1<<i);--j)
                height[j][i]=min(height[j][i-1],height[j-(1<<i-1)][i-1]);
        }
        inline int LCP(int x,int y)
        {
            x=rk[p][x];y=rk[p][y];
            if(x>y) std::swap(x,y);
            return min(height[y][lg[y-x]],height[x+(1<<lg[y-x])][lg[y-x]]);
        }
}



SAM

核心？

  • 作为一种可以表示所有后缀的状态的自动机，它得满足状态数尽可能的小
  • SAM的做法：
    1. 每个状态表示所有\(Right\)集合相同的子串，这里\(Right\)集合的定义可是一个子串在原串中所有出现位置的右端点的集合。
    2. 对于每个状态，我们定义一个\(step\)，表示该状态所能表示的所有子串中长度最大值
    3. \(fa\)指针，满足当前串的\(Right\)集合是\(fa\)指向的状态的真子集，且是最大的那一个，可以发现，\(fa\)指针所指向的状态一定是当前状态子串的一个后缀。
    4. 在线加点，每次加点后最多只会增加两个新的状态
class Suf_Automation
{
    #define MX 2000005
    private:
        int c[MX][26],fa[MX],step[MX],v[MX],rk[MX],val[MX];
        int last,cnt,n;
        ll ans=0;
    public:
        inline void init(int len)
        {
            cnt=last=1;n=len;
            for(int i=1;i<=n<<1;++i)
            memset(c[i],0,sizeof c[i]),step[i]=fa[i]=v[i]=val[i]=0;
        }
        void Insert(int x)
        {
            int p=last,np=++cnt;step[np]=step[p]+1;val[np]=1;
            for(;p&&!c[p][x];p=fa[p]) c[p][x]=np;
            if(!p) fa[np]=1;
            else 
            {
                int q=c[p][x];
                if(step[q]==step[p]+1) fa[np]=q;
                else 
                {
                    int nq=++cnt;step[nq]=step[p]+1;
                    memcpy(c[nq],c[q],sizeof c[q]);
                    fa[nq]=fa[q];fa[np]=fa[q]=nq;
                    for(;c[p][x]==q;p=fa[p]) c[p][x]=nq;
                }    
            }
            last=np;
        }
        inline void Query()
        {
            register int i;
            for(i=1;i<=cnt;++i) ++v[step[i]];
            for(i=1;i<=n;++i) v[i]+=v[i-1];
            for(i=1;i<=cnt;++i) rk[v[step[i]]--]=i;
            for(i=cnt;i;--i)
            {
                val[fa[rk[i]]]+=val[rk[i]];
                if(val[rk[i]]>1) ans=max(ans,1ll*val[rk[i]]*step[rk[i]]);
            }
            val[1]=0;
            printf("%lld\n",ans);
        }
    #undef MX
}pac;



后缀树

咕咕咕



回文树

又称作“回文自动机”

每个节点都是一个回文串，然后\(fail\)指针维护的是它的最大的后缀回文串（同时也是前缀的）。

回文树的用处？

——by \(PinkRabbit\)

  • 统计每个本质不同回文串出现次数的。这个 Manacher 很难做到（需要配合后缀自动机），但是回文自动机可以解决。
  • 有趣的是，回文自动机可以支持前端插入呢，只需要再维护一个指向最长回文前缀的指针 \(head\)就好啦。因为回文是两边对称的呢，所以前端插入也没关系的。注意两个指针要同时更新哦。就是当前字符插完后，整个串形成回文串，那么就要更新\(head\)为当前这一端的\(fail\)

例题：APIO2014 回文串

//APIO 2014 回文串
#include<bits/stdc++.h>
#define ll long long
using namespace std;
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<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}
#define MN 300005
int fail[MN],len[MN],cnt[MN];
int c[MN][26],en;ll ans;
char s[MN];
int main()
{
    scanf("%s",s+1);
    fail[0]=1;len[++en]=-1;
    for(int i=1,j=1;s[i];++i)
    {
        while(s[i]!=s[i-len[j]-1]) j=fail[j];
        if(!c[j][s[i]-'a'])
        {
            len[++en]=len[j]+2;
            int k=fail[j];
            while(s[i]!=s[i-len[k]-1])
                k=fail[k];    
            fail[en]=c[k][s[i]-'a'];
            c[j][s[i]-'a']=en;
        }
        j=c[j][s[i]-'a'];
        ++cnt[j];
    }    
    for(int i=en;i>1;i--)    
    {
        ans=max(ans,1ll*cnt[i]*len[i]);
        cnt[fail[i]]+=cnt[i];    
    }
    printf("%lld\n",ans);
    return 0;
}



manacher

\(abcba\rightarrow a!b!c!b!a\)

记\(p[i]\)表示以\(i\)为回文中心的左右能延伸的最长长度\(+1\)

\(p[1]=1\)

\(r[i]=i+p[i]\)

考虑 \(1\) 到 \(i-1\) 中 \(r[k]\) 最大的 \(k\)，分成三种情况：

  1. \(i \geq r[k]\)，令\(p[i]=1\)，然后暴力更新，更新 \(k\) 为 \(i\)。
  2. \(i < r[k]\)&&\(p[2*k-i]<r[k]-i\)，\(p[i]=p[2*k-i]\)
  3. \(i<r[k]\)&&\(p[2*k-i]\geq r[k]-i\)，令\(p[i]=r[k]-i\)，然后暴力更新，更新 \(k\) 为 \(i\)。
 for(k=p[1]=1,i=r[1]=2;i<=m;++i)
 {
     if(r[k]<=i) p[i]=1;
     else p[i]=min(p[k*2-i],r[k]-i);
     for(;s[i+p[i]]==s[i-p[i]];++p[i]);
     r[i]=p[i]+i;r[i]>r[k]?k=i:0;p[i]-1>ans?ans=p[i]-1:0;
 }



后缀平衡树？咕咕咕





Blog来自PaperCloud，未经允许，请勿转载，TKS！

Note_4.9

原文：https://www.cnblogs.com/PaperCloud/p/10680338.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！