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

【AHOI2013复仇】两道有关删边后最短路径维护的猥琐题

Mato_No1 — Sat, 19 Jan 2013 08:49:00 GMT

摘要: 【先祝贺一下@Jollwish神犇进入CMO国家集训队……合肥OI人总算出了个国家集训队员（虽然不是OI的）……】最近捉了两道猥琐题……都是有关图中删去某边后的最短路径的问题……核心思想几乎相同……但是，它们很明显是综合题，代码量太大了（与NOIP2012的drive和block... 阅读全文

Mato_No1 2013-01-19 16:49 发表评论

【AHOI2013复仇】BZOJ2165

Mato_No1 — Tue, 01 Jan 2013 07:39:00 GMT

原题地址
2013年第一题……纪念一下……

设F[i][j]表示坐i次电梯到达房间j，最多能到几楼，则有
F[i][j]=max{F[i-1][k]+W[k][j]}, 0<=k这里W[k][j]要注意，如果不存在从k到j的电梯，W[k][j]应设为-INF。
这个方程显然是可以用矩阵乘法来优化的。
然后，问题就是求出最小的i使得F[i]的状态中有值>=M的，这个可以二分（每次看当前解与W的(2^K-1)次方的运算结果，若有解则实际不进行这次运算，否则与W的2^K次方运算）……总时间复杂度是O(n³logM)的，对于本题可能要进行一些常数优化才能过（20个点，每个点5个数据，相当于100个点，时限只有40s），反正本沙茶是卡线过的。

但是，本题有一个细节很重要，必须要说一下（因为本沙茶在这里卡了1h+）……那就是溢出问题……
F[i][j]的值是有可能超过long long的范围的，然而如果硬加高精度的话稳T，这时，在进行矩阵乘法（实际是加法）的时候，需要特判一下，如果这个和超过了INF（INF是~0Ull>>2，>10¹⁸），就取INF。这样可能会破坏结合律，但是木有事，因为若两个加数都是非负数，则不会破坏，若有负数，则一定表示无解（-INF），这个特判一下就行了（若两个加数之中有负数，则结果取-INF）。

代码：

#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, MAXLEN = 61;
const ll INF = ~0Ull >> 2;
int n;
ll M, A[MAXLEN][MAXN][MAXN], W0[MAXN][MAXN], _[MAXN][MAXN], res;
void mult(ll A0[][MAXN], ll B0[][MAXN])
{
    re(i, n) re(j, n) _[i][j] = -INF; ll __;
    re(i, n) re(j, n) re(k, n) if (A0[i][k] >= 0 && B0[k][j] >= 0) {
        __ = A0[i][k] + B0[k][j];
        if (__ > INF) __ = INF;
        if (__ > _[i][j]) _[i][j] = __;
    }
}
void prepare()
{
    re2(i, 1, MAXLEN) {
        mult(A[i - 1], A[i - 1]);
        re(j, n) re(k, n) A[i][j][k] = _[j][k];
        mult(A[i], A[0]);
        re(j, n) re(k, n) A[i][j][k] = _[j][k];
    }
}
void solve()
{
    re(i, n) re(j, n) if (i == j) W0[i][j] = 0; else W0[i][j] = -INF; bool FF; res = 0;
    rre(i, MAXLEN) {
        FF = 0; re(j, n) if (A[i][0][j] >= M) {FF = 1; break;}
        if (FF) continue;
        mult(W0, A[i]);
        FF = 0; re(j, n) if (_[0][j] >= M) {FF = 1; break;}
        if (!FF) {
            re(j, n) re(k, n) W0[j][k] = _[j][k];
            mult(W0, A[0]);
            re(j, n) re(k, n) W0[j][k] = _[j][k];
            res += 2ll << i;
        }
    }
    FF = 0; re(i, n) if (W0[0][i] >= M) {FF = 1; break;}
    if (!FF) res++;
}
int main()
{
    int tests;
    scanf("%d", &tests);
    re(testno, tests) {
        cin >> n >> M;
        re(i, n) re(j, n) {scanf("%lld", &A[0][i][j]); if (!A[0][i][j]) A[0][i][j] = -INF;}
        prepare();
        solve();
        cout << res << endl;
    }
    return 0;
}

Mato_No1 2013-01-01 15:39 发表评论

【AHOI2013复仇】两道LIS模型题总结

Mato_No1 — Sat, 08 Sep 2012 12:40:00 GMT

最近做了两道LIS模型题，感觉到模型比较好，总结一下囧。
【1】[HAOI2007]上升序列
预处理：设F[i]为以i开头的最长上升序列的长度，怎么求不用说了吧囧……
假设目前需要求长度为M的、标号字典序最小的上升序列，显然其第一个元素A[i]必须满足F[i]>=M（注意，不是等于，是大于等于！），找到满足这个条件的最小的i即可。然后，设目前已经求出了该序列的第x个元素为A[y]，则第(x+1)个元素A[z]需要满足的条件是A[z]>A[y]，且F[z]=F[y]-1，找到满足这个条件的最小的z即为该序列的第(x+1)个元素。按照这种方法，扫描一遍就可以求出整个序列，时间复杂度为O(N)。如果整个序列的最长上升序列长度
代码：

【2】[HAOI2006]数字序列
首先，由于序列的所有元素都是整数，所以可以将原序列的所有元素减去它的下标，这样就把上升序列转化为不下降序列了。
第一问的结果显然就是(N-新序列的最长不下降序列长度)。关键在于第二问。以下A均表示新序列。
设F[i]为以A[i]结尾的最长不下降序列长度（同样，求法不用说了），G[i]为在A[i]不修改的前提下将A[0..i]转变为不下降序列的最小修改量。首先求出F[i]，然后在求G[i]时，枚举上一个“不动点”（就是不修改的元素）A[j]（显然必须满足A[j]<=A[i]且F[j]=F[i]-1），这样最小修改量就是G[j]+(将A[j..i]转变为不下降序列的最小修改量）。可以证明，A[j..i]的最优修改方案必然是将A[j+1..t]全部修改为A[j]，A[t+1..i]全部修改为A[i]，这里t是一个[j..i]范围的值。问题就是如何求出最优的t？
一开始，假设t=j，即把A[j+1..i-1]全部修改为A[i]，计算出修改量，设为S。然后，由于A[j+1..i-1]之间的元素要么小于A[j]，要么大于A[i]（这个是显然的囧），我们把小于A[j]的元素称为“小数”，把大于A[i]的元素称为“大数”，则当t取t0时，修改量为S-(A[i]-A[j])*(A[j+1..t0]中的“小数”个数减去“大数”个数）。这样，只需扫描一下，求出使得(A[j+1..t0]中的“小数”个数减去“大数”个数）值最大的t0即可。
当然还有一个问题，对于同一个i，满足“A[j]<=A[i]且F[j]=F[i]-1”的元素个数可能有很多，如果一个一个枚举，一个一个扫描，会很慢的囧……解决方法是，求出满足这个条件的j中最小的一个，设为j0，然后把A[j0+1..i-1]中的所有“小数”和“大数”全部处理出来，然后用类似前缀和的方法就能搞了囧……当然，为了找到j0，需要建一个二分图，边为(F[i], i)。
最后，为了方便，可以把A序列的左边加一个-INF，右边加一个+INF。最后总的时间复杂度，理论上为O(N²)，但由于是随机数据，所以远远达不到这个级别。

代码：

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

【树的路径剖分】点权型的处理办法、路径的衔接以及一些细节问题

Mato_No1 — Thu, 12 Jan 2012 12:44:00 GMT

摘要: 【例题】[SDOI2011]染色（注：数据范围木有交代，应为：点数N<=105，操作数M<=105，所有的颜色C为整数且在[0, 109]之间。一、树的路径剖分当中点权型（点上有权值而边上木有）的处理办法：（1）找重链建线段树的时候，w0中存储tot+1个数，为该重链自上而下的各点的权值（例题中为颜色）；（2）除了父边是轻边的叶结点之外，树中的每个结点都属于且仅属于一条重链（根据定义得... 阅读全文

Mato_No1 2012-01-12 20:44 发表评论

最近在BZOJ上的刷题总结

Mato_No1 — Wed, 05 Oct 2011 01:42:00 GMT

【1】BZOJ1571
DP题，写起来比较繁琐……
首先转移方程是不难想的囧……F[i][j]，表示i时间后能力为j，
然后要设一些辅助数组，G[i]表示F[i][1..MAXJ]的最大值，H2[i]表示能力不超过i的一次滑雪的最小时间（这个还要用一个H1[i]表示能力刚好为i的来辅助求出）……
剩下的也就傻掉了，
当然，WJMZBMR神犇用记忆化搜索……省去了一些计算量……有效缩短时间……Orz啊……
（其实，如果大多数状态都是无效状态或者根本导不出最优解的状态，可以用记忆化的……）
代码

【2】BZOJ1572
任务调度问题（贪心模型）的加强版，用堆优化囧……
先把所有的任务按照结束时间递减排序，然后扫描，对于当前任务A[i]，结束时间为T[i]，上一个任务A[i-1]的结束时间为T[i-1]，设D=T[i-1]-T[i]，则在堆中取出收益最大的D个任务（显然该堆是以收益为关键字的大顶堆），用它们填上[T[i]+1, T[i-1]]这个时间段（原因很简单，A[i]及以后的任务在T[i]时刻以前就结束了，不能插入到此段内，因此此段内只能插入A[i-1]及其以前的，也就是在堆中的任务），若堆中的任务数总时间复杂度：O(NlogN)；
代码

【3】BZOJ1574
很容易想到最小点割（怎么看怎么像囧），但它和最小点割又不一样，因为本题是求T部分点数最少的点割……
正解仍然是贪心。对于每个报告点，由于它没坏且到1没有只经过未坏点的路径，所以与它相邻的所有的点要么是坏点，要么到1也没有路径，因此可以认为它们都是坏点（在最优方案中一定是这样），这样标记出所有的坏点以后，从1开始做一次遍历（只经过未坏点的），最终结果就是遍历到的点数；
代码

【4】BZOJ1575
裸的DP题啊啊……关键是本沙茶WA了N次还用暴搜代码来对拍啊啊……被折磨死了啊啊……
简单讲一下易疵点：
<1>不可把两边都加上一个0来简化，因为前两条（处理两边的）规则和加上0之后的并不等价；
<2>注意边界点（i=0或j=1时）的情况；
<3>注意最终结果，要在F[0..N-1]中找最小的合法的j而不是只在F[N-1]中找；
代码

Mato_No1 2011-10-05 09:42 发表评论