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

【AHOI2013复仇】SCOI2003 字符串折叠

Mato_No1 — Wed, 24 Oct 2012 07:11:00 GMT

原题地址
本沙茶在2009年1月曾经在RQNOJ上捉过这题，那时候是很难的题，现在就很水了囧……（当然，本沙茶那个时候不会exKMP，是用暴力的，可是时间复杂度仍能是O(N³)）。

F[i][j]=min{F[i][k]+F[k+1][j]，min{((j-i+1)/(k-i+1)的十进制位数)+2+F[i][k]，k-i+1}, i<=k（加上k-i+1是因为对于以下三种重叠字符串，不压缩比压缩要短：AA型、AAA型、ABAB型）
边界：F[i][i]=1；

问题是在上述方程的第二项里如何求出可行的k。显然，只需要对[i..j]这一段作exKMP，求出nx，然后k可行当且仅当满足：（1）nx[k+1]=j-k；（2）(k-i+1)|(j-i+1)；

不过，本题在写exKMP的过程中会出现很囧的问题……由于下标不是从0开始，而是从i开始，所以很多地方关于下标的计算都要改掉，非常不方便，而且很容易疵掉。与其这样，还不如把[i..j]这一段复制到一个新字符串里，下标从0开始。对于其它的某些字符串算法和数据结构，或许也是这样囧……

代码：

#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--)
#define ll long long
const int MAXN = 110, INF = ~0U >> 2;
int n, F[MAXN][MAXN], nx[MAXN], res;
char ss[MAXN + 1], ss0[MAXN + 1];
void init()
{
    scanf("%s", ss); n = strlen(ss);
}
int sol0(int l, int r)
{
    int W = r - l + 1; re3(i, l, r) ss0[i - l] = ss[i];
    nx[0] = W; nx[1] = nx[0] - 1; re(i, W) if (ss0[i] != ss0[i + 1]) {nx[1] = i; break;}
    int k = 1, len, p = k + nx[k] - 1, x, y;
    re2(i, 2, W) {
        len = nx[i - k];
        if (i + len <= p) nx[i] = len; else {
            x = p + 1; y = p - i + 1; if (y < 0) {x++; y = 0;}
            for (; x<=W && ss0[x]==ss0[y]; x++, y++) ;
            nx[i] = y; k = i; p = i + y - 1;
        }
    }
    int res0 = INF, tmp, V;
    re2(i, 1, W) if (!(W % i) && nx[i] == W - i) {
        V = F[l][l + i - 1] + 2; tmp = W / i; while (tmp) {tmp /= 10; V++;}
        if (W < V) V = W;
        if (V < res0) res0 = V;
    }
    return res0;
}
void solve()
{
    re(i, n) F[i][i] = 1;
    int j, tmp;
    re2(x, 1, n) re(i, n-x) {
        j = i + x; F[i][j] = sol0(i, j);
        re2(k, i, j) {tmp = F[i][k] + F[k + 1][j]; if (tmp < F[i][j]) F[i][j] = tmp;}
    }
    res = F[0][n - 1];
}
void pri()
{
    printf("%d\n", res);
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-10-24 15:11 发表评论

【AHOI2013复仇】SCOI2008 着色方案

Mato_No1 — Wed, 24 Oct 2012 06:59:00 GMT

原题地址
首先，看这么小的范围就知道，数学方法肯定搞不了……又想不到其它模型……只能用状压硬搞了囧……
问题是，5^15稳T，如果能倒过来，15^5，就不会T了。
可以发现，C值相同的颜色本质上是一样的……因此，只需要保存目前C值为1、2、3、4、5的颜色各有多少种就行了囧……（当然在过程中还会出现C值为0的，即用完的颜色，不过0、1、2、3、4、5的和是颜色总数，而且从下面可以看出，C值为0的确实“木有用”）；
设F[s1][s2][s3][s4][s5][v]为涂完前若干个木块（这个个数可以通过s1~s5算出，不过我们并不需要它囧……）后，C值为1~5的颜色各有s1～s5种，且这若干个中的最后一个涂的颜色还剩的C值为v（显然0<=v<=4）。
边界：F[S[1]][S[2]][S[3]][S[4]][S[5]][0]=1，其余为0（S[i]为一开始C值为i的颜色种数）。
计算F时，前推后（注意顺序，是按照S[5]逆序最先，再依次是S[4]～S[1]，都是逆序，v可任意定序），枚举下一个木块的颜色是现在还剩多少的，如果它与目前的这个（最后一个）剩的相同，则要减1，否则不减。具体的方程见代码。
注意细节：枚举F的s1~s5下标时，都要N（颜色总数）开始枚举，因为过程中某些s值会增加；

本题的启示就是，在设计状压DP的时候，如果正着来不行，可以反着来，或许就能设计出符合要求的解法。

代码：

#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--)
#define ll long long
const int n = 5, MAXM = 16, MOD = 1000000007;
int m, S[n + 1];
ll F[MAXM][MAXM][MAXM][MAXM][MAXM][n], res;
void init()
{
    scanf("%d", &m); int x;
    re(i, m) {scanf("%d", &x); S[x]++;}
}
void solve()
{
    F[S[1]][S[2]][S[3]][S[4]][S[5]][0] = 1; int tmp;
    rre3(i5, m, 0) rre3(i4, m, 0) rre3(i3, m, 0) rre3(i2, m, 0) rre3(i1, m, 0) re(v, n)
        if (F[i1][i2][i3][i4][i5][v]) {
            if (i1) {
                if (v == 1) tmp = i1 - 1; else tmp = i1;
                if (tmp) {
                    F[i1 - 1][i2][i3][i4][i5][0] += tmp * F[i1][i2][i3][i4][i5][v];
                    F[i1 - 1][i2][i3][i4][i5][0] %= MOD;
                }
            }
            if (i2) {
                if (v == 2) tmp = i2 - 1; else tmp = i2;
                if (tmp) {
                    F[i1 + 1][i2 - 1][i3][i4][i5][1] += tmp * F[i1][i2][i3][i4][i5][v];
                    F[i1 + 1][i2 - 1][i3][i4][i5][1] %= MOD;
                }
            }
            if (i3) {
                if (v == 3) tmp = i3 - 1; else tmp = i3;
                if (tmp) {
                    F[i1][i2 + 1][i3 - 1][i4][i5][2] += tmp * F[i1][i2][i3][i4][i5][v];
                    F[i1][i2 + 1][i3 - 1][i4][i5][2] %= MOD;
                }
            }
            if (i4) {
                if (v == 4) tmp = i4 - 1; else tmp = i4;
                if (tmp) {
                    F[i1][i2][i3 + 1][i4 - 1][i5][3] += tmp * F[i1][i2][i3][i4][i5][v];
                    F[i1][i2][i3 + 1][i4 - 1][i5][3] %= MOD;
                }
            }
            if (i5) {
                F[i1][i2][i3][i4 + 1][i5 - 1][4] += i5 * F[i1][i2][i3][i4][i5][v];
                F[i1][i2][i3][i4 + 1][i5 - 1][4] %= MOD;
            }
        }
    res = F[0][0][0][0][0][0];
}
void pri()
{
    cout << res << endl;
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-10-24 14:59 发表评论

【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 — Sun, 07 Oct 2012 03:02:00 GMT

一开始想傻了囧……不过很快就发现这其实是个超级大水题……
考虑斜堆中最后插入的那个结点，容易发现：
（1）它一定是一个极左结点（就是从根往它的路上一直都是沿着左链走），因为插入的时候每次都是插入到左子树中；
（2）它一定木有右子树，因为插入的时候每次都是把原来的某棵子树作为新结点的左子树；

满足（1）（2）的结点可能有多个，但紧接着可以发现，这个斜堆中的每个结点如果木有左子结点，那么也木有右子结点（或者说，每个非叶结点都有左子树），而在插入一个结点之前，其所有的祖先都被交换了左右子树，所以，若新结点的祖先中有满足（1）（2）的，且新结点不是叶结点，那么在新结点插入之前，这个满足（1）（2）的祖先必然是只有右子树而木有左子树的，这与上面的那个性质矛盾，所以，可以得出：最后插入的那个结点一定是满足（1）（2）的结点中，深度最小的那个（设为X），除非X的左子结点是叶结点，此时为了满足字典序最小，应该取X的左子结点为最后插入的。找到这个最后插入的结点以后，只需要把它删掉，并把它的所有祖先交换左右子树，就是插入该结点以前的状态了。这样可以找到字典序最小的插入顺序。
———————————————————————————————————————————————————
但是，这个题的意义还不止于此，必须要搞清楚斜堆到底是什么，有什么应用囧……

斜堆是可合并堆的一种实现形式，其更稳定的实现是左偏树（斜堆只能做到均摊logN，而左偏树则可以严格做到每次操作O(logN)）。
斜堆最典型的特点，上面已经说过了，如果一个结点没有左子树，那么它也一定没有右子树。这样，大多数斜堆看上去是往左倾斜的（这也就是它的名字的由来……）。如果给每个结点加上一个距离值dist[]，为该结点到它最近的没有右子树的子结点的距离，并且满足任意结点的左子结点的距离值都不小于右子结点的距离值的话，就成了左偏树囧……

可合并堆，顾名思义，它必须满足两个性质：（1）是堆，也就是每个结点的关键字都不大于（小顶堆）/不小于（大顶堆）其两个子结点的关键字；（2）它必须在O(logN)时间内完成合并操作，即将两个堆合并为一个，且合并成的堆仍满足原来的性质。
斜堆的合并操作有点像某些函数式数据结构，但它并不会动用额外的空间。该合并操作使用递归实现，设两个斜堆（小顶堆）的根结点为A、B，若A和B中的某一个为空，则返回另一个；若A和B均非空，则先将它们中关键字小的那个的右子树与关键字大的那个的整棵树合并，作为关键字小的那个的新的右子树，然后，如果是左偏树的话要更新dist，若dist不满足“左不小于右”，还要交换左右子树。

斜堆可以支持的操作有（指能在O(logN)时间内完成的操作）：
（1）插入结点：（用合并实现）；
（2）删除任意结点：（将待删除结点的两棵子树合并，取代原来的位置，若是左偏树的话还要往上更新dist直到dist不变为止，某论文里有证明，每次删除更新dist次数不会超过2logN）；
（3）合并两个斜堆；
（4）找最小/大值；
（5）求以某个结点为根的子树大小（维护sz即可）；

斜堆不能支持的操作有（指不能在O(logN)时间内完成的操作）：
（1）查找任意结点。因此，若要删除某个指定结点，则必须先用下标等索引到它；
（2）找第K小（如果这个都能实现的话，斜堆就可以替代平衡树了囧……还是可合并平衡树……）；
（3）找某个结点所在树的根结点（但是配合并查集+索引可以实现，详见HDU1512）；

至于编程复杂度方面……非常非常好写！基本上一个合并操作就够了，<10行（斜堆的好写程度仅次于并查集和普通堆）；
写的之后有三个主要的易疵点：
（1）合并的时候别忘了更新一些东东，尤其别忘了返回根结点；
（2）（极易疵的！！）如果要删除某个结点，必须把它的所有信息恢复到孤立结点的状态，即断开与原树的一切联系（pr、L、R全部置0），dist（如果是左偏树）置0、sz置1；（3）下标从1开始，0号结点作特殊用途（dist值为-1，sz值为0），如果某个结点的pr、L、R不存在则为0；

例题（由于想稳定，本沙茶全都是用左偏树写的囧）：
【1】HDU1512
基本操作题，配合并查集+索引找根即可；

#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--)
#define ll long long
const int MAXN = 100010, INF = ~0U >> 2;
int n, u[MAXN], rt[MAXN], V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], res;
int UFS_find(int x)
{
    int tmp = x, r = x; while (u[r] >= 0) r = u[r]; while (x != r) {tmp = u[x]; u[x] = r; x = tmp;} return r;
}
void UFS_union(int s1, int s2, int rt0)
{
    if (u[s1] >= u[s2]) {u[s1] = s2; u[s2]--; rt[s2] = rt0;} else {u[s2] = s1; u[s1]--; rt[s1] = rt0;}
}
int heap_union(int s1, int s2)
{
    if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
        int z = heap_union(R[s1], s2);
        R[s1] = z; pr[z] = s1; if (dist[L[s1]] < dist[z]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;}
        dist[s1] = dist[R[s1]] + 1; return s1;
    } else {
        int z = heap_union(s1, R[s2]);
        R[s2] = z; pr[z] = s2; if (dist[L[s2]] < dist[z]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;}
        dist[s2] = dist[R[s2]] + 1; return s2;
    }
}
void prepare()
{
    dist[0] = -1; re1(i, n) {u[i] = -1; rt[i] = i; dist[i] = pr[i] = L[i] = R[i] = 0;}
}
void solve(int x, int y)
{
    int s1 = UFS_find(x), s2 = UFS_find(y); if (s1 == s2) {res = -1; return;}
    int rt1 = rt[s1], rt2 = rt[s2];
    int z1 = heap_union(L[rt1], R[rt1]); L[rt1] = R[rt1] = pr[z1] = 0;
    V[rt1] /= 2; z1 = heap_union(rt1, z1); pr[z1] = 0;
    int z2 = heap_union(L[rt2], R[rt2]); L[rt2] = R[rt2] = pr[z2] = 0;
    V[rt2] /= 2; z2 = heap_union(rt2, z2); pr[z2] = 0;
    int z = heap_union(z1, z2); pr[z] = 0;
    UFS_union(s1, s2, z);
    res = V[z];
}
int main()
{
    int m, x0, y0;
    while (scanf("%d", &n) != EOF) {
        re1(i, n) scanf("%d", &V[i]); prepare();
        scanf("%d", &m);
        re(i, m) {
            scanf("%d%d", &x0, &y0);
            solve(x0, y0);
            printf("%d\n", res);
        }
    }
    return 0;
}

【2】HDU3031
综合操作题，需要sz，同时也可以考察数据结构的综合应用能力。

#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--)
#define ll long long
const int MAXN = 1000010, MAXM = 101, MAXLEN_M = 10010, INF = ~0U >> 2;
int n, m, len[MAXM], V0[MAXM][MAXLEN_M], root[2];
int V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], sz[MAXN];
bool FS;
void upd(int x)
{
    sz[x] = sz[L[x]] + sz[R[x]] + 1;
}
int heap_union(int s1, int s2)
{
    if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
        int s0 = heap_union(R[s1], s2);
        pr[s0] = s1; R[s1] = s0; if (dist[L[s1]] < dist[s0]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;} dist[s1] = dist[R[s1]] + 1; upd(s1);
        return s1;
    } else {
        int s0 = heap_union(s1, R[s2]);
        pr[s0] = s2; R[s2] = s0; if (dist[L[s2]] < dist[s0]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;} dist[s2] = dist[R[s2]] + 1; upd(s2);
        return s2;
    }
}
void opr_T(int x)
{
    sort(V0[x], V0[x] + len[x]); int root0 = n + 1;
    rre(i, len[x]) {
        n++; if (i == len[x] - 1) pr[n] = 0; else pr[n] = n - 1; if (i) L[n] = n + 1; else L[n] = 0; R[n] = dist[n] = 0; V[n] = V0[x][i]; sz[n] = i + 1;
    }
    root[FS] = heap_union(root[FS], root0);
}
void opr_A(int x)
{
    V[root[FS]] += x;
}
void opr_E(int x)
{
    int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1; V[root0] = x;
    root[FS] = heap_union(z0, root0);
}
void opr_L()
{
    int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1;
}
void opr_C()
{
    int root0 = root[0], root1 = root[1];
    if (V[root0] > V[root1]) {
        root[0] = heap_union(root0, root1); root[1] = 0;
    } else if (V[root0] < V[root1]) {
        root[1] = heap_union(root0, root1); root[0] = 0;
    }
}
int main()
{
    int tests, sc0 = 0, sc1 = 0, P, tmp; char ssss[10];
    scanf("%d", &tests);
    re(testno, tests) {
        scanf("%d%d", &P, &m);
        re(i, m) scanf("%d", &len[i]);
        re(i, m) re(j, len[i]) scanf("%d", &V0[i][j]); n = root[0] = root[1] = 0; dist[0] = -1; sz[0] = 0; FS = 0;
        re(i, P) {
            scanf("%s", ssss);
            if (ssss[0] == 'T') {scanf("%d", &tmp); opr_T(--tmp);}
            else if (ssss[0] == 'A') {scanf("%d", &tmp); opr_A(tmp);}
            else if (ssss[0] == 'E') {scanf("%d", &tmp); opr_E(tmp);}
            else if (ssss[0] == 'L') opr_L(); else opr_C();
            FS = !FS;
        }
        printf("%d:%d\n", sz[root[0]], sz[root[1]]);
        if (sz[root[0]] >= sz[root[1]]) sc0++; else sc1++;
    }
    if (sc0 > sc1) puts("HahahaI win!!"); else puts("I will be back!!");
    return 0;
}

Mato_No1 2012-10-07 11:02 发表评论

【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复仇】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 发表评论