NOIP2016 提高组解题报告

最新推荐文章于 2024-08-01 18:51:07 发布

yhf_2015

最新推荐文章于 2024-08-01 18:51:07 发布

阅读量6.3k

点赞数 3

分类专栏： OI学习笔记/题解报告/经验分享文章标签： noip2016

本文链接：https://blog.csdn.net/yhf_2015/article/details/53453562

版权

OI学习笔记/题解报告/经验分享专栏收录该内容

23 篇文章 0 订阅

订阅专栏

说明：由于我能力的限制，文章中的做法不一定是最优秀的算法，但官方数据全部测试通过，使用的全部知识全部是NOIP提高组的知识，请组织放心查看。
感谢 GoodQt 的指导与帮助

DAY1 T1 玩具谜题

题目来源：洛谷 1563

吐槽：

对NOIP出题人“魔法师”英语单词拼错表示（滑稽）。

思路：

模拟操作过程，分类讨论即可。
时间复杂度： $O(n+m)$

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct node{
    int dir;
    char name[15];
};
node p[100010];
int n, m;
int main(){
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++) scanf("%d%s", &p[i].dir, p[i].name+1);
    int now = 1;
    for(int i = 1; i <= m; i ++){
        int a, b;
        scanf("%d%d", &a, &b);
        if(p[now].dir == 0){
            if(a == 0) now = ((now - b) % n + n) % n;
            else now = (now + b) % n;
        }else{
            if(a == 0) now = (now + b) % n;
            else now = ((now - b) % n + n) % n;
        }
        if(now == 0) now = n;
    }
    printf("%s", p[now].name+1);
    return 0;
}

DAY1 T2 天天爱跑步

题目来源：洛谷 1600

吐槽：

这题的正解好神啊，巨坑，说好的NOIP按难度顺序出题呢？

思路：

读入第i个点的观察时间是 $val[i]$ 。
通过DFS预处理，可以预处理得到每个节点的深度deep[i]和倍增需要的 $up[Max][MaxLog]$ 数组，用倍增求得lca，在求得lca以后，我们可以把在lca路径上的点的操作转化为从起点和终点分别到根节点的操作-lca到根节点的操作-lca的父节点到根节点的操作。这样对于每一个跑步者的一个操作，我们把它分成了4个部分。
定义对与第 $i$ 组询问，是从 $u[i]$ 到 $v[i]$ 的路径，路径长度是 $len[i]$ ，lca是 $lca[i]$ 。
具体的来说我们把问题转换成了从一个点 $x$ 到根节点的路径中，所有满足 $deep[x]+val[x]==deep[u[i]]$ 或者 $deep[x]-val[x]==deep[v[i]]-len[i]$ 的点的值加1或者减1。
不难发现，一个节点 $x$ 的答案被增加，只有可能受到以x为根的子树中某个点的影响。
而且需要满足的增加条件是定值（就是 $deep[u[i]]$ 或 $deep[v[i]]-len[i]$ ），然后就可以开一个桶，维护定值出现的次数，用邻接链表储存这些定值，根据dfs的性质（只有当子树全部访问完以后才会回到根），在访问子树之前记录下当前节点的定值，在操作完子树，维护了自己本身的节点以后，直接像前缀和一样，把新的值与操作前的值相减就好了。
时间复杂度： $O(n\log n+n)$
（时间的瓶颈在求lca，lca如果用tarjan离线求可以做到并查集复杂度 $O(\alpha n)$ ）

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 300010;
struct node{
    int begin, end, lca, len;
};
node p[maxn];
int n, m, val[maxn];
int _first[maxn], _next[maxn*2], _to[maxn*2], cnt;
int ins1[maxn], ins2[maxn], del1[maxn], del2[maxn];
int nxt[maxn*4], v[maxn*4], cnt1;
int deep[maxn], up[maxn][20];
int ans[maxn];
int ct1[maxn*2], ct2[maxn*2];
inline void add1(int a, int b, int c){
    nxt[++cnt1] = ins1[a];
    v[ins1[a] = cnt1] = c;
    nxt[++cnt1] = del1[b];
    v[del1[b] = cnt1] = c;
}
inline void add2(int a, int b, int c){
    nxt[++cnt1] = ins2[a];
    v[ins2[a] = cnt1] = c;
    nxt[++cnt1] = del2[b];
    v[del2[b] = cnt1] = c;
}
inline void add(int a, int b){
    _next[++cnt] = _first[a];
    _to[_first[a] = cnt] = b;
}
void dfs(int x){
    for(int i = 1; i <= 18; i ++){
        up[x][i] = up[up[x][i-1]][i-1];
    }
    for(int i = _first[x]; i; i = _next[i]){
        if(_to[i] == up[x][0]) continue;
        up[_to[i]][0] = x, deep[_to[i]] = deep[x]+1;
        dfs(_to[i]);
    }
}
void lca(){
    for(int ii = 1; ii <= m; ii ++){
        int x = p[ii].begin, y = p[ii].end;
        if(deep[x] < deep[y]) swap(x, y);
        if(deep[x] != deep[y])
            for(int i = 18; i >= 0; i --)
                if(deep[up[x][i]] >= deep[y]) x = up[x][i];
        if(x != y){
            for(int i = 18; i >= 0; i --)
                if(up[x][i] != up[y][i]) x = up[x][i], y = up[y][i];
            x = up[x][0];
        }
        p[ii].lca = x;
        p[ii].len = deep[p[ii].begin] - deep[x] + deep[p[ii].end] - deep[x];
    }
}
inline void dfs1(int x){
    ans[x] = - ct1[deep[x]+val[x]] - ct2[deep[x]-val[x]+n];
    for(int i = _first[x]; i; i = _next[i]){
        if(_to[i] == up[x][0]) continue;
        dfs1(_to[i]);
    }
    for(int i = ins1[x]; i; i = nxt[i]) ct1[v[i]] ++;
    for(int i = del1[x]; i; i = nxt[i]) ct1[v[i]] --;
    for(int i = ins2[x]; i; i = nxt[i]) ct2[v[i]+n] ++;
    for(int i = del2[x]; i; i = nxt[i]) ct2[v[i]+n] --;
    ans[x] += ct1[deep[x]+val[x]] + ct2[deep[x]-val[x]+n];
}
int main(){
    scanf("%d%d", &n, &m);
    for(int i = 1; i < n; i ++){
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }
    deep[1] = 1, dfs(1);
    for(int i = 1; i <= n; i ++) scanf("%d", &val[i]);
    for(int i = 1; i <= m; i ++) scanf("%d%d", &p[i].begin, &p[i].end); 
    lca();
    for(int i = 1; i <= m; i ++){
        add1(p[i].begin, up[p[i].lca][0], deep[p[i].begin]);
        add2(p[i].end, p[i].lca, deep[p[i].end]-p[i].len);
    }
    dfs1(1);
    for(int i = 1; i < n; i ++) printf("%d ", ans[i]); printf("%d", ans[n]);
    return 0;
}

DAY1 T3 换教室

题目来源：洛谷 1850

吐槽：

NOIP有史以来第一次考期望，对吧。

思路：

对于期望的概念，举例来说，已知A转换为B的代价为 $p_1$ ，现在有0.6的可能性让A转换为B的代价变为 $p_2$ ，那么A转换为B的期望代价就是 $p_1*0.4+p_2*0.6$ 。进行期望计算的时候，一定要保证所有的项出现的概率之和为1。上面的例子中， $0.4+0.6=1$ 。
对于这个题，我们可以先用Floyd预处理每两个点之间的最短路，这样走一定是最优的。
剩下的部分可以用动态规划来实现，设dp[i][j][0/1]表示考虑前 $i$ 个物品，已经换了 $j$ 个的最小期望代价。
状态转移方程：
（太长了，好难看，看程序里的吧 ^_^）
其中 $dis[i][j]$ 表示从 $i$ 到 $j$ 的最短路， $w[i]$ 表示换成功的机率。
时间复杂度： $O(e^3+nm)$

代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int inf = 2e9;
int n, m, v, e;
int a1[2010], a2[2010];
double dp[2010][2010][2], dis[310][310], w[2010], ans;
int main(){
    scanf("%d%d%d%d", &n, &m, &v, &e);
    for(int i = 1; i <= n; i ++) scanf("%d", &a1[i]);
    for(int i = 1; i <= n; i ++) scanf("%d", &a2[i]);
    for(int i = 1; i <= n; i ++) scanf("%lf", &w[i]);
    for(int i = 0; i <= v; i ++)
        for(int j = 0; j <= v; j ++)
            if(i == j) dis[i][j] = 0;
            else dis[i][j] = inf;
    for(int i = 1; i <= e; i ++){
        int a, b; double c;
        scanf("%d%d%lf", &a, &b, &c);
        dis[a][b] = min(dis[a][b], c);
        dis[b][a] = min(dis[b][a], c);
    } 
    for(int k = 1; k <= v; k ++)
        for(int i = 1; i <= v; i ++)
            for(int j = 1; j <= v; j ++)
                if(dis[i][j] > dis[i][k]+dis[k][j])
                    dis[i][j] = dis[i][k]+dis[k][j];
    for(int i = 0; i <= n; i ++)
        for(int j = 0; j <= m; j ++)
            dp[i][j][0] = dp[i][j][1] = inf;
    dp[1][0][0] = 0;
    dp[1][1][1] = 0;
    for(int i = 2, up; i <= n; i ++){
        up = min(i, m);
        for(int j = 0; j <= up; j ++){
            dp[i][j][0] = min(dp[i][j][0], dp[i-1][j][0]
                        +dis[a1[i]][a1[i-1]]);
            dp[i][j][0] = min(dp[i][j][0], dp[i-1][j][1]
                        +dis[a1[i]][a2[i-1]]*w[i-1]
                        +dis[a1[i]][a1[i-1]]*(1-w[i-1]));
            if(j-1 >= 0) dp[i][j][1] = min(dp[i][j][1], dp[i-1][j-1][0]
                        +dis[a2[i]][a1[i-1]]*w[i]
                        +dis[a1[i]][a1[i-1]]*(1-w[i]));
            if(j-1 >= 0) dp[i][j][1] = min(dp[i][j][1], dp[i-1][j-1][1]
                        +dis[a2[i]][a2[i-1]]*w[i]*w[i-1]
                        +dis[a2[i]][a1[i-1]]*w[i]*(1-w[i-1])
                        +dis[a1[i]][a2[i-1]]*(1-w[i])*w[i-1]
                        +dis[a1[i]][a1[i-1]]*(1-w[i])*(1-w[i-1]));
        }
    }
    ans = inf;
    for(int i = 0; i <= m; i ++) ans = min(ans, min(dp[n][i][0], dp[n][i][1]));
    printf("%.2lf", ans);
    return 0;
}

DAY2 T1 组合数问题

题目来源：洛谷 2822

吐槽：

果然数学题隔一年出一次。我竟然因为开小数组挂了。

思路：

预处理杨辉三角，每次转移时把相加后的值对 $k$ 取模，结果用二维前缀和记录。
时间复杂度： $O(nm+T)$

代码：

#include <cstdio>
#include <iostream>
using namespace std;
int T, k;
int sum[2010][2010], val[2010][2010];
int a[10010], b[10010], p1, p2;
int main(){
    scanf("%d%d", &T, &k);
    for(int i = 1; i <= T; i ++){
        scanf("%d%d", &a[i], &b[i]);
        p1 = max(p1, a[i]);
        p2 = max(p2, b[i]);
    }
    for(int i = 0; i <= p1; i ++){
        for(int j = 0; j <= min(p2, i); j ++){
            if(j == 0){val[i][j] = 1;continue;}
            val[i][j] = (val[i-1][j] + val[i-1][j-1]) % k;
            if(val[i][j] == 0) sum[i][j] = 1;
        }
    }
    for(int i = 1; i <= p1; i ++){
        for(int j = 1; j <= p2; j ++){
            sum[i][j] = sum[i-1][j] + sum[i][j-1] + sum[i][j] - sum[i-1][j-1];
        }
    }
    for(int i = 1; i <= T; i ++){
        printf("%d\n", sum[a[i]][b[i]]);
    }
    return 0;
}

DAY2 T2 蚯蚓

题目来源：洛谷 2827

吐槽：

论巨慢的CCF评测机与巨慢的STL优先队列。

思路：

因为每一次蚯蚓的长度都会增加，而时间又不允许把所有的长度都进行增减，考虑到我们只需要知道所有蚯蚓的相对大小关系，所以把剩余的打标记，把新切出来的减去其余增加的长度，模拟每次操作。
如果用堆来维护大小的话，时间复杂度为 $O((n+m)\log{(n+m)})$ 实测手写堆65分，优先队列60分。
考虑优化。每次取出来切的蚯蚓一定是最长的一个，切完之后的新生成的蚯蚓不会比原来的蚯蚓长。基于这一点，我们考虑优化。如果我们现将输入的 $n$ 个数按长度排序，然后把新生成的两个小的插入到输入的这 $n$ 个元素序列中，时间复杂度是 $O(n)$ 的，思考归并排序的思想，因为取出来分割的比例是固定的，所以比较长的分割出来的新蚯蚓的长度，一定比较短的分割出来的新蚯蚓的长度要长。所以说有单调性，然后就可以像归并排序一样维护最大值了。
具体的，我们开两个队列（拒绝STL），分别维护每次分割完以后较长的一段和较短的一段的长度，加上输入序列，三个数列全部满足单调性。每次要切的蚯蚓从输入数列中和新开的两个队列中取最大值。实现的细节是要注意队列的边界，实现请参考代码。
时间复杂度： $O(n\log n+(n+m))$

代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
using namespace std;
inline int gt(){  
    char _ch = ' ';  
    int _num = 0, _op = 1, _ok = 0;  
    while(1){
        _ch = getchar();
        if(_ch == '-') _op *= -1;  
        else if(_ch >= '0' && _ch <= '9') _num = _num*10 + _ch - '0', _ok = 1;  
        else if(_ok) return _op * _num; 
    } 
}  
int n, m, q, u, v, t;
int left1;
int len[100010], q1[8000010], q2[8000010];
int out[1000010], cnt;
int main(){
    scanf("%d%d%d%d%d%d", &n, &m, &q, &u, &v, &t);
    for(int i = 1; i <= n; i ++) len[i] = gt();
    sort(len+1, len+1+n);
    int p1 = 1, p2 = 0, p3 = 1, p4 = 0, p5 = n, now = 0;
    for(int i = 1; i <= m; i ++){
        if(p5 >= 1 && len[p5] >= MAX(q1[p1], q2[p3])) now = len[p5--] + left1;
        else if(p1 <= p2 && q1[p1] >= q2[p3]) now = q1[p1++] + left1;
        else if(p3 <= p4) now = q2[p3++] + left1;
        if(i%t == 0) out[++cnt] = now;
        left1 += q;
        int new1 = ((long long)now*(long long)u)/(long long)v;
        int new2 = now - new1;
        q1[++p2] = MAX(new1, new2) - left1;
        q2[++p4] = MIN(new1, new2) - left1;
    }
    for(int i = 1; i <= cnt; i ++) printf("%d ", out[i]);
    printf("\n");
    for(int i = 1, w = 0; i <= n+m; i ++, w = 0){
        if(p5 >= 1 && len[p5] >= MAX(q1[p1], q2[p3])) w = len[p5--] + left1;
        else if(p1 <= p2 && q1[p1] >= q2[p3]) w = q1[p1++] + left1;
        else if(p3 <= p4) w = q2[p3++] + left1;
        if(i%t != 0) continue;
        printf("%d ", w);
    }
    return 0;
}

DAY2 T3 愤怒的小鸟

题目来源：洛谷 2831

吐槽：

我在考前猜对了游戏，哈哈哈。正解是状压DP，又是第一次？

思路：

状态压缩动态规划。首先用18位二进制数表示，每一个是否被打了。
因为一直一定过原点，所以再有两个点就可以确定。
设另外的两个点为 $A(x_1,y_1),B(x_2,y_2)$
设抛物线的方程为 $y=ax^2+bx$
带入方程：
$y_1=ax_1^2+bx_1$
$y_2=ax_2^2+bx_2$
上面乘 $x_2$ ，下面乘 $x_1$
$y_1x_2=ax_1^2x_2+bx_1x_2$
$y_2x_1=ax_2^2x_1+bx_1x_2$
上式减下式：
$y_1x_2-y_2x_1=a(x_1^2x_2-x_2^2x_1)$
解得：
$a=\frac{y_1x_2-y_2x_1}{x_1^2x_2-x_2^2x_1}$
$b=\frac{y_1-ax_1^2}{x_1}$
应该满足的条件是： $a<0$
然后就可以预处理出 $num[i][j]$ 表示以 $i$ 为第一个点的第 $j$ 种方案。
然后就是动态规划了，设 $dp[i]$ 表示现在的攻击状态二进制表示为 $i$ 的最小次数。
$dp[i|num[now][j]]=min(dp[i|num[now][j]],dp[i]+1)$
$dp[i|(1$ << $(now-1))] = min(dp[i|(1$ << $(now-1))], dp[i] + 1)$
其中， $now$ 是 $i$ 这个状态中没有被攻击的最低的一位，因为考虑到在最优的答案中，这个位上一定会被攻击，所以只需要枚举攻击经过第 $now$ 位的即可，此时做多有 $n$ 种可能。
对于选定的第 $now$ 位来说，也可以选择只打这一个，即为第二个方程。
时间复杂度： $O(Tn2^n)$

代码：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const double eps = 0.000000001;
struct point{
    double x, y;
};
int T, n, m, ans = 1e9;
point p[25];
int num[25][25], dp[300010];
int calc(double a, double b){
    int res = 0, now = 1;
    for(int i = 1; i <= n; i ++, now <<= 1){
        double t = a*p[i].x*p[i].x+b*p[i].y;
        if(abs(a*p[i].x*p[i].x+b*p[i].x-p[i].y) < eps){
            res |= now;
        }
    }
    return res;
}
int bits(int x){
    int res = 0;
    for(int i = 1; i <= n; i ++, x >>= 1) if((x&1) == 0) res ++;
    return res;
}
int main(){
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i ++){
            scanf("%lf%lf", &p[i].x, &p[i].y);
        }
        memset(dp, 63, sizeof(dp));
        memset(num, 0, sizeof(num));
        ans = 1e9;
        for(int i = 1; i <= n; i ++){
            for(int j = i+1; j <= n; j ++){
                if(i == j) continue;
                if(abs(p[i].x-p[j].x) < eps) continue;
                double a = (p[i].y*p[j].x-p[j].y*p[i].x)/(p[i].x*p[i].x*p[j].x-p[j].x*p[j].x*p[i].x);
                if(a >= 0) continue;
                double b = (p[i].y-a*p[i].x*p[i].x)/p[i].x;
                num[i][++num[i][0]] = calc(a,b);
            } 
        }
        int MAX = (1<<n)-1;
        dp[0] = 0;
        for(int i = 0; i <= MAX; i ++){
            int now = 0;
            for(int j = 1, w = 1; j <= n; j ++, w <<= 1){
                if((w&i) == 0){now = j;break;}
            }
            if(now == 0) continue;
            dp[i|(1<<(now-1))] = min(dp[i|(1<<(now-1))], dp[i] + 1);
            for(int j = 1; j <= num[now][0]; j ++){
                dp[i|num[now][j]] = min(dp[i|num[now][j]], dp[i] + 1);
            }
        }
        printf("%d\n", dp[MAX]);
    }
    return 0;
}