tags: Combinatorics GT

写在前面

最近开始更新图论笔记系列, 没办法做到面面俱到了, 就把自己觉得重要的内容放上来, 有任何问题欢迎大家指正.

主要概念

图(graph): 关系的数学表达, 由两个集合: 非空结点集 $V$ 和有限的边集 $E$ 组成.
图的阶(order): 集合 $V (G)$ 的基数(势) $n$ .
图的规模(size): 集合 $E (G)$ 的基数 $m$ .
邻接(adjacent): 指两个节点之间有边连接.
关联(incident): 边与左右两个节点关联.
结点的度(degree): 与结点相邻接的结点数.

孤立点: 度为 $0$ 的结点.
最小度: 图中所有结点的最小度数, 记为 $\delta(G)$ .
最大度: 图中所有结点的最大度数, 记为 $\Delta(G)$ .
正则图(regular graph): 若图中所有结点有相同的度数, 则 $\delta(G)=\Delta(G)$ .
$r -$ 正则图: 图中所有结点度都为 $r$ .

$u - v$ 通道(途径, walk): 指从结点 $u$ 出发, 经过一个交互的结点和边的序列, 最后回到结点 $v$ 的路径, 其中连续的结点和边是相关联的.
通道的长度: 经过边的数量, 结点和边可以重复.
迹(trail): 没有重复边的通道, 结点可以重复.
路(路径, path): 结点都不相同的迹.
回路(圈, cycle): 即封闭的路径(闭路, closed path), 由于结点不同则边一定不同, 所以回路也可以称为闭迹(closed trail).
$u - v$ 路: 将 $u$ 和 $v$ 连接起来的路.

连通图(connected graph): 图中任意两个结点之间都存在路.
测地线路(测地线, 最短路): 长度最短的 $u - v$ 路.
子图: $H$ 结点集与边集都为 $G$ 的结点集和边集的子集, 且对 $H$ 中任意一条边, 其两个节点都在结点集 $V (H)$ 中. $G$ 称为 $H$ 的超图.
连通分量(connected component): 极大连通子图.
生成子图(spanning subgraph): $V (H) = V (G)$ .
导出子图(induced subgraph): 子图边集中包含了 $G$ 中连接子图点集的所有边.

完全图(complete graph): 所有结点对都邻接. 具有 $n$ 个结点的完全图记为 $K_n$ .
平凡图(trivial graph): $K_1$ .
圈(circle): 含有 $n$ 个结点的圈记为 $C_n$ .
路(path): 含有 $n$ 个结点的路记为 $P_n$ , 并且满足 $P_i=K_1, P_2=K_2$ .
完全二分图(complete bipartite graph): 记为 $K_{m,n}$ , 是指图的结点集可以分成两个非空集合 $A, B$ , 分别含有 $m, n$ 个结点, $A$ 中每个结点均要与 $B$ 中每个结点相关联,且都只与 $B$ 中结点相关联.
星: 只有一个结点度为 $n$ , 其余 $n$ 个结点度为 $1$ 的完全二分图, 记为 $K_{1,n}$ .

图同构

图同构: 图 $G$ 中结点 $u v$ 邻接当前节点它们在图 $H$ 中相应的结点也邻接, 记为 $G\cong H$ . 图同构则节点的度一定相同.
度序列: 含有 $n$ 个结点图 $G$ 的度序列指按照结点度数排列的 $n -$ 元非递增序列. 有相同度序列的两图不一定同构.
可绘图序列: 可以表示某个图的非负整数的非递增序列.
可绘图序列的必要条件: 度数之和为偶数.

可绘图序列的判定算法

序列 $S$ 中删除第1个数 $k$ .
如果 $S$ 的第一个数后的 $k$ 个数都大等1, 则将这 $k$ 个数分别都减去1得到新序列 $S^{'}$ ; 否则停止, 得出原序列不绘图. 若 $S^{'}$ 全是 $0$ , 停止, 得到原序列可绘图.
将2得到的序列 $S^{'}$ 重新排列, 得到非增序列 $S^*$ .
令 $S=S^*$ ,转步骤1.

直接根据上述算法进行判断, 下面给出Python以及C++代码:

S1 = [3, 2, 2, 1, 1, 1]
S2 = [5, 4, 4, 3, 3, 3, 3, 2, 2, 1]
S3 = [7, 7, 4, 3, 3, 3, 2, 1]
S4 = [6, 5, 4, 3, 3, 3, 2, 0]


def isGraphic(S):
    if len(S) == 0 or sum(S) % 2 == 1:
        return False
    # 只要不是全0序列, 就进入循环
    while S.count(0) != len(S):
        k = S.pop(0)
        if k <= len(S):
            for i in range(k):
                if S[i] >= 1:
                    S[i] -= 1
                else:
                    return False
            S.sort(reverse=True)
        else:
            return False
    return True


print(isGraphic(S1))
print(isGraphic(S2))
print(isGraphic(S3))
print(isGraphic(S4))
"""
True
True
False
True
"""

对于python代码, 用到了一些列表操作的内置函数, 进一步优化可以得到下面的代码:

def isGraphic(S):
    if len(S) == 0 or sum(S) % 2 == 1:
        return False
    # 只要不是全0序列, 就进入循环
    while S[0] != 0:
        k = S.pop(0)
        if k <= len(S):
            for i in range(k):
                if S[i] >= 1:
                    S[i] -= 1
                else:
                    return False
            S.sort(reverse=True)
    return True

// C++代码实现
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

using namespace std;

bool isGraphic(vector<int> &S) {
    if (S.size() == 0 || accumulate(S.begin(), S.end(), 0) % 2 == 1)
    {
        return false;
    }
    while(S[0] != 0) {
        int k = S[0];
        S.erase(S.begin());
        if (k <= S.size())
            for (int i=0;i<k;i++) {
                if (S[i] >= 1)
                    S[i]--;
                else
                    return false; 
            }
            sort(S.rbegin(), S.rend());
    }
    return true;
}


int main(int argc, char const *argv[])
{
    vector<int> S1 = {3, 2, 2, 1, 1, 1},
                S2 = {5, 4, 4, 3, 3, 3, 3, 2, 2, 1},
                S3 = {7, 7, 4, 3, 3, 3, 2, 1},
                S4 = {6, 5, 4, 3, 3, 3, 2, 0};
    cout<<isGraphic(S1)<<endl;
    cout<<isGraphic(S2)<<endl;
    cout<<isGraphic(S3)<<endl;
    cout<<isGraphic(S4)<<endl;

    return 0;
}