【ACM之行】◇第一站◇ 2018HDU多校赛总结

◇第一站◇ 2018HDU多校赛

---

十场多校赛下来，也算是给一个初中生开了眼界……看着清华一次次AK（默默立下flag），看着自己被同校的高中生完虐，一个蒟蒻只能给dalao们垫脚😥 

无论如何，这十场多校赛结束了——胆战心惊、士气高涨或是低头沉思，结果无法改变，比结果更有意义的是在比赛中学会了高校赛的团队攻法，以及一些闻所未闻的算法QwQ

不得不说，前5场的比赛状态实在是太差了，可能是不习惯ACM团队赛制，与队友的配合不是很默契，再加上心态非常的紧张，就把应该做的题做错甚至是忽略了😶

垫了5次底后对多校赛的心态也就逐渐平稳了，不必与高校相争，清华的队伍不是我们能力能够触及的，我们的目光逐渐放在跟上本校高中生的步伐上。接下来的第六场比赛，在较为稳定的心态支持下，我们超过了一个高中队（虽然是本校倒数第二），得到了第257名，并与第200名通过数相同，得到了第一个分数~接着第六场的状态，我们加速做出了两道题（还是非常菜鸡，但至少尽力了），再一次得分~最后两场，比赛技巧也逐渐了解了，于是我们的发挥更加稳定，最终摆脱垫底的命运……

 

---

 

◇ Score Ⅰ

 只得到了569名QwQ。可以说是把水题都刷了吧，也就是A,C,K题，前一个小时还好，其他高中队基本上也还是做了两道题，但是一个半小时后就逐渐掉队了，终于在接近两个小时的时候做出了C题……但发现没有改变掉队的事实，然后剩下的3个小时就自闭了😭

第一道：K题 Time Zone

其实就是一道模拟题，是队友做的，只是因为不怎么了解时区错了几次。

第二道：C题 Triangle Partition

一开始看到的时候以为很难，是一道计算几何……实际上就是一道贪心，按照横坐标排序，再按顺序连取3个点，我竟然想了这么久

第三道：A题 Maximum Multiple

一道结论题，靠打表找规律最后还是做出来了——当x是3的倍数时，答案是(x/3)^3，是4的倍数时，答案是(x/4)^3*2，其他都是-1……打表大法好啊！

比赛历程：信心满满 -> 刷掉A题（签到）-> 看其他题 -> 发现不会 -> 心态渐渐爆炸 -> 突然刷掉C题 -> 异常激动 -> 发现清华要AK了😱 -> Boom! -> 终于刷掉A题 -> 不会做了 -> 坐飞机✈

---

 

◇ Score Ⅱ

吃午饭太晚了……回来的时候队友已经做了一道博弈论的题了，于是我开始找题做。突然发现一道逆序对的题，愉快的刷掉了。然后我就做了一道题？？？后来整个队3个人都在搞Hack it（记忆犹新🙃），感觉非常有希望，于是就开始码代码……一直WA……最后突然找到了反例QwQ，整个人都不好了。Hack It 错10次凉凉……

第一题：D题 Game

明显博弈论。手算几个情况，就发现然而先手必胜……然后队友就不知道在坐什么飞机，并没有注意到多组数据，一行代码就交了TAT，然后又改了多组数据，发现 PE 了！！！结果是没加换行……

第二题：J题 Swaps and Inversions

不得不说隐藏得非常深，一开始根本没有看出来是逆序对（破题能力还不够啊），直到另外一个队在讨论逆序对，然后突然懂了什么。于是我就copy了一个版~😐

比赛历程：有点害怕 -> 刷掉博弈论 -> 发现掉队 -> J题通过人数很多 -> 听到其他队在讨论 -> 恍然大悟 -> copy版 -> 除了Hack It就看不懂了 -> 疯狂找规律 -> 以为对了 -> 一直WA -> 找到反例 -> 崩溃 -> over

---

 

◇ Score Ⅲ

每个人都做了一道题，感觉还好，然而其他队好像感觉更好😐结果就GG了，但是也学会了一种方法——因为我们这些蒟蒻的英语非常的弱，读题要读很久（尤其是那一大啪啦奇奇怪怪的背景），然后我们就会时刻关注排行榜，一般来说清华AC的第一道题都是水题（还是非常人性化），然后就去看那道题QwQ。但有个缺点是速度会很慢。

第一题：D题 Euler Function

不知道队友怎么找到的结论，看代码的话就只是当 x=1 时答案为5，其他时候都是 x+5。

第二题：F题 Grab The Tree

又是一道博弈论，仍然手算……就发现结论了——只有当节点值的异或值不为零时，小Q才会赢。

第三题：L题 Visual Cube

一道模拟题不知道我为什么会做这么久。把原图像分成5块，即左上角的空白、正面、顶面、侧面和右下角的空白，几个for循环搞定QwQ

比赛历程：迅速地连续A掉D,F题 -> 比较愉快 -> 终于码完L题 -> 有点激动 -> 在200名以内 -> 开始瞎码A,C题 -> WA,MLE…… -> 颓废

---

 

◇ Score Ⅳ

清华迅速的AC了L题，然后一大堆队相继也AC了，凭借经验，这应该是一道结论题。不知道哪来的直觉，我就想出了结论，然而队友直到我AC之前都不相信……然后感觉状态还不错，又做了一道构造题，最后在队友的思路下又把D题写出来了。然而结果并没有改变……还是没有分。

第一题：L题 Graph Theory Homework

不知道怎么证明，只是凭直觉找到了结论——直接从起点到终点。

第二题：K题 Expression in Memories

一道构造题……用了一个zero[]数组判断了一下前导零，再判断有没有两个符号并在一起以及开头、末尾不能为符号；碰到?的时候就尽量换成数字1，若不满足条件（比如前导零），就换成符号+。

第三题：D题 Nothing is Impossible

出题人煞费苦心啊，把这道题改来改去，改到最后就变得很水了，直接 ai=1 了QwQ，于是在原来队友的思路上改了一改就AC了——定义全部正确人数为AC，初值为m，则AC每次除以a[i]，直到结束或者AC等于0，循环的次数就是答案。

比赛历程：感觉状态不错 -> 刷了D,K两道题 -> 队友开始做E题 -> D题改了过后就水了 -> 通过D题 -> 整个队开始做E题 -> WA到最后，样例都没过 -> 发现横纵坐标反了QwQ -> [考试后十几分钟AC了]

---

 

◇ Score Ⅴ

感觉这场比赛好难啊，凉得最透的一场😭，只AC了一道题，而且是队友写的，代码都看不懂……然后就一直WA。

（由于代码看不懂，直接跳过）

---

 

◇ Score Ⅵ

一开始是崩溃的，直到3个小时40分钟才AC签到，最后AC3道竟然有分！【第一次得分的时刻】

第一题：I题 Werewolf

简单的说就是一个染色的搜索……代码是队友写的，看不太懂QwQ

第二题：A题 oval-and-rectangle

莫名结论，好像就是 πa+2b ，我也不知道为什么。

第三题：L题 Pinball

从头做到尾终于AC的高中物理题，一个初中生的我自己在网上搜资料，推抛物线、加速度（我还没学）、反弹、速度拆分……最后发现太复杂，还写WA了，样例都过不了。还得请教高中dalao，原来有定理。

比赛历程：每个人都找了一道题来做 -> 不知道为什么我就是对物理题感兴趣 -> 先AC了I题 -> 另外一个队友相继AC A题 -> 发现只要做3道题就有分 -> 仿佛全队希望就在我这道题上（大多数队都做出来了L题）-> 瞎推结论 -> 过不了样例 -> 请教dalao -> 终于AC

---

 

◇ Score Ⅶ

突然发现一道原题（在AtCoder上，还做过），只是加了一个多组数据，然后恰好队友有一个优秀的代码，加上多组数据就AC了QwQ；一道队友写的矩阵快速幂，根本看不懂。感觉这场比赛我什么都没做，好颓废啊……

第一题：A题 Age of Moyu

真的是一道原题，连样例都一样，原题链接-https://arc061.contest.atcoder.jp/tasks/arc061_c?lang=en。

第二题：J题 Sequence

矩阵快速幂真的看不懂（真的抱歉）

（我也不知道怎么描述了……全程懵过去的）

---

 

◇ Score Ⅷ

只做了两道题的蒟蒻又没分了😥，发现清华迅速的AC，就把那一道模拟大水题做出来了。然后队友最后几分钟的时候终于把D题AC了。尽管如此，还是没分……

第一题：E题 Magic Square

对于每一次操作，直接模拟，先把每一种旋转的规律找到，就可以直接用了。

第二题：D题 Parentheses Matrix

　　队友一直在找规律，然后就是一道构造结论题，也不知道他是怎么分类讨论的，就几种情况对应不同的构造方案……

比赛历程：秒A水题 -> 非常轻松 -> 一道题都不会做 -> 队友正在钻研D题 -> 坐飞机 -> 最后几分钟终于把D题AC了

---

 

◇ Score Ⅸ

看来组合数学还是我们这个队比较擅长的，两道组合数学基本上没有什么困难。在另一个高中队的帮助下终于AC了DP题。

第一题：K题 Rikka with Badminton

通过加法原理直接统计——不符合条件的情况有：a*n；a*n+b*n；b+c*n；c*n；a*n+c*n；d+c*n；a*n+d。注意统计后将重复计算的容斥一下。

第二场：D题 Rikka with Stone-Paper-Scissors

大概是结论题——分子是 剪刀胜的场数-剪刀负的场数+石头胜的场数-石头负的场数+布胜的场数-布负的场数 ；分母是 石头、剪刀、布的总数。注意实际上是统计第二个人的胜场。

第三场：A题 Rikka with Nash Equilibrium

这道题非常的有感想，然后我写了另外一篇博客QwQ-https://www.cnblogs.com/LuckyGlass-blog/p/9507466.html

比赛历程：AC了K题 -> 懵了一会儿 -> 找了找规律 -> 从样例中发现了什么东西 -> 莫名其妙AC了 -> 钻研A题 -> 瞎乱想 -> 高中dalao指点 -> DP终于写出来了 -> 终于AC了 -> 有分了！

---

◇ Score X

自己做了两道题，队友做了两道题，心态还不错。

第一题：H题 Pow

没看题目描述，直接发现样例就是2^n，只是高精度，非常高兴地找来了高精度的版QwQ

第二题：G题 Cyclic

OEIS大法好啊！！队友发现一个网站：(OEIS)http://oeis.org/；然后就找到了答案的数列，得到的递推式就是: A[i]=(i-3)*A[i-1]+(i-2)*((2*A[i-2]+A[i-3]))；注意时刻模MOD！

第三题：I题 Count

打表和OEIS简直是绝配！凭借队友敏锐的思维，正解直接锁定欧拉函数——发现一个结论：当i≥4时 ans[i]=phi[i]/2+add，其中add=Σphi[i/2*2]/2（1~i），前三个就直接计算……

第四题：L题 Videos

其实我们都不会费用流，在网上照搬过来的……还是要好好学习一下网络流，对于这道题也是挺有想法的，https://www.cnblogs.com/LuckyGlass-blog/p/9519886.html

比赛历程：找模板  -> 过H题 -> 在OEIS上乱找 -> 过G题 -> 打表 -> 在OEIS上乱找 -> 过I题 -> 一群人围着网络流 -> 瞎乱搞 -> 竟然AC了！

---

 

◇ 源代码

就当是一个记录……

·场次Ⅰ

/*Lucky_Glass*/
#include<cstdio>
#include<algorithm>
using namespace std;
int n,x;
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&x);
        if(x%3==0)
        {
            int a=x/3;
            printf("%lld\n",1LL*a*a*a);
        }
        else if(x%4==0)
        {
            int a=x/2,b=x/4;
            printf("%lld\n",1LL*a*b*b);
        }
        else
            printf("-1\n");
    }
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct POINT{
    int x,y,id;
}pnt[3005];
bool cmp(POINT A,POINT B)
{
    return A.x<B.x;
}
int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0;i<3*n;i++)
            scanf("%d%d",&pnt[i].x,&pnt[i].y),pnt[i].id=i+1;
        sort(pnt,pnt+3*n,cmp);
        for(int i=0;i<n;i++)
            printf("%d %d %d\n",pnt[i*3].id,pnt[i*3+1].id,pnt[i*3+2].id);
    }
    return 0;
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,x,y,len;
char s[15];
int main()
{
    scanf("%d\n",&n);
    while(n--)
    {
        bool f;
        memset(s,0,sizeof(s));
        scanf("%d %d %s",&x,&y,s);
        len=strlen(s);
        if(s[3]=='+')
            f=1;
        else
            f=0;
        if(s[5]=='.'||s[6]=='.')
        {
            int d=s[len-1]-'0';
            d*=6;
            if(!f)
                d=-d;
            y+=d;
            if(y>=60)
                x++,y-=60;
            else if(y<0)
                x--,y+=60;
        }
        int d=0;
        for(int i=4;i<len;i++)
        {
            if(s[i]=='.')
                break;
            d=d*10+s[i]-'0';
        }
        if(!f)
            d=-d;
        d-=8;
        x+=d;
        if(x<0)
            x+=24;
        else if(x>=24)
            x-=24;
        if(x<10)
            printf("0");
        printf("%d:",x);
        if(y<10)
            printf("0");
        printf("%d\n",y);
    }
}

 

·场次Ⅱ

#include<cstdio>
#include<vector>
#include<climits>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
    int n;
    while(~scanf("%d",&n))
        printf("Yes\n");
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<vector>
using namespace std;
int n,num[100005],x,y;
long long ans;
void Sort(int left,int right)
{
    if(left==right) return;
    int mid=(left+right)/2,i=left,j=mid+1,len=0;
    vector<int> snum;
    Sort(left,mid);Sort(mid+1,right);
    while(i<=mid && j<=right)
        if(num[i]<=num[j]) snum.push_back(num[i++]);
        else ans+=mid-i+1,snum.push_back(num[j++]);
    while(i<=mid) snum.push_back(num[i++]);
    while(j<=right) snum.push_back(num[j++]);
    for(int i=left,j=0;i<=right;i++,j++) num[i]=snum[j];
}
int main()
{
    while(~scanf("%d%d%d",&n,&x,&y))
    {
        ans=0;
        for(int i=0;i<n;i++) scanf("%d",&num[i]);
        Sort(0,n-1);
        printf("%lld\n",ans*(long long)min(x,y));
    }
    return 0;
}

 

·场次Ⅲ

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int x;
        scanf("%d",&x);
        printf("%d\n",x==1?5:x+5);
    }
    return 0;
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 100000
int T,n;
int w[MAXN+5],sum;
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        sum=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&w[i]);
            sum^=w[i];
        }
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
        }
        if(sum==0)printf("D\n");
        else printf("Q\n");
    }
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
char ans[100][100];
int main()
{
    //freopen("out.txt","w",stdout);
    int T;scanf("%d",&T);
    while(T--)
    {
        int a,b,c;scanf("%d%d%d",&a,&b,&c);
        memset(ans,'\0',sizeof ans);
        int R=2*b+2*c+1,C=2*b+2*a+1;
        for(int i=0;i<2*b;i++)
            for(int j=0;j<2*b-i;j++)
                ans[i+1][j+1]='.',
                ans[R-i][C-j]='.';
        for(int i=0;i<2*b;i++)
            for(int j=1;j<=2*a+1;j++)
                if(i%2)
                    ans[i+1][2*b-i+j]=j%2?'/':'.';
                else
                    ans[i+1][2*b-i+j]=j%2?'+':'-';
        for(int i=2*b+1;i<=R;i++)
            for(int j=1;j<=2*a+1;j++)
                if(i%2)
                    ans[i][j]=j%2? '+':'-';
                else
                    ans[i][j]=j%2? '|':'.';
        for(int i=1;i<=2*b;i++)
        {
            int x=C-i+1,y=i;
            for(int j=0;j<=2*c;j++)
                if(i%2)
                    ans[y+j][x]=j%2?'|':'+';
                else
                    ans[y+j][x]=j%2? '.':'/';
        }
        for(int i=1;i<=R;i++)
        {
            for(int j=1;j<=C;j++)
                printf("%c",ans[i][j]);
            printf("\n");
        }
    }
    return 0;
}

 

·场次Ⅳ

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
#define MAXN 100
#define LL long long
int T;
ll n,m;
LL a[MAXN+5];
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%lld%lld",&n,&m);
        for(int i=1;i<=n;i++)
        {
            ll ac;
            scanf("%lld%lld",&ac,&a[i]);
        }
        sort(a+1,a+n+1);
        int ans=0,AC=m;
        for(int i=1;i<=n;i++)
        {
            AC=AC/(a[i]+1);
            if(AC==0)break;
                ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
bool work()
{
    bool zero[505]={};
    char str[505]="";
    scanf("%s",str);
    int len=strlen(str);
    if(str[0]=='+' || str[0]=='*' || str[len-1]=='+' || str[len-1]=='*') return false;
    if(str[0]=='?') str[0]='1';
    if(str[len-1]=='?') str[len-1]='1';
    if(len==2)
    {
        if(str[0]=='0') return false;
        printf("%s\n",str);
        return true;
    }
    if('1'<=str[0] && str[0]<='9') zero[0]=true;
    for(int i=1;i<len;i++)
    {
        if(str[i]=='?')
        {
            if('0'<=str[i-1] && str[i-1]<='9' && !zero[i-1]) str[i]='+';
            else str[i]='1',zero[i]=true;
        }
        if((str[i]=='*' || str[i]=='+') && (str[i-1]=='*' || str[i-1]=='+'))
            return false;
        if('0'<=str[i] && str[i]<='9')
        {
            if(str[i]!='0') zero[i]=true;
            if(('0'<=str[i-1] && str[i-1]<='9') && !zero[i-1]) return false;
        }
        if(zero[i-1] && '0'<=str[i] && str[i]<='9')
            zero[i]=true;
    }
    printf("%s\n",str);
    return true;
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        bool res=work();
        if(!res) printf("IMPOSSIBLE\n");
    }
    return 0;
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int MAXN=int(1e5);
int dis[MAXN+5];
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        int n;scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d",&dis[i]);
        printf("%d\n",int(sqrt(fabs(dis[n-1]-dis[0]))));
    }
    return 0;
}

 

·场次Ⅴ

/*Lucky_Glass*/
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int n,m,len;
string s,s1,s2,a1,a2;
void dfs1(string s1,int x,int v)
{
    if(x>=len)
    {
        a1=min(a1,s1);
        return;
    }
    for(int i=0;i<x;i++)
    {
        if(s1[i]>a1[i])
            return;
        else if(s1[i]<a1[i])
            break;
    }
    for(int j=x+1;j<len;j++)
    {
        if(v<m&&(s1[j]!='0'||x!=0))
        {
            swap(s1[x],s1[j]);
            dfs1(s1,x+1,v+1);
            swap(s1[j],s1[x]);
        }
    }
    dfs1(s1,x+1,v);
}
void dfs2(string s2,int x,int v)
{
    if(x>=len)
    {
        a2=max(a2,s2);
        return;
    }
    for(int i=0;i<x;i++)
    {
        if(s2[i]<a2[i])
            return;
        else if(s2[i]>a2[i])
            break;
    }
    for(int j=x+1;j<len;j++)
    {
        if(v<m&&(s2[j]!='0'||x!=0))
        {
            swap(s2[x],s2[j]);
            dfs2(s2,x+1,v+1);
            swap(s2[j],s2[x]);
        }
    }
    dfs2(s2,x+1,v);
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>s>>m;
        len=s.length();
        s1=s2=a1=a2=s;
        dfs1(s1,0,0);
        dfs2(s2,0,0);
        cout<<a1<<" "<<a2<<endl;
    }
}

 

·场次Ⅵ

/*Lucky_Glass*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
int T;
double a,b,ans;
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%lf%lf",&a,&b);
        a*=10000,b*=10000;
        ans=3.1415926535897932384626433832795028841971*a+2.0*b;
        printf("%.6lf\n",ans/10000-0.0000005);
    }
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
#define N 100005
int n,m,ans,a1[N],f2[N];
bool f3[N];
struct mzls
{
    int to;
    bool f;
}g[N];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(a1,0,sizeof(a1));
        scanf("%d",&n);
        ans=n;
        for(int i=1;i<=n;i++)
        {
            char s[15];
            scanf("%d%s",&m,s);
            g[i].to=m;
            if(s[0]=='v')
                g[i].f=0;
            else
                g[i].f=1;
        }
        for(int i=1;i<=n;i++)
            if(!a1[i])
            {
                bool ff=0;
                //memset(f3,0,sizeof(f3));
                int tot=1,x=i;
                f2[tot]=x;
                f3[x]=1;
                while(1)
                {
                    bool fl=g[x].f;
                    x=g[x].to;
                    if((fl&&f3[x])||(!fl&&a1[x]==2))
                    {
                        int x1=x;
                        bool fff=0;
                        if(!fl)
                            fff=1;
                        for(int j=tot;j>=1;j--)
                        {
                            if(f2[j]==x1)
                                fff=1;
                            if(fff)
                                a1[f2[j]]=2;
                            f3[f2[j]]=0;
                        }
                        ff=1;
                        break;
                    }
                    if((!fl&&f3[x])||(fl&&!f3[x]))
                        break;
                    f3[x]=1;
                    f2[++tot]=x;
                }
                if(!ff)
                {
                    for(int j=1;j<=tot;j++)
                    {
                        f3[f2[j]]=0;
                        a1[f2[j]]=1;
                    }
                }        
            }
        for(int i=1;i<=n;i++)
            ans-=a1[i]==1;
        printf("0 %d\n",ans);
    }    
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const double g=9.8,EPS=1e-10;
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        double a,b,x,y;
        scanf("%lf%lf%lf%lf",&a,&b,&x,&y);
        double tana=b/a;
        double reala=atan(tana);
        double cosa=cos(reala),sina=sin(reala);
        a*=-1;
        double hgt=y-b/a*x;
        double now=0,vx,vy=sqrt(2*hgt*g),_1=sina*g,_2=cosa*g;
        vx=vy*sina;vy*=cosa;
        int ans=0;
        while(x+cosa*now<0)
        {
            ans++;
            double ta,tb,fx,tot;
            ta=vy/_2;
            fx=vy*ta-_2/2*ta*ta;
            tb=sqrt(2.0*fx/_2);
            tot=ta+tb;
            now+=vx*tot+_1/2*tot*tot;
            vx+=_1*tot;
            vy=_2*tb;
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

·场次Ⅶ

/*Lucky_Glass*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<climits>
#include<algorithm>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
#define MAXN 100000
#define MAXM 200000
#define INF INT_MAX
int n,m;
struct node
{
    int next,to,w;
}e[MAXM*2+5];
int b[MAXN+5];
int x,y,z,cnt,s,t,ans;
map<int,int> Ncolor[MAXN+5];
int dist[MAXN+5];
priority_queue < pair<int,int> > Q;
void fpush(int u,int v,long long w)
{
    e[++cnt].next=b[u];
    e[cnt].w=w;
    e[cnt].to=v;
    b[u]=cnt;
}
void Dijkstra()
{
     Q.push({0,s});
    dist[s]=1;
    while(!Q.empty())
    {
        int now=Q.top().second,xval=-Q.top().first;
        Q.pop();
        for(int i=b[now];i;i=e[i].next)
        {
            int xnext=e[i].to,color=e[i].w;
            int val=xval;
            if(!Ncolor[now].count(color))val++;
            if(dist[xnext]>val)
            {
                Ncolor[xnext].clear();
                Ncolor[xnext][color]=1;
                dist[xnext]=val;
                Q.push({-val,xnext});
            }
            if(dist[xnext]==val)Ncolor[xnext][color]=1;
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        cnt=0;
        for(int i=1;i<=n;i++)
        {dist[i]=INF;Ncolor[i].clear();b[i]=0;}
        s=1,t=n;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            fpush(x,y,z);
            fpush(y,x,z);
        }
        Dijkstra();
        if(dist[n]!=INF)printf("%d\n",dist[n]);
        else printf("-1\n");
    }
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define mod 1000000007
struct mzls
{
    int a,b,g[4][4];
}a1,b1,c1,d1;
inline mzls X(mzls x1,mzls x2)
{
    d1.a=x1.a,d1.b=x2.b;
    memset(d1.g,0,sizeof(d1.g));
    for(int i=1;i<=x1.a;i++)
        for(int j=1;j<=x2.b;j++)
            for(int k=1;k<=x2.a;k++)
                d1.g[i][j]=int((1ll*d1.g[i][j]+1ll*x1.g[i][k]*x2.g[k][j])%mod);
    return d1;
}
inline mzls Pow(int n1)
{
    c1.a=c1.b=3;
    memset(c1.g,0,sizeof(c1.g));
    for(int i=1;i<=3;i++)
        c1.g[i][i]=1;
    while(n1)
    {
        if(n1&1) 
            c1=X(c1,b1);
        b1=X(b1,b1);
        n1>>=1;
    }
    return c1;
}
int n,A,B,C,D,P;
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d%d%d%d",&A,&B,&C,&D,&P,&n);
        if(n<=2)
        {
            printf("%d\n",n==1?A:B);
            continue;
        }
        memset(a1.g,0,sizeof(a1.g));
        a1.a=3,a1.b=1;
        a1.g[1][1]=B,a1.g[2][1]=A,a1.g[3][1]=1;
        int v;
        for(int i=3;i<=n;i=v+1)
        {
            if(i>P)
                v=n;
            else
                v=min(n,P/(P/i));
            b1.a=3,b1.b=3;
            b1.g[1][1]=D,b1.g[2][1]=1,b1.g[3][1]=0;
            b1.g[1][2]=C,b1.g[2][2]=0,b1.g[3][2]=0;
            b1.g[1][3]=P/i,b1.g[2][3]=0,b1.g[3][3]=1;
            b1=Pow(v-i+1);
            a1=X(b1,a1);
        }
        printf("%d\n",a1.g[1][1]%mod);
    }
}

 

·场次Ⅷ

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m;
bool g[205][205];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(g,0,sizeof(g));
        char s[2]={'(',')'};
        bool f=0;
        scanf("%d%d",&n,&m);
        if((n%2==1)||(m%2==1))
        {
            f=n%2;
            if(!f)
            {
                for(int i=0;i<n;i++)
                {
                    for(int j=0;j<m;j++)
                        printf("%c",s[i%2]);
                    printf("\n");
                }
            }
            else
            {
                for(int i=0;i<n;i++)
                {
                    for(int j=0;j<m;j++)
                        printf("%c",s[j%2]);
                    printf("\n");
                }
            }
        }
        else
        {
            if(n<m)
            {
                f=1;
                swap(n,m);
            }
            for(int i=1;i<=n;i+=2)
                for(int j=1;j<=m;j++)
                    g[i][j]=(1+j)%2;
            for(int i=2;i<=n;i+=2)
            {
                g[i][1]=0;
                for(int j=2;j<m;j++)
                    g[i][j]=(j%2);
                g[i][m]=1;
            }
            if(n+m-4>n+m/2-1)
            {
                for(int i=1;i<=m;i++)
                    g[1][i]=0;
                for(int i=1;i<=m;i++)
                    g[n][i]=1;    
            }
            if(!f)
            {
                for(int i=1;i<=n;i++)
                {
                    for(int j=1;j<=m;j++)
                        printf("%c",s[g[i][j]]);
                    printf("\n");
                }
            }
            else
            {
                for(int i=1;i<=m;i++)
                {
                    for(int j=1;j<=n;j++)
                        printf("%c",s[g[j][i]]);
                    printf("\n");
                }
            }
        }
    }
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,squ[5][5],fsqu[5][5];
int main(){
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1;i<=3;i++)
        {
            char str[5]="";scanf("%s",str+1);
            for(int j=1;j<=3;j++)
                squ[i][j]=str[j]-'0';
        }
        for(int i=0;i<n;i++)
        {
            int x;char s[2]="";scanf("%d%s",&x,s);
            int a,b;
            switch(x)
            {
                case 1: a=b=1;break;
                case 2: a=1;b=2;break;
                case 3: a=2;b=1;break;
                case 4: a=b=2;break;
            }
            memcpy(fsqu,squ,sizeof squ);
            if(s[0]=='C')
                squ[a][b]=fsqu[a+1][b],
                squ[a+1][b]=fsqu[a+1][b+1],
                squ[a][b+1]=fsqu[a][b],
                squ[a+1][b+1]=fsqu[a][b+1];
            else
                squ[a][b]=fsqu[a][b+1],
                squ[a][b+1]=fsqu[a+1][b+1],
                squ[a+1][b]=fsqu[a][b],
                squ[a+1][b+1]=fsqu[a+1][b];
        }
        for(int i=1;i<=3;i++)
        {
            for(int j=1;j<=3;j++)
                printf("%d",squ[i][j]);
            printf("\n");
        }
    }
    return 0;
}

 

·场次Ⅸ

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int r,c;
long long mod;
long long dp[85][85][6405];
int main(){
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%lld",&r,&c,&mod);
        memset(dp,0,sizeof dp);
        dp[1][1][1]=1ll;
        for(int i=1;i<=r;i++)
            for(int j=(i==1? 2:1);j<=c;j++)
                for(int k=1;k<=i*j;k++)
                {
                    int A=0,B=0,C=0;
                    A=dp[i-1][j][k-1]*j*(r-i+1)%mod;
                    B=dp[i][j-1][k-1]*i*(c-j+1)%mod;
                    if(i*j-k+1>=0) C=dp[i][j][k-1]*(i*j-k+1)%mod;
                    dp[i][j][k]=((A+B)%mod+C)%mod;
                }
        printf("%lld\n",dp[r][c][r*c]*r%mod*c%mod);
    }
    return 0;
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
ll a1,b1,c1,a2,b2,c2;
bool f;
ll n,m;
ll gcd(ll x,ll y)
{
    return y==0?x:gcd(y,x%y);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        f=0;
        scanf("%lld%lld%lld%lld%lld%lld",&a1,&b1,&c1,&a2,&b2,&c2);
        n=a2*(c1-b1)+b2*(a1-c1)+c2*(b1-a1);
        m=a2+b2+c2;
        if(m<0)
            m=-m,n=-n;
        if(n<0)
            n=-n,f=1;
        ll x1=gcd(n,m);
        n/=x1,m/=x1;
        if(f)
            n=-n;
        printf("%lld",n);
        if(m!=1)
            printf("/%lld",m);
        printf("\n");
    }
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<algorithm>
#define mod 998244353
using namespace std;
typedef long long ll;
ll Pow(ll a,ll b)
{
    ll ans=1,base=a;
    while(b!=0)
    {
        if(b&1!=0)
            ans=(ans*base)%mod;
        base=(base*base)%mod;
        b/=2;
    }
    return ans%mod;
}
ll a,b,c,d;
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%lld%lld%lld%lld",&a,&b,&c,&d);
        printf("%lld\n",((b+1)*Pow(2ll,a+c)%mod+d*Pow(2ll,a+c)%mod+((Pow(2ll,b)-b-1)*Pow(2ll,a)%mod)+mod)%mod);
    }
}

 

·场次Ⅹ

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const long long MOD=998244353;
long long A[100005]={1,0,0};
int main(){
    for(int i=3;i<=100000;i++)
        A[i]=(i-3)*A[i-1]%MOD+(i-2)*((2*A[i-2]%MOD+A[i-3])%MOD)%MOD,
        A[i]%=MOD;
    int T,x;scanf("%d",&T);
    while(T--)
        scanf("%d",&x),
        printf("%lld\n",A[x]);
    return 0;
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
int a[1000005];
using namespace std;
int main()
{
    int x,n,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        memset(a,0,sizeof(a));
        int len=1;
        a[1]=1;
        for(int i=1;i<=n;i++)
        {
            x=0;
            for(int j=1;j<=len;j++)
            {
                a[j]=a[j]*2+x;
                x=a[j]/10;
                a[j]%=10;
                if(x!=0&&j==len)
                    len++;
            }
        }
        for(int i=len;i>=1;i--)
            printf("%d",a[i]);
        printf("\n");
    }
    return 0;
}

 

/*Lucky_Glass*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N int(2e7)
using namespace std;
int phi[N+10];
long long sum[N+10];
int prime[N+10],tot,ans;  
bool mark[N+10];
long long Ans[N+5];
void getphi()  
{  
   int i,j;  
   phi[1]=1;  
   for(i=2;i<=N;i++)
   {  
       if(!mark[i])  
           {  
             prime[++tot]=i;
             phi[i]=i-1;
             }  
       for(j=1;j<=tot;j++)  
       {  
          if(i*prime[j]>N)  break;  
          mark[i*prime[j]]=1;
          if(i%prime[j]==0)
          {  
             phi[i*prime[j]]=phi[i]*prime[j];break;  
          }  
          else  phi[i*prime[j]]=phi[i]*(prime[j]-1); 
       }  
   }  
}
int main(){
    Ans[1]=0;Ans[2]=1;Ans[3]=2;
    getphi();
    long long add=0;
    for(int i=1;i<=N;i++)
    {
        sum[i]=sum[i-1]+phi[i];
        if(i>=4)
        {
            if(i%2==0) add+=phi[i]/2;
            Ans[i]=sum[i]/2+add;
        }
    }
    int T;scanf("%d",&T);
    while(T--){
        int x;scanf("%d",&x);
        printf("%lld\n",Ans[x]);
    }
    return 0;
}

 

/*Lucky_Glass*/ 
#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 50002;
const int M = 500005;
#define INF 0x3f3f3f3f
struct E
{
    int to,cap,cost,flow,next;
}e[2*M];int head[N] , ecnt;
int  pre[N];
int dis[N];
bool vis[N];
int n,m,S,T;

void Clear()
{
    ecnt = 0;
    memset(head,-1,sizeof head);
}

void adde(int fr,int to,int cap,int cost)
{
    e[ecnt]=(E){to,cap,-cost,0,head[fr]};
    head[fr] = ecnt++;
    e[ecnt]=(E){fr,0,cost,0,head[to]};
    head[to] = ecnt++;
}

bool SPFA(int s,int t)
{
    memset(vis,0,sizeof vis);
    memset(dis,0x3f,sizeof dis);
    memset(pre,-1,sizeof pre);
    queue <int> q;
    q.push(s);dis[s] = 0;vis[s]=1;

    while (!q.empty())
    {
        int cur = q.front();q.pop();vis[cur] = false;
        for (int j=head[cur];j!=-1;j=e[j].next)
        {
            int to = e[j].to;
            if (dis[to] > dis[cur] + e[j].cost && e[j].cap > e[j].flow )
            {
                dis[to] = dis[cur] + e[j].cost;
                pre[to] = j;
                if (!vis[to])
                {
                    q.push(to);
                    vis[to] = true;
                }
            }
        }
    }
    return pre[t] != -1;
}

void MCMF (int s,int t,int &maxflow,int &mincost)
{
    maxflow = mincost = 0;
    while (SPFA(s,t))
    {
        int MIN = INF;
        for (int j=pre[t]; j!=-1;j=pre[e[j^1].to])
        {
            MIN = min(MIN,e[j].cap - e[j].flow);
        }
        for (int j=pre[t]; j!=-1;j=pre[e[j^1].to])
        {
            e[j].flow += MIN;
            e[j^1].flow -= MIN;
            mincost += MIN * e[j].cost;
        }
        maxflow += MIN;
    }
}

#define MAXN 3000

int L[MAXN+5],R[MAXN+5],Lk[MAXN+5],Kd[MAXN+5];
int main(){
    int TT;
    cin>>TT;
    while(TT--){
        Clear();
        int nn,mm,kk,ht;
        cin>>nn>>mm>>kk>>ht;
        for(int i=1;i<=mm;i++)
            cin>>L[i]>>R[i]>>Lk[i]>>Kd[i];
        S=1,T=kk+mm*2+2;
        for(int i=1;i<=kk;i++)
            adde(S,i+1,1,0);
        for(int i=1;i<=kk;i++)
            for(int j=1;j<=mm;j++)
                adde(i+1,j+kk+1,1,Lk[j]);
        for(int i=1;i<=mm;i++)
            adde(i+kk+1,i+kk+mm+1,1,0);
        for(int i=1;i<=mm;i++)
            adde(i+kk+mm+1,T,1,0);
        for(int i=1;i<=mm;i++)
            for(int j=1;j<=mm;j++)
                if(i!=j&&R[i]<=L[j]){
                    if(Kd[i]!=Kd[j])
                        adde(i+kk+mm+1,j+kk+1,1,Lk[j]);
                    else
                        adde(i+kk+mm+1,j+kk+1,1,Lk[j]-ht);
                }
        int ans1,ans2;
        MCMF(S,T,ans1,ans2);
        cout<<-ans2<<"\n";
    }
}

 

---

 

◇ 前行

2018的多校赛结束了，但学习编程的步伐尚未停止。尚且初三，路还很长，在 AFO 之前至少要做出一些，才对得起5年的学习。NOIP也不早了，多校赛，来年再见吧……

---

 

The End

Thanks for reading!

- Lucky_Glass

（Tab：如果我有没讲清楚的地方可以直接在邮箱lucky_glass@foxmail.com email我，在周末我会尽量解答并完善博客~📃）