无码任你躁久久久久久久,久久香综合精品久久伊人,人妻少妇久久中文字幕一区二区

【AHOI2013复仇】SCOI2005的两道搜索题�ȝ��

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

摘要: [SCOI2005]栅栏 [SCOI2005]骑士�_�� DFS优化�c�题目的代表。【栅栏】方法一�Q�将N块目标木板的长度递增排序�Q�然后，从前到后搜烦每块目标木板从哪块原料中得到�Q�直到所有的原料都不够用为止。优化：�Q?�Q�启发函敎ͼ�从目前的每块原料中，��试依次切出目前剩余的最��长度的目标木板�Q�则各块原料切出的块��C��和就是一个乐观估计（比如剩余3块原料的长度�?0�?2�?9�Q�剩余的目标木板�?�?�?�?... 阅读全文

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

【AHOI2013复仇】SCOI2008 天��^

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

摘要: 原题地址本题��是�Q�有N个变量，其取值只可能有三�U�：1�?�?。现在已知它们之间的一些大��关�p�，求有多少对变�?I, J)满��(I的�?J的�?一�?gt;�?�?lt;(A的�?B的�?�Q�A、B是指定的两个变量�Q�且I、J、A、B互不相同。首先，对于值相�{�的变量�Q�直接徏出无向图�Q�按�q�通块�~�点�Q�再考虑大于/��于关系�Q�如果I的值大于J则在I所在连通块与J所在连通块之间�q�一条有向边�Q�从I到J�Q?#8230... 阅读全文

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

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

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

RQNOJ187 巧置挡板
———————————————————————————————————————————————————
【背景（��犇不要囧视�Q?x�Q��?br />本沙茶最�q�开始猛��L��索、近伹{��随机等��法�Q�目标是A掉AHOI2012的后3题（在哪跌倒就从哪爬�v�Q�。昨天晚上找到这题，发现是搜索，于是开始捉……�l�果被折腾了一晚上加一上午才A掉，不过�Q�看在这题可以系�l�性的反映DFS优化的一般步骤，忍了……另外�Q�这题是本沙茶在RQNOJ上通过的第400�?#8230;…回想起通过�W?00题的时候已�l�是�q�三�q�半之前�?#8230;…真颓废啊……
———————————————————————————————————————————————————
普通DFS�Q�不加�P代）的优化方法主要有�Q?br />�Q?�Q�可行性剪枝，如果遇到已经无法产生可行解的情况��剪枝，有时候，可行性剪枝也可以指在搜烦�q�程中对不合法情�늚�剔除�Q?br />�Q?�Q�最优性剪枝：如果遇到已经无法产生比目前得到的最优解�q�要优的解的情况��剪枝，�q�其中包括启发式最优性剪枝（卛_��支限界）�Q�对目前解的�q�展情况作乐观估计，如果估计值都不能��越目前的最优解�Q�则剪枝�Q?br />�Q?�Q�通过改变搜烦��序�Q�尽早得��优解�Q�从而�ؓ后面的剪枝提供余圎ͼ�
�Q?�Q�通过预处理等手段�Q�提前得到启发值或者较优解�Q��ؓ后面的剪枝提供余圎ͼ�

一般步骤：
�Q?�Q�预处理�Q�当然是写在最前面�Q�在搜烦前得到启发值等东东�Q?br />�Q?�Q�搜索过�E�中�Q�先写最优性剪枝（包括已经到达搜烦�l�点了，也应该判断一下，提前排除不是最优解的情况）�Q?br />�Q?�Q�再判定搜烦�l�点�Q�如果到了，也不要马上更新解�Q�而是要判定这个解是否�W�合要求�Q�再更新�Q?br />�Q?�Q�若未到�l�点�Q�再写可行性剪枝；
�Q?�Q�最后写搜烦�q�程�Q�包括需要改变搜索顺序的情况�?br />
注意事项�Q?span style="color: red">数组的分层问题�?/strong>
�q�是一个很严重的问题，因�ؓ分层出错很可能会��D��一些很怪的错误出现�Q�难以发现。在搜烦题的调试技�?/a>�q�一��中�Q�已�l�提��C��q�个问题�Q�本题又涉及��C��?br />一般来��_��搜烦�q�程中��用的数组�Q�包括变量，可以视�ؓ零维数组�Q�可以分��Z��下三�c�：
�Q?�Q�在搜烦�q�程中，只会引用其��|��不会修改的数�l�（比如预处理中得到的那些东东）�Q�相当于帔R��Q?br />�Q?�Q�在搜烦�q�程中，会改变其��|��但在搜烦完毕后能改回原值的数组�Q?br />�Q?�Q�在搜烦�q�程中，会改变其��|��且在搜烦完毕后也改不回原值的数组�?br />对于�Q?�Q�（2�Q�类数组�Q�不需分层�Q�但对于�W�（3�Q�类数组一定要分层。这是因��些数�l�在多层搜烦中都需要修改，而且搜烦完了也改不回来，如果不分层，则当后面的搜索完毕以后，要��l�搜索前面的�Q�引用的��是后面的��|��׃��出错�?br />对于�W�（3�Q�类数组�Q�有的已�l?#8220;自然分层”�Q�每层搜索修改的元素都不一��P��Q�比如本题代码中的R[][]、C[][]。然而有的�ƈ没有自然分层�Q�比如本题的len、pos[]、tmp[]�{�，因此对于�q�些数组�Q�需要再加一�l�_��对于不同层��用该�l�不同的元素卛_��?br />
下面是本题的��法�Q?br />使用DFS搜烦每个位置的挡板是否需要放。搜索时�Q�先搜竖的再搜横的，�׃��题目要求每个�q�通块都必��L��矩�Ş�Q�因此对于竖的，如果该位�|�的上方两个盔R��位置的横的没有全放（包括只放了一个）�Q�则该位�|�的竖的放不攑֏�决于其上一行对应位�|�的竖的有没有放�Q�第一行除外）�Q�如果两个横的都放了�Q�则�q�里的竖的既可以放也可以不放�Q�先搜不攄��情况�Q�。当�Ӟ��一行的两个1之间必须臛_��有一个竖的，�q�是可行性限制。在搜横的的时候，按照该行所攄��竖的�Q�分成若�q�段�Q�显然每一�D�要么下面都用横的封上，要么一个都不封上。其中，如果该段所在的�q�通块里面�?�Q�且下一行对应位�|�也�?�Q�则必须��上�Q�若该段所在连通块里面没有1�Q�则不能��上�Q�因��Z��能有一个连通块里一�?都没有）�Q�否则可以自由选择��还是不��（当然也是先搜不封的）。这样一直搜到最后一行的竖的后，�q�要判断最后一行有没有�q�通块里没1�Q�若没有�Q�则��Z��个可行解。启发式优化�Q�设D[i]为第i行及以后臛_��要几个挡板（若某行有K�?�Q�则臛_��需�?K-1)个竖的；若某列有K�?�Q�则臛_��需�?K-1)个横的，累加��h��卛_��Q�显然这是乐观估计）�Q�D[i]可以预处理出来，当做启发倹{�?br />
代码�Q?
#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�W�K短简单�\问题

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

[SCOI2007 kshort]
求图的s-t�W�K短简单�\问题�Q�若有长度相同的�Q�字典序��的优先�?br />
首先�Q�由于是��单�\�Q�所�?a title="A*" href="http://www.shnenglu.com/MatoNo1/archive/2011/05/01/145456.html">A*是不能做的，因�ؓ有可能有两条s-i�Q�i为某个中间点�Q��\P1和P2�Q�P1比P2短，但由于P1到达的顶点与P2不同�Q�导致最�l�沿P1到达t的�\径长度长于沿P2到达t的（甚至有可能沿P1�Ҏ(gu��)��C��了t�Q�。然后，如果直接用DFS�Q�由于要求的是第K优解�Q�而不是最优解�Q�所以不能��用最优性剪枝（包括分支限界�Q�，因此专门为最优性剪枝服务的“改变搜烦��序”技巧也不能使用了，因此�Q�能够��用的只有可行性剪枝，而本题的数据范围使得�q�种��法必然TLE�?br />
正解是一�U�由�q�代加深思想扩展得到�?#8220;�q�代变优”DFS。设�|�一个�\径长度上限Z�Q�搜索s到t的所有简单�\�Q�在搜烦�q�程中，遇到长度大于Z的�\径就停止�Q�剪枝）�Q�然后，若得到�\径不��K条，则增加Z的��|��重新开始搜索，直到得到的�\径��L��大于�{�于K条�ؓ止。这里可以进行启发式的优化，设g[i]为点i到t的最短�\长度�Q�则搜烦�q�程中，假设目前搜到点i�Q�则�Q�目前�\径长�?g[i]�Q�是�Ҏ(gu��)��条�\径最短长度的乐观估计�Q�如果这个��D��q�了Z�Q�就可以剪枝�Q�但在剪枝之前要��C��q�个��过了Z的启发��|��取其中最��的作�ؓ下一�ơ�P代的Z倹{��那么对于字典序肿么办？可以在搜索过�E�中�Q�强制先搜编号小的结点，�q�样得到的s-t路径必然是字典序递增的。另外只要求出第K条�\径，搜烦��可以终止，因�ؓ�Ҏ(gu��)��证明�Q�题目要求的�W�K短的路径一定已�l�求出来了（只不�q�不一定是最后一条而已�Q�，扑ֈ�卛_��。此外，在搜索过�E�中不要忘了可行性剪枝，��是如果沿目前搜到的路径已经��C��了t了，剪枝�?br />
“�q�代变优”DFS�Q�就是设�|�一个解的评价值的上限�Q�最��|��或下限（最大��|��Q�在搜烦�q�程中，如果实际评�h(hu��n)��|��或者启发��|��如果可以加启发式优化的话�Q�越�q�这个限�Ӟ��则剪枝。在一�ơ搜索后�Q�如果没有得到符合要求的解，��将该限制�?span style="color: red">设�ؓ本次搜烦�q�程中越�?#8220;��?#8221;得最�q�的那个�?/strong>�Q�重新开始搜索，直到扑ֈ�所需要的解或�?span style="color: red">发现无解�Q�如果一�ơ搜索中没有发生��界�Q�却仍然没有扑ֈ�解）为止。其应用主要体现在两个方面：�Q?�Q�搜索树�q�深甚至无限深，但所需求的那个解却不深的情况；�Q?�Q�求�W�K优解的情��c�?br />
代码�Q?
#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
     摘要: 【背景（��犇不要鄙视�Q�】本沙茶在搜索题目的调试上已�l�挂�q�两�ơ了�Q�NOI2011的game用了2h+木有调出来，�q�耽误了��l�想show的时��_��l�果被挡在了集训队门外；NOIP2011的mayan�Q�用暴搜都调�?h+�Q�木有调出来�Q�结果惨挂，全国�W?00名，如果�q�题AC了就是全国前50�?#8230;…�Q�，��Z��防止在接下来的比赛中再在�q�里挂掉�Q�本沙茶军_��好好搞一下这个。【DFS的调试技巧】如...  阅读全文

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

Mato_No1 — Wed, 20 Jul 2011 15:07:00 GMT
     摘要: 【原题见�q�里】很明显的精��覆盖的模型�Q?2个零�Ӟ��再加上它们经�q�旋转、翻转后的不同�Ş�Ӟ��?0�U�，每种又可以放在不同的位置�Q�只看最左上的那个珠子）一�U�零件的一�U�位�|�就是一行。列�Q�限�Ӟ��有两�U�：每个格子只能放一个（55列）�Q�以及每个零�Ӟ��注意是每个零�Ӟ��不是每种零�g�Q�只能用一�ơ（12列）�Q�共67列。预先放的那些零件可以看成预先选中的行。然后DLX�_��覆盖卛_��。下面是DLX�_��覆盖的几个易�늂��Q�（1�Q?..  阅读全文

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

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

昨天在刷PKU1084的时候，调了很久�Q�发现原来那样实现有�~�陷。（原来的实现见�q�里�Q?br />
在重复覆盖问题中�Q�删��M��整列的操作（delcol�Q�是断开该列除了初始�l�点外的所有结点的左右链（delLR�Q�，�q�样�Q�如果有一些行预先已被选中�Q�则删去�q�一行（准确来说是对�q�一行所有结�Ҏ(gu��)��行delcol操作�Q�，�q�时��׃��出现问题�Q�因为在删去�q�一行的最后一个结点的时候，其左、右��N��指向其本�w�，此时��无法删掉这个结炏V��解册��一问题的办法是除了在矩阵中引入列头以外�Q�还要引入行��_��rowh�Q�，�q�且保证行头不删掉。这样在删掉一整行的时候就不会出问题了。但是，如果�q�样的话�Q�需要在搜烦�q�程中执行delcol操作前进行特判，保证不删掉行头结点（比如��行头结点的U、D域置�?1�Q�，�q�且�Q�在求启发函数h()值的时候也要防止在行头处出现问题，可以��行头结点的行列号均�|��ؓ0�?br />
而在�_��覆盖问题中，删去一整列的操作是断开�l�点的上下链而不是左右链�Q�因此在删去一整行时就不需要引入行头结炏V�?br />
下面是PKU1084的AC代码�Q?
#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
【问题描�q��?br>�l�出一个图G和指定的源点s、汇点t�Q�求图中从点s到点t的第K短�\�?br>【具体题目�?a title=PKU2449 >PKU2449�Q�注意：本题有一个猥琐之处：不允许空路径。也��是当s�{�于t时要��K值加1�Q?br>【算法�?br>本题有一�U�最朴素的办法：攚w��Dijkstra�Q�一开始�\�?s, 0)�Q�这里设路径(i, l)表示从s到i的一条长度�ؓl的�\径）入队。然后，每次取队中长度最短的路径�Q�该路径(i, l)出队�Q�可以证明，若这是终点�ؓi的�\径第x�ơ出队，该�\径一定是图中从s到i的第x短�\�Q�若x>K则该路径已无用，舍弃�Q�。然后从点i扩展�Q�将扩展到的路径全部入队。这��L(f��ng)��到终点�ؓt的�\径第K�ơ出队即可�?br>该算法容易实玎ͼ�借助priority_queue�Q�，但时间复杂度可能辑ֈ�O(MK)�Q�需要优化�?br>优化�Q�容易发现该��法其实有A*的思想�Q�或者说�Q�该��法其实是所有结点的��C�h(hu��n)函数h()值均�?的A*��法。�ؓ了优化此题，需要将h()值改大。显�Ӟ��h(i)值可以设�?span style="COLOR: red">从i到t的最短�\径长�?/strong>�Q�容易证明它是一致的�Q�，然后g(i)=目前�l�点代表的�\径长度，f(i)=g(i)+h(i)�Q�然后A*卛_��?br>
注意�Q�更改�\径条数应该在出队时更改，而不能在入队时更改，因�ؓ可能在该路径出队之前会有新的比它更短的�\径入队�?br>
代码�Q�PKU2449�Q�：

#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, 12 Apr 2011 14:27:00 GMT

放了�?个月�?#8230;…�Q�准��来说放�?�q�了�Q�本沙茶�?�q�前��开始捉�q�道猥琐�?#8230;…�Q?br>DLX重复覆盖的几点说明：
�Q?�Q�必��L��启发函数优化�Q�否则TLE�Q?br>�Q?�Q�不需要二分下界，只要��目前f��|��f=g+h�Q�即实际深度加上启发函数��|��与目前求得的最优解比较卛_��Q�f>=最优解卛_��枝；
�Q?�Q�删一整列�Q�delcol�Q�操作时�Q�可以从��L��一个结点开始删�Q�不一定要向精��覆盖那样非要从列头开始）�Q�但是，开始的那个�l�点不删�Q�恢复（resucol�Q�时也不恢复开始的那个�l�点�Q�这是�ؓ了在接下来的横向遍历中不受媄响。由于不删开始结点，所以在��最优列删除�Ӟ��需要��@环一�ơ删除一�ơ，恢复一�ơ�?br>
代码�Q�（RQNOJ P89�Q?/p>
#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;
}

�ȝ��Q�DLX�_��覆盖和重复覆盖其实是有大用的�Q�很多搜索问题都可以转化��两种问题�Q�效率奇高无比，且写��h��也很�Ҏ(gu��)��Q�只是在建模的时候可能有点猥琐，下面的模板，和网�l�流一��P��10min的事�Q�，至于NOIP2009引出的数独系列问题，�_��覆盖可以直接�U�杀�?br>

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