2016 10 28考试 dp 乱搞树状数组

最新推荐文章于 2024-11-16 19:42:41 发布

原创最新推荐文章于 2024-11-16 19:42:41 发布 · 327 阅读

0 ·

CC 4.0 BY-SA版权

本文总结了一次算法竞赛的经验，详细分析了三道题目的解题思路及实现过程，包括动态规划、构造算法和树状数组的应用，并反思了比赛中的失误。

2016 10 28 考试

时间 7：50 AM to 11：15 AM

下载链接：

试题
 考试包

这次考试对自己的表现非常不满意！！
T1看出来是dp题目，但是在考试过程中并没有推出转移方程，考虑了打表，但是发现暴力程序的速度不够，直接交了暴力，没想到暴力程序爆0，考试后仔细查找发现是在深搜过程中的一个剪枝处忘记调整全局变量的值，，，低级错误要引以为戒！！

for (int i = 0; i <= cur; i++) {
        a[x] += i;
        if (a[x] < a[x-1]) {
            a[x] -= i;          // 考试时此处直接写成了continue，忘记还原a数组
            continue;
        }
        dfs(x + 1, cur - i);
        a[x] -= i;
    }

T2乱搞题，考试时连样例都没过，但是，输出时忘记写("Case")，，虽然结果都是零分，但是这种低级错误不能容忍！！
T3送分题，想出来了是树状数组，但是还是被最后三个点卡了读入常数。。Pascal直接写read就能A，然而C++的scanf就被卡了常数，，改成手写读入后AC，收了一个教训，当数据量较大时要考虑手写读入

官方题解：

a:
    看到200的数据范围，看到个数和总和的范围的限制，我想所有人都会想到dp吧。。。
    但是他说能凑成1~M的所有数字，这个略难满足
    我们来看一个结论 假设我们选出的数字从小到大排序后，是a[]， sum[]为a的前缀和
    那么只要sum[N] = M 而且 a[i + 1] <= sum[i] + 1 那么就能满足1~M的所有数字
    证明
        充分性
        可以数学归纳法证明
        首先第一项a[1]必然等于1 他能凑成1~sum[1]的所有数字
        假设前i项能组成sum[i]的所有数字，那么加上第i+1项后就能凑出a[i + 1] ~ a[i + 1] + sum[i] 
        因为a[i+ 1] <= sum[i] + 1 所以可以凑出1~a[i + 1] + sum[i] 也就是 1~sum[i+1]
        必要性
        可以想到如果不满足，那么起码sum[i] + 1就不能凑出来
    这样就可以DP了
    用f[i][j][k]代表前i个数字，和为j，是用小于等于k的数字凑出来的 即可
    空间限制就用滚动数组吧
b:
    如果只是单纯想如何组织这些边去形成一个方差最小的生成树,那是很困难的,至少我没有什么很好的解决办法
    但是如果我们假定知道了平均值,想得出一个方差最小的生成树呢?
    显然,边权尽量靠近平均值即可,而又要是棵树,那么明显只要用我们最常用的求最小生成树的方法即可.
    那么平均值就可以直接枚举了，注意算出是哪些边之后要重新算出平均值
    如果直接暴力枚举,时间复杂度是O(N*50*MlogM） 其中，N*M是平均值的个数。
    可以发现这样可能超时
    MlogM的最小生成树的算法已经无法再降，我们考虑平均值的枚举
    首先一个很重要的条件，权值都是整数，那么如果你枚举的平均值x在[p, p+1]中，那么其实只有p.25 和 p.75 是需要枚举的
    （自己想想为什么）
    那么复杂度就是50*MlogM
c：
    送分树状数组
    把一个牌后面去就在最后加1，之前的位置减1，问她前面有多少人直接求前缀和吧

解题报告：

T3：

树状数组裸题，数组a记录每个人当前所在的位置，数组C为0/1数组记录当前位置是否有人，利用树状数组维护前缀和，每次查询直接查询前缀和，每次修改x时先change当前位置-1，change目标位置+1，再修改a数组更新x的位置。注意数组大小

#include <cstdio>
#include <cstring>
#include <algorithm>

const int maxn = 4000500;

int a[maxn];        // a[x] the cur location of x 
int c[maxn];        
int tot;
int n, m;
int k;
int x;
char s;

inline int lowbit(int x) {
    return (x & (-x));
}

void change(int x, int z) {
    while (x <= k) {
        c[x] += z;
        x = x + (x & (-x));
    }
}

int xfind(int x) {
    int ans = 0;
    while (x > 0) {
        ans += c[x];
        x = x - (x & (-x));
    }
    return (ans);
}

int readint(void) {
    s = getchar();
    while (s < '0' && s > '9') s = getchar();
    int x;
    while (s >= '0' && s <= '9') {
        x = x * 10;
        x += (int) (s - '0');
        s = getchar();
    }
    return x;
}

int main () {
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    n = readint();
    m = readint();
    k = n + m;
    for (int i = 1; i <= n; i++) {
        a[i] = n - i + 1;
        change(i, 1);
    }
    tot = n;
    for (int i = 1; i <= m; i++) {
        x = readint();
        printf("%d\n", n - xfind(a[x]));
        change(a[x], -1);
        tot++;
        a[x] = tot;
        change(a[x], 1);
    }
    return 0;
}

T1:

dp题目（~~最近为什么这么多dp题目~~）首先考虑一个性质

假设当前已经选择了i-1个砝码，它们能够满足题意的最大质量为j，那么对于第i个砝码，其质量为a[i]，如果a[i] <= j + 1，显然它能够达到j + a[i]，（可以尝试举个栗子验证），而反之如果a[i] > j显然j + 1就已经不能满足。由此可推得转移时保证合法性的条件

设dp[i][j][k]表示当前取到第i个砝码，当前的最大满足条件为j，当前的最大砝码为k，
dp[i][j][k] = dp[i][j][k-1] + dp[i-1][j-k][k] (当i，j，k满足题意时)
貌似出题人是打算卡一下空间放滚动数组，不过，，好像并没有用上，，

#include <cstdio>
#include <cstring>
#include <algorithm>

const int maxn = 200 + 10;
const long long mod = 4294967296ll;
long long dp[maxn][maxn][maxn];
int T;

bool check(int i, int j, int k) {
    if (k > (j - i + 1)) return 1;
    if (j % 2 == 1) j = (j >> 1) + 1;
    else j = j >> 1;
    if (k > j) return 1;
    return 0; 
}

int main () {
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    scanf("%d", &T);
    for (int i = 1; i <= 200; i++)
        dp[1][1][i] = 1;
    for (int i = 2; i <= 200; i++)
        for (int j = 2; j <= 200; j++) {
            if (i > j) continue;
            for (int k = 1; k <= 200; k++) {
                dp[i][j][k] = dp[i][j][k-1];
                if (check(i, j, k)) continue;
                dp[i][j][k] = (dp[i][j][k] + dp[i-1][j-k][k]) % mod;
            }
        }
    int n, m;
    while (T--) {
        scanf("%d %d", &n, &m);
        printf("%I64d\n", (dp[n][m][m] % mod + mod) % mod);
    }

    return 0;
}

T2

乱搞题，题目中要求求方差最小的生成树，看起来比较无从下手，那么结合方差的性质可知，如果加入的边边权差尽量小，方差一定相应变小，这样就将方差问题转化为排序问题。之后考虑题目的数据范围，可以发现题目中的边的边权均较小，由此可以直接枚举平均值，每次按照abs(p[x].val - w_average)来排序，加入直到形成生成树，求出此时方差并更新答案。
注意，由于枚举平均值可能带来的精度问题，建议转而枚举边的总值

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdlib>
const int maxn = 1000 + 10;
const int maxm = 10000 + 10;
struct data {
    int from;
    int to;
    int val;    
};
data p[maxm];
int tim;
int n, m;
int minw, maxw;
bool flag[maxn];
double t_average;
double fc;
double ans = 0x7fffffff;
int father[maxn];

int getfather(int x) {
    if (father[x] == x) return (x);
    return (father[x] = getfather(father[x]));
}

bool cmp1 (data aa, data bb) {
    return (aa.val < bb.val);
}

bool cmp2(data aa, data bb) {
    double a1 = (double) aa.val;
    double a2 = (double) bb.val;
    a1 = fabs(a1 - t_average);
    a2 = fabs(a2 - t_average);
    return (a1 < a2);
}

int main () {
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    while (scanf("%d %d", &n, &m) == 2 && n && m) {
        tim++;
        printf("Case %d: ", tim);
        for (int i = 1; i <= m; i++) scanf("%d %d %d", &p[i].from, &p[i].to, &p[i].val);
        std :: sort(p + 1, p + m + 1, cmp1);
        for (int i = 1; i < n; i++) {
            minw += p[i].val;
            maxw += p[m - i + 1].val;
        }   
        for (int k = minw; k <= maxw; k++) {
            memset(flag, 0, sizeof(flag));
            for (int j = 1; j <= n; j++ ) father[j] = j;
            t_average = (double) k / (double) (n-1);
            std :: sort(p + 1, p + m + 1, cmp2);
            int t_sumw = 0;
            for (int i = 1; i <= m; i++) {
                int fx = getfather(p[i].from);
                int fy = getfather(p[i].to);
                if (fx != fy) {
                    father[fx] = fy;
                    flag[i] = 1;
                    t_sumw += p[i].val;
                }
            }
            if (t_sumw == k) {
                fc = 0;
                for (int i = 1; i <= m; i++) 
                    if (flag[i]) fc += ((double)p[i].val - t_average) * ((double)p[i].val - t_average);
                if (fc < ans) ans = fc;
            }
        }
        ans = ans / (double) (n-1);
        printf("%.2lf\n", ans);
    }
}