『8.21考试题解及反思』

UNO

Description

良心出题人Magolor找到了你，想要和你一起玩桌(mo)游(ni)。

Magolor: "杀蚂蚁?猪国杀?斗地主?麻将?立体图?哪一个好啊?"

你: "毒瘤出题人!"

Magolor伤心了……"我应该给人留下一个良心出题人的印象啊!"

于是Magolor选择了众所周知的UNO。整个周游只使用UNO牌，但完全不按照UNO的规则来打。牌局有3位玩家(你、Magolor、Magolor的好朋友TTL):

每个人将会摸到7张牌，然后从中选择5张组成一副手牌，最后三人中手牌大者胜。

UNO牌由无限多张0~9数字牌组成，分为RGBY四种颜色，颜色无关大小，以及一些功能牌，功能牌这里相当于废牌。

功能牌一般不参与组成任何牌种，凡是含有功能牌的手牌，无论其他牌，总是最小且相等。比如 -1 4 4 4 4 < 1 3 7 8 9, -1 3 3 4 4 =-1 -1 -1 2 3 = minimum。

其他情况手牌大小:先比较等级大的牌大，再按照等级内部比较。

Input Format

第一行数据组数T，其后每3行一组数据，3行中每行7张牌，形式见样例输入(-1为功能牌废牌)。

第一行为你，第二行为Magolor，第三行为TTL的牌。

相邻数据之间有一组空行。

Output Format

一人胜利则输出胜利者；如果有两人并列获胜，按照类似格式输出输者；如果三人并列，输出平局，形式见样例输出。

Sample Input

7
Y1 R2 B3 G4 G5 Y1 G1
G1 G2 G3 G4 G5 Y1 G1
Y1 R2 R3 Y4 R5 Y1 G1

Y3 R1 R5 G4 Y1 -1 -1
R1 R3 R9 R0 G3 -1 -1
B3 B0 B4 B5 R1 -1 -1

R1 R3 R9 R0 G3 -1 -1
Y3 R1 R5 G4 Y1 -1 -1
B3 B2 B4 B5 R1 -1 -1

R1 R3 R9 R0 G3 -1 -1
B3 B2 B4 B5 R1 -1 -1
Y3 R1 R5 G4 Y1 -1 -1

-1 -1 -1 -1 -1 -1 -1
B0 R1 B2 R3 B4 R5 B6
G0 Y1 G2 Y3 G4 Y5 G6

B0 R1 B2 R3 B4 R5 B6
-1 -1 -1 -1 -1 -1 -1
G0 Y1 G2 Y3 G4 Y5 G6

B0 R1 B2 R3 B4 R5 B6
G0 Y1 G2 Y3 G4 Y5 G6
-1 -1 -1 -1 -1 -1 -1

Sample Output

Draw!
I w1n!
Magolor w1n!
TTL w1n!
I l0se!
Magolor l0se!
TTL l0se!

解析

考场上看问题之后直接想到的就是大模拟，分类讨论，先求出最高等级，然后再同级比较，然后敲了一个半小时才过样例，最后只有\(40\)分，\(cena\)评测的还因为用了一个\(lmabda\)表达式\(CE\)了。

其实可以有很简单的写法，就是对每一副手牌评价一个权值，然后直接按照权值比较即可，剩下的就是输赢的分类讨论了，也不是很长。

权值设计的方法就是首先等级之间的权值差一定要足够大，然后就是按照比较优先级设置不同的权值，就和数位的进制一样，然后就可以直接比较了。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
const char name[3][10] = {"I","Magolor","TTL"};
const int INF = 0x3f3f3f3f;
const long long Base[] = {-INF,0,(LL)1e5,(LL)2e5,(LL)3e5,(LL)4e5,(LL)5e5,(LL)6e5,(LL)7e5,(LL)8e5,(LL)9e5};
int _buc[20],num[20]; int *buc = _buc + 1;
long long val[20];
inline int read(void)
{
    int w = 0 , x = 0; char ch = ' ';
    while ( !isdigit(ch) ) w |= ch=='-' , ch = getchar();
    while ( isdigit(ch) ) x = x*10 + ch-48 , ch = getchar();
    return w ? -x : x;
}
inline int find(int x)
{
    for (int i=9;i>=0;i--)
        if ( num[i] >= x )
            return num[i] -= x , i;
    return Base[0];
}
inline long long calc(void)
{
    memset( _buc , 0 , sizeof _buc );
    for (int i=1;i<=7;i++) buc[read()]++;
    if ( buc[-1] > 2 ) return Base[0];
    if ( buc[1] >= 2 && buc[3] && buc[4] && buc[5] ) return Base[10];
    if ( buc[1] && buc[3] && buc[5] && buc[7] && buc[9] ) return Base[9] + 1;
    if ( buc[0] && buc[2] && buc[4] && buc[6] && buc[8] ) return Base[9];
    for (int i=9;i>=4;i--)
    {
        int x = i;
        while ( x >= i - 4 && buc[x] ) x--;
        if ( x == i - 5 ) return Base[8] + i;
    }
    int a,b,c,d,e; long long ans = 0;
    memcpy( num , buc , 80 );
    a = find(5);
    ans = max( ans , a * 1LL + Base[7] );

    memcpy( num , buc , 80 );
    a = find(3) , b = find(2);
    ans = max( ans , a * 10LL + b * 1LL + Base[6] );

    memcpy( num , buc , 80 );
    a = find(4) , b = find(1);
    ans = max( ans , a * 10LL + b * 1LL + Base[5] );

    memcpy( num , buc , 80 );
    a = find(2) , b = find(2) , c = find(1);
    ans = max( ans , a * 100LL + b * 10LL + c * 1LL + Base[4] );

    memcpy( num , buc , 80 );
    a = find(3) , b = find(1) , c = find(1);
    ans = max( ans , a * 100LL + b * 10LL + c * 1LL + Base[3] );

    memcpy( num , buc , 80 );
    a = find(2) , b = find(1) , c = find(1) , e = find(1);
    ans = max( ans , a * 1000LL + b * 100LL + c * 10LL + e * 1LL + Base[2] );

    memcpy( num , buc , 80 );
    a = find(1) , b = find(1) , c = find(1) , d = find(1) , e = find(1);
    ans = max( ans , a * 10000LL + b * 1000LL + c * 100LL + d * 10LL + e * 1LL + Base[1] );
    return ans;
}
inline void solve(void)
{
    val[1] = calc() , val[2] = calc() , val[3] = calc();
    if ( val[1] == val[2] && val[2] == val[3] ) return puts("Draw!") , void();
    if ( val[1] == val[2] )
    {
        if ( val[3] < val[1] ) printf("%s l0se!\n",name[2]);
        else printf("%s w1n!\n",name[2]);
    }
    else if ( val[3] == val[2] )
    {
        if ( val[1] < val[2] ) printf("%s l0se!\n",name[0]);
        else printf("%s w1n!\n",name[0]);
    }
    else if ( val[1] == val[3] )
    {
        if ( val[2] < val[1] ) printf("%s l0se!\n",name[1]);
        else printf("%s w1n!\n",name[1]);
    }
    else if ( val[1] > val[2] && val[1] > val[3] ) printf("%s w1n!\n",name[0]);
    else if ( val[2] > val[1] && val[2] > val[3] ) printf("%s w1n!\n",name[1]);
    else if ( val[3] > val[1] && val[3] > val[2] ) printf("%s w1n!\n",name[2]);
}
int main(void)
{
    freopen("uno.in","r",stdin);
    freopen("uno.out","w",stdout);
    int T; scanf("%d",&T);
    while ( T --> 0 ) solve();
    return 0;
}

gcd

Description

众所周知，GCD的意思分别是是钢琴的索(5)、哆(1)和来(2)。因此求两个数字的最大公因数的函数 GCD(a,b) 又可以被称作索哆来函数。当然，广义索哆来函数 GCD(a,b,c,d,...)=GCD(a,GCD(b,c,d,...))。

现在Magolor有一棵n个点n-1条边的连通图状乐谱(???)，乐谱中每个点有一个音高。

Magolor想求一条最长的路径，使得路径上的所有点(包括端点)的音高的广义索哆来函数值不是1。

Input Format

第一行输入正整数 。

第二行输入n个正整数，分别表示第i个点的音高ai。

接下来n-1行每行两个正整数，表示a和b之间有一条无向边。

Output Format

一个整数表示最长路径的长度(所包含的点数，包括端点)。

Sample Input

7
2 4 1 6 2 6 4
1 2
2 3
2 4
4 5
4 6
5 7

Sample Output

5

解析

看到这种\(gcd\)的题首先应该想到的是枚举因数或者倍数，然后这道题就有两种思路了。

第一个就是枚举因数，那么也就是说一条合法的路径必然有一个共同的因子，于是就可以树形\(dp\)。\(f[x][d]\)代表以\(x\)为根的子树中共同包含\(x\)的第\(d\)个质因子的最长链，可以直接转移。

\[f[x][d]=\max_{y\in son(x),fac[y][d']=fac[x][d]}\{f[y][d']+1\}\]

然后顺带地更新答案即可。

第二种思路就是枚举倍数。我们可以先枚举一个节点，然后枚举这个节点权值的倍数，这样把这个节点倍数的其他节点都标记起来，然后设法有效地建立标记节点的森林，直接跑直径即可。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5+20;
inline int read(void)
{
    int x = 0 , w = 0; char ch = ' ';
    while ( !isdigit(ch) ) w |= ch=='-' , ch = getchar();
    while ( isdigit(ch) ) x = x*10 + ch-48 , ch = getchar();
    return w ? -x : x;
}
struct edge { int ver,next; } e[N*2];
int n,t,Head[N],a[N],ans;
vector < int > fac[N],f[N];
inline void insert(int x,int y) { e[++t] = (edge){y,Head[x]} , Head[x] = t; }
inline void input(void)
{
    n = read();
    for (int i=1;i<=n;i++)
        a[i] = read();
    for (int i=1;i<n;i++)
    {
        int x = read() , y = read();
        insert( x , y ) , insert( y , x );
    }
}
inline void init(void)
{
    for (int i=1;i<=n;i++)
    {
        int v = a[i];
        for (int j=2;j*j<=a[i];j++)
            if ( v % j == 0 )
            {
                fac[i].push_back( j );
                f[i].push_back( 0 );
                while ( v % j == 0 ) v /= j;
            }
        if ( v > 1 ) fac[i].push_back( v ) , f[i].push_back( 0 );
    }
}
inline void dp(int x,int fa)
{
    for (int i=Head[x];i;i=e[i].next)
    {
        int y = e[i].ver;
        if ( y == fa ) continue;
        dp( y , x );
        for (int j=0;j<fac[x].size();j++)
            for (int k=0;k<fac[y].size();k++)
                if ( fac[x][j] == fac[y][k] )
                    ans = max( ans , f[x][j] + f[y][k] ),
                    f[x][j] = max( f[x][j] , f[y][k] + 1 );
    }
}
int main(void)
{
    freopen("gcd.in","r",stdin);
    freopen("gcd.out","w",stdout);
    input();
    init();
    dp( 1 , 0 );
    printf("%d\n",ans+2);
    return 0;
}

lorem

Description

当然，人不能总是回忆过去，更要向前看。

Magolor准备为9102的选手们出一道题。当然是一道简单题，虽然2019年的选手可能不会这样认为。因为9102年与2019年相比变化很大，甚至连语言都相差甚远，Lorem Ipsum 在9102年已经成为世界唯一通用语言。显然，题目的题面是使用Lorem Ipsum 写的。

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmodtempor incididunt ut labore et dolore magna aliqua. Ut enim ad minimveniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex eacommodo consequat. Duis aute irure dolor in reprehenderit in volupta tevelit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
est laborum.

这份题面不仅有文采，而且颇具迷惑性。作为一名要参加NOIP9102的选手，相信你可以一眼看出解决这道题的关键就是对于q个关于这个长度为n的序列A的询问(l,r,MOD) ，分别求出区间[l,r]内所有 dolor 的 ut 值的和对 MOD 取余的结果。

Input Format

第一行两个正整数n,q，分别表示序列A的长度和询问数目。

第二行有n个正整数，即序列A。

接下来q行，每行读入 l r MOD 表示一个询问，保证1<=l<=r<=n。

Output Format

输出文件包含 q 行，每行输出一个答案表示区间[l,r]内所有 dolor 的 ut 值的和对MOD取余的结果，即「所有2^(r-l+1)个子序列的「去除重复数字以后的和」的和」

Sample Input

5 5
1 2 2 3 4
1 2 233333
2 3 333333
1 5 5
3 5 15
2 4 8

Sample Output

6
6
1
6
0

解析

首先我们必须知道一个权值在区间内的贡献，假设区间为\([l,r]\)，颜色\(x\)出现了\(k\)次，那么他的贡献就是\(x(2^{r-l+1}-2^{r-l+1-k})\)。

然后这道题就好做了。考虑莫队，我们可以有效地维护出现次数的数组，这是莫队很容易实现的。但是由于模数不断在变化，所以不能直接维护答案。

我们考虑用一个均摊的莫队思路，也就是利用莫队维护颜色出现次数和一些其他的信息，然后在每一个询问区间移动结束后使用分块算法，在\(O(\sqrt n )\)的时间之内求出答案即可。

如何计算答案，我们考虑分块。首先，对于一个确定的颜色我们可以直接计算贡献，但是直接枚举颜色会超时。然后我们发现颜色不同的出现次数是不会超过\(\sqrt n\)，于是我们就可以在维护一个\(sum\)数组，代表出现次数为某个值的颜色的权值和，然后也可以直接计算贡献。

但是还有一个问题，即使不同的出现次数不超过\(\sqrt n\)种，但是其值的大小可能超过\(\sqrt n\)，不方便枚举。于是就分一下块，当出现次数小于\(\sqrt n\)时，直接枚举计算贡献即可。大于\(\sqrt n\)时，由于出现次数大于\(\sqrt n\)的颜色不会超过\(\sqrt n\)种，直接枚举颜色计算贡献即可。

还有一个小\(trick\)，就是对\(2\)的幂也分块预处理一下，方法和\(BSGS\)算法的分块是一样的，这样就能少一个\(log\)了。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+20 , SQRTN = 500;
inline int read(void)
{
    int x = 0 , w = 0; char ch = ' ';
    while ( !isdigit(ch) ) w |= ch=='-' , ch = getchar();
    while ( isdigit(ch) ) x = x*10 + ch-48 , ch = getchar();
    return w ? -x : x;
}
struct query { int l,r,mod,id; } q[N];
int n,m,T,tot,Max,Mod,a[N],flag[N];
int cnt[N],num[SQRTN],s[SQRTN][N];
long long ans[N],_pow[2][SQRTN],sum[N];
inline void input(void)
{
    n = read() , m = read();
    for (int i=1;i<=n;i++)
        cnt[ a[i] = read() ] ++,
        Max = max( Max , a[i] );
    for (int i=1;i<=m;i++)
        q[i].l = read() , q[i].r = read() , q[i].mod = read() , q[i].id = i;
}
inline void init(void)
{
    T = sqrt(n);
    for (int i=1;i<=Max;i++)
        if ( cnt[i] > T ) num[++tot] = i , flag[i] = true;
    for (int i=1;i<=tot;i++)
        for (int j=1;j<=n;j++)
            s[i][j] = s[i][j-1] + ( a[j] == num[i] );
}
inline bool compare(query p1,query p2)
{
    if ( ( p1.l / T ) ^ ( p2.l / T ) )
        return p1.l < p2.l;
    else if ( ( p1.l / T ) & 1 )
        return p1.r < p2.r;
    else return p1.r > p2.r;
}
inline void insert(int p) { if ( flag[p] ) return; sum[cnt[p]] -= p; sum[++cnt[p]] += p; }
inline void remove(int p) { if ( flag[p] ) return; sum[cnt[p]] -= p; sum[--cnt[p]] += p; }
inline long long mul(long long a,long long b) { return a * b % Mod; }
inline void add(long long &a,long long b) { a += b; if ( a >= Mod ) a -= Mod; }
inline long long sub(long long a,long long b) { return a - b < 0 ? a - b + Mod : a - b; }
inline void calcpow(void)
{
    _pow[0][0] = _pow[1][0] = 1;
    for (int i=1;i<=T;i++)
        _pow[0][i] = mul( _pow[0][i-1] , 2 );
    for (int i=1;i<=T;i++)
        _pow[1][i] = mul( _pow[1][i-1] , _pow[0][T] );
}
inline long long quickpow(int x) { return mul( _pow[0][x%T] , _pow[1][x/T] ); }
inline void CaptainMo(void)
{
    sort( q+1 , q+m+1 , compare );
    memset( cnt , 0 , sizeof cnt );
    int l = 1 , r = 0;
    for (int i=1;i<=m;i++)
    {
        int ql = q[i].l , qr = q[i].r;
        long long res = 0;
        while ( ql < l ) insert( a[--l] );
        while ( qr > r ) insert( a[++r] );
        while ( ql > l ) remove( a[l++] );
        while ( qr < r ) remove( a[r--] );
        Mod = q[i].mod;
        calcpow();
        for (int j=1;j<=T;j++)
            add( res , mul( sum[j] % Mod , sub( quickpow(r-l+1) , quickpow(r-l+1-j) ) ) );
        for (int j=1;j<=tot;j++)
            add( res , mul( num[j] , sub( quickpow(r-l+1) , quickpow(r-l+1-s[j][r]+s[j][l-1]) ) ) );
        ans[q[i].id] = res;
    }
}
int main(void)
{
    freopen("lorem.in","r",stdin);
    freopen("lorem.out","w",stdout);
    input();
    init();
    CaptainMo();
    for (int i=1;i<=m;i++)
        printf("%d\n",ans[i]);
    return 0;
}

『8.21考试题解及反思』

原文地址：https://www.cnblogs.com/Parsnip/p/11386671.html

时间： 2024-11-02 02:19:19

『8.21考试题解及反思』的相关文章

『2020第一次考试总结及规划』

多校联合测试 一场常规省选难度的模拟赛,三题的标签分别是"结论题","多项式","费用流". 第一题看似是数位题,但是卡空间,并且删除操作难以用\(\mathrm{Trie}\)等数据结构维护,让人匪夷所思. 正解是一个结论,值域区间最大的\(\mathrm{and}\)和必然诞生在前\(p\)大的数当中,\(p\)与值域的一个\(\log\)同阶.证明可以考虑反证法,分成\(\mathrm{ans}\)最高位以上的位和最高位以下的位两部分考虑即

9.21考试总结

9.21考试总结(填坑) 分组 少分析了一种情况,一直以为填坑数和挖坑数一起算.实际上只需要将填坑和挖坑取最大值.原理就是直接把多出来的部分填入缺少的部分.然后比较到底是多出的部分多还是比要求范围少的部分多.但是有一种情况.所有数字加起来的总和比要求最低值还少或者比要求范围最高值还高就不能满足题目要求. 核心代码,证明一下自己码过,233 for (int i=1; i<=n; ++i) { if (a[i] < l) ans_l += (l - a[i]); if (a[i] > r)

考试题解集合

某天忽然发现自己的blog里全是考试题解--那么为什么不链到一篇blog里呢?避免首页全是加密blog看起来不大友善,大概也会整齐一点.估计是个大工程但还是作死地开始啦.有些难题是单独写的,就不链了.希望总是能比过去的自己更用心! 2018 2月:21 2017 11月:1-2.4-5.6-7.8-9 10月:1.2.3-6.7-8.9-11.12.13.14-15.17-18.19-20.22-24.25-26.27-28.31 9月:10.14.20.25.27 8月:7.8.9.10.11

2014.08.16『转岗』『该来的，总得面对』

转岗申请的Email总算发出去了,心里长舒一口气,该来的,总得面对. 愿在阿里研究院的未来依然光明. 安全部,提前说再见了. 2014.08.16『转岗』『该来的,总得面对』,布布扣,bubuko.com

『战略游戏 最大利润 树形DP』

通过两道简单的例题,我们来重新认识树形DP. 战略游戏(luoguP1026) Description Bob喜欢玩电脑游戏,特别是战略游戏.但是他经常无法找到快速玩过游戏的办法.现在他有个问题.他要建立一个古城堡,城堡中的路形成一棵树.他要在这棵树的结点上放置最少数目的士兵,使得这些士兵能了望到所有的路.注意,某个士兵在一个结点上时,与该结点相连的所有边将都可以被了望到. 请你编一程序,给定一树,帮Bob计算出他需要放置最少的士兵. Input Format 输入文件中数据表示一棵树,描述如下

『土地征用 Land Acquisition 斜率优化DP』

斜率优化DP的综合运用,对斜率优化的新理解. 详细介绍见『玩具装箱TOY 斜率优化DP』 土地征用 Land Acquisition(USACO08MAR) Description Farmer John is considering buying more land for the farm and has his eye on N (1 <= N <= 50,000) additional rectangular plots, each with integer dimensions (1

『最短Hamilton路径 状态压缩DP』

状压DP入门 最短Hamilton路径 Description 给定一张 n(n≤20) 个点的带权无向图,点从 0~n-1 标号,求起点 0 到终点 n-1 的最短Hamilton路径. Hamilton路径的定义是从 0 到 n-1 不重不漏地经过每个点恰好一次. Input Format 第一行一个整数n. 接下来n行每行n个整数,其中第i行第j个整数表示点i到j的距离(一个不超过10^7的正整数,记为a[i,j]). 对于任意的x,y,z,数据保证 a[x,x]=0,a[x,y]=a[y

『这是一篇干货blog』

更新记录一些有用的东西,把之前在『关于博客的一些信息』一文中的一些东西也搬了过来. 各文章版权归原作者所有,仅做搬运工作,侵删. 浅谈C++ IO优化--读优输优方法集锦 浅谈斜率优化 思维导图好助手--开心食用Xmind Typora ---一款简洁的Markdown编辑器 在线生成树图 csacademy 在线平面直角坐标系和函数解析 desmos 在线音乐解析 音乐搜索器 BZOJ离线题库 BZOJ 图床smms 渐变色渲染itmeo NOIP选手必知的编程技巧 轻量级编辑器透彻指南--N

『寝室管理 基环树点分』

寝室管理 Description T64有一个好朋友,叫T128.T128是寄宿生,并且最近被老师叫过去当宿管了. 宿管可不是一件很好做的工作,碰巧T128有一个工作上的问题想请T64帮忙解决.T128的寝室条件不是很好,所以没有很多钱来装修.礼间寝室仅由n-1条双向道路连接,而且任意两间寝室之间都可以互达.最近,T128被要求对一条路径上的所有寝室进行管理,这条路径不会重复经过某个点或某条边.但他不记得是哪条路径了.他只记得这条路径上有不少于k个寝室.于是,他想请T64帮忙数一下,有多少条这样