C++博客-Mato is No.1-随笔分类-搜索

【AHOI2013复仇】SCOI2005的两道搜索题总结

Mato_No1 — Fri, 19 Oct 2012 13:48:00 GMT

摘要: [SCOI2005]栅栏 [SCOI2005]骑士精神 DFS优化类题目的代表。【栅栏】方法一：将N块目标木板的长度递增排序，然后，从前到后搜索每块目标木板从哪块原料中得到，直到所有的原料都不够用为止。优化：（1）启发函数：从目前的每块原料中，尝试依次切出目前剩余的最小长度的目标木板，则各块原料切出的块数之和就是一个乐观估计（比如剩余3块原料的长度为10、12、19，剩余的目标木板为3、4、5、6... 阅读全文

Mato_No1 2012-10-19 21:48 发表评论

【AHOI2013复仇】SCOI2008 天平

Mato_No1 — Tue, 25 Sep 2012 13:26:00 GMT

摘要: 原题地址本题就是，有N个变量，其取值只可能有三种：1、2、3。现在已知它们之间的一些大小关系，求有多少对变量(I, J)满足(I的值+J的值)一定>或=或<(A的值+B的值)，A、B是指定的两个变量，且I、J、A、B互不相同。首先，对于值相等的变量，直接建出无向图，按连通块缩点，再考虑大于/小于关系，如果I的值大于J则在I所在连通块与J所在连通块之间连一条有向边（从I到J）…... 阅读全文

Mato_No1 2012-09-25 21:26 发表评论

【AHOI2013复仇】从一道题来看DFS及其优化的一般步骤和数组分层问题

Mato_No1 — Sun, 23 Sep 2012 07:16:00 GMT

RQNOJ187 巧置挡板
———————————————————————————————————————————————————
【背景（神犇不要囧视，3x）】
本沙茶最近开始猛攻搜索、近似、随机等算法，目标是A掉AHOI2012的后3题（在哪跌倒就从哪爬起）。昨天晚上找到这题，发现是搜索，于是开始捉……结果被折腾了一晚上加一上午才A掉，不过，看在这题可以系统性的反映DFS优化的一般步骤，忍了……另外，这题是本沙茶在RQNOJ上通过的第400题……回想起通过第300题的时候已经是近三年半之前了……真颓废啊……
———————————————————————————————————————————————————
普通DFS（不加迭代）的优化方法主要有：
（1）可行性剪枝，如果遇到已经无法产生可行解的情况就剪枝，有时候，可行性剪枝也可以指在搜索过程中对不合法情况的剔除；
（2）最优性剪枝：如果遇到已经无法产生比目前得到的最优解还要优的解的情况就剪枝，这其中包括启发式最优性剪枝（即分支限界），对目前解的进展情况作乐观估计，如果估计值都不能超越目前的最优解，则剪枝；
（3）通过改变搜索顺序，尽早得出较优解，从而为后面的剪枝提供余地；
（4）通过预处理等手段，提前得到启发值或者较优解，为后面的剪枝提供余地；

一般步骤：
（1）预处理，当然是写在最前面，在搜索前得到启发值等东东；
（2）搜索过程中，先写最优性剪枝（包括已经到达搜索终点了，也应该判断一下，提前排除不是最优解的情况）；
（3）再判定搜索终点，如果到了，也不要马上更新解，而是要判定这个解是否符合要求，再更新；
（4）若未到终点，再写可行性剪枝；
（5）最后写搜索过程，包括需要改变搜索顺序的情况。

注意事项：数组的分层问题。
这是一个很严重的问题，因为分层出错很可能会导致一些很怪的错误出现，难以发现。在搜索题的调试技巧这一篇中，已经提到了这个问题，本题又涉及到了。
一般来说，搜索过程中使用的数组（包括变量，可以视为零维数组）可以分为以下三类：
（1）在搜索过程中，只会引用其值，不会修改的数组（比如预处理中得到的那些东东），相当于常量；
（2）在搜索过程中，会改变其值，但在搜索完毕后能改回原值的数组；
（3）在搜索过程中，会改变其值，且在搜索完毕后也改不回原值的数组。
对于（1）（2）类数组，不需分层，但对于第（3）类数组一定要分层。这是因为这些数组在多层搜索中都需要修改，而且搜索完了也改不回来，如果不分层，则当后面的搜索完毕以后，要继续搜索前面的，引用的将是后面的值，就会出错。
对于第（3）类数组，有的已经“自然分层”（每层搜索修改的元素都不一样），比如本题代码中的R[][]、C[][]。然而有的并没有自然分层，比如本题的len、pos[]、tmp[]等，因此对于这些数组，需要再加一维，对于不同层使用该维不同的元素即可。

下面是本题的算法：
使用DFS搜索每个位置的挡板是否需要放。搜索时，先搜竖的再搜横的，由于题目要求每个连通块都必须是矩形，因此对于竖的，如果该位置的上方两个相邻位置的横的没有全放（包括只放了一个），则该位置的竖的放不放取决于其上一行对应位置的竖的有没有放（第一行除外），如果两个横的都放了，则这里的竖的既可以放也可以不放（先搜不放的情况）。当然，一行的两个1之间必须至少有一个竖的，这是可行性限制。在搜横的的时候，按照该行所放的竖的，分成若干段，显然每一段要么下面都用横的封上，要么一个都不封上。其中，如果该段所在的连通块里面有1，且下一行对应位置也有1，则必须封上；若该段所在连通块里面没有1，则不能封上（因为不能有一个连通块里一个1都没有），否则可以自由选择封还是不封（当然也是先搜不封的）。这样一直搜到最后一行的竖的后，还要判断最后一行有没有连通块里没1，若没有，则为一个可行解。启发式优化：设D[i]为第i行及以后至少要几个挡板（若某行有K个1，则至少需要(K-1)个竖的；若某列有K个1，则至少需要(K-1)个横的，累加起来即可，显然这是乐观估计），D[i]可以预处理出来，当做启发值。

代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.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
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 35, INF = ~0U >> 2;
int n, m, D[MAXN], len[MAXN], pos[MAXN][MAXN], tmp[MAXN][MAXN], res = INF;
bool A[MAXN][MAXN], C[MAXN][MAXN], R[MAXN][MAXN], S[MAXN][MAXN][MAXN][MAXN];
void dfs0(int No, int v, int sum, bool FF);
void init()
{
    scanf("%d%d", &n, &m); int x;
    re(i, n) re(j, m) {scanf("%d", &x); A[i][j] = x;}
}
void prepare()
{
    re(i, n) re(j, m) {
        S[i][j][i][j] = A[i][j];
        re2(k, i+1, n) S[i][j][k][j] = A[k][j] || S[i][j][k - 1][j];
        re2(k, j+1, m) S[i][j][i][k] = A[i][k] || S[i][j][i][k - 1];
        re2(k, i+1, n) re2(k0, j+1, m) S[i][j][k][k0] = A[k][k0] || S[i][j][k - 1][k0] || S[i][j][k][k0 - 1];
    }
    int sum;
    re(i, n) {
        D[i] = 0;
        re2(j, i, n) {sum = 0; re(k, m) if (A[j][k]) sum++; if (sum) D[i] += sum - 1;}
        re(k, m) {sum = 0; re2(j, i, n) if (A[j][k]) sum++; if (sum) D[i] += sum - 1;}
    }
}
void dfs1(int No, int v, int sum)
{
    if (sum + D[No + 1] >= res) return;
    if (v == len[No] + 1) dfs0(No + 1, 0, sum, 1); else if (tmp[No][v] != 1) dfs1(No, v + 1, sum); else {
        int l, r, sum0 = sum;
        if (v) l = pos[No][v - 1] + 1; else l = 0;
        if (v == len[No]) r = m - 1; else r = pos[No][v];
        re3(j, l, r) R[No][j] = 0; dfs1(No, v + 1, sum);
        re3(j, l, r) {R[No][j] = 1; sum0++;} dfs1(No, v + 1, sum0);
    }
}
void dfs0(int No, int v, int sum, bool FF)
{
    if (sum + D[No + 1] >= res) return;
    bool FF0; if (A[No][v]) {if (!FF) return; else FF0 = 0;} else FF0 = FF;
    if (v == m - 1) {
        if (No == n - 1) {
            len[No] = 0; re(i, m-1) if (C[No][i]) pos[No][len[No]++] = i;
            int l, r, x; bool FFF = 1;
            re3(i, 0, len[No]) {
                if (i) l = pos[No][i - 1] + 1; else l = 0;
                if (i == len[No]) r = m - 1; else r = pos[No][i];
                x = 0; rre(j, No) if (R[j][l]) {x = j + 1; break;}
                if (!S[x][l][No][r]) {FFF = 0; break;}
            }
            if (FFF) res = sum;
            return;
        }
        len[No] = 0; re(i, m-1) if (C[No][i]) pos[No][len[No]++] = i;
        int l, r, x, sum0 = sum;
        re3(i, 0, len[No]) {
            if (i) l = pos[No][i - 1] + 1; else l = 0;
            if (i == len[No]) r = m - 1; else r = pos[No][i];
            x = 0; rre(j, No) if (R[j][l]) {x = j + 1; break;}
            if (S[x][l][No][r] && S[No + 1][l][No + 1][r]) {
                tmp[No][i] = 2; re3(j, l, r) {sum0++; R[No][j] = 1;}
            } else if (S[x][l][No][r]) {
                tmp[No][i] = 1; re3(j, l, r) R[No][j] = 0;
            } else {
                tmp[No][i] = 0; re3(j, l, r) R[No][j] = 0;
            }
        }
        dfs1(No, 0, sum0);
    } else if (No && (!R[No - 1][v] || !R[No - 1][v + 1])) {
        if (C[No - 1][v]) {C[No][v] = 1; dfs0(No, v + 1, sum + 1, 1);} else {C[No][v] = 0; dfs0(No, v + 1, sum, FF0);}
    } else {
        C[No][v] = 0; dfs0(No, v + 1, sum, FF0);
        C[No][v] = 1; dfs0(No, v + 1, sum + 1, 1);
    }
}
void pri()
{
    printf("%d\n", res);
}
int main()
{
    init();
    prepare();
    dfs0(0, 0, 0, 1);
    pri();
    return 0;
}

Mato_No1 2012-09-23 15:16 发表评论

【AHOI2013复仇】s-t第K短简单路问题

Mato_No1 — Sun, 23 Sep 2012 06:28:00 GMT

[SCOI2007 kshort]
求图的s-t第K短简单路问题，若有长度相同的，字典序小的优先。

首先，由于是简单路，所以A*是不能做的，因为有可能有两条s-i（i为某个中间点）路P1和P2，P1比P2短，但由于P1到达的顶点与P2不同，导致最终沿P1到达t的路径长度长于沿P2到达t的（甚至有可能沿P1根本到不了t）。然后，如果直接用DFS，由于要求的是第K优解，而不是最优解，所以不能使用最优性剪枝（包括分支限界），因此专门为最优性剪枝服务的“改变搜索顺序”技巧也不能使用了，因此，能够使用的只有可行性剪枝，而本题的数据范围使得这种算法必然TLE。

正解是一种由迭代加深思想扩展得到的“迭代变优”DFS。设置一个路径长度上限Z，搜索s到t的所有简单路，在搜索过程中，遇到长度大于Z的路径就停止（剪枝），然后，若得到路径不足K条，则增加Z的值，重新开始搜索，直到得到的路径总数大于等于K条为止。这里可以进行启发式的优化，设g[i]为点i到t的最短路长度，则搜索过程中，假设目前搜到点i，则（目前路径长度+g[i]）是对整条路径最短长度的乐观估计，如果这个值超过了Z，就可以剪枝，但在剪枝之前要记下这个超过了Z的启发值，取其中最小的作为下一次迭代的Z值。那么对于字典序肿么办？可以在搜索过程中，强制先搜编号小的结点，这样得到的s-t路径必然是字典序递增的。另外只要求出第K条路径，搜索就可以终止，因为容易证明，题目要求的第K短的路径一定已经求出来了（只不过不一定是最后一条而已），找到即可。此外，在搜索过程中不要忘了可行性剪枝，就是如果沿目前搜到的路径已经到不了t了，剪枝。

“迭代变优”DFS，就是设置一个解的评价值的上限（最小值）或下限（最大值），在搜索过程中，如果实际评价值（或者启发值，如果可以加启发式优化的话）越过这个限制，则剪枝。在一次搜索后，如果没有得到符合要求的解，就将该限制值设为本次搜索过程中越界“越”得最近的那个值，重新开始搜索，直到找到所需要的解或者发现无解（如果一次搜索中没有发生越界，却仍然没有找到解）为止。其应用主要体现在两个方面：（1）搜索树过深甚至无限深，但所需求的那个解却不深的情况；（2）求第K优解的情况。

代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.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++)
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 51, MAXK = 201, MAXM = 3000, INF = ~0U >> 2;
struct edge {
    int a, b, w, pre, next;
} E[MAXM + MAXN], E0[MAXM + MAXN];
struct edge0 {
    int a, b, w;
    bool operator< (edge0 e0) const {return b < e0.b;}
} _E[MAXM];
int n, m, s, t, K, dist[MAXN], Q[MAXN + 1];
int Z, Z0, vst0[MAXN], _FL, len0, X00[MAXN], No, len[MAXK], X0[MAXK][MAXN], sum0[MAXK], reslen, res[MAXN];
bool vst[MAXN], res_ex = 0;
void init_d()
{
    re(i, n) E[i].pre = E[i].next = E0[i].pre = E0[i].next = i; m = n;
}
void add_edge(int a, int b, int w)
{
    E[m].a = a; E[m].b = b; E[m].w = w; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m;
    E0[m].a = b; E0[m].b = a; E0[m].w = w; E0[m].pre = E0[b].pre; E0[m].next = b; E0[b].pre = m; E0[E0[m].pre].next = m++;
}
void init()
{
    int m0; scanf("%d%d%d%d%d", &n, &m0, &K, &s, &t); init_d(); s--; t--;
    re(i, m0) {scanf("%d%d%d", &_E[i].a, &_E[i].b, &_E[i].w); _E[i].a--; _E[i].b--;}
    sort(_E, _E + m0);
    re(i, m0) add_edge(_E[i].a, _E[i].b, _E[i].w);
}
void prepare()
{
    re(i, n) {vst[i] = 0; dist[i] = INF;} vst[t] = 1; dist[t] = 0; Q[0] = t;
    int x, y, d0, d1;
    for (int front=0, rear=0; !(!front && rear==n || front==rear+1); front==n ? front=0 : front++) {
        x = Q[front]; d0 = dist[x];
        for (int p=E0[x].next; p != x; p=E0[p].next) {
            y = E0[p].b; d1 = d0 + E0[p].w;
            if (d1 < dist[y]) {
                dist[y] = d1;
                if (!vst[y]) {vst[y] = 1; Q[rear==n ? rear=0 : ++rear] = y;}
            }
        }
        vst[x] = 0;
    }
}
void dfs(int x, int sum)
{
    if (x == t) {
        if (sum <= Z) {sum0[No] = sum; len[No] = len0; re(i, len0) X0[No][i] = X00[i]; No++; if (No == K) res_ex = 1;}
        else if (sum < Z0) Z0 = sum;
        return;
    } else {
        int h0 = sum + dist[x];
        if (h0 > Z) {if (h0 < Z0) Z0 = h0; return;}
        vst0[x] = ++_FL; Q[0] = x; int _x, _y;
        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;
                if (!vst[_y] && vst0[_y] != _FL) {vst0[_y] = _FL; Q[++rear] = _y;}
            }
        }
        if (vst0[t] != _FL) return;
        for (int p=E[x].next; p != x; p=E[p].next) {
            _y = E[p].b;
            if (!vst[_y]) {vst[_y] = 1; X00[len0++] = _y; dfs(_y, sum + E[p].w); if (res_ex) return; else {len0--; vst[_y] = 0;}}
        }
    }
}
void solve()
{
    Z = dist[s]; int No0 = 0; _FL = 0;
    while (1) {
        Z0 = INF; No = 0; re(i, n) {vst[i] = 0; vst0[i] = 0;}
        vst[s] = 1; len0 = 1; X00[0] = s; dfs(s, 0);
        if (res_ex) {
            No0 = K - No0;
            re(i, K) if (sum0[i] == Z) {No0--; if (!No0) {reslen = len[i]; re(j, len[i]) res[j] = X0[i][j];}}
            break;
        } else if (Z0 == INF) break; else {No0 = No; Z = Z0;}
    }
}
void pri()
{
    if (res_ex) {
        printf("%d", res[0] + 1);
        re2(i, 1, reslen) printf("-%d", res[i] + 1);
        puts("");
    } else puts("No");
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-09-23 14:28 发表评论

搜索题的调试技巧以及一些附加内容

Mato_No1 — Thu, 22 Mar 2012 12:49:00 GMT

摘要: 【背景（神犇不要鄙视）】本沙茶在搜索题目的调试上已经挂过两次了（NOI2011的game用了2h+木有调出来，还耽误了继续想show的时间，结果被挡在了集训队门外；NOIP2011的mayan，用暴搜都调了2h+，木有调出来，结果惨挂，全国第200名，如果这题AC了就是全国前50名……），为了防止在接下来的比赛中再在这里挂掉，本沙茶决定好好搞一下这个。【DFS的调试技巧】如... 阅读全文

Mato_No1 2012-03-22 20:49 发表评论

NOI2005 智慧珠游戏

Mato_No1 — Wed, 20 Jul 2011 15:07:00 GMT

摘要: 【原题见这里】很明显的精确覆盖的模型，12个零件，再加上它们经过旋转、翻转后的不同形状，共60种，每种又可以放在不同的位置（只看最左上的那个珠子）一种零件的一种位置就是一行。列（限制）有两种：每个格子只能放一个（55列），以及每个零件（注意是每个零件，不是每种零件）只能用一次（12列），共67列。预先放的那些零件可以看成预先选中的行。然后DLX精确覆盖即可。下面是DLX精确覆盖的几个易疵点：（1）... 阅读全文

Mato_No1 2011-07-20 23:07 发表评论

关于DLX重复覆盖的补充

Mato_No1 — Wed, 20 Jul 2011 04:28:00 GMT

昨天在刷PKU1084的时候，调了很久，发现原来那样实现有缺陷。（原来的实现见这里）

在重复覆盖问题中，删去一整列的操作（delcol）是断开该列除了初始结点外的所有结点的左右链（delLR），这样，如果有一些行预先已被选中，则删去这一行（准确来说是对这一行所有结点执行delcol操作），这时就会出现问题，因为在删去这一行的最后一个结点的时候，其左、右链都指向其本身，此时就无法删掉这个结点。解决这一问题的办法是除了在矩阵中引入列头以外，还要引入行头（rowh），并且保证行头不删掉。这样在删掉一整行的时候就不会出问题了。但是，如果这样的话，需要在搜索过程中执行delcol操作前进行特判，保证不删掉行头结点（比如将行头结点的U、D域置为-1），并且，在求启发函数h()值的时候也要防止在行头处出现问题，可以将行头结点的行列号均置为0。

而在精确覆盖问题中，删去一整列的操作是断开结点的上下链而不是左右链，因此在删去一整行时就不需要引入行头结点。

下面是PKU1084的AC代码：

#include <iostream>
#include <stdio.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 re3(i, l, r) for (int i=l; i<=r; i++)
const int MAXN = 60, MAXM = 55, INF = ~0U >> 2;
struct dlnode {
    int r, c, U, D, L, R;
} d[(MAXN + 1) * (MAXM + 1)];
int _n, n, m, nodes, rowh[MAXN + 1], cols[MAXM + 1], B[5][5][4], res;
bool A[MAXN + 1], vst[MAXN];
void init_d()
{
    re3(i, 0, m) {d[i].U = d[i].D = i; d[i].L = i - 1; d[i].R = i + 1;} d[0].L = m; d[m].R = 0;
    nodes = m; re1(i, n) {rowh[i] = ++nodes; d[nodes].L = d[nodes].R = nodes; d[nodes].U = d[nodes].D = -1;}
    re1(i, m) cols[i] = 0;
}
void add_node(int r, int c)
{
    cols[c]++; d[++nodes].r = r; d[nodes].c = c;
    d[nodes].U = d[c].U; d[nodes].D = c; d[c].U = nodes; d[d[nodes].U].D = nodes;
    int rh = rowh[r]; d[nodes].L = d[rh].L; d[nodes].R = rh; d[rh].L = nodes; d[d[nodes].L].R = nodes;
}
void delLR(int x)
{
    d[d[x].L].R = d[x].R; d[d[x].R].L = d[x].L;
}
void delUD(int x)
{
    d[d[x].U].D = d[x].D; d[d[x].D].U = d[x].U;
}
void resuLR(int x)
{
    d[d[x].L].R = d[d[x].R].L = x;
}
void resuUD(int x)
{
    d[d[x].U].D = d[d[x].D].U = x;
}
void delcol(int x)
{
    for (int i=d[x].D; i != x; i=d[i].D) delLR(i);
}
void resucol(int x)
{
    for (int i=d[x].U; i != x; i=d[i].U) resuLR(i);
}
void prepare()
{
    int x = 0;
    re(i, _n) {
        re(j, _n) {B[i][j][0] = ++x; B[i][j][1] = x + _n; B[i][j][2] = x + _n + 1; B[i][j][3] = x + _n + _n + 1;}
        x += _n + 1;
    }
    x = 0;
    re(i, _n) re(j, _n - i) re(k, _n - i) {
        x++;
        re(t, i+1) {
            add_node(B[j][k + t][0], x);
            add_node(B[j + t][k][1], x);
            add_node(B[j + t][k + i][2], x);
            add_node(B[j + i][k + t][3], x);
        }
    }
    int rh;
    re1(i, n) if (A[i]) {
        rh = rowh[i];
        for (int j=d[rh].R; j != rh; j=d[j].R) delcol(j);
    }
    res = n;
}
int h()
{
    re1(i, m) vst[i] = 0;
    int z = 0;
    for (int i=d[0].R; i; i=d[i].R) if (!vst[i]) {z++; vst[i] = 1; for (int j=d[i].D; j != i; j=d[j].D) for (int k=d[j].R; k != j; k=d[k].R) vst[d[k].c] = 1;}
    return z;
}
void dfs(int dep)
{
    int h0 = h(); if (dep + h0 >= res) return; else if (!h0) {res = dep; return;}
    int mins = INF, c0; for (int i=d[0].R; i; i=d[i].R) if (!cols[i]) return; else if (cols[i] < mins) {mins = cols[i]; c0 = i;}
    for (int i=d[c0].D; i != c0; i=d[i].D) {
        delcol(i); for (int j=d[i].R; j != i; j=d[j].R) if (d[j].U != -1) delcol(j);
        dfs(dep + 1);
        for (int j=d[i].L; j != i; j=d[j].L) if (d[j].U != -1) resucol(j); resucol(i);
    }
}
int main()
{
    int tests, _n0, x;
    scanf("%d", &tests);
    re(testno, tests) {
        scanf("%d%d", &_n, &_n0);
        n = _n * (_n + 1) << 1; m = 0; re1(i, _n) m += i * i; init_d(); re1(i, n) A[i] = 0;
        re(i, _n0) {scanf("%d", &x); A[x] = 1;}
        prepare();
        dfs(0);
        printf("%d\n", res);
    }
    return 0;
}

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

用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 发表评论

RQNOJ P89，DLX重复覆盖……终于AC了

Mato_No1 — Tue, 12 Apr 2011 14:27:00 GMT

放了快2个月了……（准确来说放了2年了，本沙茶从2年前就开始捉这道猥琐题……）
DLX重复覆盖的几点说明：
（1）必须有启发函数优化，否则TLE；
（2）不需要二分下界，只要将目前f值（f=g+h，即实际深度加上启发函数值）与目前求得的最优解比较即可，f>=最优解即剪枝；
（3）删一整列（delcol）操作时，可以从任意一个结点开始删（不一定要向精确覆盖那样非要从列头开始），但是，开始的那个结点不删！恢复（resucol）时也不恢复开始的那个结点！这是为了在接下来的横向遍历中不受影响。由于不删开始结点，所以在将最优列删除时，需要循环一次删除一次，恢复一次。

代码：（RQNOJ P89）

#include <iostream>
#include <stdio.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 re3(i, l, r) for (int i=l; i<=r; i++)
const int MAXN = 61, MAXM = 61, INF = ~0U >> 2;
struct DLnode {
    int r, c, U, D, L, R;
} d[MAXN * MAXM];
int n, m, nodes, rowh[MAXN], cols[MAXM], res = INF;
void init_d()
{
    re3(i, 0, m) {
        d[i].r = 0; d[i].c = 0; d[i].U = d[i].D = i; d[i].L = i - 1; d[i].R = i + 1;
    }
    d[0].L = m; d[m].R = 0;
    memset(rowh, 0, n + 1 << 2); memset(cols, 0, m + 1 << 2); nodes = m + 1;
}
void add_node(int r, int c)
{
    d[nodes].r = r; d[nodes].c = c; d[nodes].U = d[c].U; d[nodes].D = c; d[c].U = nodes; d[d[nodes].U].D = nodes;
    int rh = rowh[r];
    if (rh) {
        d[nodes].L = d[rh].L; d[nodes].R = rh; d[rh].L = nodes; d[d[nodes].L].R = nodes;
    } else d[nodes].L = d[nodes].R = rowh[r] = nodes;
    cols[c]++; nodes++;
}
void init()
{
    scanf("%d%d", &m, &n);
    init_d();
    int k, x;
    re1(i, n) {
        scanf("%d", &k);
        re(j, k) {
            scanf("%d", &x); add_node(i, x);
        }
    }
}
void delUD(int x)
{
    d[d[x].U].D = d[x].D; d[d[x].D].U = d[x].U;
}
void resuUD(int x)
{
    d[d[x].U].D = d[d[x].D].U = x;
}
void delLR(int x)
{
    d[d[x].L].R = d[x].R; d[d[x].R].L = d[x].L;
}
void resuLR(int x)
{
    d[d[x].L].R = d[d[x].R].L = x;
}
void delcol(int c)
{
    for (int i=d[c].D; i != c; i = d[i].D) delLR(i);
}
void resucol(int c)
{
    for (int i=d[c].U; i != c; i = d[i].U) resuLR(i);
}
int h()
{
    bool vst[MAXM]; memset(vst, 0, m + 1);
    int z = 0;
    for (int i=d[0].R; i; i = d[i].R) if (!vst[i]) {
        vst[i] = 1; z++;
        for (int j=d[i].D; j != i; j = d[j].D) for (int k=d[j].R; k != j; k = d[k].R) vst[d[k].c] = 1;
    }
    return z;
}
void dfs(int v)
{
    if (v + h() >= res) return;
    if (!d[0].R) {res = v; return;}
    int min = INF, x;
    for (int i=d[0].R; i; i = d[i].R) if (cols[i] < min) {min = cols[i]; x = i;}
    for (int i=d[x].D; i != x; i = d[i].D) {
        delcol(i);
        for (int j=d[i].R; j != i; j = d[j].R) delcol(j);
        dfs(v + 1);
        for (int j=d[i].L; j != i; j = d[j].L) resucol(j);
        resucol(i);
    }
}
void pri()
{
    printf("%d\n", res);
}
int main()
{
    init();
    dfs(0);
     pri();
    return 0;
}

总结：DLX精确覆盖和重复覆盖其实是有大用的，很多搜索问题都可以转化为这两种问题，效率奇高无比，且写起来也很容易（只是在建模的时候可能有点猥琐，下面的模板，和网络流一样，10min的事），至于NOIP2009引出的数独系列问题，精确覆盖可以直接秒杀。

Mato_No1 2011-04-12 22:27 发表评论