ZOJ Monthly, July 2012 题解

既然官方没有出题解，这里就说下比赛时候过的几题的题解。

A - Magic Number  

讨论下 1000/x 的情况就可以了。  

 

B - Battle Ships  

dp[i][j] 表示 伤了i血,当前伤害为j。 dp[i][j] = min(dp[i][j], dp[i-t[k]*(j-l[k])][j-l[k]] + t[k]);

当然最后不能只去找 dp[L][j] 。  不造战舰的时间最后累加伤害到L。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<climits>
#include<cstdlib>
#include<queue>
using namespace std;
#define N 710
#define inf 1000000000
typedef long long LL;
int t[N], l[N], dp[N][N];
int main() {
    int n, len;
    while (scanf("%d%d", &n, &len) != EOF) {
        int Max = 700;
        for (int i = 0; i < n; ++i) 
            scanf("%d%d", &t[i], &l[i]);
        for (int i = 0; i <= len; ++i) for (int j = 0; j <= Max; ++j)
            dp[i][j] = inf;
        dp[0][0] = 0;
        for (int i = 0; i <= len; ++i) {
            for (int j = 0; j <= Max; ++j) {
                for (int k = 0; k < n; ++k) {
                    if (j >= l[k] && i >= t[k]*(j-l[k])) 
                        dp[i][j] = min(dp[i][j], dp[i-t[k]*(j-l[k])][j-l[k]] + t[k]);
                }
            }
        }
        int ans = inf;
        for (int i = 0; i <= len; ++i) for (int j = 1; j <= Max; ++j) {
            int temp = (len-i)/j;
            if ((len-i) % j) temp ++;
            ans = min(ans, temp + dp[i][j]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

 

C,D可以推出公式，反正我是推不出来。这里给各种神牛跪了。

 

E - Treasure Hunt I

树形背包，n很小， 偷懒的话 n^3 就可以过去

dp[u][j] = max(dp[u][j], dp[v][k]+dp[u][j-k-l*2]);  l是边的值

 

F - Treasure Hunt II

每个大方向最多转一次，每次按照大方向走，另一边尽量贴近反方向，记录区间金币值sum[l, r] ，然后正反扫一次，统计最大的。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<climits>
#include<cstdlib>
#include<queue>
using namespace std;
typedef long long LL;
#define N 100010
#define inf 1000000000
LL val[N], sum[N];
int id[N];
int n, p, m, t;
LL solve() {
    memset(id, -1, sizeof(id));
    id[p] = p;
    LL ans = 0;
    int s1, s2;
    s1 = s2 = p;
    for (int cs = 0; cs < t; ++cs) {
        if (s1 != 1) s1--;
        else break;
        if (s2 != n && s2+1-s1 <= m) s2++;
        else if (s2-s1 > m && s2 != 1) s2--;
        id[s1] = s2;
    }
    for (int i = 1; i <= p; ++i) {
        if (p-i > t || id[i] == -1) continue;
        LL temp = sum[p]-sum[i-1];
        int r = min(n, id[i]+t-(p-i));
        if (r < p) continue;
        ans = max(ans, temp + sum[r]-sum[p]);
    }
    return ans;
}
int main() {
    while (scanf("%d%d", &n, &p) != EOF) {
        sum[0] = 0;
        for (int i = 1; i <= n; ++i) {
            scanf("%lld", &val[i]);
            sum[i] = sum[i-1] + val[i];
        }
        scanf("%d%d", &m, &t);
        if (n == 1) {
            printf("%lld\n", val[1]);
            continue;
        }
        LL ans = solve();
        for (int i = 1; i <= n/2; ++i)
            swap(val[i], val[n-i+1]);
        for (int i = 1; i <= n; ++i)
            sum[i] = sum[i-1] + val[i];
        p = n-p+1;
        ans = max(ans, solve());
        printf("%lld\n", ans);
    }
    return 0;
}

 

 G - Treasure Hunt III

麻烦的dp，题解在下一篇报告中，比赛没出。

 

H - Treasure Hunt IV

看这么多人过只好找规律了...

然后，推出公式水过。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<climits>
#include<cstdlib>
#include<queue>
using namespace std;
typedef long long LL;
#define N 210 
#define inf 1000000000
LL so(LL n) {
    return n*(n+1)*4;
}
LL find(LL x) {
    if (x == -1) return 0;
    LL l = 0, r = 1518500249ll, t;
    while (l <= r) {
        LL mid = (l+r)/2;
        if (so(mid)-1 < x) {
            t = mid;
            l = mid+1;
        }
        else r = mid-1;
    }
    x = x - so(t) + 1;
    t++;
    LL id = 2*t*t-t;
    t *= 4;
    if (x <= t) return id;
    else return id + x - t;
}
int main() {
    LL a, b;
    while (scanf("%lld%lld", &a, &b) != EOF) {
        printf("%lld\n", find(b)-find(a-1));
    }
    return 0;
}

 

I - Information

好残暴的强连通，直接枚举删掉的点就行了 复杂度 n*m

 

J - Watashi's BG

把n个点平分成l, r两堆点。

2^l 和 2^r 枚举。排序后，一队数据从小到大，一队数据从大到小扫过去就可以了。

复杂度 2^15 * 15

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<climits>
#include<cstdlib>
#include<queue>
using namespace std;
#define N 710
#define inf 1000000000
typedef long long LL;
int val[N];
int qu[2][1<<16];
int main() {
    int n, m;
    while (scanf("%d%d", &n, &m) != EOF) {
        for (int i = 0; i < n; ++i) 
            scanf("%d", &val[i]);
        int a = n/2;
        int b = n-a;
        int top1, top2;
        top1 = top2 = 0;
        for (int i = 0; i < 1<<a; ++i) {
            int temp = i, k = 0, s = 0;
            while (temp) {
                if (temp&1) s += val[k];
                temp >>= 1;
                k++;
            }
            qu[0][top1++] = s;
        }
        int ans = 0;
        for (int i = 0; i < 1<<b; ++i) {
            int temp = i, k = a, s = 0;
            while (temp) {
                if (temp&1) s += val[k];
                temp >>= 1;
                k++;
            }
            qu[1][top2++] = s;
        }
        sort(qu[0], qu[0]+top1);
        sort(qu[1], qu[1]+top2);
        int j = top2-1;
        for (int i = 0; i < top1; ++i) {
            for ( ; j >= 0; --j) {
                if (qu[0][i] + qu[1][j] <= m) {
                    ans = max(ans, qu[0][i] + qu[1][j]);
                    break;
                }
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

 

 

K - Watermelon Full of Water

dp[i] 处理完前i天的最小花费。

当然直接转移会TLE，我是用线段树优化的，把能转移前K天到状态添加进去， 查找是找I~N天的转移状态的最小值。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<climits>
#include<cstdlib>
using namespace std;
#define N 50010 
#define inf 1000000000
typedef long long LL;
struct node {
    int l, r;
    LL num;
}tr[N*5];
LL val[N], dp[N];
int day[N];
void build(int L, int R, int x) {
    tr[x].l = L;
    tr[x].r = R;
    tr[x].num = 1000000000000000ll;
    if (L == R) return ;
    int mid = L+R >> 1;
    build(L, mid, x<<1);
    build(mid+1, R, x<<1|1);
}
void add(int id, int x, LL v) {
    if (tr[x].l == tr[x].r) {
        tr[x].num = min(tr[x].num, v);
        return ;
    }
    int mid = tr[x].l + tr[x].r >> 1;
    if (mid >= id) add(id, x<<1, v);
    else add(id, x<<1|1, v);
    tr[x].num = min(tr[x<<1].num, tr[x<<1|1].num);
}
LL find(int L, int R, int x) {
    if (tr[x].l >= L && tr[x].r <= R)
        return tr[x].num;
    int mid = tr[x].l + tr[x].r >> 1;
    if (mid >= R) return find(L, R, x<<1);
    else if (mid < L) return find(L, R, x<<1|1);
    else return min(find(L, mid, x<<1), find(mid+1, R, x<<1|1));
}
int main() {
    int n;
    while (scanf("%d", &n) != EOF) {
        for (int i = 1; i <= n; ++i) 
            scanf("%lld", &val[i]);
        for (int i = 1; i <= n; ++i)
            scanf("%d", &day[i]);
        build(1, n, 1);
        for (int i = 1; i <= n; ++i) {
            add(day[i]+i-1 > n ? n : day[i]+i-1, 1, dp[i-1]+val[i]);
            dp[i] = find(i, n, 1);
        }
        printf("%lld\n", dp[n]);
    }
    return 0;
}