欧美视频官网,中日韩高清电影网,欧美日韩精品免费观看视频

Mato_No1 — Thu, 28 Feb 2013 10:29:00 GMT

摘要: 原题地址写了几天�l�于写出来了……�Q�显�Ӟ��我太�׃��Q�请各位��犇不要鄙视�Q�在有加点的情况下，动态地�l�护凸包�Q�有以下两种�Ҏ��Q?lt;1>�l�护上、下凸壳�Q�本沙茶采用的方法）�Q�凸包可以拆成上、下凸壳�Q�对它们分别�l�护。两个凸壛_��按照下面定义�?lt;关系�Q�即先x增、再y增）排序�Q�注意，两个凸壳的两端是相同的，均�ؓ整个凸包的最��点与最大点�Q�除两端外，它们没有公共定点。以上凸壳�ؓ�?.. 阅读全文

Mato_No1 2013-02-28 18:29 发表评论

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

原题地址
首先�Q�看�q�么��的范围��q��道，数学�Ҏ��肯定搞不�?#8230;…又想不到其它模型……只能用状压硬搞了�?#8230;…
问题是，5^15�E�T�Q�如果能倒过来，15^5�Q�就不会T了�?br />可以发现�Q�C值相同的颜色本质上是一��L��……因此�Q�只需要保存目前C��gؓ1�?�?�?�?的颜色各有多��种��p��了囧……�Q�当然在�q�程中还会出现C��gؓ0的，即用完的颜色�Q�不�q?�?�?�?�?�?的和是颜色��L��Q�而且从下面可以看出，C��gؓ0的确�?#8220;木有�?#8221;�Q�；
设F[s1][s2][s3][s4][s5][v]为涂完前若干个木块（�q�个个数可以通过s1~s5��出�Q�不�q�我们�ƈ不需要它�?#8230;…�Q�后�Q�C��gؓ1~5的颜色各有s1～s5�U�，且这若干个中�?strong>最后一个涂的颜色还剩的C�?/span>为v�Q�显�?<=v<=4�Q��?br />边界�Q�F[S[1]][S[2]][S[3]][S[4]][S[5]][0]=1�Q�其余�ؓ0�Q�S[i]��Z��开始C��gؓi的颜色种敎ͼ��?br />计算F�Ӟ��前推后（注意��序�Q�是按照S[5]逆序最先，再依�ơ是S[4]～S[1]�Q�都是逆序�Q�v可�Q意定序）�Q�枚举下一个木块的颜色是现在还剩多��的�Q�如果它与目前的�q�个�Q�最后一个）剩的相同�Q�则要减1�Q�否则不减。具体的方程见代码�?br />注意�l�节�Q�枚举F的s1~s5下标�Ӟ��都要N�Q�颜色��L��Q�开始枚举，因�ؓ�q�程中某些s��g��增加�Q?br />
本题的启�C�就是，在设计状压DP的时候，如果正着来不行，可以反着来，或许��p��设计出符合要求的解法�?br />
代码�Q?br />

#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复仇】NOI2008 道�\设计

Mato_No1 — Sat, 22 Sep 2012 08:21:00 GMT

原题地址
典型的二�ơ递推/DP的题目�?br />首先�Q�题目中�?#8220;不便利�?#8221;指的是某个点到根的�\径上的木有被选定链覆盖的边的条数�?br />
�W�一问：设F[i][0..2]分别为当子树i中结点i的状态�ؓ不参与链�Q?�Q�、作为某铄��点（1�Q�、作为某链中间点�Q?�Q�时�Q�子树i中的�l�点到i的最��不便利倹{��ؓ了得到F�Q�需要设立G[j][k(0..2)]表示�l�点i的前j��子树中�Q�有k��늚�根结点与�l�点i接上的最��的最大不便利倹{��显�Ӟ��不和i接上的，状态�ؓ0�?�?都行�Q�但不便利��D��?�Q�而和i接上的状态只能是0�?�Q�不�?�?br />
问题是第二问。第二问的难点在于，当i取得最��不便利值时�Q�i的每个子�l�点�q��都取到最��不便利�?/strong>。�D个例子，�l�点i的最��不便利��gؓ3�Q�它的某个子�l�点j的最��不便利��gؓ2�Q�则当j与i接上�Ӟ��子树j的内部既可以取不便利��gؓ2的解�Q�也可以取不便利��gؓ3的解。所以，��Z��解决�W�二问，需要求出结点i的最��不便利��gؓx的解的��L��?strong>万幸的是�Q�x的范围�ƈ不是太大�Q�可以证明，x不会��过log₃N�Q�下取整�Q�，也就是当N=100000时x最大�ؓ10�?/span>因此�Q�最后仍然不会T掉�?br />
�q�题的一个启�C�就是，在求�c�M��?#8220;最优解计数”的问题中�Q?span style="color: red">不要认�ؓ当后面的状态取得最优解�Ӟ��前面的状态一定取得最优解�?/strong>因此�Q�不能只记录某状态取得最优解的个敎ͼ�而要记录该状态取得每一个可行解时的个数�?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--)
#define ll long long
const int MAXN = 100010, MAXW = 11, INF = ~0U >> 2;
struct edge {
    int a, b, pre, next;
} E0[MAXN * 3], E[MAXN << 1];
int n, m0, m, Q[MAXN], F[MAXN][3], G[MAXN][3], res1 = 0;
ll MOD, FS[MAXN][MAXW][3], S[MAXN][MAXW][3], res2 = 0;
bool vst[MAXN];
void init_d()
{
    re(i, n) E0[i].pre = E0[i].next = E[i].pre = E[i].next = i; m0 = 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()
{
    int _M; scanf("%d%d", &n, &_M); cin >> MOD; if (_M < n - 1) {res1 = res2 = -1; return;} init_d(); int a0, b0;
    re2(i, 1, n) {scanf("%d%d", &a0, &b0); add_edge0(--a0, --b0);}
}
void prepare()
{
    re(i, n) vst[i] = 0; Q[0] = 0; vst[0] = 1; int x, y;
    for (int front=0, rear=0; front<=rear; front++) {
        x = Q[front];
        for (int p=E0[x].next; p != x; p=E0[p].next) {
            y = E0[p].b;
            if (!vst[y]) {vst[y] = 1; Q[++rear] = y; add_edge(x, y);}
        }
    }
    re(i, n) if (!vst[i]) {res1 = -1; res2 = -1; return;}
}
inline int minv3(int s1, int s2, int s3)
{
    int s0 = s1 <= s2 ? s1 : s2;
    return s0 <= s3 ? s0 : s3;
}
inline int minv2(int s1, int s2)
{
    return s1 <= s2 ? s1 : s2;
}
void solve()
{
    int x, y, len, v1, v2, v01, v02; ll sum;
    rre(i, n) {
        x = Q[i]; len = 0; G[0][0] = 0; G[0][1] = G[0][2] = INF;
        for (int p=E[x].next; p != x; p=E[p].next) {
            y = E[p].b; len++;
            v1 = minv3(F[y][0], F[y][1], F[y][2]) + 1; v2 = minv2(F[y][0], F[y][1]);
            G[len][0] = v1 >= G[len - 1][0] ? v1 : G[len - 1][0];
            v01 = v1 >= G[len - 1][1] ? v1 : G[len - 1][1];
            v02 = v2 >= G[len - 1][0] ? v2 : G[len - 1][0];
            G[len][1] = minv2(v01, v02);
            v01 = v1 >= G[len - 1][2] ? v1 : G[len - 1][2];
            v02 = v2 >= G[len - 1][1] ? v2 : G[len - 1][1];
            G[len][2] = minv2(v01, v02);
        }
        re(j, 3) F[x][j] = G[len][j];
        re(j, MAXW) {S[0][j][0] = 1; S[0][j][1] = S[0][j][2] = 0;} len = 0;
        for (int p=E[x].next; p != x; p=E[p].next) {
            y = E[p].b; len++;
            re(j, MAXW) re(k, 3) {
                S[len][j][k] = 0;
                if (j) {
                    sum = 0; re(k0, 3) {sum += FS[y][j - 1][k0]; if (sum >= MOD) sum -= MOD;}
                    S[len][j][k] = (sum * S[len - 1][j][k]) % MOD;
                }
                if (k) {
                    sum = 0; re(k0, 2) {sum += FS[y][j][k0]; if (sum >= MOD) sum -= MOD;}
                    S[len][j][k] = (S[len][j][k] + sum * S[len - 1][j][k - 1]) % MOD;
                }
            }
        }
        re(j, MAXW) re(k, 3) FS[x][j][k] = S[len][j][k];
    }
    res1 = minv3(F[0][0], F[0][1], F[0][2]);
    res2 = 0; re(i, 3) if (F[0][i] == res1) res2 += FS[0][F[0][i]][i]; res2 %= MOD;
}
void pri()
{
    cout << res1 << endl << res2 << endl;
}
int main()
{
    init();
    if (!res1) prepare();
    if (!res1) solve();
    pri();
    return 0;
}

Mato_No1 2012-09-22 16:21 发表评论

【AHOI2013复仇】两道LIS模型题�ȝ��

Mato_No1 — Sat, 08 Sep 2012 12:40:00 GMT
最�q�做了两道LIS模型题，感觉到模型比较好�Q��ȝ��一下囧�?br />�?�?a title="[HAOI2007]上升序列 " >[HAOI2007]上升序列
预处理：设F[i]��Z��i开头的最长上升序列的长度�Q�怎么求不用说了吧�?#8230;…
假设目前需要求长度为M的、标号字典序最��的上升序列�Q�显然其�W�一个元素A[i]必须满��F[i]>=M�Q�注意，不是�{�于�Q�是大于�{�于�Q�）�Q�找到满��个条件的最��的i卛_��。然后，讄��前已�l�求��Z��该序列的�W�x个元素�ؓA[y]�Q�则�W?x+1)个元素A[z]需要满��的条�g是A[z]>A[y]�Q�且F[z]=F[y]-1�Q�找到满��个条件的最��的z即�ؓ该序列的�W?x+1)个元素。按照这�U�方法，扫描一遍就可以求出整个序列�Q�时间复杂度为O(N)。如果整个序列的最长上升序列长�?lt;M�Q�则无解�?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--)
#define ll long long
const int MAXN = 10010,    MAXM = 1010, INF = ~0U >> 2;
int n, m, len, A[MAXN], F[MAXN], D[MAXN], res[MAXM];
void prepare()
{
    D[len = 0] = INF; int l, r, mid;
    rre(i, n) if (A[i] < D[len]) D[F[i] = ++len] = A[i]; else {
        l = 0; r = len;
        while (l < r) {
            mid = l + r + 1 >> 1;
            if (A[i] < D[mid]) l = mid; else r = mid - 1;
        }
        F[i] = l + 1; D[l + 1] = A[i];
    }
}
void solve()
{
    int x, y;
    re(i, n) if (F[i] >= m) {
        res[0] = A[i]; if (m == 1) return; x = m - 1; y = 1;
        re2(j, i+1, n) if (F[j] >= x && A[j] > res[y - 1]) {res[y++] = A[j]; if (y == m) return; else x--;}
    }
}
int main()
{
    scanf("%d", &n); re(i, n) scanf("%d", &A[i]);
    prepare();
    int m_s; scanf("%d", &m_s);
    re(i, m_s) {scanf("%d", &m); if (m > len) puts("Impossible"); else {solve(); re(j, m-1) printf("%d ", res[j]); printf("%d\n", res[m - 1]);}}
    return 0;
}

�?�?a title="[HAOI2006]数字序列 " >[HAOI2006]数字序列
首先�Q�由于序列的所有元素都是整敎ͼ�所以可以将原序列的所有元素减��d��的下标，�q�样��把上升序列转化��Z��下降序列了�?br />�W�一问的�l�果昄��是(N-新序列的最长不下降序列长度)。关键在于第二问。以下A均表�C�新序列�?br />设F[i]��Z��A[i]�l�尾的最长不下降序列长度�Q�同��P��求法不用说了�Q�，G[i]为在A[i]不修改的前提下将A[0..i]转变��Z��下降序列的最��修攚w��。首先求出F[i]�Q�然后在求G[i]�Ӟ��枚�D上一�?#8220;不动�?#8221;�Q�就是不修改的元素）A[j]�Q�显然必��L��A[j]<=A[i]且F[j]=F[i]-1�Q�，�q�样最��修攚w��是G[j]+(��A[j..i]转变��Z��下降序列的最��修攚w��Q�。可以证明，A[j..i]的最优修�Ҏ��案必然是��A[j+1..t]全部修改为A[j]�Q�A[t+1..i]全部修改为A[i]�Q�这里t是一个[j..i]范围的倹{��问题就是如何求出最优的t�Q?br />一开始，假设t=j�Q�即把A[j+1..i-1]全部修改为A[i]�Q�计��出修改量，设�ؓS。然后，�׃��A[j+1..i-1]之间的元素要么小于A[j]�Q�要么大于A[i]�Q�这个是昄��的囧�Q�，我们把小于A[j]的元素称�?#8220;��数”�Q�把大于A[i]的元素称�?#8220;大数”�Q�则当t取t0�Ӟ��修改量�ؓS-(A[i]-A[j])*(A[j+1..t0]中的“��数”个数减去“大数”个数�Q�。这��P��只需扫描一下，求出使得(A[j+1..t0]中的“��数”个数减去“大数”个数�Q�值最大的t0卛_��?br />当然�q�有一个问题，对于同一个i�Q�满��?#8220;A[j]<=A[i]且F[j]=F[i]-1”的元素个数可能有很多�Q�如果一个一个枚举，一个一个扫描，会很慢的�?#8230;…解决�Ҏ��是，求出满��q�个条�g的j中最��的一个，设�ؓj0�Q�然后把A[j0+1..i-1]中的所�?#8220;��数”�?#8220;大数”全部处理出来�Q�然后用�c�M��前缀和的�Ҏ��p��搞了�?#8230;…当然�Q��ؓ了找到j0�Q�需要徏一个二分图�Q�边�?F[i], i)�?br />最后，��Z��方便�Q�可以把A序列的左边加一�?INF�Q�右边加一�?INF。最后�ȝ��旉��复杂度，理论上�ؓO(N²)�Q�但�׃��是随机数据，所以远�q�达不到�q�个�U�别�?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--)
#define ll long long
const int MAXN = 40010, INF = ~0U >> 2;
struct edge {
    int a, b, pre, next;
} E[MAXN << 1];
int n, m, A[MAXN], D[MAXN], F[MAXN], W[MAXN], res1;
ll G[MAXN], res2;
void init_d()
{
    re(i, n) E[i].pre = E[i].next = i; m = n;
}
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);
    A[0] = -INF; re1(i, n) {scanf("%d", &A[i]); A[i] -= i;} A[++n] = INF; n++;
}
void solve()
{
    init_d(); F[0] = 0; G[0] = 0; D[0] = -INF; add_edge(0, 0); int len = 0, l, r, mid, x, maxw; ll sum, tmp;
    re2(i, 1, n) {
        if (A[i] >= D[len]) D[F[i] = ++len] = A[i]; else {
            l = 0; r = len;
            while (l < r) {
                mid = l + r + 1 >> 1;
                if (A[i] >= D[mid]) l = mid; else r = mid - 1;
            }
            D[F[i] = ++l] = A[i];
        }
        for (int p=E[F[i]-1].next; ; p=E[p].next) if (A[i] >= A[x = E[p].b]) break;
        W[x] = 0; re2(j, x+1, i) if (A[j] < A[i]) W[j] = W[j - 1] + 1; else W[j] = W[j - 1] - 1;
        sum = 0; maxw = -INF; G[i] = ~0Ull >> 2;
        rre2(j, i, x) {
            if (A[j] <= A[i] && F[j] == F[i] - 1) {
                tmp = G[j] + sum; if (tmp < G[i]) G[i] = tmp;
                tmp = G[j] + sum - (ll) (maxw - W[j]) * (A[i] - A[j]); if (tmp < G[i]) G[i] = tmp;
            }
            if (A[j] > A[i]) sum += A[j] - A[i]; else sum += A[i] - A[j];
            if (W[j] > maxw) maxw = W[j];
        }
        add_edge(F[i], i);
    }
    res1 = n - F[n - 1] - 1; res2 = G[n - 1];
}
void pri()
{
    cout << res1 << endl << res2 << endl;
}
int main()
{
    init();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-09-08 20:40 发表评论

炮兵阵地以及与其相关的一�cȝ��压DP问题

Mato_No1 — Sat, 10 Mar 2012 15:27:00 GMT

原题地址
说实话我�W�一�ơ尝试写炮兵阵地是在2009�q?#8230;…已经�q�去两年多了�Q�终于找��C��一个好的解�?#8230;…庆祝一�?#8230;…

【状态压�~�DP�?br />所谓状态压�~�DP�Q�就是对于某些DP问题�Q�每一阶段的状态都有很多维�Q�要利用某些手段��它们压�~�到一�l�_��一个正整数�Q�，��Z��q�行状态的�_��Q�去掉不合法的状态）�Q�然后再�q�行DP。这里讲的主要是传统的状压DP�Q�有一�U�基�?#8220;插头”的DP�Q�更高��Q�以后再搞�?br />对于本题�Q�可以设计出一个这��L��状态：[0..1][0..1][0..1]...[0..1]�Q�有M个[0..1]�Q�，表示该行的每个格子放不放炮兵�Q�如果放�Q��ؓ1�Q�否则�ؓ0。显�Ӟ��q�是一个M位二�q�制敎ͼ�如果能把它们压羃成一个int��好了�?br />
【如何压�~��?br />�W�一个问题是�q�么多维的状态如何压�~�的问题�?br />对于本题�Q�由于是二进制数�Q�直接压�~�就可以了。但是对于某些情况，状态是个三�q�制敎ͼ�每个格子的属性都�?�U�）甚至更多�q�制敎ͼ��q�样�Q�直接压�~�会��D��无法使用位运��，从而��“解压”变得很麻烦，耗时也很长（需要暴力）�Q�因此，可以��每位三�q�制都拆成两位二�q�制�Q?br />0->00
1->01
2->10
�Q�当�?拆成10�?拆成11也木有问题，只要能区分开��p��了）
�q�样�Q�每个状态就可以�?个二�q�制数来表示�Q�可以在构造出所有合法状态以后将每个状态所对应的两位二�q�制数存到struct里面�Q��用时调出卛_��?br />
【如何精��?br />�q�个问题是最重要的，因�ؓ�Q�如果不�_��Q�在枚�D状态以及�{�Uȝ��时候就会枚丑ֈ�很多不合法状态，��D��旉��费�?br />所谓精��Q�是指在预处理以及DP�q�程中，��量避开不合法状态�?br />�Q?�Q�预处理中的�_��Q?br />包括3个部分：
<1>扑ֈ�所有可能的合法状态�ƈ�~�号�Q�根据题意限�Ӟ��有的状态在阶段内就不合法（比如本题�Q�一行一阶段�Q�那么凡是有两个1位的距离��于2的状态都不合法）�Q�而且�q�种状态所占的比重往往�q�很大（本题中，M=10�Ӟ��也只�?0�U�可能的合法状态）�Q�此�Ӟ��Z��扑ֈ��q�些合法状态，可以DFS构造实现�?br />需要注意的是，有的题不光要扑ֈ�一个阶�D�内的合法状态，�q�要扑ֈ�两个或两个以上阶�D�内的合法状态（比如那个有关多米诺骨牌的题）�Q�此旉��要两个int同时DFS�Q?br />在找到合法状态以后，需要对每个合法状态进行编��P��以达�?#8220;压羃”的目的。这里就涉及��C��状态编号和状态表�C�的问题�Q�比如，状�?001�Q�表�C�Zؓ9�Q�在DFS中第一个被搜到�Q�因此编号�ؓ0�Q�不要搞混了�q�两个（��其不要搞�؜“�~�号�?”�?#8220;状态表�C�Zؓ0”�Q�它们是不同的）。在预处理和DP的过�E�中�Q�所有涉及到状态的数组下标�Q�全部是�~�号而不是表�C�，知道�~�号要求表示�Q�可以在DFS中记录的数组里面调，而知道表�C��求编��P��可以利用逆数�l�或者哈希；
<2>扑ֈ�每一阶段的合法状态：即��?lt;1>中被判定为合法的状态，在具体的各个阶段中也未必合法�Q�比如本题，如果某一行的某一个位�|�是'H'�Q�不能放�Q�而某一个状态在�q�里放了�Q�则不合法）�Q�因此要�Ҏ��个阶�D�再枚�D一遍，扑ֈ�真正合法的状态，�q�计入一个vector�Q?br /><3>扑ֈ�状态�{�U�M��的合法状态：在状态�{�U�M��Q�往往要求状态不冲突�Q�比如本题，在连�l�的三个阶段中，都不能有某一位有两个�?的情况）�Q�因此，�q�要枚�D每个状态在转移时与其不冲突的状态，�q�计入vector�?br />注意�Q�有时候这一步不是很�Ҏ��q�行�Q�需要在DP�q�程中进行；
�Q?�Q�DP�q�程中的�_��Q?br />DP�q�程中，枚�D状态、�{�U�d��{�都只枚丑֐�法的�Q�在vector里面调（注意vector里记录的全都是状态编可��不是表�C�！�Q�，可以大大减少枚�D量，不过有时候，�q�会有一些时间浪费，�q�时候，可以采取一些其它的办法来精��Q�比如再�ơ进行DFS构造合法状态等�?br />
��M��Q�这�c�问题的目标��是“�_��Q�精��Q�再�_��Q��枚�D到的不合法状态减到最��?#8221;�?br />
代码�Q?br />
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
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 pb push_back
#define IR iterator
typedef vector <int> vi;
const int MAXN = 103, MAXM = 11, MAXS = 100, INF = ~0U >> 2;
int n, m, S, A[MAXN], B[MAXS], T1[MAXS], F[MAXN][MAXS][MAXS], res;
bool F0[MAXN][MAXS];
vi P0[MAXN], P1[MAXS][MAXS];
void init()
{
     scanf("%d%d", &n, &m); getchar();
     re1(i, n) {A[i] = 0; re(j, m) A[i] |= ((getchar() == 'P') << j); getchar();}
}
void dfs(int v, int ST)
{
    if (v >= m) B[S++] = ST; else {dfs(v + 3, ST | (1 << v)); dfs(v + 1, ST);}
}
void prepare()
{
    S = 0; dfs(0, 0);
    re(i, S) {T1[i] = 0; for (int j=B[i]; j; j-=j&(-j)) T1[i]++;}
    re1(i, n) re(j, S) if (!(~A[i] & B[j])) {P0[i].pb(j); F0[i][j] = 1;} P0[0].pb(S - 1); F0[0][S - 1] = 1;
    re(i, S) re(j, S) if (!(B[i] & B[j])) re(k, S) if (!(B[i] & B[k]) && !(B[j] & B[k])) P1[i][j].pb(k);
}
void solve()
{
    re3(i, 0, n) re(j1, S) re(j2, S) F[i][j1][j2] = -INF; F[0][S - 1][S - 1] = 0;
    vi::IR vi_e0, vi_e1, vi_e2; int j0, j1, k, V;
    re(i, n) {
        vi_e0 = P0[i].end(); if (i) vi_e1 = P0[i - 1].end(); else vi_e1 = P0[i].end();
        for (vi::IR p=P0[i].begin(); p != vi_e0; p++)
            for (vi::IR p_=P0[i ? i - 1 : i].begin(); p_ != vi_e1; p_++) {
                j0 = *p; j1 = *p_;
                if (!(B[j0] & B[j1])) {
                    vi_e2 = P1[j0][j1].end();
                    for (vi::IR p__ = P1[j0][j1].begin(); p__ != vi_e2; p__++) {
                        k = *p__;
                        if (F0[i + 1][k]) {
                            V = F[i][j0][j1] + T1[k];
                            if (V > F[i + 1][k][j0]) F[i + 1][k][j0] = V;
                        }
                    }
                }
            }
    }
    res = 0; re(i, S) re(j, S) if (F[n][i][j] > res) res = F[n][i][j];
}
void pri()
{
     printf("%d\n", res);
}
int main()
{
    init();
    prepare();
    solve();
    pri();
    return 0;
}

Mato_No1 2012-03-10 23:27 发表评论

Mato_No1 — Sun, 30 Oct 2011 03:22:00 GMT
有一�c�d��态规划（其中也包含递推�Q�问题，要求满��一些限制条件的字符�Ԍ��q�些限制条�g�?#8220;需要含有某个子�?#8221;�?#8220;不能含有某个子串”�Q�那么KMP、AC自动机等��有大用了�?br />
【例1�?a title="HDU3689" >HDU3689
题意�Q�字�W�集中有一些字�W�，�l�出每个字符的出现概率（它们的和保证�?�Q�，再给��Z��个子串B�Q�求�Q��Q�l�一个长度�ؓN的字�W�串A�Q�只能包含字�W�集中的字符�Q�，使得S是A的子串的概率�?br />
求解�q�类问题首先要进行补集�{化。因为子串可能有重叠�Q�比�?ababa"中就出现了两�?aba"�Q�，所以先转化�?#8220;求�Q�l�一个长度�ؓN的字�W�串A�Q�只能包含字�W�集中的字符�Q�，使得B不是A的子�?/strong>的概�?#8221;�Q�然后再�?减去�q�个概率即�ؓ�l�果�?br />设F[i][j]�?#8220;在所有长度�ؓi�?span style="color: red">不出现B的字�W�串中，后缀与B的前�~�匚w��长度为j�Q�即该字�W�串的后�~�与B的前�~��?span style="color: red">最�?/strong>匚w��长度为j�Q�的概率”�Q�很昄��Q�F是由递推得到了，关键是如何进行状态�{�U�？或者说�Q�在递推�q�程中，哪些状态可能成为F[i][j]的前��状态？
假设F[i-1][k]是F[i][j]的前��状态，也就是说�Q?span style="color: red">在字�W�集中至��存在一个字�W�c�Q��得主串的�W�i位（最后一位）取c�Ӟ��能够从F[i-1][k]转移到F[i][j]。这��需要求一个值S[k][c]�Q�表�C�当��M��的后�~�与B的前�~�的（最大）匚w��长度为k�Ӟ��在主串后再加上一个字�W�c�Q�其匚w��长度会变成什么。�D例：讄��前主串A'="abasab"�Q�B="asabs"�Q�其匚w��长度�?�Q�若在A'后加上一个字�W?s'�Q�则匚w��长度变�ؓ5�Q�所以S[4]['s']=5�Q�而若在A'后加上一个字�W?a'�Q�则匚w��长度会变�?�Q�所以S[4]['a']=1。显然S值和A前面的哪些字�W�是没有关系的�?br />那么�q�个S值如何计��？其实可以发现�Q�S和KMP��法中的nx数组��似�Q�因此完全可以按照计��nx数组的办法来计算S。具体来��_��先要对B作KMP自��n匚w��Q�求出其nx数组�Q�然后，在求S[k][c]的时候，��试在B的第k位（�׃��B的下标从0开始所以B[k-1]�Q�后加上字符c�Q�看看会“回退”到哪里即可。代码：
     int j = 0; nx[0] = 0;
     re2(i, 1, m) {
            while (j && A[i] != A[j]) j = nx[j - 1];
            if (A[i] == A[j]) j++;
            nx[i] = j;
     }
     re(i, m) re(k, SZ) {
           j = i;
           while (j && A[j] != k + 97) j = nx[j - 1];
           if (A[j] == k + 97) S[i][k] = ++j; else S[i][k] = 0;
     }
�q�里m是B的长度。注意，当i=m�Ӟ��S[i][j]是无意义的，因�ؓ前面已经说过了不能出现B�?br />在求出S值后��p��求出F��g��。对于状态F[i][j]�Q�若存在一个字�W�c使得x=S[i][c]�Q�满��?<=x最�l�结果�ؓ1-∑F[N][0..m-1]�?br />
代码

【例2�?a title="PKU1625" >PKU1625�Q?a title="URAL1158" >URAL1158�Q?br />题意�Q�给��Z��些子�Ԍ��求长度�ؓN�Q�各个字�W�都属于�l�定的字�W�集的所有字�W�串中，不包含�Q何一个给出的子串的字�W�串个数�Q�需要��用压9位的高精度）�?br />
本题昄��是【例1】的多子串�Ş式，而用来解军_��个字�W�串同时匚w��的只有AC自动机，那么如何在本题中使用AC自动机求解呢�Q?br />观察【例1】中的F[i][j]�Q�可以想象一下，一个图中有m个顶点，分别表示匚w��长度�?..(m-1)�Q�然后不断新加入的字�W�让�q�些状态在�q�些�l�点间不断�{�U�（状态�{�U�d��是图中的边）�Q�这��P��F[i][j]��p��C?#8220;阶段i到达�l�点j�?#8221;。而AC自动机是��Z��Trie�Q�树�Q�的�Q?/span>其中有现�?/span>的结点，�q�就揭示了本题的�?/span>�?/span>�Q?/strong>
F[i][j]�?/span>�C?/span>长度为i的合法的字符�Ԍ��是满��字符集限制且不包含�Q何一个给定子�Ԍ��中，在匹配到最后一位（�W�i位）后，刚好到达�l�点j的字�W�串�?/strong>个数�?br />同样�Q�S[k][c]表示“目前到达�l�点k�Q�接下来的一个字�W�是c的时候，会到辑֓�个结炏V��在�Ҏ��有的子串建立了自动机之后�Q�S值只要类似地搞就能求出来了。然后F的�{�U�M��搞定了�?br />不过�Q�本题要万分注意AC自动机的一个BUG�Q�在建立了自动机以后�Q�需要把所有本�w�不危险�Q�如果一个结点代表的字符串刚好是某一个给出的不能出现的子�Ԍ��则该�l�点是危险结点）�Q�但通过��p�|指针不断上溯能够到达一个危险结点的�l�点�Q�也标记为危险结点，比如两个子串�?abcde"�?bc"�Q�则代表"abcd"的那个结点由于包含了"bc"所以也是危险的�?br />此外�Q�本题的输入要注意，字符集的ASCII码范围是-128~127�Q�所以必��ȝ��char而不是unsigned char�Q�且�׃��可能包含�I�格所以必��ȝ��gets()而不是scanf()输入�Q�又因�ؓC/C++中木有负��C��标，因此在输入之后还要�{化一下（�?28�Q��?br />
代码

【例3�?a title="PKU3691" >PKU3691
题意�Q�给��Z��些子串和一个字�W�串A�Q�其每个字符均属于字�W�集{'A', 'C', 'G', 'T'}�Q�，求至��要改动A的几个字�W�（不能�Ҏ��不属于字�W�集的字�W�）�Q��得它不包含�Q何一个给出的子串�Q�若不管怎么攚w��不行�Q�则�l�果�?1�?br />
�q�就是真正的DP了。设F[i][j]为前i位，到达的结点�ؓj�Q�最��改动的字符个数�Q�则转移方程�?br />F[i][j] = min{F[i-1][x] + (A[i] != c)}�Q�c∈{'A', 'C', 'G', 'T'}�Q�S[x][c]=j。边界：F[0][root]=0�Q�其余的F[0][]=+∞�Q�A的实际下标从1开始�?br />求S数组的方法见【例2�?br />
代码

【例4�?a title="PKU3208" >PKU3208
题意�Q�含有连�l�的三个数字6的正整数�Q�称�?beastly number"�Q�求�W�P个（1<=P<=50000000�Q?beastly number"�Q�其位数不会��过15位）�?br />�Q�这题是本沙茶在PKU上至今�ؓ止，自己惛_��法的AC人数最��的题）
本题其实是用不着KMP的，因�ؓ"666"�q�样��单的子串……

思�\�Q�由于位��C��会超�q?5位（后来发现最多只�?0位）�Q�所以每�?beastly number"都可以看成一个长度�ؓ15�Q�字�W�集为['0'..'9']的字�W�串�Q�注意是可以有前�?的，因�ؓ位数可能不��15位）A�Q�整个过�E�也��是从高位（�W?位）向低位（�W?4位）求出A的各位�?br />
预处理：求出F[i][j]�Q�表�C��A的前i位已�l�确定（其中不含"666"�Q�准��来说是非末��不�?666"�Q�，且前i位的末尾刚好有j�?6'�Q�j的范围是0�?�Q�时�Q�有多少�?beastly number"�Q�注意，前i位既然已�l�确定，��׃��可更改了�Q�能够决定的只有�W�i位的后面�Q��?br />昄��先要求出F0[i][j]表示有多��个不是"beastly number"。其递推方程不好写，见代码（其实也是很好理解的）。然后F[i][j]=10^14-i - F0[i][j]�?br />
然后��是不断调整边界来构造了。准��来��_��讑։�i-1位已�l�确定，现在要确定第i位，则枚丄��i位是0~9中的哪个��|��然后求出满��条�g的最��的"beastly number"和最大的"beastly number"的名�ơ（注意�Q�名�ơ是�?开始的�Q�，看看P在不在其中，�q�样��p��定了。严重注意：如果已确定的位数中已�l�出��C��"666"�Q�接下来的就不用枚�D了，直接在后面接上P-L��p��了，L为左边界�?br />
但是�Q��ؓ什么要把本题放在KMP的专题里面呢囧？因�ؓ如果�q�个子串不是"666"而是一些结构复杂的东东比如"123131"�q�样的，只有借助KMP��法了。这�Ӟ��F[i][j]��p��C?A的前i位已�l�确定（非末��不含这个子�Ԍ��Q�且其后�~�与这个子串的前缀�?/span>配长度�ؓj�Q?/span>有多��个"beastly number" �Q��{�U�L��E�与前几个例子类伹{�?br />
代码

�ȝ��Q?br />KMP��法和AC自动机的状态�{�U�L��质军_��了它们在字符串匹配类DP问题中的巨大作用。在实际应用中，要注意灵�z�M��用它们。此外，AC自动机的那个BUG是一定要注意的�?

Mato_No1 2011-10-30 11:22 发表评论

PKU3017

Mato_No1 — Fri, 08 Jul 2011 04:40:00 GMT

【原题见�q�里�?br />
本沙茶见�q�的最猥琐的DP题啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊�?#8230;…

设F[i]为将A[1..i]拆分成若�q�段的最大值最��和�Q�则�?br />F[i]=min{F[j] + max[j+1, i]}�Q�B[i]<=j边界�Q�F[0]=0�?br />
下面是优化过�E�。JZP��犇的论文里面已�l�够详细了。这里只是简要说明一下�?br />首先�Ҏ��证明�Q�F是单调递增的�?br />然后一个很关键的定理是�Q?strong style="color: red">若F[i]的最优决�{��ؓj�Q�则有A[j]>∀A[k]�Q�j
证明�Q�用反证法。若A[j+1..i]中存在不��于A[j]的��|��则可得max[j..i]=max[j+1..i]�Q�又因�ؓF单调递增�Q�所以F[j-1]+max[j..i]<=F[j]+max[j+1.i]�Q�即决策(j-1)一定不比决�{�j差，也就是决�{�j不可能成为最优决�{��?br />�q�样�Q�可以维护一个下标严格递增、A��g��格递减的队列Q�Q�即对于队列中的��L��两个元素Q[i]和Q[j]�Q�若iA[Q[j].pos]�Q�具体实现时pos可省略）。则可能成�ؓ最优决�{�的决策要么是在�q�个队列Q里，要么是B[i]。对于队列中的某个决�{�Q[x]�Q�该决策导出的��gؓF[Q[x]]+A[Q[x + 1]]�Q�很�Ҏ��证明max[Q[x]+1..i]=A[Q[x + 1]]�Q�，扑ֈ��q�些导出的��g��的最��值即可（注意�Q�队��օ�素没有导出��|��。对于决�{�B[i]�Q�只需要在预处理的时候同时得到MAX[i]=max[B[i]+1..i]卛_��Q�也可以在O(N)旉��内得刎ͼ��Q�决�{�B[i]导出的��gؓF[B[i]]+MAX[i]�?br />在删除队首过时元素的时候，需要把导出��g��删除�Q�删除队��օ�素也一��P��插入的时候，若插入前队列不�ؓ�I�，则需要插入一个导出倹{��也��是�Q�需要一个支持在�Ҏ��旉��内进行插入、删除�Q意结炏V��找最��值等操作�Q�显然用�q��树最好�?br />
注意事项�Q?br />�Q?�Q�不��是在队首删除还是在队尾删除�Q�若删除的是队列中的最后一个元素，则不需要在�q��树中删除导出��|��
�Q?�Q�插入时�Q�若插入前队列�ؓ�I�，则不需要在�q��树中插入导出��|��
�Q?�Q�在计算F[i]�Ӟ��应先��决�{�i压入�?br />
代码�Q?
#include <iostream>
#include <stdio.h>
using namespace std;
#define re1(i, n) for (int i=1; i<=n; i++)
const int MAXN = 100001;
struct node {
    int l, r, p, sz0, sz, mul;
    long long v;
} T[MAXN];
const long long INF = ~0Ull >> 2;
int n, N = 0, a[MAXN], b[MAXN], MAX[MAXN], Q[MAXN], front = 0, rear = -1, root = 0;
long long m, F[MAXN], res = 0;
void init()
{
    cin >> n >> m;
    re1(i, n) scanf("%d", &a[i]); a[0] = ~0U >> 2;
}
void prepare()
{
    re1(i, n) if (a[i] > m) {res = -1; return;}
    int x = 1;
    long long sum = 0;
    re1(i, n) {
        for (sum+=a[i]; sum>m; sum-=a[x++]) ;
        b[i] = x - 1;
    }
    re1(i, n) {
        for (; front<=rear && Q[front]<=b[i]; front++) ;
        for (; front<=rear && a[Q[rear]]<=a[i]; rear--) ;
        Q[++rear] = i; MAX[i] = a[Q[front]];
    }
}
void vst(int x)
{
    if (x) {
        cout << T[x].v << ' ';
        vst(T[x].l); vst(T[x].r);
    }
}
void slc(int _p, int _c)
{
    T[_p].l = _c; T[_c].p = _p;
}
void src(int _p, int _c)
{
    T[_p].r = _c; T[_c].p = _p;
}
void upd(int x)
{
    T[x].sz0 = T[T[x].l].sz0 + T[T[x].r].sz0 + T[x].mul;
    T[x].sz = T[T[x].l].sz + T[T[x].r].sz + 1;
}
void lrot(int x)
{
    int y = T[x].p;
    if (y == root) T[root = x].p = 0; else {int p = T[y].p; if (y == T[p].l) slc(p, x); else src(p, x);}
    src(y, T[x].l); slc(x, y); T[x].sz0 = T[y].sz0; T[x].sz = T[y].sz; upd(y);
}
void rrot(int x)
{
    int y = T[x].p;
    if (y == root) T[root = x].p = 0; else {int p = T[y].p; if (y == T[p].l) slc(p, x); else src(p, x);}
    slc(y, T[x].r); src(x, y); T[x].sz0 = T[y].sz0; T[x].sz = T[y].sz; upd(y);
}
void maintain(int x, bool ff)
{
    int z;
    if (ff) {
        if (T[T[T[x].r].r].sz > T[T[x].l].sz) {z = T[x].r; lrot(z);}
        else if (T[T[T[x].r].l].sz > T[T[x].l].sz) {z = T[T[x].r].l; rrot(z); lrot(z);} else return;
    } else {
        if (T[T[T[x].l].l].sz > T[T[x].r].sz) {z = T[x].l; rrot(z);}
        else if (T[T[T[x].l].r].sz > T[T[x].r].sz) {z = T[T[x].l].r; lrot(z); rrot(z);} else return;
    }
    maintain(T[z].l, 0); maintain(T[z].r, 1); maintain(z, 0); maintain(z, 1);
}
int find(long long _v)
{
    int i = root;
    long long v0;
    while (i) {
        v0 = T[i].v;
        if (_v == v0) return i; else if (_v < v0) i = T[i].l; else i = T[i].r;
    }
    return 0;
}
int Find_Kth(int K)
{
    int i = root, s0, m0;
    while (1) {
        s0 = T[T[i].l].sz0; m0 = T[i].mul;
        if (K <= s0) i = T[i].l; else if (K <= s0 + m0) return i; else {K -= s0 + m0; i = T[i].r;}
    }
}
void ins(long long _v)
{
    if (!root) {
        T[++N].v = _v; T[N].l = T[N].r = T[N].p = 0; T[N].sz0 = T[N].sz = T[N].mul = 1; root = N;
    } else {
        int i = root, j;
        long long v0;
        while (1) {
            T[i].sz0++; v0 = T[i].v;
            if (_v == v0) {T[i].mul++; return;} else if (_v < v0) j = T[i].l; else j = T[i].r;
            if (j) i = j; else break;
        }
        T[++N].v = _v; T[N].l = T[N].r = 0; T[N].sz0 = T[N].sz = T[N].mul = 1; if (_v < v0) slc(i, N); else src(i, N);
        while (i) {T[i].sz++; maintain(i, _v > T[i].v); i = T[i].p;}
    }
}
void del(int x)
{
    if (T[x].mul > 1) {
        T[x].mul--; while (x) {T[x].sz0--; x = T[x].p;}
    } else {
        int l = T[x].l, r = T[x].r, p;
        if (l && r) {
            int y; while (y = T[l].r) l = y;
            T[x].v = T[l].v; T[x].mul = T[l].mul; p = T[l].p;
            if (l == T[p].l) slc(p, T[l].l); else src(p, T[l].l);
            while (p) {upd(p); p = T[p].p;}
        } else {
            if (x == root) T[root = l + r].p = 0; else {p = T[x].p; if (x == T[p].l) slc(p, l + r); else src(p, l + r); while(p) {upd(p); p = T[p].p;}}
        }
    }
}
long long h(int x)
{
    return F[Q[x]] + a[Q[x + 1]];
}
void solve()
{
    F[0] = 0; front = 0; rear = 0; Q[0] = 0;
    re1(i, n) {
        for (; front<=rear && Q[front]<b[i];) {if (front < rear) del(find(h(front))); front++;}
        for (; front<=rear && a[Q[rear]]<=a[i];) {if (front < rear) del(find(h(rear - 1))); rear--;}
        Q[++rear] = i; if (front < rear) ins(h(rear - 1));
        if (root) F[i] = T[Find_Kth(1)].v; else F[i] = INF;
        if (F[b[i]] + MAX[i] < F[i]) F[i] = F[b[i]] + MAX[i];
    }
    res = F[n];
}
void pri()
{
    cout << res << endl;
}
int main()
{
    init();
    prepare();
    if (!res) solve();
    pri();
    return 0;
}

Mato_No1 2011-07-08 12:40 发表评论

Mato_No1 — Tue, 05 Jul 2011 10:00:00 GMT
多重背包问题朴素旉��复杂度�ؓO(NMS)�Q�这里S是所有物品的数量s之和�Q�，�l�过二进制优化后旉��复杂度�ؓO(NMlog2S)�Q�这个复杂度已经能够应付大多数题了，但对于某些特别卡旉��的题�Q�比如N*M=10⁷�?�Q�仍然会TLE。这�Ӟ��可以用单调队列优化，旉��复杂度降为O(NM)�?br />
首先看一下多重背包问题的朴素转移方程�Q?br />F[i][j] = max{F[i-1][j-x*w[i]]+x*v[i]} (0<=x<=s[i], j>=x*w[i])
如果使用滚动数组�Q�忽略i�q�一�l�_��设w0=w[i]�Q�v0=v[i]�Q�s0=s[i]�Q�得�Q?br />F[j] = max{F[j-x*w0]+x*v0} (0<=x<=s0, j>=x*w0)
看上去这和单调队列木有神马关�p�，因�ؓ决策下标�Q�j-x*w0�Q�不是一个整数区��_��中间是有间隔的。然而可以发玎ͼ��q�个方程的限制条�?#8220;0<=x<=s0�Q�j>=x*w0”�Q�也��是x的下界是max{0, j/w0�Q�下取整�Q�}�Q�当j单调递增�Ӟ��q�个下界也是单调递增的。这满��单调队列优化的条件中�?#8220;决策下标的下界单�?#8221;……不是�Q�还不能�q�样��_��因�ؓ�q�里的决�{�下标是j-x*w0�Q�而不是x�?br />那么怎样才可以把决策下标变�ؓx�Q?br />
��决�{�下标按照模w0的余数进行分�c�，可以分成w0�c�，分别对应模w0�?、余1……�?w0-1)的情��c��这�Ӟ��上面方程中的所有决�{�下标j-x*w0都是同一�cȝ��。进一步，设q =j/w0�Q�下取整�Q�，r=j%w0�Q�则j=q*w0+r�Q�对于某个决�{�下标j'�Q�设k=(j'-r)/w0�Q�即j'=k*w0+r。显然可以发玎ͼ�k的取��D��围是�Q�k>=0且q-s0<=k<=q�Q�也即k的下界是max{0, q-s0}——随j的单调而单调�?br />然后�Q��{�U�L��E�可以改为（�q�里把r当成一个已知量了）�Q?br />F[q*w0+r] = max{F[k*w0+r]+(q-k)*v0} (k>=0且q-s0<=k<=q)
即F[q*w0+r]=max{F[k*w0+r]-k*v0}+q*v0 (k>=0且q-s0<=k<=q)
设G[k]=F[k*w0+r]得：
G[q]=max{G[k]-k*v0}+q*v0 (k>=0且q-s0<=k<=q)
�q�个方程已经可以使用单调队列来优化了�Q?br />
�q�样可以得出��法�Q?br />�Q?�Q�从1到n�Q�枚举i�Q�徏立w[i]个空的单调队列，每个队列的元素都是两个int��|��(k, val)�Q�表�C��{换后下标和决�{��?G[k]-k*v[i])�Q?br />�Q?�Q�从0到m�Q�枚举j�Q�得出q、r的��|��对于队列r�Q?br />�?】删去队首过�Ӟ��k�?】F[j]入队�Q�这里的F[j]指上一阶段的F[j]�Q�即F[i-1][j]。因此这一步操作一定要先进行）�Q�删去队��所有决�{�值val不大�?F[j]-q*v[i])的元素�?br />�?】取出队首结点，其val值加上q*v[i]后即为本阶段F[j]的倹{�?br />最后F[m]即�ؓ�l�果。��L��间复杂度为O(NM)�?br />
其实�q�个是可以推�q�的�Q�即对于如下形式的�{�U�L��E�（其中H、G和W均�ؓ帔R��Q�B[i]为决�{�下标的下界�Q�随i单调�Q�：
F[i] = opt{F[i-x*H+W]}+G (B[i]<=i-x*H+WN�Q?br />都可以用上述的办法进行�{化，从而进行单调队列优化�?br />

Mato_No1 2011-07-05 18:00 发表评论