C++博客-Mato is No.1-随笔分类-图算法

【AHOI2013复仇】两道有关删边后最短路径维护的猥琐题

Mato_No1 — Sat, 19 Jan 2013 08:49:00 GMT

摘要: 【先祝贺一下@Jollwish神犇进入CMO国家集训队……合肥OI人总算出了个国家集训队员（虽然不是OI的）……】最近捉了两道猥琐题……都是有关图中删去某边后的最短路径的问题……核心思想几乎相同……但是，它们很明显是综合题，代码量太大了（与NOIP2012的drive和block... 阅读全文

Mato_No1 2013-01-19 16:49 发表评论

Tarjan算法——求有向图强连通分支

Mato_No1 — Thu, 28 Jul 2011 12:57:00 GMT

在图DFS的过程中，给每个点设立两个附加值dfn和low。dfn[i]表示点i被发现（变灰）的时间，也就是“发现次序”。而low[i]表示i能够到达的dfn值最小的i的祖先结点或i本身的dfn值，即low[i]=min{dfn[i], dfn[j], low[k]}（其中j为满足以下条件的点：图中存在边且这条边在遍历到的时候j在栈中（这个栈的具体说明见下）；k为遍历树中i的某个子结点，）。

Tarjan算法就是在图DFS过程中，得到每个点的dfn值和low值，并且设立一个栈，点变灰的时候入栈，在某个点i的low值真正确定后（容易发现，一个点只有变黑了，它的low值才真正确定），若low[i]=dfn[i]，则将栈中点i及其上面的所有点全部弹出（这些点一定是以i为根的子树中的结点，因为它们比i后入栈，却比i先出栈），这些点组成一个强连通分支，这样在图DFS遍历完后，即可得到所有的强连通分支。

下面证明结点i变黑时，若low[i]=dfn[i]，则i及其所有未出栈的后代组成一个强连通分支。
证明这个需要分两步：
【1】i的所有未出栈的后代与i处于同一个强连通分支。
设j是i的某个后代且j在i变黑时尚未出栈。显然i可达j，因此只需证明j可达i。
在遍历树中，从i到j路径上除i外的所有结点的low值都小于dfn值（否则，设这条路径上存在结点k，k≠i，low[k]=dfn[k]。因为k比i先变黑，所以在k变黑时，其所有后代就会出栈，这与j在i变黑时仍未出栈矛盾，故这样的结点k不存在）。设dfn[x]=low[j]，则根据low的定义以及low[j]=low[i]，又因为dfn[x]j上且x≠j。若x=i，则j可达i，结束，否则先从j到达x，再将x当成j，继续往上……这样最终必然能到达点i。因此j可达i，即j与i处于同一个强连通分支。
【2】不是i的未出栈的后代不与i处于同一个强连通分支。
设j不是i的未出栈的后代，则j有两种情况：
（1）j是i的后代，且在i变黑前已经出栈：
此时，i->j路径上必然存在一个点k，满足k≠i，且dfn[k]=low[k]（这样的k可能有多个，此时取最深的那个为k），当k变黑时j出栈。这时，由与【1】类似的推导过程可得，j不断往上到达的最上层祖先结点也只能是k，到不了i，故j不可达i，也即j与i不处于同一个强连通分支；
（2）j不是i的后代，考虑当i变黑时，j的颜色：
<1>白色：此时，若i可达j，则j在i变黑前，就会成为i的后代，这与j不是i的后代矛盾，故i一定不可达j，也即j与i不处于同一个强连通分支；
<2>灰色：若j为灰色，则j一定是i的祖先，若i可达j，根据low的定义可得，必有low[i]<=dfn[j]<3>黑色：若j不是i的后代，且比i先变黑，则必然是在i变灰前j已经变黑。这时，若j可达i，则i会成为j的后代，也即j是i的祖先，这样在i变黑时，j应为灰色，矛盾，故j不可达i，也即j与i不处于同一个强连通分支；
综上可得，i、j一定不处于同一个强连通分支。故原命题得证，也就证明了Tarjan算法是可以求出有向图的所有强连通分支的。

时间复杂度分析：由于每个点都要入栈一次，出栈一次，每条边都要被访问一次，所以总时间复杂度为O(N+M)。

写代码时注意事项：
（1）要用人工栈实现DFS，不可用递归，防止爆栈；另外注意不要将这个人工栈与上面说到的“栈”弄混，本沙茶下面的代码中，用于搜索、回溯的人工栈为stk0，而用于找强分支的栈为stk；
（2）注意边界情况；
（3）注意在出栈时要将V值设为2；
（4）注意计算low[i]时，需要考虑非i的祖先，但仍在栈中的结点，它们也被视为i的“祖先”。

核心代码：

void solve()
{
    re(i, n) {V[i] = vst[i] = 0; st[i] = E[i].next;}
    int x, y, x0, tp, tp0, ord = 0, No = 0;
    bool fd;
    re(i, n) if (!V[i]) {
        stk[tp = 0] = stk0[tp0 = 0] = i; vst[i] = 1; low[i] = dfn[i] = ++ord; V[i] = 1;
        while (tp0 >= 0) {
            x = stk0[tp0]; fd = 0;
            for (int p=st[x]; p != x; p=E[p].next) {
                y = E[p].b;
                if (!V[y]) {
                    fd = 1; stk[++tp] = stk0[++tp0] = y; vst[y] = 1; low[y] = dfn[y] = ++ord; V[y] = 1; st[x] = E[p].next; break;
                } else if (vst[y] && dfn[y] < low[x]) low[x] = dfn[y];
            }
            if (!fd) {
                V[x] = 2;
                if (low[x] == dfn[x]) {while (stk[tp] != x) {vst[stk[tp]] = 0; w[stk[tp--]] = No;} vst[x] = 0; w[stk[tp--]] = No++;}
                if (tp0) {x0 = stk0[tp0 - 1]; if (low[x] < low[x0]) low[x0] = low[x];} tp0--;
            }
        }
    }
    re(i, n) {reslen[i] = 0; for (int p=E[i].next; p != i; p=E[p].next) if (w[i] == w[E[p].b]) reslen[i]++;}
}

Mato_No1 2011-07-28 20:57 发表评论

关于KM算法的详细解释

Mato_No1 — Sat, 23 Jul 2011 14:14:00 GMT

【背景（神犇不要鄙视）】
本沙茶今年AHOI的时候，遇到裸的最佳匹配的题，竟然把KM算法搞忘了，幸亏是WJMZBMR神犇保佑，临时乱弄一通，想起来了……这MS反映出了本沙茶以前在看某些经典算法的时候看得不深，木有理解透彻……
前几天又遇到一道最佳匹配的题，发现KM算法竟然又忘了……米办法，只有把这个搞死人的算法的具体过程重新看了一遍，终于懂了……
【KM算法及其具体过程】
（1）可行点标：每个点有一个标号，记lx[i]为X方点i的标号，ly[j]为Y方点j的标号。如果对于图中的任意边(i, j, W)都有lx[i]+ly[j]>=W，则这一组点标是可行的。特别地，对于lx[i]+ly[j]=W的边(i, j, W)，称为可行边；
（2）KM算法的核心思想就是通过修改某些点的标号（但要满足点标始终是可行的），不断增加图中的可行边总数，直到图中存在仅由可行边组成的完全匹配为止，此时这个匹配一定是最佳的（因为由可行点标的的定义，图中的任意一个完全匹配，其边权总和均不大于所有点的标号之和，而仅由可行边组成的完全匹配的边权总和等于所有点的标号之和，故这个匹配是最佳的）。一开始，求出每个点的初始标号：lx[i]=max{e.W|e.x=i}（即每个X方点的初始标号为与这个X方点相关联的权值最大的边的权值），ly[j]=0（即每个Y方点的初始标号为0）。这个初始点标显然是可行的，并且，与任意一个X方点关联的边中至少有一条可行边；
（3）然后，从每个X方点开始DFS增广。DFS增广的过程与最大匹配的Hungary算法基本相同，只是要注意两点：一是只找可行边，二是要把搜索过程中遍历到的X方点全部记下来（可以用vst搞一下），以进行后面的修改；
（4）增广的结果有两种：若成功（找到了增广轨），则该点增广完成，进入下一个点的增广。若失败（没有找到增广轨），则需要改变一些点的标号，使得图中可行边的数量增加。方法为：将所有在增广轨中（就是在增广过程中遍历到）的X方点的标号全部减去一个常数d，所有在增广轨中的Y方点的标号全部加上一个常数d，则对于图中的任意一条边(i, j, W)（i为X方点，j为Y方点）：
<1>i和j都在增广轨中：此时边(i, j)的(lx[i]+ly[j])值不变，也就是这条边的可行性不变（原来是可行边则现在仍是，原来不是则现在仍不是）；
<2>i在增广轨中而j不在：此时边(i, j)的(lx[i]+ly[j])的值减少了d，也就是原来这条边不是可行边（否则j就会被遍历到了），而现在可能是；
<3>j在增广轨中而i不在：此时边(i, j)的(lx[i]+ly[j])的值增加了d，也就是原来这条边不是可行边（若这条边是可行边，则在遍历到j时会紧接着执行DFS(i)，此时i就会被遍历到），现在仍不是；
<4>i和j都不在增广轨中：此时边(i, j)的(lx[i]+ly[j])值不变，也就是这条边的可行性不变。
这样，在进行了这一步修改操作后，图中原来的可行边仍可行，而原来不可行的边现在则可能变为可行边。那么d的值应取多少？显然，整个点标不能失去可行性，也就是对于上述的第<2>类边，其lx[i]+ly[j]>=W这一性质不能被改变，故取所有第<2>类边的(lx[i]+ly[j]-W)的最小值作为d值即可。这样一方面可以保证点标的可行性，另一方面，经过这一步后，图中至少会增加一条可行边。
（5）修改后，继续对这个X方点DFS增广，若还失败则继续修改，直到成功为止；

下面分析整个算法的时间复杂度：每次修改后，图中至少会增加一条可行边，故最多增广M次、修改M次就可以找到仅由可行边组成的完全匹配（除非图中不存在完全匹配，这个可以通过预处理得到），故整个算法的时间复杂度为O(M * (N + 一次修改点标的时间))。而一次修改点标的时间取决于计算d值的时间，如果暴力枚举计算，这一步的时间为O(M)，优化：可以对每个Y方点设立一个slk值，表示在DFS增广过程中，所有搜到的与该Y方点关联的边的(lx+ly-W)的最小值（这样的边的X方点必然在增广轨中）。每次DFS增广前，将所有Y方点的slk值设为+∞，若增广失败，则取所有不在增广轨中的Y方点的slk值的最小值为d值。这样一次修改点标的时间降为O(N)，总时间复杂度降为O(NM)。

需要注意的一点是，在增广过程中需要记下每个X、Y方点是否被遍历到，即fx[i]、fy[j]。因此，在每次增广前（不是对每个X方点增广前）就要将所有fx和fy值清空。

代码：

void init_d()
{
    re(i, n) E[i].pre = E[i].next = i; m = n;
}
void add_edge(int a, int b, int len)
{
    E[m].a = a; E[m].b = b; E[m].len = len; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
inline int dist(int x, int y, int x0, int y0)
{
    return abs(x - x0) + abs(y - y0);
}
bool dfs(int x)
{
    int y, x0; fx[x] = _FLAG;
    for (int p=E[x].next; p != x; p=E[p].next) {
        y = E[p].b;
        if (lx[x] + ly[y] > E[p].len) {
            if (lx[x] + ly[y] - E[p].len < slk[y]) slk[y] = lx[x] + ly[y] - E[p].len;
        } else if (fy[y] != _FLAG) {
            fy[y] = _FLAG; x0 = z[y];
            if (x0 == -1 || dfs(x0)) {z[y] = x; return 1;}
        }
    }
    return 0;
}
void solve()
{
    re(i, n) {
        lx[i] = -INF;
        for (int p=E[i].next; p != i; p=E[p].next) if (E[p].len > lx[i]) lx[i] = E[p].len;
    }
    re(i, n0) {ly[i] = 0; z[i] = -1;}
    int d;
    re(i, n) {
        re(j, n0) slk[i] = INF; _FLAG++;
        while (!dfs(i)) {
            d = INF; re(j, n0) if (fy[j] != _FLAG && slk[j] < d) d = slk[j];
            re(j, n) if (fx[j] == _FLAG) lx[j] -= d;
            re(j, n0) {slk[j] = INF; if (fy[j] == _FLAG) ly[j] += d;}
            _FLAG++;
        }
    }
    res = 0; re(i, n) res += lx[i]; re(i, n0) res += ly[i];
}

Mato_No1 2011-07-23 22:14 发表评论

NOI2008 party

Mato_No1 — Thu, 14 Jul 2011 04:23:00 GMT

原题见这里（BZOJ和BSOJ都挂了，真杯具，只能借助RQ了囧……）

难度不是很大，就是特殊情况比较多，比较猥琐（不过本题数据弱，就算不考虑所有的特殊情况也能过7个点）。
首先O(NM)的朴素算法很好想到：枚举K，然后给每个结点编号即可。在编号时，先随便指定一个未编号的点，设它的编号为0，然后遍历所有和它相关联的边（这里可以把原图想象成一个无向图），将这些边的另一个端点编上号即可，中间若某个点的编号出现矛盾，则这个K不合法，否则这个K合法。
然后进行优化：合法的K实际上是有限制的，它必然是某个数的因数，具体来说，对这个图进行DFS，并考察其中所有的跨越边和逆向边，对于跨越边，设遍历树中i、j间距离为D，则合法的K必然是(D-1)的因数（因为i和遍历树中j的父结点都有指向j的边，它们的编号应相同，而它们之间的距离为(D-1)）；对于逆向边，设遍历树中i、j间距离为D'，则合法的K必然是(D'+1)的因数（因为这里形成了一个环，环的长度为(D'+1)）。这样一来就明显缩小了K的取值范围，再进行枚举，就可以显著缩短时间。

下面是一些极其猥琐的特殊情况：
（1）根据题意，必须是K类每类都有，因此在尝试编号成功（没有发生任何矛盾）后，还要看一下实际出现的编号数目是否等于K，若小于K，同样不合法；
（2）该图的基图可能不连通，此时对于其基图的每个连通块，其编号互不影响，所以要对每个连通块分别统计实际出现的编号数目，设它们的和为SUM，则不大于SUM的K值均合法（只要中间不出现矛盾），因此可以直接得到最大值为SUM，提前结束；不过，这种特判只有在总共实际出现的编号数目小于K的情况下才能进行；
（3）由于考察的是实际出现的编号数目，因此最后求出的最大值、最小值可能小于3，这时应作出如下处理：若最大值小于3，则无解；若最小值小于3，则将最小值改为3。

本题比较猥琐的数据是第4、5、6个点，分别出现了上述的第（1）、（2）、（3）种特殊情况，此外，这三个点建出的图中竟然没有一条跨越边或逆向边！

代码：

#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
const int MAXN = 100000, MAXM = 1100001;
struct edge {
    int a, b, s, pre, next;
} E0[MAXM], E[MAXM + MAXM];
int n, m0, m, P, len, X[MAXN], No[MAXN], stk[MAXN], st[MAXN], dep[MAXN], V[MAXN], fo[MAXN], Q[MAXN], res0, res1;
bool vst[MAXN], T0[MAXN];
long long T[MAXN], _Z = 0;
void init_d()
{
    re(i, n) E[i].a = E[i].pre = E[i].next = E0[i].a = E0[i].pre = E0[i].next = i;
    m0 = n; if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b)
{
    E0[m0].a = a; E0[m0].b = b; E0[m0].pre = E0[a].pre; E0[m0].next = a; E0[a].pre = m0; E0[E0[m0].pre].next = m0++;
    E[m].a = a; E[m].b = b; E[m].s = 1; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
    E[m].a = b; E[m].b = a; E[m].s = -1; E[m].pre = E[b].pre; E[m].next = b; E[b].pre = m; E[E[m].pre].next = m++;
}
void init()
{
    freopen("party.in", "r", stdin);
    int _m, a, b; scanf("%d%d", &n, &_m); init_d();
    re(i, _m) {
        scanf("%d%d", &a, &b);
        add_edge(--a, --b);
    }
    fclose(stdin);
}
int gcd(int a, int b)
{
    int r;
    while (b) {
        r = a % b; a = b; b = r;
    }
    return a;
}
void prepare()
{
    int tp, x, y, ord = 0;
    bool fd;
    re(i, n) V[i] = 0; P = 0;
    re(i, n) if (!V[i]) {
        stk[tp = 0] = i; fo[i] = ord++; V[i] = 1; st[i] = E0[i].next; dep[i] = 0;
        while (tp >= 0) {
            x = stk[tp]; fd = 0;
            for (int p=st[x]; p != x; p=E0[p].next) {
                y = E0[p].b;
                if (!V[y]) {
                    stk[++tp] = y; fo[y] = ord++; V[y] = 1; st[y] = E0[y].next; dep[y] = dep[x] + 1; st[x] = E0[p].next; fd = 1; break;
                } else if (V[y] == 1) P = gcd(P, dep[x] - dep[y] + 1); else if (fo[y] > fo[x]) P = gcd(P, dep[y] - dep[x] - 1);
            }
            if (!fd) {V[x] = 2; tp--;}
        }
    }
    len = 0; re3(i, 3, n) if (!(P % i)) X[len++] = i;
}
int test(int K)
{
    re(i, n) {vst[i] = 0; No[i] = -1;}
    re(i, K) T0[i] = 0;
    int x, y, No0, sum = 0, sum0 = 0;
    re(i, n) if (!vst[i]) {
        No[i] = 0; Q[0] = i; vst[i] = 1; _Z++; if (T[0] != _Z) {T[0] = _Z; sum++;} if (!T0[0]) {T0[0] = 1; sum0++;}
        for (int front=0, rear=0; front<=rear; front++) {
            x = Q[front];
            for (int p=E[x].next; p != x; p=E[p].next) {
                y = E[p].b; No0 = No[x] + E[p].s;
                if (No0 == K) No0 = 0; else if (No0 == -1) No0 = K - 1;
                if (No[y] >= 0 && No0 != No[y]) return -1; else {
                    No[y] = No0;
                    if (T[No0] != _Z) {T[No0] = _Z; sum++;}
                    if (!T0[No0]) {T0[No0] = 1; sum0++;}
                }
                if (!vst[y]) {vst[y] = 1; Q[++rear] = y;}
            }
        }
    }
    if (sum0 < K) res0 = sum;
    return sum0;
}
void solve()
{
    int K, K0; res0 = res1 = -1;
    re(i, len) {
        K = X[i]; K0 = test(K);
        if (K0 != -1) {
            if (res1 == -1) res1 = K0;
            if (K0 < K) break; else res0 = K;
        }
    }
    if (res0 < 3) res0 = res1 = -1; else if (res1 < 3) res1 = 3;
}
void pri()
{
    freopen("party.out", "w", stdout);
    printf("%d %d\n", res0, res1);
    fclose(stdout);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-07-14 12:23 发表评论

2-SAT问题及其算法

Mato_No1 — Wed, 13 Jul 2011 03:51:00 GMT

摘要: 【2-SAT问题】现有一个由N个布尔值组成的序列A，给出一些限制关系，比如A[x] AND A[y]=0、A[x] OR A[y] OR A[z]=1等，要确定A[0..N-1]的值，使得其满足所有限制关系。这个称为SAT问题，特别的，若每种限制关系中最多只对两个元素进行限制，则称为2-SAT问题。由于在2-SAT问题中，最多只对两个元素进行限制，所以可能的限制关系共... 阅读全文

Mato_No1 2011-07-13 11:51 发表评论

次小生成树的一种极其神犇的算法

Mato_No1 — Fri, 01 Jul 2011 01:10:00 GMT

相关链接

Orz AHdoc!!!!!!!!!!!!!

这种神犇算法的关键在于真正利用了MST是一棵“树”的性质。也就是，它在求出MST后把它转化为有根树，然后，按长度递增顺序对于图中每一条不在MST中的边(i, j)，找到树中i、j的最近公共祖先(LCA)，记为p=LCA(i, j)。这样，树中i->p->j就是从i到j的路径。然后，依次扫描这条路径上的所有的边，将新边(i, j)的长度与路径上所有边的长度比较，找到长度差最小的（不过由于边(i, j)的长度一定不小于路径上所有边的长度，所以只要找到路径上最长边，则“删去这条最长边，加入边(i, j)”一定是所有加入的边为(i, j)的可行变换中代价最小的），取这个长度差最小的即可。不过最为神犇的一点是，这个算法在遍历完这条路径后，会将路径上所有的点（p点除外）的父结点全部设为p，也就是相当于并查集的路径压缩！这虽然会改变树的形态，但任何两点的LCA都是不会变的，因此不会影响后面的边。

注意上面“按长度递增顺序”是重点，原因是“路径压缩”可能会改变某些点之间的路径，也就是将某些点之间的路径长度减小。但是，很容易发现，被“压缩”的这些边必然是已经访问过的，也就是说这些边必然已经作为了前面的某条边(i, j)，i到j路径上的边。对于这条边来说，可行变换中，新加入的边的长度应尽量小，因此，如果按长度递增顺序，则这些边在(i, j)之后肯定不会出现代价更小的可行变换，因此就可以将它们压缩，不会影响最优解。

复杂度分析：先不管求LCA的时间复杂度。设树中结点i的深度为h[i]（h[root]=0）。对于树中的任意一个叶结点v，从root到v的路径的总长度（总边数）为h[v]，因此，若某次要尝试的边(i, j)的某一端点（设为i）在从root到v的这条路径上，则p=LCA(i, j)一定也在这条路径上。这样，访问从i到p的路径上的总访问次数（也就是从i到p路径上的边数）为(h[i]-h[p])。在访问完成后，需要将从i到p路径上除p外的所有结点的父结点都设为p，也就是从root到v的路径的总长度减少了(h[i]-h[p]-1)。因此，在尝试所有不在MST中的边的过程中，访问从root到v的最初路径上的边的总次数不会超过(h[v]+这些边的总数)（这里h[v]指初始的h[v]）。因此可以得到：访问树中所有边的总次数不会超过（最初所有叶结点深度之和+2*M），M为所有不在MST中边的总数！由于“最初所有叶结点深度之和”不会超过Nlog2N，因此总时间复杂度为O(Mlog2M+M+Nlog2N)，其中O(Mlog2M)为用Kruskal求MST的时间，如果忽略这部分时间，则总时间复杂度为O(M+Nlog2N)。
其实这个算法的时间复杂度在忽略排序的情况下是线性的，即O(M+N)，但本沙茶搞不懂怎么证明这一步。

下面是具体实现时的注意事项：
（1）将MST转化为有根树时，应用BFS，而不要用DFS，否则对于特殊数据可能爆栈；
（2）求LCA时，应用先让深度大的结点向上的方法（AHdoc神犇的方法），具体见下面的代码片段1；或者应用两者同时往上的方法（本沙茶的方法），具体见下面的代码片段2；否则，对于树是一条链，且每次访问都是访问最深的两个结点时，一次求LCA的时间复杂度可能升到O(N)。

【代码片段1】

int lca(int a, int b)
{
    for (;;)
    {
        if (a == b) return b;
        if (h[a] >= h[b]) a = Fa[a]; else b = Fa[b];
    }
}

【代码片段2】

int LCA(int x, int y)
{
    while (x && y) {
        if (fl[x] == _s) return x; else fl[x] = _s;
        if (fl[y] == _s) return y; else fl[y] = _s;
        x = pr[x]; y = pr[y];
    }
    if (x) while (1) if (fl[x] == _s) return x; else x = pr[x]; else while (1) if (fl[y] == _s) return y; else y = pr[y];
}

【具体题目】Beijing2010 Tree（BZOJ1977）
这题要求严格次小生成树，因此在枚举的时候要注意，不能使可行变换的代价为0。

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
const int MAXN = 100001, MAXM = 300001;
const long long INF = ~0Ull >> 2;
struct edge {
    int a, b, len;
    friend bool operator< (edge e0, edge e1) {return e0.len < e1.len;}
} E[MAXM];
struct edge0 {
    int a, b, id, pre, next;
} E0[MAXM + MAXM];
int n, m, m0, u[MAXN], pr[MAXN], No[MAXN], s[MAXM], Q[MAXN], fl[MAXN], _s;
long long mst_v = 0, res;
bool inmst[MAXM], vst[MAXN];
void init()
{
    scanf("%d%d", &n, &m);
    re(i, m) scanf("%d%d%d", &E[i].a, &E[i].b, &E[i].len);
}
int find(int x) {int r = x, r0; while (u[r] > 0) r = u[r]; while (u[x] > 0) {r0 = u[x]; u[x] = r; x = r0;} return r;}
void uni(int s1, int s2) {int tmp = u[s1] + u[s2]; if (u[s1] > u[s2]) {u[s1] = s2; u[s2] = tmp;} else {u[s2] = s1; u[s1] = tmp;}}
void init_d()
{
    re1(i, n) {E0[i].a = i; E0[i].pre = E0[i].next = i;}
    if (n % 2) m0 = n + 1; else m0 = n + 2;
}
void add_edge(int a, int b, int id)
{
    E0[m0].a = a; E0[m0].b = b; E0[m0].id = id; E0[m0].pre = E0[a].pre; E0[m0].next = a; E0[a].pre = m0; E0[E0[m0].pre].next = m0++;
    E0[m0].a = b; E0[m0].b = a; E0[m0].id = id; E0[m0].pre = E0[b].pre; E0[m0].next = b; E0[b].pre = m0; E0[E0[m0].pre].next = m0++;
}
void prepare()
{
    sort(E, E + m);
    re1(i, n) u[i] = -1; init_d();
    int s1, s2, z = 0;
    re(i, m) {
        s1 = find(E[i].a); s2 = find(E[i].b);
        if (s1 != s2) {z++; mst_v += E[i].len; add_edge(E[i].a, E[i].b, i); inmst[i] = 1; uni(s1, s2); if (z == n - 1) break;}
    }
}
void bfs()
{
    re1(i, n) vst[i] = 0;
    Q[0] = 1; vst[1] = 1;
    int i, j;
    for (int front=0, rear=0; front<=rear; front++) {
        i = Q[front];
        for (int p=E0[i].next; p != i; p=E0[p].next) {
            j = E0[p].b;
            if (!vst[j]) {
                vst[j] = 1; Q[++rear] = j; pr[j] = i; No[j] = E0[p].id;
            }
        }
    }
}
int LCA(int x, int y)
{
    while (x && y) {
        if (fl[x] == _s) return x; else fl[x] = _s;
        if (fl[y] == _s) return y; else fl[y] = _s;
        x = pr[x]; y = pr[y];
    }
    if (x) while (1) if (fl[x] == _s) return x; else x = pr[x]; else while (1) if (fl[y] == _s) return y; else y = pr[y];
}
void sol0(int a, int b, int l)
{
    int p = LCA(a, b), p0, No0;
    while (a != p) {No0 = No[a]; if (!s[No0] && l > E[No0].len) s[No0] = l - E[No0].len; p0 = pr[a]; pr[a] = p; a = p0;}
    while (b != p) {No0 = No[b]; if (!s[No0] && l > E[No0].len) s[No0] = l - E[No0].len; p0 = pr[b]; pr[b] = p; b = p0;}
}
void solve()
{
    pr[1] = 0; bfs();
    re(i, m) if (!inmst[i]) {_s = i + 1; sol0(E[i].a, E[i].b, E[i].len);}
    res = INF;
    re(i, m) if (inmst[i] && s[i] && s[i] < res) res = s[i];
    res += mst_v;
}
void pri()
{
    cout << res << endl;
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-07-01 09:10 发表评论

次小生成树

Mato_No1 — Sun, 29 May 2011 08:03:00 GMT

给出一个带边权的无向图G，设其最小生成树为T，求出图G的与T不完全相同的边权和最小的生成树（即G的次小生成树）。一个无向图的两棵生成树不完全相同，当且仅当这两棵树中至少有一条边不同。注意，图G可能不连通，可能有平行边，但一定没有自环（其实对于自环也很好处理：直接舍弃。因为生成树中不可能出现自环）。
【具体题目】URAL1416（注意，这一题的边数M的范围没有给出，视为124750）
【分析】
定义生成树T的一个可行变换(-E1, +E2)：将T中的边E1删除后，再加入边E2（满足边E2原来不在T中但在G中），若得到的仍然是图G的一棵生成树，则该变换为可行变换，该可行变换的代价为(E2权值 - E1权值)。这样，很容易证明，G的次小生成树就是由G的最小生成树经过一个代价最小的可行变换得到。进一步可以发现，这个代价最小的可行变换中加入的边E2的两端点如果为V1和V2，那么E1一定是原来最小生成树中从V1到V2的路径上的权值最大的边。

这样，对于本题就有两种算法了：（以下的T全部指G的最小生成树）
（1）Prim：
设立数组F，F[x][y]表示T中从x到y路径上的最大边的权值。F数组可以在用Prim算法求最小生成树的过程中得出。每次将边(i, j)加入后（j是新加入树的边，i=c[j]），枚举树中原有的每个点k（包括i，但不包括j），则F[k][j]=max{F[k][i], (i, j)边权值}，又由于F数组是对称的，可以得到F[j][k]=F[k][j]。然后千万记住将图G中的边(i, j)删除（就是将邻接矩阵中(i, j)边权值改为∞）！因为T中的边是不能被加入的。等T被求出后，所有的F值也求出了，然后，枚举点i、j，若邻接矩阵中边(i, j)权值不是无穷大（这说明i、j间存在不在T中的边），则求出{(i, j)边权值 - F[i][j]}的值，即为加入边(i, j)的代价，求最小的总代价即可。
另外注意三种特殊情况：【1】图G不连通，此时最小生成树和次小生成树均不存在。判定方法：在扩展T的过程中找不到新的可以加入的边；【2】图G本身就是一棵树，此时最小生成树存在（就是G本身）但次小生成树不存在。判定方法：在成功求出T后，发现邻接矩阵中的值全部是无穷大；【3】图G存在平行边。这种情况最麻烦，因为这时代价最小的可行变换(-E1, +E2)中，E1和E2可能是平行边！因此，只有建立两个邻接矩阵，分别存储每两点间权值最小的边和权值次小的边的权值，然后，每当一条新边(i, j)加入时，不是将邻接矩阵中边(i, j)权值改为无穷大，而是改为连接点i、j的权值次小的边的权值。

代码：

#include <iostream>
using namespace std;
#define re(i, n) for (int i=0; i
#define re2(i, l, r) for (int i=l; i
const int MAXN = 7000, INF = ~0U >> 2;
int n, s[MAXN][MAXN], s2[MAXN][MAXN], f[MAXN][MAXN], c[MAXN], v[MAXN], res1 = 0, res2 = 0;
bool vst[MAXN];
void init()
{
    freopen("mst.in", "r", stdin);
    scanf("%d", &n);
    re(i, n) re(j, n) s[i][j] = s2[i][j] = INF;
    int m, a, b, len;
    scanf("%d", &m);
    if (!m) {
        if (n > 1) res1 = -INF; res2 = -INF;
        return;
    }
    re(i, m) {
        scanf("%d%d%d", &a, &b, &len); a--; b--;
        if (len < s[a][b]) {s2[a][b] = s2[b][a] = s[a][b]; s[a][b] = s[b][a] = len;} else if (len < s2[a][b]) s2[a][b] = s2[b][a] = len;
    }
    fclose(stdin);
}
void solve()
{
    re(i, n) {f[i][i] = c[i] = vst[i] = 0; v[i] = s[0][i];} vst[0] = 1;
    int l0, l1 = INF, x, y, z;
    re2(i, 1, n) {
        l0 = INF; re(j, n) if (!vst[j] && v[j] < l0) {l0 = v[j]; x = j; y = c[j];}
        if (l0 == INF) {res1 = res2 = -INF; return;}
        vst[x] = 1; res1 += l0; s[x][y] = s[y][x] = INF; if (s2[x][y] < INF && s2[x][y] - l0 < l1) l1 = s2[x][y] - l0;
        re(j, n) if (!vst[j] && s[x][j] < v[j]) {v[j] = s[x][j]; c[j] = x;}
        re(j, n) if (vst[j] && j != x) f[j][x] = f[x][j] = max(f[j][y], l0);
    }
    re(i, n-1) re2(j, i+1, n) if (s[i][j] < INF) {
        z = s[i][j] - f[i][j];
        if (z < l1) l1 = z;
    }
    if (l1 == INF) res2 = -INF; else res2 = res1 + l1;
}
void pri()
{
    freopen("mst.out", "w", stdout);
    printf("Cost: %d\nCost: %d\n", res1 == -INF ? -1 : res1, res2 == -INF ? -1 : res2);
    fclose(stdout);
}
int main()
{
    init();
    if (!res2) solve();
    pri();
    return 0;
}

效率分析：Prim算法求次小生成树的时空复杂度均为O(N²)。

（2）Kruskal：
Kruskal算法也可以用来求次小生成树。在准备加入一条新边(a, b)（该边加入后不会出现环）时，选择原来a所在连通块（设为S1）与b所在连通块（设为S2）中，点的个数少的那个（如果随便选一个，最坏情况下可能每次都碰到点数多的那个，时间复杂度可能增至O(NM)），找到该连通块中的每个点i，并遍历所有与i相关联的边，若发现某条边的另一端点j在未选择的那个连通块中（也就是该边(i, j)跨越了S1和S2）时，就说明最终在T中"删除边(a, b)并加入该边"一定是一个可行变换，且由于加边是按照权值递增顺序的，(a, b)也一定是T中从i到j路径上权值最大的边，故这个可行变换可能成为代价最小的可行变换，计算其代价为[(i, j)边权值 - (a, b)边权值]，取最小代价即可。注意，在遍历时需要排除一条边，就是(a, b)本身（具体实现时由于用DL边表，可以将边(a, b)的编号代入）。另外还有一个难搞的地方：如何快速找出某连通块内的所有点？方法：由于使用并查集，连通块是用树的方式存储的，可以直接建一棵树（准确来说是一个森林），用“最左子结点+相邻结点”表示，则找出树根后遍历这棵树就行了，另外注意在合并连通块时也要同时合并树。
对于三种特殊情况：【1】图G不连通。判定方法：遍历完所有的边后，实际加入T的边数小于(N-1)；【2】图G本身就是一棵树。判定方法：找不到这样的边(i, j)；【3】图G存在平行边。这个对于Kruskal来说完全可以无视，因为Kruskal中两条边只要编号不同就视为不同的边。
其实Kruskal算法求次小生成树还有一个优化：每次找到边(i, j)后，一处理完这条边就把它从图中删掉，因为当S1和S2合并后，(i, j)就永远不可能再是可行变换中的E2了。

代码：

#include <iostream>
#include <stdlib.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
const int MAXN = 7000, MAXM = 130000, INF = ~0U >> 2;
struct edge {
    int a, b, len, pre, next;
} ed[MAXM + MAXM];
struct edge2 {
    int a, b, len, No;
} ed2[MAXM];
int n, m = 0, m2, u[MAXN], ch[MAXN], nx[MAXN], q[MAXN], res1 = 0, res2 = INF;
void init_d()
{
    re(i, n) ed[i].a = ed[i].pre = ed[i].next = i;
    if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b, int l)
{
    ed[m].a = a; ed[m].b = b; ed[m].len = l; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
    ed[m].a = b; ed[m].b = a; ed[m].len = l; ed[m].pre = ed[b].pre; ed[m].next = b; ed[b].pre = m; ed[ed[m].pre].next = m++;
}
void del_edge(int No)
{
    ed[ed[No].pre].next = ed[No].next; ed[ed[No].next].pre = ed[No].pre;
    ed[ed[No ^ 1].pre].next = ed[No ^ 1].next; ed[ed[No ^ 1].next].pre = ed[No ^ 1].pre;
}
void init()
{
    freopen("mst.in", "r", stdin);
    scanf("%d%d", &n, &m2);
    if (!m2) {
        if (n > 1) res1 = -INF;
        res2 = -INF; return;
    }
    init_d();
    int a, b, len;
    re(i, m2) {
        scanf("%d%d%d", &a, &b, &len);
        ed2[i].No = m; add_edge(--a, --b, len);
        ed2[i].a = a; ed2[i].b = b; ed2[i].len = len;
    }
    fclose(stdin);
}
int cmp(const void *s1, const void *s2)
{
    return ((edge2 *)s1)->len - ((edge2 *)s2)->len;
}
void prepare()
{
    re(i, n) u[i] = ch[i] = nx[i] = -1;
    qsort(ed2, m2, 16, cmp);
}
int find(int x)
{
    int r = x, r0 = x, tmp;
    while (u[r] >= 0) r = u[r];
    while (u[r0] >= 0) {tmp = u[r0]; u[r0] = r; r0 = tmp;}
    return r;
}
void uni(int r1, int r2, int No, int l0)
{
    q[0] = r1;
    int j, k, l1, front, rear;
    for (front=0, rear=0; front<=rear; front++) {
        j = ch[q[front]];
        while (j != -1) {
            q[++rear] = j;
            j = nx[j];
        }
    }
    re3(i, 0, rear) {
        j = q[i];
        for (int p=ed[j].next; p != j; p=ed[p].next) {
            k = ed[p].b;
            if (p != No && find(k) == r2) {
                l1 = ed[p].len - l0;
                if (l1 < res2) res2 = l1;
                del_edge(p);
            }
        }
    }
    u[r2] += u[r1]; u[r1] = r2; nx[r1] = ch[r2]; ch[r2] = r1;
}
void solve()
{
    int r1, r2, l0, num = 0;
    re(i, m2) {
        r1 = find(ed2[i].a); r2 = find(ed2[i].b);
        if (r1 != r2) {
            l0 = ed2[i].len; res1 += l0; num++;
            if (u[r1] >= u[r2]) uni(r1, r2, ed2[i].No, l0); else uni(r2, r1, ed2[i].No ^ 1, l0);
        }
    }
    if (num < n - 1) {res1 = res2 = -INF; return;}
    if (res2 == INF) res2 = -INF; else res2 += res1;
}
void pri()
{
    freopen("mst.out", "w", stdout);
    printf("Cost: %d\nCost: %d\n", res1 == -INF ? -1 : res1, res2 == -INF ? -1 : res2);
    fclose(stdout);
}
int main()
{
    init();
    if (!res1 && res2 == INF) {
        prepare();
        solve();
    }
    pri();
    return 0;
}

效率分析：可以证明，如果每次都选取点少的连通块，Kruskal算法求次小生成树的时间复杂度为O(M*(logN+logM))，空间复杂度为O(M)。
总结：显然Prim适用于稠密图，而Kruskal适用于稀疏图。

下面是对于一些数据的测试结果（数据说明：第1~9个点和第15个点为稠密图或一般图，第10~14个点为稀疏图）

Prim：

Kruskal（加入删边优化）：

Kruskal（未加删边优化）：

Mato_No1 2011-05-29 16:03 发表评论

最小度限制生成树

Mato_No1 — Mon, 23 May 2011 13:05:00 GMT

给出一个带边权连通无向图，当中指定一个点V0，要求这个图的一个生成树，使得树中V0点的度数（和V0点关联的边数）刚好为一个指定值P，求满足此条件的边权和最小的生成树。

【算法】（某神犇的论文里有详细证明，这里省略了囧……）
设l[i]为连接图中点V0与点i之间的边的长度（若有多条边取权值最小的，若没有边则为无穷大）。
（1）在图中删除点V0，新的图不一定是连通图，设其有B个连通块；
（2）若P（3）对这B个连通块分别求最小生成树，得到一个生成森林。然后在图中重新加入点V0，对每个连通块，找出该连通块内l值最小的点V'，添加边(V0, V')，这样就得到了一棵初始的生成树，或者说，这是V0点度数为B的最小的生成树；
（4）然后就是不断往里面加入与V0相关联的边。从V0点开始，对整棵生成树BFS遍历，对每个点i，找到目前的生成树中从V0到i的路径上权值最大的边，设E_len[i]为这条边的权值，E_No[i]为这条边的编号（由于本沙茶使用的是DL边表，故记录编号），这个东东的求法很容易，省略；
（5）最后，枚举除V0点外的每个点，找到(E_len[i]-l[i])值最大的点i，然后在图中删除边E_No[i]，加入边(V0, i)，这样得到的仍然是原图的生成树，且V0的度数增加1；
（6）重复以上过程(P-B)次即得结果。

【实现注意】
为了编程实现更加方便，注意以下几点：
（1）一开始不加入V0，而不是加入了再删去（但各点l值要在输入时求出）；
（2）一开始不用先求出B的值，而是先求出最小生成森林（用Kruskal，不断加边，直到加到不能再加为止）和初始生成树，再遍历初始生成树得到B值；
（3）由于涉及删边，一定要用DL边表。

【代码】（PKU1639，注意这题是求V0度数不超过给定值P的最小生成树，简单改装即可）：

#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
#define re(i, n) for (int i=0; i
#define re2(i, l, r) for (int i=l; i
const int MAXN = 30, MAXM = 5000, MAXLEN = 20, INF = ~0U >> 2;
struct edge {
    int a, b, len, pre, next;
} ed[MAXM + MAXM];
struct edge0 {
    int a, b, len;
} ed0[MAXM];
int n, m, m0 = 0, P, B = 0, l[MAXN], u[MAXN], B_No[MAXN], q[MAXN], E_No[MAXN], E_len[MAXN], res = 0;
string NAMELIST[MAXN];
bool vst[MAXN];
void add_edge0(int a, int b, int len)
{
    ed0[m0].a = a; ed0[m0].b = b; ed0[m0++].len = len;
}
void init_d()
{
    re(i, n) ed[i].a = ed[i].pre = ed[i].next = i;
    if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b, int len)
{
    ed[m].a = a; ed[m].b = b; ed[m].len = len; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
    ed[m].a = b; ed[m].b = a; ed[m].len = len; ed[m].pre = ed[b].pre; ed[m].next = b; ed[b].pre = m; ed[ed[m].pre].next = m++;
}
void del_edge(int No)
{
    ed[ed[No].pre].next = ed[No].next; ed[ed[No].next].pre = ed[No].pre;
    ed[ed[No ^ 1].pre].next = ed[No ^ 1].next; ed[ed[No ^ 1].next].pre = ed[No ^ 1].pre;
}
void init()
{
    n = 1; NAMELIST[0] = "Park"; int m_;
    scanf("%d", &m_); char ch = getchar(), s01[MAXLEN], s02[MAXLEN]; int No1, No2, l0, tmp;
    re(i, MAXN) l[i] = INF;
    re(i, m_) {
        scanf("%s %s %d", s01, s02, &l0); ch = getchar();
        No1 = -1; re(j, n) if (NAMELIST[j] == s01) {No1 = j; break;} if (No1 == -1) NAMELIST[No1 = n++] = s01;
        No2 = -1; re(j, n) if (NAMELIST[j] == s02) {No2 = j; break;} if (No2 == -1) NAMELIST[No2 = n++] = s02;
        if (No1 > No2) {tmp = No1; No1 = No2; No2 = tmp;}
        if (No1) add_edge0(No1, No2, l0); else if (l0 < l[No2]) l[No2] = l0;
    }
    scanf("%d", &P);
}
int cmp(const void *s1, const void *s2)
{
    return ((edge0 *)s1)->len - ((edge0 *)s2)->len;
}
int find_root(int x)
{
    int r = x, r0 = x, tmp;
    while (u[r] >= 0) r = u[r];
    while (u[r0] >= 0) {tmp = u[r0]; u[r0] = r; r0 = tmp;}
    return r;
}
void uni(int r1, int r2)
{
    int sum = u[r1] + u[r2];
    if (u[r1] >= u[r2]) {u[r1] = r2; u[r2] = sum;} else {u[r2] = r1; u[r1] = sum;}
}
void prepare()
{
    qsort(ed0, m0, 12, cmp);
    re2(i, 1, n) u[i] = -1; init_d();
    int x1, x2, l0, r1, r2;
    re(i, m0) {
        x1 = ed0[i].a; x2 = ed0[i].b; l0 = ed0[i].len; r1 = find_root(x1); r2 = find_root(x2);
        if (r1 != r2) {uni(r1, r2); add_edge(x1, x2, l0); res += l0;}
    }
    re2(i, 1, n) B_No[i] = -1;
    int Best, Best_No;
    re2(i, 1, n) if (B_No[i] == -1) {
        B_No[i] = B; Best = l[i]; Best_No = q[0] = i;
        int j, k;
        for (int front=0, rear=0; front<=rear; front++) {
            j = q[front];
            for (int p=ed[j].next; p != j; p=ed[p].next) {
                k = ed[p].b;
                if (B_No[k] == -1) {
                    B_No[k] = B; q[++rear] = k; if (l[k] < Best) {Best = l[k]; Best_No = k;}
                }
            }
        }
        add_edge(0, Best_No, Best); res += Best; B++;
    }
}
void solve()
{
    vst[0] = 1;
    re2(P0, B, P) {
        re2(i, 1, n) {E_len[i] = INF; vst[i] = 0;} q[0] = 0;
        int i, j, l0;
        for (int front=0, rear=0; front<=rear; front++) {
            i = q[front];
            for (int p=ed[i].next; p != i; p=ed[p].next) {
                j = ed[p].b; l0 = ed[p].len;
                if (!vst[j]) {
                    vst[j] = 1; q[++rear] = j;
                    if (E_len[i] > l0) {E_len[j] = E_len[i]; E_No[j] = E_No[i];} else {E_len[j] = l0; E_No[j] = p;}
                }
            }
        }
        int Best = 0, Best_No, Best_v;
        re2(i, 1, n) {
            l0 = E_len[i] - l[i];
            if (l0 > Best) {Best = l0; Best_No = E_No[i]; Best_v = i;};
        }
        if (Best) {del_edge(Best_No); add_edge(0, Best_v, l[Best_v]); res -= Best;} else break;
    }
}
void pri()
{
    printf("Total miles driven: %d\n", res);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-05-23 21:05 发表评论

最近捉的一些图论题

Mato_No1 — Sun, 22 May 2011 03:09:00 GMT

摘要: 【1】PKU1094思考难度不大，就是不断在有向图中加边，求加了几条边以后，图中出现一条连接N个点的简单路径（就是一条长度为(N-1)的链），或者图中出现环。判定连接N个点的简单路径的算法：拓扑排序，若每次队列中有且只有一个入度为0的点，则这样的路径存在，所排出的顺序就是结果。注意两点：（1）如果在前面的若干条边加入后，已经找到了解，那么就输出解，结束（不管后面的边了，即使后面的边加入后形成环也无... 阅读全文

Mato_No1 2011-05-22 11:09 发表评论

在二分图中应用Dancing Link边表的一个实例

Mato_No1 — Sun, 08 May 2011 04:04:00 GMT

搞完了网络流图，搞完了一般图，最后应该是二分图了（在本沙茶知道的图的范围内）
二分图的边有些特别，边并不是表示从a到b的边，而是从X方点a（简记为X_a）到Y方点b（简记为Y_b）的边。在二分图中，边其实是无向的，但由于大多数引用的时候都是X方点引用Y方点，所以可以把边看成有向的（如果实在要逆向引用的话，加一条逆向边吧囧……）
边类型定义（和一般图完全一致。这里是不带权的，如果像KM算法里面有带权边，加一个len域即可）：

struct edge {
int a, b, pre, next;
} ed[MAXM];

关键是在初始化表头的时候，设图中有NX个X方点和NY个Y方点，则单点链表数其实只有NX。故只需弄NX个表头即可：

void init_d()
{
re(i, nx) ed[i].a = ed[i].pre = ed[i].next = i;
if (nx % 2) m = nx + 1; else m = nx;
}

然后是加边，和一般图完全一致：

void add_edge(int a, int b)
{
ed[m].a = a; ed[m].b = b; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
}

差不多就搞完了。下面是用Dancing Link边表实现的Hungary算法的深度优先遍历部分：

bool dfs(int x)
{
    vst[x] = 1;
    int y, x1;
    for (int p=ed[x].next; p != x; p=ed[p].next) {
        y = ed[p].b; x1 = xz[y];
        if (x1 == -1 || !vst[x1] && dfs(x1)) {
            xz[y] = x; return 1;
        }
    }
    return 0;
}

这里xz[y]指的是y所匹配的X方点编号（若y是未盖点则xz[y]=-1），vst[x]是X方点x是否被访问的标志，在每次遍历前，vst都要全部清零。

【应用实例】PKU1087
题意很难懂，其实就是：房间里有N个插座，每个插座都有一个型号（没有两个插座的型号相同），现在要把M个用电器插到这N个插座里，每个用电器有一个默认型号，表示该用电器只能插到其默认型号的插座里（有可能有的用电器的默认型号不与房间里的任意一个插座对应，如样例中的X型号）。有K种适配器（每种适配器可以用无限次），每一种适配器都有两个参数S1和S2，表示该种适配器使用一次可以将某个默认型号为S1的用电器的默认型号改为S2（同一个用电器可以被多次改变默认型号）。问在使用了若干次适配器后，最少有多少个用电器插不到插座里？
首先将每种型号作为一个点，若某种适配器的两个参数分别为S1和S2则连边，对这个有向图求传递闭包。然后再建一个二分图，X方点表示用电器，Y方点表示插座，若X_i的初始默认型号在一开始建的有向图中可以到达Y_j的型号（用传递闭包直接得到），则连边(X_i, Y_j)。对这个二分图求最大匹配，则(M - 最大匹配值)就是结果。
代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;
#define re(i, n) for (int i=0; i
const int MAXN = 500, MAXM = 250500, MAXLEN = 50, INF = ~0U >> 2;
struct edge {
    int a, b, pre, next;
} ed[MAXM];
int n, nx, ny, m, xt[MAXN], yt[MAXN], xz[MAXN], res = 0;
bool f[MAXN][MAXN], vst[MAXN];
string nm[MAXN];
void init()
{
    string s1, s2;
    char s01[MAXLEN], s02[MAXLEN], ch;
    scanf("%d", &ny); ch = getchar();
    re(i, ny) {gets(s01); nm[i] = s01; yt[i] = i;} n = ny;
    scanf("%d", &nx); ch = getchar();
    re(i, nx) {
        scanf("%s %s", s01, s02); ch = getchar(); xt[i] = n;
        re(j, n) if (nm[j] == s02) {xt[i] = j; break;}
        if (xt[i] == n) nm[n++] = s02;
    }
    int z, t1, t2;
    scanf("%d", &z); ch = getchar();
    re(i, z) {
        scanf("%s %s", s01, s02); ch = getchar();
        t1 = n; re(j, n) if (nm[j] == s01) {t1 = j; break;}
        if (t1 == n) nm[n++] = s01;
        t2 = n; re(j, n) if (nm[j] == s02) {t2 = j; break;}
        if (t2 == n) nm[n++] = s02;
        f[t1][t2] = 1;
    }
    re(i, n) f[i][i] = 1;
}
void add_edge(int a, int b)
{
    ed[m].a = a; ed[m].b = b; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
}
void prepare()
{
    re(k, n) re(i, n) re(j, n) f[i][j] = f[i][j] || f[i][k] && f[k][j];
    re(i, nx) ed[i].a = ed[i].pre = ed[i].next = i;
    if (nx % 2) m = nx + 1; else m = nx;
    re(i, nx) {
        int t0 = xt[i];
        re(j, ny) if (f[t0][j]) add_edge(i, j);
    }
}
bool dfs(int x)
{
    vst[x] = 1;
    int y, x1;
    for (int p=ed[x].next; p != x; p=ed[p].next) {
        y = ed[p].b; x1 = xz[y];
        if (x1 == -1 || !vst[x1] && dfs(x1)) {
            xz[y] = x; return 1;
        }
    }
    return 0;
}
void solve()
{
    re(i, ny) xz[i] = -1;
    re(i, nx) {
        re(j, ny) vst[j] = 0;
        res += dfs(i);
    }
}
void pri()
{
    printf("%d\n", nx - res);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

有关图的Dancing Link边表的内容就到此为止了。这真是一种有大用的数据结构。

Mato_No1 2011-05-08 12:04 发表评论

在一般的图中应用Dancing Link边表的一个实例

Mato_No1 — Sun, 08 May 2011 02:04:00 GMT

之前本沙茶成功地在网络流图中搞出Dancing Link边表，那么对于一般的图，是否也能用Dancing Link边表呢？答案是肯定的。

边类型（带权的，不带边权的图把len域去掉即可）：

struct edge {
int a, b, len, pre, next;
} ed[MAXM];

初始化表头：

void init_d()
{
re(i, n) ed[i].a = ed[i].pre = ed[i].next = i;
if (n % 2) m = n + 1; else m = n;
}

加边（这里是加有向边，如果加无向边的话，再加一条边即可）：

void add_edge(int a, int b, int len)
{
ed[m].a = a; ed[m].b = b; ed[m].len = len; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
}

在一般的图中应用Dancing Link边表的优势：【1】能够有效处理删边删点问题；【2】在无向图中，能够很快找到一条边对应的逆向边；【3】最大的优势是：如果要从某一条单点链表（其实整个边表可以看成N个单点链表的并，N为图中的点数）的中间开始遍历，或者逆向遍历整个表的话，一般的邻接链表几乎不可能完成，一般的边表也很麻烦，这种Dancing Link边表则可以很快搞定。不过它也有缺点：空间消耗比邻接链表和一般边表大一些（不过这个影响不大）。

【应用实例】PKU1062（PKU上少有的中文题）
很水的最短路问题。将每个物品当成一个点，若j可作为i的优惠品则连边，边权为优惠价格，然后，枚举等级限制（由于物品1是必须选的，因此设最大等级限制为lmt，物品1的等级为V，则可在[V-lmt, V]范围内枚举最低等级，最高等级就是(最低等级+lmt)），将所有不在等级限制内的点全部删除（其实不用真删除，只要设一个del数组避开它们即可），求从结点1到各结点的最短路，则min(dist[i]+cs[i])（dist[i]表示1到i的最短路，cs[i]表示直接购买物品i的价格）就是结果。
代码（2Y，一开始把solve里的g[j]弄成g[i]了囧……静态查错V5啊……神犇不要鄙视）：

#include <iostream>
#include <stdio.h>
#include <queue>
#include <utility>
using namespace std;
#define re(i, n) for (int i=0; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
typedef pair <int, int> i_i;
typedef priority_queue <i_i, vector<i_i>, greater<i_i> > pqi_i;
const int MAXN = 100, MAXM = 30000, INF = ~0U >> 2;
struct edge {
    int a, b, len, pre, next;
} ed[MAXM];
int n, m, s, lmt, cs[MAXN], g[MAXN], dist[MAXN], res = INF;
bool del[MAXN];
pqi_i q;
void init_d()
{
    re(i, n) ed[i].a = ed[i].pre = ed[i].next = i;
    if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b, int len)
{
    ed[m].a = a; ed[m].b = b; ed[m].len = len; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
}
void init()
{
    int b0, x, y;
    scanf("%d%d", &lmt, &n);
    init_d();
    re(i, n) {
        scanf("%d%d%d", &cs[i], &g[i], &x);
        re(j, x) {
            scanf("%d%d", &b0, &y);
            add_edge(i, --b0, y);
        }
    }
}
void sol1()
{
    re(i, n) if (!del[i]) dist[i] = INF + 1; q.push(i_i(0, s));
    int i, j, d0, d1;
    while (!q.empty()) {
        d0 = q.top().first; i = q.top().second; q.pop();
        if (dist[i] == INF + 1) {
            dist[i] = d0;
            for (int p=ed[i].next; p != i; p=ed[p].next) {
                j = ed[p].b;
                if (!del[j]) {
                    d1 = d0 + ed[p].len; q.push(i_i(d1, j));
                }
            }
        }
    }
    re(i, n) if (!del[i]) {
        d0 = cs[i] + dist[i];
        if (d0 < res) res = d0;
    }
}
void solve()
{
    int lf, rt; s = 0;
    re3(i, 0, lmt) {
        lf = g[s] - i; rt = lf + lmt;
        re(j, n) del[j] = g[j] < lf || g[j] > rt;
        sol1();
    }
}
void pri()
{
    printf("%d\n", res);
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-05-08 10:04 发表评论

网络流图边表的新表示法：Dancing Link边表（解决需要删边或删点或改容量的多次求最大流问题）

Mato_No1 — Sat, 07 May 2011 06:12:00 GMT

考虑这样一种网络流问题：需要对同一个图求多次最大流。则在每次求最大流之前，需要将所有边的容量全部恢复到初始值（求最大流的过程中，边的容量f值被改变了）。不过这还不算最猥琐的，有的时候，我们需要在每次求最大流之前都删去图中的一些点或一些边，或者改变某些原有的边的容量，特别是需要删点或删边的情况爆难搞。因为，一般的边表中边类型定义如下：

struct edge {
int a, b, f, next;
} ed[MAXM + MAXM];

表示这条边起点为a，终点为b，容量为f，邻接边（就是下一条起点为a的边）的编号为next。
如果要求多次最大流，那么在每次求最大流之前就要把所有边的容量恢复到初始值，解决方法是引入一个“初始容量”域fs，在这条边刚刚被加入的时候将它的fs值和f值都设为初始给它的容量，在恢复时，只要将所有边的f值恢复到fs即可。若要改变边容量，则将该边的fs值和f值都设为改变后的容量即可。

下面来分析需要删边或删点的情况。在这种情况下，如果采用只有next的单向链表，则删除时next域极难处理，而且，在一般的边表中，还设立了表头hd，hd[a]表示边表中起点为a的第一条边的编号。因此，若删除的边是起点为a的第一条边，还会影响hd[a]的值，使情况变得更为复杂。因此，必须采用双向链表！还记得Dancing Link么？边表其实也可以搞成Dancing Link，方法如下：
设图中有N个点，M条边（注意，这M条边只包括正向边，不包括反向边。由于每条正向边都对应一条反向边，因此边表中边的数目其实是M+M）。首先把边表ed的0~N这(N+1)个位置（下标）空出来，作表头（表头不是边，因此在遍历边的时候不会遍历到它们）。其中，ed[0]为总表头，用于遍历ed[1..N]中每个未被删去的点；ed[1..N]为单点表头，ed[i]用来遍历图中所有以i为起点的边（和DLX中的二维DL惊人相似）。然后，若N为偶数，则空一个位置（也就是将ed[N+1]丢弃不用），这是因为我们在增广过程中需要引用到一条边对应的逆向边（正向边对应反向边，反向边对应正向边），一般认为编号为p的边对应的逆向边是p ^ 1，这样，就要求图中所有正向边的编号都是偶数，所有反向边的编号都是奇数（否则会造成混乱）。因此当N为偶数时，(N+1)为奇数，不能放置第一条正向边，需要从ed[N+2]开始放置正向边。若N为奇数则不用空位。
接下来就是边类型了。在这里，边类型一共需要包括6个域：a, b, fs, f, pre, next，表示这条边起点为a，终点为b，初始容量为fs，当前容量为f，上一条起点为a的边编号为pre，下一条起点为a的边编号为next。注意，和DL一样，整个链表是循环的，也就是我们认为表中最后一条起点为a的边的下一条邻接边编号就是a（表头），同样，a的上一条邻接边也就是这条边。

struct edge {
int a, b, fs, f, pre, next;
} ed[MAXM + MAXM];

接下来就是几个重要过程了。
（1）初始化表头：

void init_d()
{
re1(i, n) {ed[i].a = i; ed[i].b = -1; ed[i].f = 0; ed[i].pre = ed[i].next = i;}
if (n % 2) m = n + 1; else m = n + 2;
}

这里n是图中的点数（相当于N），m是边的编号指针（相当于DLX中的nodes）
（2）添加新边：

void add_edge(int a, int b, int f)
{
ed[m].a = a; ed[m].b = b; ed[m].fs = ed[m].f = f; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
ed[m].a = b; ed[m].b = a; ed[m].fs = ed[m].f = 0; ed[m].pre = ed[b].pre; ed[m].next = b; ed[b].pre = m; ed[ed[m].pre].next = m++;
}

这个和DLX类似，不解释了囧……

最后进入最核心的部分——到底如何处理删边或删点？有了DL型边表就爆好搞了：删去一条边，只要直接删去该边在DL中的位置即可：

void deledge(int No)
{
ed[ed[No].pre].next = ed[No].next; ed[ed[No].next].pre = ed[No].pre;
}

恢复一条已删去的边：

void resuedge(int No)
{
ed[ed[No].pre].next = ed[ed[No].next].pre = No;
}

需要删点的情况类似，对单点表头处理即可。

【具体题目】PKU1815
这题就是求有向图的字典序最小的最小点割集问题，方法是先求出最小点连通度（有关最小点连通度的求法见图的连通度问题的求法），然后按编号递增顺序枚举每个点，若删去该点（其实是删去建成的新图中该点i'到该点附加点i''之间的边）后图的最小点连通度减小，则应删去该点，否则不应删去该点。删去后，继续枚举下一个点，直到求出点割集为止。
注意，本题只有删边，没有删点，因此总表头可以不需要，直接从ed[0]开始作单点表头。此时，关于是否空位就刚好反过来了：如果N是奇数就要空位，N是偶数不空位（不过这题里由于建出的网络流图中有2*N0个结点，总是偶数，可以不管，不过本沙茶还是管这个了）。

代码（神犇不要鄙视）：

#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
const int MAXN = 501, MAXM = 100000, INF = ~0U >> 2;
struct edge {
    int a, b, fs, f, pre, next;
} ed[MAXM + MAXM];
int n0, n, m = 0, s, t, start[MAXN], pr[MAXN], hs[MAXN], lev[MAXN], q[MAXN], now, flow, reslen = 0, res[MAXN];
bool vst[MAXN];
void init_d()
{
    re(i, n) {ed[i].a = i; ed[i].b = -1; ed[i].f = 0; ed[i].pre = ed[i].next = i;}
    if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b, int f)
{
    ed[m].a = a; ed[m].b = b; ed[m].fs = ed[m].f = f; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
    ed[m].a = b; ed[m].b = a; ed[m].fs = ed[m].f = 0; ed[m].pre = ed[b].pre; ed[m].next = b; ed[b].pre = m; ed[ed[m].pre].next = m++;
}
void init()
{
    int x;
    scanf("%d%d%d", &n0, &s, &t);
    n = n0 << 1; s--; t += n0 - 1; init_d();
    re(i, n0) re(j, n0) {
        scanf("%d", &x);
        if (i == j) {
            if (i == s || i == t - n0) add_edge(i, i + n0, INF); else add_edge(i, i + n0, 1);
        } else if (x) add_edge(i + n0, j, INF);
    }
}
void aug()
{
    int z = hs[t], i = t, p; flow += z;
    while (i != s) {
        hs[i] -= z; p = pr[i]; ed[p].f -= z; ed[p ^ 1].f += z; i = ed[p].a;
        if (!ed[p].f) now = i;
    }
}
bool dfs()
{
    re(i, n) vst[i] = 0; vst[s] = 1; q[0] = s; lev[s] = 0;
    int i, j, f0;
    for (int front=0, rear=0; front<=rear; front++) {
        i = q[front];
        for (int p=ed[i].next; p != i; p=ed[p].next) if (ed[p].f) {
            j = ed[p].b;
            if (!vst[j]) {vst[j] = 1; q[++rear] = j; lev[j] = lev[i] + 1;}
        }
    }
    if (!vst[t]) return 0;
    now = s; re(i, n) {start[i] = ed[i].next; vst[i] = 0;} hs[now] = INF;
    bool fd;
    while (!vst[s]) {
        if (now == t) aug();
        fd = 0;
        for (int p=start[now]; p != now; p=ed[p].next) {
            j = ed[p].b; f0 = ed[p].f;
            if (lev[now] + 1 == lev[j] && !vst[j] && f0) {
                fd = 1; start[now] = pr[j] = p; hs[j] = hs[now] <= f0 ? hs[now] : f0; now = j; break;
            }
        }
        if (!fd) {
            vst[now] = 1;
            if (now != s) now = ed[pr[now]].a;
        }
    }
    return 1;
}
void deledge(int No)
{
    ed[ed[No].pre].next = ed[No].next; ed[ed[No].next].pre = ed[No].pre;
}
void resuedge(int No)
{
    ed[ed[No].pre].next = ed[ed[No].next].pre = No;
}
void resu_all()
{
    re(i, n) for (int p=ed[i].next; p != i; p=ed[p].next) ed[p].f = ed[p].fs;
}
void solve()
{
    flow = 0; while (dfs()) ; int f_ = flow;
    if (!flow) {reslen = -1; return;}
    re(i, m) if (ed[i].a + n0 == ed[i].b && ed[i].a != s && ed[i].b != t) {
        deledge(i); deledge(i ^ 1); resu_all();
        flow = 0; while (dfs()) ;
        if (flow < f_) {res[reslen++] = ed[i].a + 1; f_--;} else {resuedge(i ^ 1); resuedge(i);}
    }
}
void pri()
{
    if (reslen == -1) puts("0"); else if (reslen) {
        printf("%d\n", reslen);
        re(i, reslen - 1) printf("%d ", res[i]); printf("%d\n", res[reslen - 1]);
    } else puts("NO ANSWER!");
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-05-07 14:12 发表评论

用A*求图的单源单汇第K短路

Mato_No1 — Sun, 01 May 2011 07:25:00 GMT

【问题描述】
给出一个图G和指定的源点s、汇点t，求图中从点s到点t的第K短路。
【具体题目】PKU2449（注意：本题有一个猥琐之处：不允许空路径。也就是当s等于t时要将K值加1）
【算法】
本题有一种最朴素的办法：改造Dijkstra，一开始路径(s, 0)（这里设路径(i, l)表示从s到i的一条长度为l的路径）入队。然后，每次取队中长度最短的路径，该路径(i, l)出队，可以证明，若这是终点为i的路径第x次出队，该路径一定是图中从s到i的第x短路（若x>K则该路径已无用，舍弃）。然后从点i扩展，将扩展到的路径全部入队。这样直到终点为t的路径第K次出队即可。
该算法容易实现（借助priority_queue），但时间复杂度可能达到O(MK)，需要优化。
优化：容易发现该算法其实有A*的思想，或者说，该算法其实是所有结点的估价函数h()值均为0的A*算法。为了优化此题，需要将h()值改大。显然，h(i)值可以设为从i到t的最短路径长度（容易证明它是一致的），然后g(i)=目前结点代表的路径长度，f(i)=g(i)+h(i)，然后A*即可。

注意：更改路径条数应该在出队时更改，而不能在入队时更改，因为可能在该路径出队之前会有新的比它更短的路径入队。

代码（PKU2449）：

#include <iostream>
#include <stdio.h>
#include <queue>
using namespace std;
#define re(i, n) for (int i=0; i
const int MAXN = 1500, MAXM = 150000, INF = ~0U >> 2;
struct edge {
    int kk, len, next;
} ed[MAXM], ed2[MAXM];
int n, m, s, t, k_, hd[MAXN], tl[MAXN], hd2[MAXN], tl2[MAXN], h[MAXN], q[MAXN + 1], No[MAXN], res = -1;
bool vst[MAXN];
struct qnode {
    int i, g;
};
typedef priority_queue <qnode, vector<qnode> > pq;
pq z;
bool operator< (qnode q1, qnode q2)
{
    return q1.g + h[q1.i] > q2.g + h[q2.i];
}
void init()
{
    int a0, b0, l0;
    scanf("%d%d", &n, &m);
    re(i, n) hd[i] = tl[i] = hd2[i] = tl2[i] = -1;
    re(i, m) {
        scanf("%d%d%d", &a0, &b0, &l0); a0--; b0--;
        ed[i].kk = b0; ed[i].len = l0; ed[i].next = -1;
        if (hd[a0] == -1) hd[a0] = tl[a0] = i; else tl[a0] = ed[tl[a0]].next = i;
        ed2[i].kk = a0; ed2[i].len = l0; ed2[i].next = -1;
        if (hd2[b0] == -1) hd2[b0] = tl2[b0] = i; else tl2[b0] = ed2[tl2[b0]].next = i;
    }
    scanf("%d%d%d", &s, &t, &k_); --s; --t; k_ += s == t;
}
void prepare()
{
    re(i, n) {h[i] = INF; vst[i] = 0;} h[t] = 0; vst[t] = 1; q[0] = t;
    int i, h0, j, h1;
    for (int front=0, rear=0; !(!front && rear == n || front == rear + 1); front == n ? front = 0 : front++) {
        i = q[front]; h0 = h[i];
        for (int p=hd2[i]; p != -1; p=ed2[p].next) {
            j = ed2[p].kk; h1 = h0 + ed2[p].len;
            if (h1 < h[j]) {
                h[j] = h1;
                if (!vst[j]) {vst[j] = 1; if (rear == n) q[rear = 0] = j; else q[++rear] = j;}
            }
        }
        vst[i] = 0;
    }
}
void solve()
{
    qnode q0; q0.i = s; q0.g = 0; z.push(q0);
    re(i, n) No[i] = 0;
    int i, d0, j, d1;
    while (!z.empty()) {
        i = z.top().i; d0 = z.top().g; z.pop();
        if (No[i] >= k_) continue;
        No[i]++;
        if (i == t && No[i] == k_) {res = d0; break;}
        for (int p=hd[i]; p != -1; p=ed[p].next) {
            j = ed[p].kk; d1 = d0 + ed[p].len;
            q0.i = j; q0.g = d1; z.push(q0);
        }
    }
}
void pri()
{
    printf("%d\n", res);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-05-01 15:25 发表评论

有向无环图的最小路径覆盖问题

Mato_No1 — Tue, 05 Apr 2011 08:04:00 GMT

有向无环图的最小路径覆盖问题包括两种（设G是一个有向无环图，S是G的一个路径集合）：
（1）最小点路径覆盖：满足对于G中所有的点i，i在S中的一条路径中出现，且只在S中的一条路径中出现，求S的最小容量；
（2）最小边路径覆盖：满足对于G中所有的边E，E在S中的一条路径中出现，且只在S中的一条路径中出现，求S的最小容量；

（1）最小点路径覆盖：
建立一个新图，将G中的每个点i在新图中拆成两个点i'、i''，若G中存在边则在新图中连边，显然新图是一个二分图，求其最大匹配，则(N-新图最大匹配的值)就是最小点路径覆盖值。
时间复杂度：O(NM)（Hungary算法）

（2）最小边路径覆盖：
对于图中的每个点i，设D[i]为(i的入度-i的出度)的值，按照D[i]将图中的点分类：D[i]<0的称为“入少出多”的点，D[i]>0的称为“出少入多”的点，D[i]=0的称为“入出相等”的点。则有：
定理有向无环图中最小边路径覆盖的值等于图中所有“入少出多”的点的D值之和。
证明：
其实只需证明：对于一个至少有一条边的有向无环图，必然存在一条路径，其起点是“入少出多”的点，终点是“出少入多”的点，所有中间点都是“入出相等”的点（只要不断的在图中找到并删去这条路径，直到图中无边为止）。
首先，由于图中无环，一定存在“入少出多”的点和“出少入多”的点。
然后，假设图中所有“入少出多”的点的后继（注意：后继和后代是不同的，一个点的后代包括这个点的所有后继、所有后继的后继、所有后继的后继的后继……）也都是“入少出多”的点，则图中所有“入少出多”的点构成了一个闭合子图，在这个闭合子图中，由于所有的点都是“入少出多”的，整个子图的入度之和必然大于出度之和，这是不可能的（有向图中的所有点入度之和必然等于所有点出度之和），故可得：图中必然存在至少一个“入少出多”的点，它有不是“入少出多”的后继。
这样，在这些拥有不是“入少出多”的后继的点中选择一个点i，将其作为路径的起点，在它的不是“入少出多”的后继中选出一个点j，若j是“出少入多”的点，则边就是符合条件的一条路径，结束；若这样的j都是“入出相等”的点，则考虑j的后代：j的后继可能都是“入少出多”的，但j的后代中必然存在至少一个点j'不是“入少出多”的（否则j的所有后代也将构成全都是“入少出多”的闭合子图），这些j'中必然存在一个点的前趋i'是“入少出多”的，这是，需要舍弃原来的路径，将i'作为新路径的起点，j'作为新路径的第一个中间点，继续找；若j的后继不全是“入少出多”的，则若其中有“出少入多”的则路径已找到，若都是“入出相等”的，由于图中无环，将路径不断延伸，最终一定会找到合法路径。

由此可得，对于任何有向无环图，这样的路径都是存在的，也就证明了一开始的求最小边路径覆盖值的定理。
求有向无环图最小边路径覆盖值的时间复杂度：O(M+N)。

Mato_No1 2011-04-05 16:04 发表评论

最大闭合子图的预处理（去环）问题

Mato_No1 — Sun, 27 Mar 2011 10:30:00 GMT

网络流最让人不能忍受的不是模板，而是建模！尤其是某些题目里面需要搞一段很长的预处理才能开始写网络流……

最大闭合子图就是其中的一种。如果要求最大闭合子图的有向图里面有环就很囧了，因为在某些题目里（比如NOI2009的pvz），取点是有先后顺序的，因此环中的点一个也取不了（有的题则不是这样，子图里的点可以一次全部取来，这时对于环就有两种方案了：要么全取，要么一个不取，此时不用管环，直接进入网络流即可），不仅如此，根据闭合子图的定义，如果一个点i可以到达一个点j（注，是“可以到达”点j，也就是从i到j有路径），而点j属于某个环，那么点i也不能取，因此在预处理中需要把点i也删掉。以下将属于某个环中的点成为“环点”，将可以到达环点的点称为“环限制点”，这两种点在预处理中都要删除。

本沙茶以前用的一般方法是：先求图的传递闭包，找出所有的环点（能够到达自己的点），再从每个环点开始进行逆向遍历（将原图所有边反向，再遍历），找到所有的环限制点。该方法的时间复杂度高达O(N³)，且写起来也爆麻烦。

其实，真正用于去环的最佳方法是拓扑排序！！！

首先将原图的所有边反向，然后进行拓扑排序，所有遍历到的点是保留下来的点，而没有遍历到的点就是环点或环限制点，需要删除。
【证明：环点显然是不可能被遍历到的，而在反向后的新图中，对于一个环限制点j，必然存在一个环点i能够到达它，而i不能被遍历到，故j也不能被遍历到。除了这两种点外，其它的点的所有前趋必然也都不是环点或环限制点（否则这些点就成了环限制点），因此只要入度为0（不存在前趋）的点能够遍历到，这些点也能够遍历到，而入度为0的点显然能遍历到，故这些点也能被遍历到。证毕】
由于求反向图和拓扑排序都可以在O(M)时间内完成，整个去环过程的时间复杂度就是O(M)的。

下面附上NOI2009 pvz代码：（注意，本题的第9个点是一个超级大数据，最后建出来的网络的边数将会达到300000，故MAXM取150000，另外，本题必须使用Dinic，SAP会超）

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i
const int MAXN = 602, MAXM = 150000, INF = ~0U >> 2;
struct link {
    int kk;
    link *next;
} *ed[MAXN], *ed2[MAXN];
struct edge {
    int a, b, f, next;
    edge () {}
    edge (int _a, int _b, int _f): a(_a), b(_b), f(_f), next(-1) {}
} ed_[MAXM + MAXM];
int n, m = 0, s, t, sc[MAXN], hd[MAXN], tl[MAXN], st[MAXN], lev[MAXN], q[MAXN], hs[MAXN], pr[MAXN], ind[MAXN], now, res = 0;
bool vst[MAXN];
void init()
{
    freopen("pvz.in", "r", stdin);
    int n0, m0, A[20][30], num = 1, x, y, z;
    scanf("%d%d", &n0, &m0);
    re(i, n0) re(j, m0) A[i][j] = num++;
    n = n0 * m0 + 2; s = 0; t = n - 1; memset(ed, 0, n << 2); memset(ed2, 0, n << 2);
    re1(i, n - 2) {
        scanf("%d%d", &sc[i], &num);
        re(j, num) {
            scanf("%d%d", &x, &y); z = A[x][y];
            link *p1 = new link; p1->kk = i; p1->next = ed[z]; ed[z] = p1;
            link *p2 = new link; p2->kk = z; p2->next = ed2[i]; ed2[i] = p2; ind[z]++;
        }
    }
    re(i, n0) re2(j, 1, m0) {
        z = A[i][j];
        link *p1 = new link; p1->kk = z; p1->next = ed[z - 1]; ed[z - 1] = p1;
        link *p2 = new link; p2->kk = z - 1; p2->next = ed2[z]; ed2[z] = p2; ind[z - 1]++;
    }
    fclose(stdin);
}
inline void add_edge(int a, int b, int f)
{
    ed_[m] = edge(a, b, f);
    if (hd[a] != -1) tl[a] = ed_[tl[a]].next = m++; else hd[a] = tl[a] = m++;
    ed_[m] = edge(b, a, 0);
    if (hd[b] != -1) tl[b] = ed_[tl[b]].next = m++; else hd[b] = tl[b] = m++;
}
void prepare()
{
    int front = 0, rear = -1;
    re1(i, n - 2) if (!ind[i]) {q[++rear] = i; vst[i] = 1;}
    int i, j;
    for (; front<=rear; front++) {
        i = q[front];
        for (link *p=ed2[i]; p; p=p->next) {
            j = p->kk; ind[j]--;
            if (!ind[j]) {vst[j] = 1; q[++rear] = j;}
        }
    }
    memset(hd, -1, n << 2); memset(tl, -1, n << 2);
    re1(i, n - 2) if (vst[i]) {
        if (sc[i] > 0) {res += sc[i]; add_edge(s, i, sc[i]);}
        if (sc[i] < 0) add_edge(i, t, -sc[i]);
    }
    re1(i, n - 2) if (vst[i]) for (link *p=ed[i]; p; p=p->next) {
        j = p->kk;
        if (vst[j]) add_edge(i, j, INF);
    }
}
void aug()
{
    int z = hs[t], i = t, p;
    while (i != s) {
        hs[i] -= z; p = pr[i]; ed_[p].f -= z; ed_[p ^ 1].f += z; i = ed_[p].a;
        if (!ed_[p].f) now = i;
    }
    res -= z;
}
bool dfs()
{
    q[0] = s; memset(vst, 0, n); vst[s] = 1; lev[s] = 0;
    int i, j, f0;
    for (int front=0, rear=0; front<=rear; front++) {
        i = q[front];
        for (int p=hd[i]; p != -1; p=ed_[p].next) {
            j = ed_[p].b; f0 = ed_[p].f;
            if (!vst[j] && f0) {vst[j] = 1; lev[j] = lev[i] + 1; q[++rear] = j;}
        }
    }
    if (!vst[t]) return 0;
    now = s; hs[s] = INF; memset(vst, 0, n);
    re(i, n) st[i] = hd[i];
    bool ff;
    while (!vst[s]) {
        if (now == t) aug();
        ff = 0;
        for (int p=st[now]; p != -1; p=ed_[p].next) {
            j = ed_[p].b; f0 = ed_[p].f;
            if (lev[now] + 1 == lev[j] && !vst[j] && f0) {
                st[now] = pr[j] = p; hs[j] = hs[now] <= f0 ? hs[now] : f0; now = j; ff = 1; break;
            }
        }
        if (!ff) {
            vst[now] = 1;
            if (now != s) now = ed_[pr[now]].a;
        }
    }
    return 1;
}
void solve()
{
    while (dfs()) ;
}
void pri()
{
    freopen("pvz.out", "w", stdout);
    printf("%d\n", res);
    fclose(stdout);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2011-03-27 18:30 发表评论

欧拉环、欧拉路径的判定和求法

Mato_No1 — Sun, 27 Mar 2011 03:06:00 GMT

欧拉环：图中经过每条边一次且仅一次的环；
欧拉路径：图中经过每条边一次且仅一次的路径；
欧拉图：有至少一个欧拉环的图；
半欧拉图：没有欧拉环，但有至少一条欧拉路径的图。

【无向图】
一个无向图是欧拉图当且仅当该图是连通的（注意，不考虑图中度为0的点，因为它们的存在对于图中是否存在欧拉环、欧拉路径没有影响）且所有点的度数都是偶数；一个无向图是半欧拉图当且仅当该图是连通的且有且只有2个点的度数是奇数（此时这两个点只能作为欧拉路径的起点和终点）；

证明：因为任意一个点，欧拉环（或欧拉路径）从它这里进去多少次就要出来多少次，故(进去的次数+出来的次数)为偶数，又因为(进去的次数+出来的次数)=该点的度数（根据定义），所以该点的度数为偶数。

【有向图】
一个有向图是欧拉图当且仅当该图的基图（将所有有向边变为无向边后形成的无向图，这里同样不考虑度数为0的点）是连通的且所有点的入度等于出度；一个有向图是半欧拉图当且仅当该图的基图是连通的且有且只有一个点的入度比出度少1（作为欧拉路径的起点），有且只有一个点的入度比出度多1（作为终点），其余点的入度等于出度。

证明：与无向图证明类似，一个点进去多少次就要出来多少次。

【无向图、有向图中欧拉环的求法】
与二分图匹配算法类似，是一个深度优先遍历的过程，时间复杂度O(M)（因为一条边最多被访问一次）。核心代码（边是用边表存储的而不是邻接链表，因为无向图中需要对其逆向的边进行处理，在有向图中，可以用邻接链表存储边）：

void dfs(int x)
{
    int y;
    for (int p=hd[x]; p != -1; p=ed[p].next) if (!ed[p].vst) {
        y = ed[p].b;
        ed[p].vst = 1;
        ed[p ^ 1].vst = 1;     //如果是有向图则不要这句
        dfs(y);
        res[v--] = y + 1;
    }
}

要注意的是在res中写入是逆序的，所以初始的v应设成(边数-1)。
但是有一个问题是，这是递归实现的，当点数过多时有爆栈危险，所以最好使用非递归：

void dfs()
{
    int x = 0, y, tp = 1; stk[0] = 0;
    re(i, n) now[i] = hd[i];
    bool ff;
    while (tp) {
        ff = 0;
        for (int p=now[x]; p != -1; p=ed[p].next) if (!ed[p].vst) {
            y = ed[p].b;
            ed[p].vst = 1;
            ed[p ^ 1].vst = 1;     //如果是有向图则不要这句
            now[x] = p; stk[tp++] = y; x = y; ff = 1; break;
        }
        if (!ff) {
            res[v--] = x + 1;
            x = stk[--tp - 1];
        }
    }
}

当原图是欧拉图时，一定可以求出欧拉回路。当原图是半欧拉图时，求欧拉路径，只要找到起点i和终点j，添加边（或(j, i)），求欧拉环，再在求出的欧拉环中删除添加的新边即可。

不过最为BT的还不是这个，而是接下来的——
【混合图】
混合图（既有有向边又有无向边的图）中欧拉环、欧拉路径的判定需要借助网络流！

（1）欧拉环的判定：
一开始当然是判断原图的基图是否连通，若不连通则一定不存在欧拉环或欧拉路径（不考虑度数为0的点）。

其实，难点在于图中的无向边，需要对所有的无向边定向（指定一个方向，使之变为有向边），使整个图变成一个有向欧拉图（或有向半欧拉图）。若存在一个定向满足此条件，则原图是欧拉图（或半欧拉图）否则不是。关键就是如何定向？

首先给原图中的每条无向边随便指定一个方向（称为初始定向），将原图改为有向图G'，然后的任务就是改变G'中某些边的方向（当然是无向边转化来的，原混合图中的有向边不能动）使其满足每个点的入度等于出度。
设D[i]为G'中(点i的出度 - 点i的入度）。可以发现，在改变G'中边的方向的过程中，任何点的D值的奇偶性都不会发生改变（设将边改为，则i入度加1出度减1，j入度减1出度加1，两者之差加2或减2，奇偶性不变）！而最终要求的是每个点的入度等于出度，即每个点的D值都为0，是偶数，故可得：若初始定向得到的G'中任意一个点的D值是奇数，那么原图中一定不存在欧拉环！

若初始D值都是偶数，则将G'改装成网络：设立源点S和汇点T，对于每个D[i]>0的点i，连边，容量为D[i]/2；对于每个D[j]<0的点j，连边，容量为-D[j]/2；G'中的每条边在网络中仍保留，容量为1（表示该边最多只能被改变方向一次）。求这个网络的最大流，若S引出的所有边均满流，则原混合图是欧拉图，将网络中所有流量为1的中间边（就是不与S或T关联的边）在G'中改变方向，形成的新图G''一定是有向欧拉图；若S引出的边中有的没有满流，则原混合图不是欧拉图。

为什么能这样建图？
考虑网络中的一条增广路径S-->i-->...-->j-->T，将这条从i到j的路径在G'中全部反向，则：i的入度加1出度减1，j的入度减1出度加1，路径中其它点的入度出度均不变。而i是和S相连的，因此初始D[i]>0，即i的出度大于入度，故这样反向之后D[i]减少2；同理，j是和T相连的，这样反向之后D[j]增加2。因此，若最大流中边满流（流量为初始D[i]/2），此时D[i]值就变成了0，也就是i的入度等于出度。因此只要使所有S引出的边全部满流，所有初始D值>0的点的D值将等于0，又因为将边变向后所有点的D值之和不变，所有初始D值小于0的点的D值也将等于0，而初始D值等于0的D点既不与S相连也不与T相连，所以它们是网络中的中间点，而中间点的流入量等于流出量，故它们的入度和出度一直不变，即D值一直为0。因此，整个图G'成为欧拉图。

（2）欧拉路径的判定：
首先可以想到的是枚举欧拉路径的起点i和终点j，然后在图中添加边，再求图中是否有欧拉回路即可。但是，该算法的时间复杂度达到了O(M * 最大流的时间)，需要优化。
前面已经说过，在将边变向的过程中任何点的D值的奇偶性都不会改变，而一个有向图有欧拉路径的充要条件是基图连通且有且只有一个点的入度比出度少1（作为欧拉路径的起点），有且只有一个点的入度比出度多1（作为终点），其余点的入度等于出度。这就说明，先把图中的无向边随便定向，然后求每个点的D值，若有且只有两个点的初始D值为奇数，其余的点初始D值都为偶数，则有可能存在欧拉路径（否则不可能存在）。进一步，检查这两个初始D值为奇数的点，设为点i和点j，若有D[i]>0且D[j]<0，则i作起点j作终点（否则若D[i]与D[j]同号则不存在欧拉路径），连边，求是否存在欧拉环即可（将求出的欧拉环中删去边即可）。这样只需求一次最大流。

【典型例题】Sightseeing tour（PKU1637，ZJU1992）
本题就是求混合图的欧拉环问题，题目中已经说明图是连通的（Input的最后一句话），故不需判连通。
（本沙茶一开始把DFS中的l0 = aug中的"= aug"写漏了，TLE了N次）

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i
const int MAXN = 2002, MAXM = 10000, INF = ~0U >> 2;
struct edge {
    int a, b, f, next;
    edge () {}
    edge (int _a, int _b, int _f): a(_a), b(_b), f(_f), next(-1) {}
} ed[MAXM + MAXM];
int n, m, s, t, D[MAXN], hd[MAXN], tl[MAXN], lb[MAXN], vl[MAXN], flow, lmt;
bool res;
int dfs(int i, int aug)
{
    if (i == t) {flow += aug; return aug;}
    int l0 = aug, l1, j, f0;
    for (int p=hd[i]; p != -1; p=ed[p].next) {
        j = ed[p].b; f0 = ed[p].f;
        if (lb[i] == lb[j] + 1 && f0) {
            l1 = dfs(j, l0 <= f0 ? l0 : f0);
            l0 -= l1; ed[p].f -= l1; ed[p ^ 1].f += l1;
            if (lb[s] == n || !l0) return aug;
        }
    }
    int minlb = n - 1;
    for (int p=hd[i]; p != -1; p=ed[p].next) if (ed[p].f) {
        j = ed[p].b;
        if (lb[j] < minlb) minlb = lb[j];
    }
    if (--vl[lb[i]]) vl[lb[i] = minlb + 1]++; else lb[s] = n;
    return aug - l0;
}
inline void add_edge(int a, int b, int f)
{
    ed[m] = edge(a, b, f);
    if (hd[a] != -1) tl[a] = ed[tl[a]].next = m++; else hd[a] = tl[a] = m++;
    ed[m] = edge(b, a, 0);
    if (hd[b] != -1) tl[b] = ed[tl[b]].next = m++; else hd[b] = tl[b] = m++;
}
void solve()
{
    int tests;
    scanf("%d", &tests);
    int n0, m0, a0, b0, f;
    re(testno, tests) {
        scanf("%d%d", &n0, &m0);
        n = n0 + 2; m = 0; s = 0; t = n - 1;
        memset(D, 0, n0 << 2); memset(hd, -1, n << 2); memset(tl, -1, n << 2);
        re(i, m0) {
            scanf("%d%d%d", &a0, &b0, &f);
            D[a0 - 1]++; D[b0 - 1]--;
            if (!f) add_edge(a0, b0, 1);
        }
        res = 1; lmt = 0; flow = 0;
        re(i, n0) {
            if (D[i] % 2) {res = 0; break;}
            if (D[i] > 0) {add_edge(s, i + 1, D[i] >> 1); lmt += D[i] >> 1;}
            if (D[i] < 0) add_edge(i + 1, t, -D[i] >> 1);
        }
        if (res) {
            memset(lb, 0, n << 2); vl[0] = n; memset(vl + 1, 0, n << 2);
            while (lb[s] < n) dfs(s, INF);
            if (flow < lmt) res = 0;
        }
        puts(res ? "possible" : "impossible");
    }
}
int main()
{
    solve();
    return 0;
}

Mato_No1 2011-03-27 11:06 发表评论