2023五一外出学习整理（图论

Day1:

上午：

引入：

 对任意两个元素a，b之间关系（a，b）的取值仅为 True 或者 False，可以考虑使用图来抽象。这样我们称一个元素 a 为一个结点，（a，b）== True 则称结点 a，b 间有连边，否则 a，b 间没有连边。

 问题转化：一张奇数个点的图 G，证明存在一个点度数为偶数。

转化为更强的问题为：给定一张奇数个点的图 G，证明度数为偶数的点的个数为奇数。

（相反的问题：给定一张奇数个点的图 G，证明度数为奇数的结点的个数为偶数。）

证明：考虑所有点的度数和，由于一条边会被计算到两个结点的度数上，故其必定为偶数。（小学数学易得结论？）

 

Ex.1：首先可证 n-1 个点与除它之外 n-2 个点连边所以可连 (n-1)(n-2)/2 条边，因此可得 n 个点和至少 ((n-1)(n-2)/2)+1 条边的图是连通图。

Ex.2：

 由图可得，对于任意一个图，可将其分为若干个连通块，连通块内部各点都相连，因此其补图原来的连通块内各点于其他各连通块各点相连，因此一定是联通的。

Ex.3：

任意两边至少有一个点是重合的，即为如图：

 因此当为完全图时，每点度数>=2，因此不可能为星星，反之亦然。

Ex.4：***

Ex.5：分类讨论，

当存在度数为一的点时，删掉度数为一的点剩下的图依旧是连通图。

当不存在时，选择任意一点为起点，计算其他点与起点的距离，删掉距离起点最远的点后，图依旧为连通图。

欧拉回路和哈密顿回路：

1）考虑一个度数为奇数的点，因为它的所有邻边均要遍历恰好一次，故其必须为欧
拉路径的起点或终点。因此可以立即推出，一张存在欧拉路径的图恰好有两个度数为奇数
的点，存在欧拉回路的图没有度数为奇数的点。

2）任意两个回路，可以拼成一个大的回路。

由这两个观察可以发现，Fact 1是存在欧拉路径或者欧拉回路的充要条件。

反证法，假设没有哈密顿回路。

我们由图 G 构造出一个新的没有哈密顿回路的图 G'，具体的，令 G'=G，对于每条不在图 G 中的边，如果加入 G' 后不会产生哈密顿回路，则加入，该构造的顺序不重要。

此时我们得到了一个图 G'，再加入任何一条边都会得到一条哈密顿回路，并且由于我们仅加入了新的边，所有结点的度数任然大于等于 n/2。

假设 (v₁，v_n) 这条边不在 G' 中，我们知道必定存在一条哈密顿路径 v₁，v₂，...，v_n 考虑 (v₁，v_i) 有一条边，则 (v_i-1，v_n) 必定不能有边，否则可以构造出一条哈密顿回路。

因为这样的 v_i 至少有 n/2 个，从而这样的 v_i-1 也至少有 n/2 个，又由于 v_n 不能和自己连边，故而它至多与 n-n/2-1 个点连边，<=n/2 ，因此与定理矛盾，因此假设不成立。

Ex.6：因为两数互质，因此间隔至少为2，又因为有 n+1，个小于等于 2n 的正整数，所以显然，存在两个数互质。

Ex.7：...

Ex.8：将棋盘进行黑白染色和蓝红染色

Ex.9：Luogu P1341

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e3+5;
int n,sum,dis[N][N];
char in[N],a[N];
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-48;ch=getchar();}
    return x*f;
}

void Find(int i)
{
    for (int j=1;j<=150;j++)
    {
        if(dis[i][j]>0)
        {
            dis[i][j]--;
            dis[j][i]--;
            Find(j);
        }
    }
    a[++sum]=i;
    return ;
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++)
    {
        string s;
        cin>>s;
        dis[s[0]][s[1]]++;
        dis[s[1]][s[0]]++;
        in[s[0]]++;
        in[s[1]]++;
    }
    int h=0;
    int cnt=0;
    for (int i=1;i<=150;i++)
    {
        if(in[i] & 1)
        {
            cnt++;
            if(!h)
                h=i;
        }
    }
    if(!h)
    {
        for (int i=0;i<150;i++)
        {
            if(in[i])
            {
                h=i;
                break;
            }
        }
    }
    if(cnt && cnt!=2)
    {
        cout<<"No Solution";
        exit(0);
    }
    Find(h);
    if(sum<n+1)
    {
        cout<<"No Solution";
        exit(0);
    }
    for(int i=sum;i>=1;i--)
        cout<<a[i];
    return 0;
    //Amireux_35
}

图的储存和遍历：

 1）邻接矩阵： .........没啥可说的

2）邻接表：

vector ：

#include <vector>
vector<int> Edge[1000];
// Edge[i] 是一个一维数组，存了所有 i 能到的点
void add(int u, int v) // 插入一条 (u,v) 的边
{
    Edge[u].push_back(v);
    Edge[v].push_back(u);
}
void search(int u) // 遍历 u 的所有邻边
{
    for ( int i = 0; i < Edge[u].size(); i++ )
    //Edge[u].size() 是unsigned int，0-1=2^32-1
    {
        int v = Edge[u][i];
        //(u,v) 有一条边
        ......
    }
}

链式前向星：

int Begin[1000], Next[1000], To[1000], e;
void add(int u, int v) // 插入一条 (u,v) 的边
{
    To[++ e] = v;
    Next[e] = Begin[u];
    Begin[u] = e;
}
void search(int u)
{
    for ( int i = Begin[u]; i; i = Next[i] ) // 遍历 u 的所有邻边
    {
        int v = To[i];
        ...
    }
}

注：这是ljf的代码，本人等习惯用结构体。

Ex.10：CF 1472C

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6+5;
int T,n,a[N];
bool vis[N];
vector<int> edge[N];
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-48;ch=getchar();}
    return x*f;
}

int dfs(int u)
{
    if(u>n || vis[u])
        return 0;
    vis[u]=true;
    if(edge[u].size()==1)
        return a[u]+dfs(edge[u][0]);
    return a[u];
}

int main()
{
    T=read();
    while (T--)
    {
        int ans=0;
        n=read();
        for (int i=1;i<=n;i++)
        {
            vis[i]=false;
            edge[i].clear();
        }
        for (int i=1;i<=n;i++)
        {
            cin>>a[i];
            edge[i].push_back(i+a[i]);
        }
        for (int i=1;i<=n;i++)
            ans=max(ans,dfs(i));
        cout<<ans<<"\n";
    }
    return 0;
    //Amireux_35
}

二分图：

 显然，二分图 G 存在完美匹配的必要条件是 ιAι = ιBι

 

匈牙利算法

Ex.11：Luogu P3386

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6+5;
int n,m,p,ans,cnt,e_cnt,sum[N],dfn[N],head[N];
struct node{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

bool dfs(int u,int t)
{
    for (int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(dfn[v]!=t)
        {
            dfn[v]=t;
            if(!sum[v] || dfs(sum[v],t))
            {
                sum[v]=u;
                return true;
            }
        }
    }
    return false;
}

int main()
{
    n=read();
    m=read();
    p=read();
    for (int i=1;i<=p;i++)
    {
        int u=read();
        int v=read();
        if(u>n || v>m)
            continue;
        add(u,v);
    }
    for (int i=1;i<=n;i++)
        if(dfs(i,++cnt))
            ans++;
    cout<<ans;
    return 0;
}

Ex.12：CF 1764C

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define int long long
const int N = 1e6+5;
int T,n,a[N],sum[N];
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-48;ch=getchar();}
    return x*f;
}

signed main()
{
    T=read();
    while (T--)
    {
        int cnt=0;
        int ans=0;
        n=read();
        for (int i=1;i<=n;i++)
        {
            a[i]=read();
            sum[a[i]]++;
        }
        sort(a+1,a+1+n);
        for (int x=1;x<=n;x++)
        {
            if(a[x]==a[x-1])
                continue;
            cnt+=sum[a[x]];
            if(cnt==n)
                ans=max(ans,n/2);
            else
                ans=max(ans,cnt*(n-cnt));
        }
        cout<<ans<<"\n";
        for (int i=1;i<=n;i++)
            sum[a[i]]--;
//        memset(sum,0,sizeof sum);
    }
    return 0;
    //Amireux_35
}

一份 vector 的使用说明：

#include <vector> // 头文件
vector<int> a; // 等价于定义一个 int a[] 的数组
int a[100];
vector<int> a(100);
printf("%d\n", a.size()); // 100
a.push_back(1);
printf("%d\n", a.size()); // 101
a.push_back(x); // 在 a 的最末尾插入一个值为 x 的元素
a[i] // 访问 a 的第 i 个元素
a.size() // 返回 a 的元素个数（类型为 unsigned int）
a.pop() // 移除 a 的最末尾的元素
a.empty() // 返回 a 的 size 是否非零 (True or False)
a.resize(10) // 修改 a 的 size 为 10

下午：(树)

 基本知识：

直观上来说，树等价于没有环的连通图。

树有非常好的性质：

1）任意两点间存在唯一的路径，不存在回路。

2）树一定存在叶结点，即 deg==1 的结点。

树作为一种特殊的图，研究他的重要意义是，在这些特殊性质下，我们可以解决一些在图中无法解决的问题。------ljf

树的储存通常使用与图相同的储存方式，而遍历通常使用DFS

DFS(root, 0); // root 表示整棵树的根

void DFS(int u, int from)
{
    ......
    for ( int i = 0; i < Edge[u].size(); ++i )
    {
        int v = Edge[u][i];
        if ( v == from )
            continue ;
        DFS(v, u);
    }
    ......
}

Ex.1：CF 522A

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 401;
int n,cnt,ans,dep[N];
string a,b;
map<string,int> mp;
vector<vector<int>> g;
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-48;ch=getchar();}
    return x*f;
}

void change(string &a)
{
    int len=a.size();
    for (int i=0;i<len;i++)
    {
        if(a[i]>='A' && a[i]<='Z')
        {
            a[i]-='A';
            a[i]+='a';
        } 
    }
}

void dfs(int x)
{
    for (int i=0;i<g[x].size();i++)
    {
        int v=g[x][i];
        dep[v]=dep[x]+1;
        dfs(v);
    }
    ans=max(ans,dep[x]);
}

int main()
{
    n=read();
    g.resize(2*n+3);
    for (int i=1;i<=n;i++)
    {
        cin>>a>>b>>b;
        change(a);
        change(b);
        if(!mp.count(a))
            mp[a]=++cnt;
        if(!mp.count(b))
            mp[b]=++cnt;
        g[mp[a]].push_back(mp[b]);
    }
    for (int i=1;i<=cnt;i++)
    {
        if(!dep[i])
        {
            dep[i]=1;
            dfs(i);
        }
    }
    cout<<ans;
    return 0;
    //Amireux_35
}

Ex.2：CF 115A

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int n,ans,fa[N];
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-48;ch=getchar();}
    return x*f;
}

int Find(int x)
{
    int cnt=0;
    while (x!=-1)
    {
        x=fa[x];
        cnt++;
    }
    return cnt;
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++)
        fa[i]=read();
    for (int i=1;i<=n;i++)
        ans=max(ans,Find(i));
    cout<<ans;
    return 0;
    //Amireux_35
}

直径和重心：

称树的直径为树上最长的一条路径，树的重心为 删去这个点后，最大的子树最小

int DFS(int u, int from)
{
    int Max = 0, Maxx = 0;
    for ( int i = 0; i < Edge[u].size(); ++ i )
    {
        int v = Edge[u][i];
        if ( v == from ) continue ;
        int dis = DFS(v, u);
        if ( dis > Max ) { Maxx = Max; Max = dis; }
        else if ( dis > Maxx ) Maxx = dis;
    }
    ans = max(ans, Max + Maxx + 1);
    return Max + 1;
}

int ans = n + 1, pos = 0;
int DFS(int u, int from)
{
    int size = 1, Max = 0;
    for ( int i = 0; i < Edge[u].size(); ++ i )
    {
        int v = Edge[u][i];
        if ( v == from ) continue ;
        int x = DFS(v, u);
        size += x;
        Max = max(Max, x);
    }
    Max = max(Max, n - size);
    if ( Max < ans ) { ans = Max, pos = u; }
    return size;
}

Ex.3：CF 690C2

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int n,m,p,ans,e_cnt,dis[N],head[N];
struct node{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void dfs(int u,int frm)
{
    int Max=0;
    int Maxx=0;
    for (int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(v==frm)
            continue;
        dfs(v,u);
        int w = dis[v]+1;
        dis[u]=max(dis[u],w);
        if(w>Max)
        {
            Maxx=Max;
            Max=w;
        }
        else if (w>Maxx)
            Maxx=w;
    }
    ans=max(ans,Max+Maxx);
    }

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add(u,v);
        add(v,u);
    }
    dfs(1,0);
    cout<<ans;
    return 0;
}

 

最近公共祖先：

 倍增算法

int LCA(int u, int v)
{
    if ( dis[u] < dis[v] ) swap(u,v);
    for ( int j = 20; j >= 0; -- j )
        if ( dis[f[u][j]] >= dis[v] ) u = f[u][j];
    if ( u == v ) return u;
    for ( int j = 20; j >= 0; -- j )
        if ( f[u][j] ！= f[v][j] ) { u = f[u][j]; v = f[v][j]; }
    return f[u][0];
}
void INIT()
{
    DFS(); // 使用 DFS 处理好 f[u][0] 和 dis[u]
    for ( int j = 1; j <= 20; ++ j )
        for ( int i = 1; i <= n; ++ i )      
            f[i][j] = f[f[i][j - 1]][j - 1];
}

Tarjan算法

void DFS(int u, int from)
{
    vis[u] = true;
    for ( int i = 0; i < Edge[u].size(); ++ i )
    {
        int v = Edge[u][i];
        if ( v == from ) continue ;
        DFS(v, u);
        Merge(u, v); // 并查集
    }
    for ( int i = 0; i < query[u].size(); ++ i ) // 在 u 点的查询列表
    {
        int v = query[u][i];
        if ( vis[v] == true ) ans[u][v] = Find(v); 
        //u,v 的查询答案是Find(v)
    }
}

其它：

满二叉树是一种特殊的树，所有非叶结点都恰有两个子结点，它拥有更加优秀的性质：

Ex.4：CF 1741D

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int T,n,a[N];
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-48;ch=getchar();}
    return x*f;
}

int main()
{
    T=read();
    while (T--)
    {
        n=read();
        clear(a);
        for (int i=1;i<=n;i++)
            a[i]=read();
        int cnt=0;
        bool flag=false;
        for (int i=2;i<=n;i<<=1)
        {
            for (int j=i;j<=n;j+=i)
            {
                if(a[j-(i>>1)]>a[j])
                {
                    swap(a[j-(i>>1)],a[j]);
                    cnt++;
                }
                if(a[j-(i>>1)]+(i>>1)!=a[j])
                {
                    cout<<-1<<"\n";
                    flag=true;
                    break;
                }
            }
            if(flag)
                break;
        }
        if(flag)
            continue;
        cout<<cnt<<"\n";
    }
    return 0;
    //Amireux_35
}

/*
  你考虑根左子树的数集合是A
  右子树的数集合是B
  那么无论你左右子树内部怎么转
  这个集合是不会变的
  所以你只有可能通过根的交换
  来换A,B这两个完整的集合
  所以有解当且仅当
  A,B集合有一个全是小的数
  另外一个全是大的数
  然后递归做这个问题就行
 */

Ex.5：CF 1675D

// Problem: CF1675D Vertical Paths
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1675D
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 2e6+5;
int T,n,ans,y[N],p[N],sum[N];
bool vis[N];
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-48;ch=getchar();}
    return x*f;
}

int main()
{
    T=read();
    while (T--)
    {
        ans=0;
        n=read();
        for (int i=1;i<=n;i++)
        {
            vis[i]=false;
            y[i]=1;
        }
        for (int i=1;i<=n;i++)
        {
            p[i]=read();
            if(p[i]!=i)
                y[p[i]]=0;
        }
        for (int i=1;i<=n;i++)
            if(y[i])
                ans++;
        cout<<ans<<"\n";
        for (int i=1;i<=n;i++)
        {
            if(y[i])
            {
                int now=i;
                int cnt=0;
                while (!vis[now])
                {
                    sum[++cnt]=now;
                    vis[now]=true;
                    if(p[now]==now)
                        break;
                    now=p[now];
                }
                cout<<cnt<<"\n";
                for (int j=cnt;j>=1;j--)
                    cout<<sum[j]<<" ";
                putchar('\n');
            }
        }
        putchar('\n');
    }
    return 0;
    //Amireux_35
}

 

---

 

Day2:

上午：

生成树问题：

DFS生成树：

对于任意一棵DFS生成树，其必定只有返祖边，没有横叉边，在求割点和强连通分量上方便很多。

CF 1104E

CF 1726D

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
const int N = 2e6+10;
int T,n,m,pre,flag,u[N],v[N],du[N],fa[N];
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-48;ch=getchar();}
    return x*f;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void init()
{
    for (int i=1;i<=n;i++)
    {
        fa[i]=i;
        du[i]=0;
    }
}

int main()
{
    T=read();
    while (T--)
    {
        vector<int> g;
        pre=0;
        flag=0;
        n=read();
        m=read();
        init();
        for (int i=1;i<=m;i++)
        {
            u[i]=read();
            v[i]=read();
            int r1=Find(u[i]);
            int r2=Find(v[i]);
            if(r1!=r2)
            {
                fa[r1]=r2;
                g.push_back(1);
            }
            else
            {
                // flag+=(++du[u[i]]==2);
                // flag+=(++du[v[i]]==2);
                if(++du[u[i]]==2)
                    flag++;
                if(++du[v[i]]==2)
                    flag++;
                g.push_back(0);
                pre=i;
            }
        }
        if(flag==3)
        {
            init();
            fa[Find(u[pre])]=Find(v[pre]);
            for (int i=0;i<m;i++)
            {
                if(g[i])
                {
                    if(Find(u[i+1])==Find(v[i+1]))
                    {
                         g[i]=0;
                         break;
                    }
                    fa[Find(u[i+1])]=Find(v[i+1]);
                }
            }
            g[pre-1]=1;
        }
        for (int i=0;i<g.size();i++)
            cout<<g[i];
        putchar('\n');
    }
    return 0;
    //Amireux_35
}

/*
5 7

1 2
2 3
3 4
4 5
5 1
1 3
3 5
*/

最小生成树：

1）Kruskal

贪心的思想，最小生成树肯定会尽可能的包含边权较小的边

考虑将将所有边权按从小到大排序，依次判断，若没有与之前选择的边一起构成环，则选择该边

正确性可以考虑对于边 e，若加入它后就不能变成最优的生成树 T，则 T+e 必定构成环

Luogu P3366

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int n,m,cnt,ans,e_cnt,fa[N];
bool flag;
struct node{
    int u;
    int v;
    int w;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v,int w)
{
    e[++e_cnt].u=u;
    e[e_cnt].v=v;
    e[e_cnt].w=w;
}

int Find(int x)
{
    if(x==fa[x])
        return x;
    return fa[x]=Find(fa[x]);
}

bool cmp(node a,node b)
{
    return a.w<b.w;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int x=read();
        int y=read();
        int w=read();
        add(x,y,w);
    }
    for (int i=1;i<=n;i++)
        fa[i]=i;
    sort(e+1,e+1+e_cnt,cmp);
    for (int i=1;i<=e_cnt;i++)
    {
        int u=e[i].u;
        int v=e[i].v;
        int w=e[i].w;
        int r1=Find(u);
        int r2=Find(v);
        if(r1!=r2)
        {
            fa[r2]=r1;
            cnt++;
            ans+=w;
        }
        if(cnt==n-1)
        {
            flag=true;
            break;
        }
    }
    if(flag)
        cout<<ans;
    else
        puts("orz");
    return 0;
    //Amireux_35
}

2）Prim

同样使用贪心的思想，Kruskal是加边，Prim是加点构成最小生成树 

具体的，从任意结点开始，每次选择一个距离当前已选结点最近的点，选择并重复

 最小生成树 - OI Wiki (oi-wiki.org)（严格次小/非严格次小生成树）

CF 707B

就是对于每一个仓库考虑与它有连边的非仓库的最短距离。

（为什么这么做是对的，因为除了仓库，所有点都是非仓库，那么如果最后选的点和最靠近它的仓库不是相邻的，那么必然可以在这个点与最靠近它的仓库的路径上选一个点使得答案可以更小）

然后把所有的取一个最小值，若所有仓库旁边都没有非仓库，那么输出 −1。

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int INF = 0x3f3f3f3f;
const int N = 1e6+5;
int n,m,k,e_cnt,head[N];
bool vis[N];
struct node{
    int v;
    int w;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v,int w)
{
    e[++e_cnt].v=v;
    e[e_cnt].w=w;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

int main()
{
    n=read();
    m=read();
    k=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        int w=read();
        add(u,v,w);
        add(v,u,w);
    }
    for (int i=1;i<=k;i++)
        vis[read()]=true;
    int ans=INF;
    for (int i=1;i<=n;i++)
        if(vis[i])
            for (int j=head[i];j;j=e[j].nxt)
                if(!vis[e[j].v])
                    ans=min(ans,e[j].w);
    if(ans==INF)
        cout<<-1;
    else
        cout<<ans;
    return 0;
    //Amireux_35
}

CF 1242B

// Problem: CF1242B 0-1 MST
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1242B
// Memory Limit: 250 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int n,m,id,cnt,ans=-1,e_cnt,Min,p[N],fa[N],siz[N],head[N];
struct edge{
    int v;
    int nxt;
}e[4*N];
bool vis[N],k[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void U(int x,int y)
{
    int r1=Find(x);
    int r2=Find(y);
    if(r1!=r2)
        fa[r2]=r1;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add(u,v);
        add(v,u);
        siz[u]++;
        siz[v]++;
    }
    Min=n;
    for (int i=1;i<=n;i++)
    {
        if(Min>siz[i])
        {
            Min=siz[i];
            id=i;
        }
    }
    for (int i=1;i<=n;i++)
        fa[i]=i;
    for (int i=head[id];i;i=e[i].nxt)
        vis[e[i].v]=true;
    for (int i=1;i<=n;i++)
    {
        if(!vis[i])
        {
            fa[i]=id;
            k[i]=1;
        }
    }
    for (int i=1;i<=n;i++)
        if(!k[i])
            p[++cnt]=i;
    clear(vis);
    for (int i=1;i<=n;i++)
    {
        int tot=0;
        for (int j=head[i];j;j=e[j].nxt)
        {
            int v=e[j].v;
            vis[v]=true;
            tot+=k[v];
        }
        if(tot+cnt<n)
            U(i,id);
        for (int j=1;j<=cnt;j++)
            if(!vis[p[j]])
                U(i,p[j]);
        for (int j=head[i];j;j=e[j].nxt)
            vis[e[j].v]=0;
    }
    for (int i=1;i<=n;i++)
        if(i==fa[i])
            ans++;    
    cout<<ans;
    return 0;
    //Amireux_35
}

CF 606D

// Problem: D. Lazy Student
// Contest: Codeforces - Codeforces Round 335 (Div. 2)
// URL: https://codeforces.com/problemset/problem/606/D
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int n,m,u=2,v=3,cnt=1;
bool flag;
struct node{
    int u;
    int v;
    int w;
    int op;
    int id;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

bool cmp(node a,node b)
{
    if(a.w==b.w)
        return a.op>b.op;
    return a.w<b.w;
}

bool out(node a,node b)
{
    return a.id<b.id;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        e[i].w=read();
        e[i].op=read();
        e[i].id=i;
    }
    sort(e+1,e+1+m,cmp);
    for (int i=1;i<=m;i++)
    {
        if(e[i].op)
        {
            e[i].u=1;
            e[i].v=++cnt;
        }
        else
        {
            if(v>cnt)
            {
                flag=true;
                break;
            }
            e[i].u=u++;
            e[i].v=v;
            if(u==v)
            {
                v++;
                u=2;
            }
        }
    }
    if(flag)
        cout<<-1;
    else
    {
        sort(e+1,e+1+m,out);
        for (int i=1;i<=m;i++)
            cout<<e[i].u<<" "<<e[i].v<<"\n";
    }
    return 0;
    //Amireux_35
}

 

下午：

最短路问题：

1）Floyd

 Floyd还有很多用处

比如：找图中最小环，任意两点最短路径数，计算一个图的传递背包（判断两点是否联通）

2）Dijkstra

单元最短路径算法，即求起点 S 到所有点的最短距离，但有一个限制是不能存在负权边

 3）SPFA

用于负权边的图求最短路径

CF 95C

两边DJ即可

第一次跑 n 次 DJ，求出所有点间的最短路

建新图后在跑一次 DJ，求出 S 点到 T 点的最短路

注意开 long long ，并且 INF 要设大一点

// Problem: CF95C Volleyball
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF95C
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define int long long
const int INF = 0x7fffffffffffffff;
const int N = 1e6+5;
int n,m,s,t,dis[N],dist[N],cost[N];
bool vis[N];
vector<pair<int,int>> g[N],G[N];
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-48;ch=getchar();}
    return x*f;
}

void DJ1(int s)
{
    clear(vis);
    for (int i=0;i<=n;i++)
        dis[i]=INF;
    dis[s]=0;
    priority_queue<pair<int,int>> q;
    q.push(make_pair(0,s));
    while (!q.empty())
    {
        int u=q.top().second;
        q.pop();
        if(vis[u])
            continue;
        vis[u]=true;
        for (int i=0;i<g[u].size();i++)
        {
            int v=g[u][i].first;
            if(!vis[v] && dis[v]>g[u][i].second+dis[u])
            {
                dis[v]=g[u][i].second+dis[u];
                q.push(make_pair(-dis[v],v));
            }
        }
    }
    for (int i=1;i<=n;i++)
        if(i!=s && dis[i]<=dist[s])
            G[s].push_back(make_pair(i,cost[s]));
}

void DJ2(int s)
{
    clear(vis);
    for (int i=0;i<=n;i++)
        dis[i]=INF;
    dis[s]=0;
    priority_queue<pair<int,int>> q;
    q.push(make_pair(0,s));
    while (!q.empty())
    {
        int u=q.top().second;
        q.pop();
        if(vis[u])
            continue;
        vis[u]=true;
        for (int i=0;i<G[u].size();i++)
        {
            int v=G[u][i].first;
            if(!vis[v] && dis[v]>G[u][i].second+dis[u])
            {
                dis[v]=G[u][i].second+dis[u];
                q.push(make_pair(-dis[v],v));
            }
        }
    }
}

signed main()
{
    n=read();
    m=read();
    s=read();
    t=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        int w=read();
        g[u].push_back(make_pair(v,w));
        g[v].push_back(make_pair(u,w));
    }
    for (int i=1;i<=n;i++)
    {
        dist[i]=read();
        cost[i]=read();
    }
    for (int i=1;i<=n;i++)
        DJ1(i);
    DJ2(s);
    if(dis[t]==INF)
        cout<<-1;
    else
        cout<<dis[t];
    return 0;
    //Amireux_35
}

次短路问题：

CF 25C

Floyd

每次加边后，Floyd暴力更新所有点对最短路即可

// Problem: CF25C Roads in Berland
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF25C
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 310;
int n,m,K,mp[N][N];
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-48;ch=getchar();}
    return x*f;
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++)
    {
        mp[i][i]=0;
        for (int j=1;j<=n;j++)
            mp[i][j]=mp[j][i]=read();
    }
    K=read();
    for (int i=1;i<=K;i++)
    {
        ll ans=0;
        int a=read();
        int b=read();
        int c=read();
        if(mp[a][b]>c)
        {
            mp[a][b]=mp[b][a]=c;
            for (int i=1;i<=n;i++)
            {
                for (int j=1;j<=n;j++)
                {
                    if(i==j)
                        continue;
                    mp[i][j]=mp[j][i]=min(mp[i][j],mp[i][a]+mp[a][j]);
                    mp[i][j]=mp[j][i]=min(mp[i][j],mp[i][b]+mp[b][j]);
                }
            }
        }
        for (int i=1;i<=n;i++)
            for (int j=i+1;j<=n;j++)
                ans+=mp[i][j];
        cout<<ans<<" ";
    }
    return 0;
    //Amireux_35
}

CF 938D

有点权有边权，建虚点，连接每个点，边权为每个点的点权

而对于每个城市之间路径的边权，因为要来回两次，可直接 * 2

然后跑DJ即可（因为第一遍写的SPFA貌似被卡了

// Problem: CF938D Buy a Ticket
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF938D
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0x3f,sizeof a)
#define int long long
const int INF = 0x3f3f3f33f3f3f3f;
const int N = 4e5+10;
int n,m,a[N],dis[N];
bool vis[N];
vector<pair<int,int>> g[N];
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-48;ch=getchar();}
    return x*f;
}

void DJ(int s)
{
    priority_queue<pair<int,int>> q;
    q.push(make_pair(0,s));
    dis[s]=0;
    while (!q.empty())
    {
        int u=q.top().second;
        q.pop();
        if(vis[u])
            continue;
        vis[u]=true;
        for (int i=0;i<g[u].size();i++)
        {
            int v=g[u][i].first;
            if(dis[v]>dis[u]+g[u][i].second)
            {
                dis[v]=dis[u]+g[u][i].second;
                q.push(make_pair(-dis[v],v));
            }
        }
    }
}

signed main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        int w=read();
        g[u].push_back(make_pair(v,w*2));
        g[v].push_back(make_pair(u,w*2));
    }
    for (int i=1;i<=n;i++)
    {
        a[i]=read();
        g[0].push_back(make_pair(i,a[i]));
        g[i].push_back(make_pair(0,a[i]));
    }
    clear(dis);
    DJ(0);
    for (int i=1;i<=n;i++)
        cout<<dis[i]<<" ";
    return 0;
    //Amireux_35
}

差分约束：

CF 1450E

// Problem: CF1450E Capitalism
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1450E
// Memory Limit: 250 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 300;
int n,m,pos,ans=-1,a[2*N],fa[2*N],mp[N][N];
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-48;ch=getchar();}
    return x*f;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void U(int x,int y)
{
    int r1=Find(x);
    int r2=Find(y);
    if(r1!=r2)
        fa[r2]=r1;
}

void init()
{
    memset(mp,N,sizeof(mp));
    for (int i=1;i<=n;i++)
        mp[i][i]=0;
    for (int i=1;i<=2*n;i++)
        fa[i]=i;
}

int main()
{
    n=read();
    m=read();
    init();
    for (int o=1;o<=m;o++)
    {
        int i=read();
        int j=read();
        int b=read();
        U(i+n,j);
        U(i,j+n);
        if(b==1)
        {
            mp[i][j]=1;
            mp[j][i]=-1;
        }
        else
            mp[i][j]=mp[j][i]=1;
    }
    for (int i=1;i<=n;i++)
    {
        if(Find(i)==Find(i+n))
        {
            cout<<"NO";
            exit(0);
        }
    }
    for (int k=1;k<=n;k++)
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++)
                mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]);
    for (int i=1;i<=n;i++)
    {
        if(mp[i][i]<0)
        {
            cout<<"NO";
            exit(0);
        }
        int Max=-n-1;
        for (int j=1;j<=n;j++)
            Max=max(Max,mp[i][j]);
        if(Max>ans)
        {
            ans=Max;
            pos=i;
        }
    }
    cout<<"YES"<<"\n";
    cout<<ans<<"\n";
    for (int i=1;i<=n;i++)
        cout<<mp[pos][i]<<" ";
    return 0;
    //Amireux_35
}

CF 1131D

// Problem: CF1131D Gourmet choice
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1131D
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define int long long
const int N = 1e6+5;
int n,m,cnt,sum,e_cnt,du[N],fa[N],dis[N],head[N];
string s[N];
struct edge{
    int v;
    int nxt;
}e[N];
queue<int> q;
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void U(int x,int y)
{
    int r1=Find(x);
    int r2=Find(y);
    if(r1!=r2)
        fa[r1]=r2;
}

void TP()
{
    for (int i=1;i<=n+m;i++)
    {
        if(fa[i]==i)
        {
            if(!du[i])
            {
                dis[i]=1;
                q.push(i);
            }
            ++sum;
        }
    }
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        ++cnt;
        for (int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            dis[v]=max(dis[v],dis[u]+1);
            du[v]--;
            if(!du[v])
                q.push(v);
        }
    }
}

signed main()
{
    n=read();
    m=read();
    for (int i=1;i<=n+m;i++)
        fa[i]=i;
    for (int i=1;i<=n;i++)
    {
        cin>>s[i];
        s[i]=' '+s[i];
        for (int j=1;j<=m;j++)
            if(s[i][j]=='=')
                U(i,j+n);
    }
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=m;j++)
        {
            if(s[i][j]=='>')
            {
                add(Find(j+n),Find(i));
                du[Find(i)]++;
            }
            else if(s[i][j]=='<')
            {
                add(Find(i),Find(j+n));
                du[Find(j+n)]++;
            }
        }
    }
    TP();
    if(cnt!=sum)
        puts("No");
    else
    {
        puts("Yes");
        for (int i=1;i<=n;i++)
            cout<<dis[Find(i)]<<" ";
        putchar('\n');
        for (int i=n+1;i<=n+m;i++)
            cout<<dis[Find(i)]<<" ";
    }
    return 0;
    //Amireux_35
}

CF 1473E

根据题意可知，要求最短路，同时最短路上最大最小边权，建分层图跑最短路即可

// Problem: CF1473E Minimum Path
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1473E
// Memory Limit: 250 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0x3f,sizeof a)
#define int long long
const int N = 1e6+5;
int n,m,e_cnt,dis[N],head[N];
bool vis[N];
struct edge{
    int v;
    int w;
    int nxt;
}e[N];
vector<pair<int,int>> g[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v,int w)
{
    g[u].push_back(make_pair(v,w));
}

void SPFA(int s)
{
    priority_queue<pair<int,int>> q;
    dis[s]=0;
    vis[s]=true;
    q.push(make_pair(0,s));
    while (!q.empty())
    {
        int u=q.top().second;
        q.pop();
        vis[u]=false;
        for (int i=0;i<g[u].size();i++)
        {
            int v=g[u][i].first;
            if(dis[v]>dis[u]+g[u][i].second)
            {
                dis[v]=dis[u]+g[u][i].second;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(make_pair(-dis[v],v));
                }
            }
        }
    }
}

signed main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        int w=read();
        add(u,v,w);
        add(v,u,w);
        add(u+n,v+n,w),add(v+n,u+n,w);
        add(u+n*2,v+n*2,w),add(v+n*2,u+n*2,w);
        add(u+n*3,v+n*3,w),add(v+n*3,u+n*3,w);
        
        add(u,v+n,w*2),add(v,u+n,w*2);
        add(u,v+n*2,0),add(v,u+n*2,0);
        add(u+n,v+n*3,0),add(v+n,u+n*3,0);
        add(u+2*n,v+3*n,2*w),add(v+2*n,u+3*n,2*w);
    }
    clear(dis);
    SPFA(1);
    for(int i=2;i<=n;i++)
        cout<<min(dis[i],dis[n*3+i])<<" ";
    return 0;
    //Amireux_35
}

CF 208C

首先最短路计数

通过题目易得当警局在 1 或 n 点时，每条最短路都会经过一条安全边，所以等同于最短路计数

其他情况下，只有当 1 到警局的最短路和警局到 n 的最短路之和等于 1 到 n 的最短路，才能使最短路径经过安全边，经过的条数为两倍的 1 到警局 最短路条数乘上警局到 n 的最短路条数。

// Problem: CF208C Police Station
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF208C
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define int long long
const int N = 1e6+5;
const int M = 210;
int n,m,e_cnt,cnt[N],sum[M][M],dis[M][M],head[N];
bool vis[N];
struct edge{
    int v;
    int w;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void BFS(int s)
{
    clear(vis);
    queue<int> q;
    vis[s]=true;
    q.push(s);
    sum[s][s]=1;
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        for (int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(!vis[v])
            {
                vis[v]=true;
                dis[s][v]=dis[s][u]+1;
                q.push(v);
            }
            if(dis[s][v]==dis[s][u]+1)
                sum[s][v]+=sum[s][u];
        }
    }
}

signed main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add(u,v);
        add(v,u);
    }
    BFS(1);
    BFS(n);
    int k=sum[1][n];
    for (int i=2;i<n;i++)
        if(dis[1][i]+dis[n][i]==dis[1][n])
            k=max(k,sum[1][i]*sum[n][i]*2);
    printf("%.12lf",k*1.0/sum[1][n]);
    return 0;
    //Amireux_35
}

扩展

prufer序列

对于这样一棵树：

初始叶结点最小为 1 号，因此对应的prufer序列先是 2 

然后叶结点 4 号对应的prufer序列是 2

依次可得 5 号对应 3，6 号对应 3，3 号对应 2，7 号对应 2；

最后这棵树的prufer序列为 223322

 Prüfer 序列 - OI Wiki (oi-wiki.org)

---

 

day3:

连通性问题：

有向无环图：

有向无环图是一种特殊的图，其最大意义在于能够拓扑排序。

 拓扑排序：

考虑维护一个入度为 0 的点的集合

因为这些点之间没有依赖关系，我们可以将它放在序列的开头，所有依赖关系，我们可以将它放在序列的开头，所有依赖它的点都在它后面

放在开头后删掉它，更新剩余入度为 0 的点，继续这个过程

CF 1572A

// Problem: CF1572A Book
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1572A
// Memory Limit: 250 MB
// Time Limit: 1500 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 2e5+5;
int T,n,k,ans,e_cnt,du[N],dis[N],head[N];
struct edge{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

queue<int> q;
void TP()
{
    for (int i=1;i<=n;i++)
    {
        if(!du[i])
        {
            q.push(i);
            dis[i]=1;
        }
    }
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        for (int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(u>v)
                dis[v]=max(dis[v],dis[u]+1);
            else
                dis[v]=max(dis[v],dis[u]);
            du[v]--;
            if(!du[v])
                q.push(v);
        }
    }
    for (int i=1;i<=n;i++)
    {
        if(du[i]!=0)
        {
            ans=-1;
            return ;
        }
        ans=max(ans,dis[i]);
    }
}

void init()
{
    ans=0;
    e_cnt=0;
    clear(du);
    clear(dis);
    clear(head);
}

int main()
{
    T=read();
    while (T--)
    {
        n=read();
        init();
        for (int i=1;i<=n;i++)
        {
            k=read();
            for (int j=1;j<=k;j++)
            {
                int p=read();
                add(p,i);
                du[i]++;
            }
        }
        TP();
        cout<<ans<<"\n";
    }
    return 0;
    //Amireux_35
}

CF 510C

// Problem: CF510C Fox And Names
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF510C
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
const int M = 110;
int n,cnt,e_cnt,du[N],head[N],vis[M][M];
char s[M][M],ans[N];
struct edge{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void TP()
{
    queue<int> q;
    for (int i=1;i<=26;i++)
        if(!du[i])
            q.push(i);
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        ans[++cnt]=u+'a'-1;
        for (int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            du[v]--;
            if(!du[v])
                q.push(v);
        }
    }
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++)
        scanf("%s",s[i]+1);
    for (int i=1;i<=n;i++)
    {
        for (int j=i+1;j<=n;j++)
        {
            int len=min(strlen(s[i]+1),strlen(s[j]+1));
            bool flag=false;
            for (int k=1;k<=len;k++)
            {
                if(s[i][k]!=s[j][k])
                {
                    flag=true;
                    int u=s[i][k]-'a'+1;
                    int v=s[j][k]-'a'+1;
                    if(!vis[u][v])
                    {
                        add(u,v);
                        vis[u][v]++;
                        du[v]++;
                    }
                    break;
                }
            }
            if(!flag && strlen(s[i]+1)>strlen(s[j]+1))
            {
                puts("Impossible");
                exit(0);
            }
        }
    }
    TP();
    if(cnt==26)
        cout<<ans+1;
    else
    puts("Impossible");
    return 0;
    //Amireux_35
}

CF 1679D

看题目：最大权值最小，容易得出二分答案。

建出图后，若图中有环，答案显然成立，若没有环，则需要判断图中的最长路是否大于等于 k。

// Problem: CF1679D Toss a Coin to Your Graph...
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1679D
// Memory Limit: 250 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
// #define clear(a) memset(a,0,sizeof a)
#define int long long
const int N = 1e6+5;
int n,m,k,cnt,sum,Max,a[N],u[N],v[N],du[N],dis[N],vis[N];
vector<int> g[N];
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-48;ch=getchar();}
    return x*f;
}

void init()
{
    cnt=0;
    sum=0;
    Max=-1;
    for (int i=1;i<=n;i++)
    {
        g[i].clear();
        du[i]=0;
        dis[i]=0;
        vis[i]=0;
    }
}

bool check(int x)
{
    init();
    for (int i=1;i<=n;i++)
        if(a[i]<=x)
            dis[i]=1;
    for (int i=1;i<=m;i++)
    {
        if(a[u[i]]<=x && a[v[i]]<=x)
        {
            du[v[i]]++;
            g[u[i]].push_back(v[i]);
            vis[u[i]]=vis[v[i]]=1;
        }
    }
    queue<int> q;
    for (int i=1;i<=n;i++)
    {
        if(!du[i] && vis[i])
        {
            dis[i]=1;
            q.push(i);
            sum++;
        }
        else
            sum+=vis[i];
    }
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        ++cnt;
        for (int i=0;i<g[u].size();i++)
        {
            int v=g[u][i];
            du[v]--;
            dis[v]=max(dis[v],dis[u]+1);
            if(!du[v])
                q.push(v);
        }
    }
    if(cnt!=sum)
        return true;
    for (int i=1;i<=n;i++)
        Max=max(Max,dis[i]);
    return Max>=k;
}

signed main()
{
    n=read();
    m=read();
    k=read();
    for (int i=1;i<=n;i++)
        a[i]=read();
    for (int i=1;i<=m;i++)
    {
        u[i]=read();
        v[i]=read();
    }
    int l=1;
    int r=1e9;
    while (l<=r)
    {
        int mid=(l+r)>>1;
        if(check(mid))
            r=mid-1;
        else
            l=mid+1;
    }
    if(r==1e9)
        cout<<-1;
    else
        cout<<r+1;
    return 0;
    //Amireux_35
}

强连通分量：

CF 1220E

// Problem: CF1220E Tourism
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1220E
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define int long long
const int N = 1e6+5;
int n,m,k,e_cnt=1,a[N],f[N],g[N],head[N];
bool vis[N];
struct edge{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void DFS(int u,int now)
{
    int sum=0;
    int sum_=0;
    bool flag=false;
    vis[u]=true;
    for (int i=head[u];i;i=e[i].nxt)
    {
        if(i==now)
            continue;
        int v=e[i].v;
        if(vis[v])
            flag=true;
        else
        {
            DFS(v,i^1);
            if(f[v]>=0)
            {
                sum+=f[v];
                flag=true;
                sum_=max(sum_,g[v]-f[v]);
            }
            else
                sum_=max(sum_,g[v]);
        }
    }
    if(flag)
        f[u]=sum+a[u];
    else
        f[u]=-1;
    g[u]=sum+sum_+a[u];
}

signed main()
{
    n=read();
    m=read();
    for (int i=1;i<=n;i++)
        a[i]=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add(u,v);
        add(v,u);
    }
    k=read();
    DFS(k,0);
    cout<<g[k];
    return 0;
    //Amireux_35
}

CF 118E

有桥则一定无解

无桥则一定有解

注意路径输出

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int n,m,tim,cnt,e_cnt,dfn[N],low[N],head[N];
bool vis[N];
struct node{
    int v;
    int nxt;
}e[N];
struct edge{
    int u;
    int v;
};
int ansu[N],ansv[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void TJ(int u,int fa)
{
    low[u]=dfn[u]=++tim;
    vis[u]=true;
    for (int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(v==fa)
            continue;
        if(!dfn[v])
        {
            TJ(v,u);
            ansu[++cnt]=u;
            ansv[cnt]=v;
            low[u]=min(low[u],low[v]);
        }
        else
        {
            low[u]=min(low[u],dfn[v]);
            if(dfn[v]<dfn[u])
            {
                ansu[++cnt]=u;
                ansv[cnt]=v;
            }
        }
        if(low[v]>dfn[u])
        {
            putchar('0');
            exit(0);
        }
    }
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add(u,v);
        add(v,u);
    }
    TJ(1,-1);
    for (int i=1;i<=cnt;i++)
        cout<<ansu[i]<<" "<<ansv[i]<<"\n";
    return 0;
    //Amireux_35
}

CF 555E

CF 427C

由题目易得，每个连通块只需要建一个检查站即可

所以首先求出强连通分量并缩点，每个强连通分量里的最小点权作为缩点后的点权，然后新的点权之和就是最小费用。

再求出每个强连通分量中点权与最小点权相同的点数，作为缩完后这个点的大小，根据乘法原理，最小花费的方案数就是缩完点后所有点的大小的乘积。

// Problem: CF427C Checkposts
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF427C
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define int long long
const int MOD = 1000000007;
const int N = 1e6+5;
int n,m,tim,cnt,tot,ans,ans_=1,e_cnt,a[N],siz[N],st[N],sum[N],num[N],low[N],dfn[N],head[N];
bool vis[N];
struct edge{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void TJ(int u)
{
    low[u]=dfn[u]=++tim;
    st[++cnt]=u;
    vis[u]=true;
    for (int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(!dfn[v])
        {
            TJ(v);
            low[u]=min(low[u],low[v]);
        }
        else if(vis[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        ++tot;
        int k=st[cnt--];
        vis[k]=false;
        num[k]=tot;
        sum[tot]=a[k];
        while (k!=u)
        {
            k=st[cnt--];
            vis[k]=false;
            num[k]=tot;
            sum[tot]=min(sum[tot],a[k]);
        }
    }
}

signed main()
{
    n=read();
    for (int i=1;i<=n;i++)
        a[i]=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add(u,v);
    }
    for (int i=1;i<=n;i++)
        if(!dfn[i])
            TJ(i);
    for (int i=1;i<=n;i++)
        if(a[i]==sum[num[i]])
            siz[num[i]]++;
    for (int i=1;i<=tot;i++)
    {
        ans+=sum[i];
        ans_=(ans_*siz[i])%MOD;
    }
    cout<<ans<<" "<<ans_%MOD;
    return 0;
    //Amireux_35
}

2-SAT：

CF 1697F

CF 1475F

// Problem: CF1475F Unusual Matrix
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1475F
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1100;
int T,n;
char mp1[N][N],mp2[N][N];
bool vis[N];
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-48;ch=getchar();}
    return x*f;
}

int main()
{
    T=read();
    while (T--)
    {
        bool flag=false;
        memset(vis,0,sizeof(vis));
        n=read();
        for (int i=1;i<=n;i++)
            scanf("%s",mp1[i]+1);
        for (int i=1;i<=n;i++)
        {
            scanf("%s",mp2[i]+1);
            for (int j=1;j<=n;j++)
                mp1[i][j]^=mp2[i][j];
        }
        for (int i=1;i<=n;i++)
            if(mp1[1][i] & 1)
                vis[i]=true;
        for (int i=1;i<=n;i++)
            for (int j=1;j<=n;j++)
                mp1[i][j]^=vis[j];
        for (int i=1;i<=n;i++)
        {
            for (int j=2;j<=n;j++)
            {
                if(mp1[i][j-1]!=mp1[i][j])
                {
                    puts("NO");
                    flag=true;
                    break;
                }
            }
            if(flag)
                break;
        }
        if(!flag)
            puts("YES");
    }
    return 0;
    //Amireux_35
}

线段树：

李超线段树

数学：

概率论

导数

同余

 

---

 

day4：

上午：

图论精题：

CF 1245D

 思路和前面一个题差不多，也是需要建虚点，对边权进行处理，然后跑最小生成树。

// Problem: CF1245D Shichikuji and Power Grid
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1245D
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e6+5;
int n,sum,ans,tot,e_cnt,st_cnt,u[N],v[N],x[N],y[N],c[N],k[N],st[N],fa[N];
struct edge{
    int u;
    int v;
    int w;
}e[6*N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v,int w)
{
    e[++e_cnt].u=u;
    e[e_cnt].v=v;
    e[e_cnt].w=w;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

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

void Kru()
{
    sort(e+1,e+1+e_cnt,cmp);
    for (int i=1;i<=e_cnt;i++)
    {
        int U=e[i].u;
        int V=e[i].v;
        int W=e[i].w;
        int r1=Find(U);
        int r2=Find(V);
        if(r1!=r2)
        {
            fa[r1]=r2;
            sum++;
            ans+=W;
            if(!e[i].u)
                st[++st_cnt]=e[i].v;
            else
            {
                u[++tot]=e[i].u;
                v[tot]=e[i].v;
            }
        }
        if(sum==n)
            break;
    }
}

signed main()
{
    n=read();
    for (int i=1;i<=n;i++)
        fa[i]=i;
    for (int i=1;i<=n;i++)
    {
        x[i]=read();
        y[i]=read();
    }
    for (int i=1;i<=n;i++)
    {
        c[i]=read();
        add(0,i,c[i]);
    }
    for (int i=1;i<=n;i++)
        k[i]=read();
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=n;j++)
        {
            int C=(k[i]+k[j])*(abs(x[i]-x[j])+abs(y[i]-y[j]));
            add(i,j,C);
        }
    }
    Kru();
    cout<<ans<<"\n"<<st_cnt<<"\n";
    for (int i=1;i<=st_cnt;i++)
        cout<<st[i]<<" ";
    putchar('\n');
    cout<<tot<<"\n";
    for (int i=1;i<=tot;i++)
        cout<<u[i]<<" "<<v[i]<<"\n";
    return 0;
    //Amireux_35
}

CF 1244D

// Problem: CF1244D Paint the Tree
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF1244D
// Memory Limit: 250 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 0x7fffffffffffffff;
const int N = 1e6+5;
int n,pos,ANS=INF,a[N],b[N],c[N],k[N],du[N],ans[N];
vector<int> e[N];
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-48;ch=getchar();}
    return x*f;
}

void DFS(int now,int fa,int tot,int A,int B)
{
    int v=-1;
    for (int i=0;i<e[now].size();i++)
        if(e[now][i]^fa)
            v=e[now][i];
    if(v==-1)
    {
        if((A==1 || A==2) && (B==1 || B==2))
        {
            tot+=c[now];
            k[now]=3;
        }
        if((A==3 || A==2) && (B==3 || B==2))
        {
            tot+=a[now];
            k[now]=1;
        }
        if((A==1 || A==3) && (B==1 || B==3))
        {
            tot+=b[now];
            k[now]=2;
        }
        if(tot<ANS)
        {
            ANS=tot;
            for (int i=1;i<=n;i++)
                ans[i]=k[i];
        }
        return;
    }
    if(!A && !B)
    {
        k[now]=1;
        DFS(v,now,tot+a[now],1,0);
        k[now]=2;
        DFS(v,now,tot+b[now],2,0);
        k[now]=3;
        DFS(v,now,tot+c[now],3,0);
    }
    if(A && !B)
    {
        if(A==1)
        {
            k[now]=2;
            DFS(v,now,tot+b[now],A,2);
            k[now]=3;
            DFS(v,now,tot+c[now],A,3);
        }
        if(A==2)
        {
            k[now]=1;
            DFS(v,now,tot+a[now],A,1);
            k[now]=3;
            DFS(v,now,tot+c[now],A,3);
        }
        if(A==3)
        {
            k[now]=2;
            DFS(v,now,tot+b[now],A,2);
            k[now]=1;
            DFS(v,now,tot+a[now],A,1);
        }
    }
    if(A && B)
    {
        if((A==1 || A==2) && (B==1 || B==2))
        {
            k[now]=3;
            DFS(v,now,tot+c[now],B,3);
        }
        if((A==3 || A==2) && (B==3 || B==2))
        {
            k[now]=1;
            DFS(v,now,tot+a[now],B,1);
        }
        if((A==1 || A==3) && (B==1 || B==3))
        {
            k[now]=2;
            DFS(v,now,tot+b[now],B,2);
        }
    }
}

signed main()
{
    n=read();
    for (int i=1;i<=n;i++)
        a[i]=read();
    for (int i=1;i<=n;i++)
        b[i]=read();
    for (int i=1;i<=n;i++)
        c[i]=read();
    for (int i=1;i<=n-1;i++)
    {
        int u=read();
        int v=read();
        e[u].push_back(v);
        e[v].push_back(u);
        du[u]++;
        du[v]++;
    }
    for (int i=1;i<=n;i++)
    {
        if(du[i]>2)
        {
            cout<<-1;
            exit(0);
        }
        if(du[i]==1)
            pos=i;
    }
    DFS(pos,-1,0,0,0);
    cout<<ANS<<"\n";
    for (int i=1;i<=n;i++)
        cout<<ans[i]<<" ";
    return 0;
    //Amireux_35
}

CF 623A

// Problem: CF623A Graph and String
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF623A
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6+5;
const int M = 510;
int n,m,cnt,du[N],fa[N],vis[N],mp[M][M];
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-48;ch=getchar();}
    return x*f;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void U(int x,int y)
{
    int r1=Find(x);
    int r2=Find(y);
    if(r1!=r2)
        fa[r1]=r2;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=n;i++)
    {
        fa[i]=i;
        mp[i][i]=1;
    }
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        mp[u][v]=mp[v][u]=1;
        du[u]++;
        du[v]++;
    }
    for (int i=1;i<=n;i++)
    {
        if(du[i]==n-1)
            continue;
        for (int j=1;j<=n;j++)
            if(du[j]!=n-1)
                if(mp[i][j])
                    U(i,j);
        int k=Find(i);
        if(!vis[k])
            vis[k]=++cnt;
    }
    if(cnt>2)
    {
        puts("No");
        exit(0);
    }
    for (int i=1;i<=n;i++)
    {
        if(du[i]==n-1)
            continue;
        for (int j=1;j<=n;j++)
        {
            if(Find(i)==Find(j))
            {
                if(!mp[i][j])
                {
                    puts("No");
                    exit(0);
                }
            }
        }
    }
    puts("Yes");
    for (int i=1;i<=n;i++)
    {
        int k=Find(i);
        if(du[i]==n-1)
            putchar('b');
        else if(vis[k]==1)
            putchar('a');
        else if(vis[k]==2)
            putchar('c');
    }
    return 0;
    //Amireux_35
}

CF 580C

// Problem: CF580C Kefa and Park
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF580C
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6+5;
int n,m,ans,e_cnt,a[N],du[N],head[N];
struct edge{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void DFS(int u,int from,int sum)
{
    if(u!=1 && du[u]==1)
    {
        if(sum<=m)
            ans++;
        return ;
    }
    for (int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(v==from)
            continue;
        if(!a[v])
            DFS(v,u,0);
        else if(sum<m)
            DFS(v,u,sum+1);
    }
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=n;i++)
        a[i]=read();
    for (int i=1;i<=n-1;i++)
    {
        int u=read();
        int v=read();
        add(u,v);
        add(v,u);
        du[u]++;
        du[v]++;
    }
    DFS(1,0,a[1]);
    cout<<ans;
    return 0;
    //Amireux_35
}

CF 489D

// Problem: CF489D Unbearable Controversy of Being
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF489D
// Memory Limit: 250 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6+5;
const int M = 3005;
int n,m,ans,mp[M][M];
vector<int> e[N];
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-48;ch=getchar();}
    return x*f;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        e[u].push_back(v);
    }
    for (int i=1;i<=n;i++)
        for (int j=0;j<e[i].size();j++)
            for (int k=0;k<e[e[i][j]].size();k++)
                if(i!=e[e[i][j]][k])
                    mp[i][e[e[i][j]][k]]++;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            ans+=mp[i][j]*(mp[i][j]-1)/2;
    cout<<ans;
    return 0;
    //Amireux_35
}

CF 776D

// Problem: CF776D The Door Problem
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF776D
// Memory Limit: 250 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6+5;
int n,m,a[N],fa[N],sum[N],k[3][N];
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-48;ch=getchar();}
    return x*f;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void U(int x,int y)
{
    int r1=Find(x);
    int r2=Find(y);
    if(r1!=r2)
        fa[r1]=r2;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=n;i++)
        a[i]=read();
    for (int i=1;i<=m;i++)
    {
        fa[i]=i;
        fa[i+m]=i+m;
    }
    for (int i=1;i<=m;i++)
    {
        int x=read();
        while (x--)
        {
            int y=read();
            k[sum[y]++][y]=i;
        }
    }
    for (int i=1;i<=n;i++)
    {
        if(!a[i])
        {
            U(k[0][i],k[1][i]+m);
            U(k[1][i],k[0][i]+m);
        }
        else
        {
            U(k[0][i],k[1][i]);
            U(k[0][i]+m,k[1][i]+m);
        }
    }
    for (int i=1;i<=m;i++)
    {
        if(Find(i)==Find(i+m))
        {
            puts("NO");
            exit(0);
        }
    }
    puts("YES");
    return 0;
    //Amireux_35
}

CF 767C

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 2e6+5;
int n,cnt,sum,root,e_cnt,t[N],ans[3],num[N],head[N];
struct node{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void DFS(int u,int from)
{
    num[u]=t[u];
    for (int i=head[u];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(v==from)
            continue;
        DFS(v,u);
        num[u]+=num[v];
    }
    if(num[u]==sum)
    {
        ans[++cnt]=u;
        num[u]=0;
    }
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++)
    {
        int a=read();
        t[i]=read();
        if(a)
        {
            add(a,i);
            add(i,a);
        }
        else
            root=i;
        sum+=t[i];
    }
    if(sum%3)
    {
        cout<<-1;
        exit(0);
    }
    sum/=3;
    DFS(root,0);
    if(cnt<=2)
        cout<<-1;
    else
        cout<<ans[1]<<" "<<ans[2];
    return 0;
    //Amireux_35
}

CF 472D

 

线性代数

 

下午：

NOIP历年真题：

P7113 [NOIP2020] 排水系统

 题面非常复杂（简直可以说ex，简化为：给出一个DAG，1 ~ m为源点，出度为零的点是汇点，每个源点流量为1，过程中每个节点的流量均等的流向所有的出路。求每个汇点的流量。

依据题意建图：

 但是这题还需要高精，已经忘记高精怎么写了，所以这里用了__int128（不是懒

// Problem: P7113 [NOIP2020] 排水系统
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P7113
// Memory Limit: 512 MB
// Time Limit: 1000 ms
// 
// Powered by CP Edixr (https://cpedixr.org)

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll __int128
const int N = 1e6+5;
int n,m,sum,e_cnt,d[N],in[N],num[N],head[N];
struct edge{
    int v;
    int nxt;
}e[N];
struct node{
    ll fz;
    ll fm;
}k[N];
queue<int> q;
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-48;ch=getchar();}
    return x*f;
}

void write(ll x)
{
    if(x/10)
    write(x/10);
    putchar(x%10+'0');
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

ll gcd(ll x,ll y)
{
    if(y==0)
        return x;
    else
        return gcd(y,x%y);
}

void yf(int p)
{
    ll tmp=gcd(k[p].fz,k[p].fm);
    k[p].fz/=tmp;
    k[p].fm/=tmp;
}

void clac(int x,int now)
{
    ll kkk=k[x].fm*k[now].fm/(gcd(k[x].fm,k[now].fm));
    k[x].fz=k[x].fz*(kkk/k[x].fm);
    k[now].fz=k[now].fz*(kkk/k[now].fm);
    k[x].fz=k[x].fz+k[now].fz;
    k[x].fm=k[now].fm=kkk;
    if(k[x].fz)
        yf(x);
}

void TP()
{
    while (!q.empty())
    {
        int u=q.front();
        bool flag=false;
        q.pop();
        if(d[u])
            k[u].fm*=d[u];
        if(k[u].fz)
            yf(u);
        for (int i=head[u];i;i=e[i].nxt)
        {
            flag=true;
            int v=e[i].v;
            in[v]--;
            clac(v,u);
            if(!in[v])
                q.push(v);
        }
        if(flag)
        {
            k[u].fz=0;
            k[u].fm=1;
        }
    }
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=n;i++)
    {
        k[i].fz=0;
        k[i].fm=1;
        d[i]=read();
        if(!d[i])
            num[++sum]=i;
        for (int j=1;j<=d[i];j++)
        {
            int a=read();
            add(i,a);
            in[a]++;
        }
    }
    for (int i=1;i<=n;i++)
    {
        if(!in[i])
        {
            k[i].fz=k[i].fm=1;
            q.push(i);
        }
    }
    TP();
    for (int i=1;i<=sum;i++)
    {
        yf(num[i]);
        write(k[num[i]].fz);
        putchar(' ');
        write(k[num[i]].fm);
        putchar('\n');
    }
    return 0;
    //Amireux_35
}

P1525 [NOIP2010 提高组] 关押罪犯

并查集

首先从大到小排序

然后再结合敌人的敌人和自己在一个监狱的规律合并

当查找时发现其中两个罪犯不可避免地碰撞到一起时 只能将其输出并结束

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6+5;
int n,m,fa[N],vis[N];
struct node{
    int u;
    int v;
    int w;
}a[N];
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-48;ch=getchar();}
    return x*f;
}

bool cmp(node x,node y)
{
    return x.w>y.w;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void U(int x,int y)
{
    int s1=Find(x);
    int s2=Find(y);
    if(s1!=s2)
        fa[s1]=s2;
}

bool check(int x,int y)
{
    int t1=Find(x);
    int t2=Find(y);
    if(t1==t2)
        return true;
    return false;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=n;i++)
        fa[i]=i;
    for (int i=1;i<=m;i++)
    {
        a[i].u=read();
        a[i].v=read();
        a[i].w=read();
    }
    sort(a+1,a+1+m,cmp);
    for (int i=1;i<=m;i++)
    {
        int u=a[i].u;
        int v=a[i].v;
        int w=a[i].w;
        if(check(u,v))
        {
            cout<<w;
            exit(0);
        }
        if(!vis[u])
            vis[u]=v;
        else
            U(vis[u],v);
        if(!vis[v])
            vis[v]=u;
        else
            U(vis[v],u);
    }
    cout<<0;
    return 0;
    //Amireux_35
}

P1983 [NOIP2013 普及组] 车站分级

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6;
const int M = 1e3+5;
int n,m,ans,e_cnt,a[N],k[N],in[N],head[N],vis[M][M];
struct node{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void TP()
{
    queue<pair<int,int>> q;
    for (int i=1;i<=n;i++)
        if(!in[i])
            q.push(make_pair(i,1));
    while (!q.empty())
    {
        int now=q.front().first;
        int dep=q.front().second;
        q.pop();
        if(dep>ans)
            ans=dep;
        for (int i=head[now];i;i=e[i].nxt)
        {
            int v=e[i].v;
            in[v]--;
            if(in[v]==0)
                q.push(make_pair(v,dep+1));
        }
    }
}

int main()
{
    n=read();
    m=read();
    while (m--)
    {
        memset(k,0,sizeof(k));
        int s=read();
        for (int i=1;i<=s;i++)
        {
            scanf("%d",a+i);
            k[a[i]]=1;
        }
        for (int i=a[1];i<=a[s];i++)
        {
            if(!k[i])
            {
                for (int j=1;j<=s;j++)
                {
                    if(!vis[a[j]][i])
                    {
                        add(a[j],i);
                        vis[a[j]][i]=1;
                        in[i]++;
                    }
                }
            }
        }
    }
    TP();
    cout<<ans;
    return 0;
}

P2296 [NOIP2014 提高组] 寻找道路

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int INF = 0x3f3f3f;
const int N = 1e6+5;
int n,m,s,t,e_cnt,dis[N],head[N];
bool vis[N],vis_[N];
struct edge{
    int v;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void add(int u,int v)
{
    e[++e_cnt].v=v;
    e[e_cnt].nxt=head[u];
    head[u]=e_cnt;
}

void bfs(int t)
{
    memset(vis,false,sizeof(vis));
    queue<int> q;
    q.push(t);
    vis[t]=vis_[t]=true;
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        for (int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(!vis[v])
            {
                vis[v]=true;
                vis_[v]=true;
                q.push(v);
            }
        }
    }
}

void SPFA(int t)
{
    memset(vis,false,sizeof(vis));
    memset(dis,INF,sizeof(dis));
    queue<int> q;
    q.push(t);
    vis[t]=true;
    dis[t]=0;
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for (int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].v;
            if(dis[v]>dis[u]+1 && vis_[v])
            {
                dis[v]=dis[u]+1;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add(v,u);
    }
    s=read();
    t=read();
    bfs(t);
    for (int i=1;i<=n;i++)
    {
        if(!vis[i])
            for (int j=head[i];j;j=e[j].nxt)
                if(vis_[e[j].v])
                    vis_[e[j].v]=false;
    }
    SPFA(t);
    if(dis[s]>=INF)
        cout<<-1;
    else
        cout<<dis[s];
    return 0;
    //Amireux_35
}

P1967 [NOIP2013 提高组] 货车运输

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int INF = 0x3f3f3f3f;
const int N = 1e6+5;
const int M= 1e2;
int n,m,cnt,fa[N],vis[N],dep[N],head[N],f[N][M],w[N][M];
struct edge{
    int x;
    int y;
    int dis;
}E[N];
struct node{
    int v;
    int w;
    int nxt;
}e[N];
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-48;ch=getchar();}
    return x*f;
}

void addedge(int u,int v,int w)
{
    e[++cnt].v=v;
    e[cnt].w=w;
    e[cnt].nxt=head[u];
    head[u]=cnt;
}

bool cmp(edge a,edge b)
{
    return a.dis>b.dis;
}

int Find(int x)
{
    if(fa[x]==x)
        return x;
    return fa[x]=Find(fa[x]);
}

void Kru()
{
    sort(E+1,E+1+m,cmp);
    for (int i=1;i<=n;i++)
        fa[i]=i;
    for (int i=1;i<=m;i++)
    {
        int s1=Find(E[i].x);
        int s2=Find(E[i].y);
        if(s1^s2)
        {
            fa[s2]=s1;
            addedge(E[i].x,E[i].y,E[i].dis);
            addedge(E[i].y,E[i].x,E[i].dis);
        }
    }
    return ;
}

void dfs(int k)
{
    vis[k]=1;
    for (int i=head[k];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(vis[v])
            continue;
        dep[v]=dep[k]+1;
        f[v][0]=k;
        w[v][0]=e[i].w;
        dfs(v);
    }
    return ;
}

int LCA(int x,int y)
{
    if(Find(x)^Find(y))
        return -1;
    int ans=INF;
    if(dep[x]>dep[y])
        swap(x,y);
    for (int i=20;i>=0;i--)
    {
        if(dep[f[y][i]]>=dep[x])
        {
            ans=min(ans,w[y][i]);
            y=f[y][i];
        }
    }
    if(x==y)
        return ans;
    for (int i=20;i>=0;i--)
    {
        if(f[x][i]^f[y][i])
        {
            ans=min(ans,min(w[x][i],w[y][i]));
            x=f[x][i];
            y=f[y][i];
        }
    }
    ans=min(ans,min(w[x][0],w[y][0]));
    return ans;
}

int main()
{
    n=read();
    m=read();
    for (int i=1;i<=m;i++)
    {
        int x=read();
        int y=read();
        int z=read();
        E[i].x=x;
        E[i].y=y;
        E[i].dis=z;
    }
    Kru();
    for (int i=1;i<=n;i++)
    {
        if(!vis[i])
        {
            dep[i]=1;
            dfs(i);
            f[i][0]=i;
            w[i][0]=INF;
        }
    }
    for (int i=1;i<=20;i++)
    {
        for (int j=1;j<=n;j++)
        {
            f[j][i]=f[f[j][i-1]][i-1];
            w[j][i]=min(w[j][i-1],w[f[j][i-1]][i-1]);
        }
    }
    int q=read();
    for (int i=1;i<=q;i++)
    {
        int x=read();
        int y=read();
        cout<<LCA(x,y)<<"\n";
    }
    return 0;
}

P2661 [NOIP2015 提高组] 信息传递

//By:Komorebi_03
#include<bits/stdc++.h>
using namespace std;
#define clear(a) memset(a,0,sizeof a)
#define ll long long
const int N = 1e6+5;
int n,Min=0x3f3f3f,t[N],f[N],dis[N];
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-48;ch=getchar();}
    return x*f;
}

int Find(int x)
{
    if(f[x]!=x)
    {
        int root=f[x];
        f[x]=Find(f[x]);
        dis[x]+=dis[root];
    }
    return f[x];
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++)
        f[i]=i;
    for (int i=1;i<=n;i++)
    {
        t[i]=read();
        int r1=Find(i);
        int r2=Find(t[i]);
        if(r1!=r2)
        {
            f[r1]=r2;
            dis[i]=dis[t[i]]+1;    
        }
        else
            Min=min(Min,dis[i]+dis[t[i]]+1);
    }
    cout<<Min;
    return 0;
    //Amireux_35
}

P2680 [NOIP2015 提高组] 运输计划

 

 

 

---

 

五一题单