【AHOI2013复仇】ZJOI2010 Perm 排列计数

Mato_No1 — Tue, 30 Oct 2012 13:35:00 GMT

原题地址
这是个超级大水题，我太沙茶了，想傻了N久……后来才反应过来……所以要写一下作为警示。

首先这个序列就是一个堆……
因此，问题也就是说N个结点，权值刚好取遍1~N的堆的总数……
设结果为F[N]。设N个结点的堆，左子树有l个结点，右子树有r个结点（显然有l+r+1=N），则有
F[N]=C(N-1, l) * F[l] * F[r]
这个理解起来很容易囧……因为根结点只能是1，左子树和右子树显然也都是堆，因此相当于在2~N中取l个数组成左子树，剩下的数组成右子树……又因为不管取哪些数，左右子树的组成方法总数都是F[l]、F[r]（只与次序有关）……这样就得到上面的式子了囧……
C(N-1, l)=N! / l! / r!，因此需要预处理出来A[i] = i! mod P，然后除法用逆元就行了囧……

不过，本沙茶一开始想按照层数枚举，然后相乘……自然搞不出来囧……后来又用暴力把N<=15的结果拿出来分析，想找到规律……结果毫无规律……后来又纠结了N久才想到上面这个……真正比赛的时候就悲剧了囧……所以要警示一下……

代码：

Mato_No1 2012-10-30 21:35 发表评论

【AHOI2013复仇】ZJOI2008 骑士题解

Mato_No1 — Sat, 01 Sep 2012 09:03:00 GMT

原题地址
本沙茶的第一个无向环套树模型，纪念一下……

环套树，指的是每个连通块中点数都等于边数的无向图（称为无向环套树）或者是每个点有且只有一个前趋（称为内向环套树）或后继（称为外向环套树）的有向图，由于这个图的每个连通块当中有且只有一个环（注意，可能是自环，即长度为1的环），且这个环上的每个点都可以当作根引出一棵树，所以叫“环套树”。

对于无向环套树，先将整个图进行一次DFS，当中如果发现有逆向边（这条边第一次被发现必然是作为逆向边的，也就是起点是终点的后代），就说明找到了这个环，记录其起点和终点（注意，如果有多个连通块的话，不能退出，要继续遍历完），再不断上溯（因此在DFS过程中当然要记录父边了囧），就可以找到整个环了，然后再以环上的结点为根建树即可，这样依次处理每个连通块。

对于内向环套树（外向类似），找环更为简单，只需要任选一个点，不断去找它的前趋，同时记录找到的点序列，直到某个点在序列中出现两次为止，此时这个点以及序列中它两次出现的位置中间的所有点，就是环上的点，顺序也顺便记录下来，然后树也不用建了，直接在原图中找就行了。

对于这题，由于每个点都有且只有一个后继，所以是外向环套树，不过本沙茶更倾向于它的基图（无向图，是无向环套树），然后就是一个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 MAXN = 1000010;
const ll INF = ~0Ull >> 2;
struct edge {
    int a, b, pre, next;
} E0[MAXN * 3], E[MAXN << 1];
int n, m0, m, A[MAXN], stk[MAXN], st[MAXN], pr[MAXN], Q[MAXN];
ll F[MAXN][2], res = 0;
bool vst[MAXN], vst0[MAXN];
void init_d()
{
    re(i, n) E0[i].pre = E0[i].next = E[i].pre = E[i].next = i; if (n & 1) m0 = n + 1; else m0 = n; m = n;
}
void add_edge0(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++;
    E0[m0].a = b; E0[m0].b = a; E0[m0].pre = E0[b].pre; E0[m0].next = b; E0[b].pre = m0; E0[E0[m0].pre].next = m0++;
}
void add_edge(int a, int b)
{
    E[m].a = a; E[m].b = b; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m++;
}
void init()
{
    scanf("%d", &n); int x; init_d();
    re(i, n) {
        scanf("%d%d", &A[i], &x); add_edge0(--x, i);
    }
}
void sol0(int x)
{
    Q[0] = x; int i, j, front, rear;
    for (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 (!vst0[j]) {Q[++rear] = j; vst0[j] = 1; add_edge(i, j);}
        }
    }
    rre3(z, rear, 0) {
        i = Q[z];
        F[i][0] = 0; F[i][1] = A[i];
        for (int p=E[i].next; p != i; p=E[p].next) {
            j = E[p].b; F[i][0] += F[j][0] >= F[j][1] ? F[j][0] : F[j][1]; F[i][1] += F[j][0];
        }
    }
}
void solve()
{
    re(i, n) {vst[i] = vst0[i] = 0; st[i] = E0[i].next;} int x, y, tp, x0, y0; bool FF, FF2; ll tmp0, tmp1, tmp00, tmp01, res0;
    re(i, n) if (!vst[i]) {
        stk[tp = 0] = i; vst[i] = 1; FF2 = 0;
        while (tp >= 0) {
            x = stk[tp]; FF = 0;
            for (int p=st[x]; p != x; p=E0[p].next) {
                y = E0[p].b;
                if (!vst[y]) {vst[y] = 1; stk[++tp] = y; pr[y] = p; st[x] = E0[p].next; FF = 1; break;}
                else if (p != (pr[x] ^ 1) && !FF2) {FF2 = 1; x0 = x; y0 = y;}
            }
            if (!FF) tp--;
        }
        if (FF2) {
            tp = 0; vst0[y0] = 1; while (x0 != y0) {stk[tp++] = x0; vst0[x0] = 1; x0 = E0[pr[x0]].a;} stk[tp++] = y0;
            re(j, tp) sol0(stk[j]);
            tmp0 = F[stk[0]][0]; tmp1 = -INF;
            re2(j, 1, tp) {
                tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
                tmp01 = tmp0 + F[stk[j]][1];
                tmp0 = tmp00; tmp1 = tmp01;
            }
            res0 = tmp0 >= tmp1 ? tmp0 : tmp1;
            tmp0 = -INF; tmp1 = F[stk[0]][1];
            re2(j, 1, tp) {
                tmp00 = (tmp0 >= tmp1 ? tmp0 : tmp1) + F[stk[j]][0];
                tmp01 = tmp0 + F[stk[j]][1];
                tmp0 = tmp00; tmp1 = tmp01;
            }
            res += res0 >= tmp0 ? res0 : tmp0;
        }
    }
}
void pri()
{
    cout << res << endl;
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-09-01 17:03 发表评论

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

【AHOI2013复仇】ZJOI2010 Perm 排列计数

【AHOI2013复仇】ZJOI2008 骑士 题解

【AHOI2013复仇】ZJOI2008 骑士题解