正睿多校联盟训练Week6

并没有参加

Problem A.阿瓦分蛋糕
输入文件： cake.in
输出文件： cake.out
时间限制： 1 second
空间限制： 512 megabytes
阿瓦为了庆祝自己自己成长为了一只可爱的小猫，决定提前过生日！
她觉得，在这一年当中帮助过他最多的就是阿卡和烤乐滋了，于是决定这次只请阿卡和烤乐滋两个人吃蛋糕。
阿瓦买了一个 n × m 的蛋糕，她打算分给三个人吃，同时她切蛋糕的时候为了美观，只会在整块的蛋糕上一
划到底。也就是说，她如果在蛋糕上切了一刀，那么这一刀的起点和终点一定在蛋糕的边界上。同时这一刀切下去
的痕迹一定是平行于蛋糕的某条边界的线段，阿瓦认为这样才比较整齐。很容易看出，这样一来阿瓦一定会将整个
蛋糕分成三个长方形。另外值得注意的是，当你切完了一刀之后，蛋糕自动一分为二，你的下一刀的起点或终点就
可以在新产生的边界上了。
阿瓦希望分给三个人的蛋糕面积尽量平均，也就是三个人当中，分到的最大面积与最小面积之差最小。她希望
你来替她求出那个最小的面积差。
Input
一行两个数 n- m。意义如题面中所述。
Output
一行一个数，表示最大面积与最小面积之差。
Example

cake.in	cake.out
3 3	0

Constraints
对于 30% 的数据， n, m ≤ 10。
对于 70% 的数据， n, m ≤ 3000 。
对于 100% 的数据， n, m ≤ 1e5。

看一看这道题应该是乱搞。“有一万种方法能过O（1）。"

当然如果蛋糕面积为3的倍数，直接输出0。

题解里给出了一种“O（n)”的做法，即枚举第一次切得位置，那么第二次一定是均分。

然而写完发现理解题意错了。30分。

事实上蛋糕的这个矩形本身就被分成了有限个1x1的小矩形。我们只能从“这种边界”来进行切割。

枚举两次。纵着切和横着切。如果只枚举一次，那么70分。

在各自枚举纵着切和横着切的时候还要枚举第二刀是顺着第一刀的方向切还是垂直第一刀方向切。QAQ。

考虑全面，就不是难题了。QAQ。注意开long long。

code

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 ll n,m;
 ll maxer,miner;
 ll a,b,c;
 ll ans=0x7f7f7f7f;
 int main()
 {
     scanf("%lld%lld",&n,&m);
     if(n*m%==)
     {
         printf("0\n");
         return ;
     }
     for(ll i=;i<=n;i++)
     {
         a=(n-i)*m;
         b=(i>>)*m;
         c=i*m-b;
         maxer=max(max(a,b),c);
         miner=min(min(a,b),c);
         ans=min(ans,maxer-miner);
         b=(m>>)*i;
         c=i*m-b;
         maxer=max(max(a,b),c);
         miner=min(min(a,b),c);
         ans=min(ans,maxer-miner);
     }
     for(ll i=;i<=m;i++)
     {
         a=(m-i)*n;
         b=(i>>)*n;
         c=i*n-b;
         maxer=max(max(a,b),c);
         miner=min(min(a,b),c);
         ans=min(ans,maxer-miner);
         b=(n>>)*i;
         c=i*n-b;
         maxer=max(max(a,b),c);
         miner=min(min(a,b),c);
         ans=min(ans,maxer-miner);
     }
     printf("%lld",ans);
     return ;
 }

Problem B.幻想机器人
输入文件： robot.in
输出文件： robot.out
时间限制： 1 second
空间限制： 512 megabytes
幻想世界科技中心研发出了一种机器人，这种机器人的主要作用是清扫地面。但由于性能还不够稳定，所以它
正常工作的时间不是连续的。
更具体地说，我们可以把幻想世界的地面抽象成一个 n 行 m 列的网格，这个机器人刚开始在科技中心的位置
(x, y)，即第 x 行第 y 列，我们把左上角定为第一行第一列。初始时整个网格除了科技中心的位置都是未清扫过的，
科技中心由于测试了多遍机器人的功能非常洁净不需要清扫。
接下来，人们可以给机器人下达一系列命令，但每个命令都是L（左）R（右）U（上）D（下）之
一。表示让机器人往指定的方向移动一格。如果当前格子还能够朝指定方向移动一格，则移动，如果在指定方向已
到达边界，则不移动，并输出一行"AWaDa!"（不包含引号）。
机器人性能不够稳定，它每 K 个指令后清扫一遍它所在的格子。也就是说，第 K、 2K、 3K 个指令后它所
在的格子都会被清扫一遍。注意，不移动位置的指令也算作一个指令。另外，每清扫到一个之前清扫过的格子，输
出一行"AKTang!"（不包含引号）。
最后，大家最关心的还是地面被清扫得怎么样，请你最后再输出一个数，表示未被清扫过的地面格子数。
Input
第一行六个数 n-m- K- len- x- y。意义如题面中所述。 len 表示指令的长度。
第二行一个长度为 len 的字符串，每个字符都是L,R,U,D之一，依次表示每个指令。
Output
对于无法移动的情况，输出一行"AWaDa!"。对于清扫过重复格子的情况，输出一行"AKTang!"。最后输出一行
一个数表示未被清扫过的格子数。
注意输出要按照时间顺序输出。

乍一看还以为是dfs，其实是水模拟。但是很难满分啊QAQ。

读题，明确：题目有两种操作，移动，清扫。清扫仅在第k,2k...步操作后进行。（开始读题这理解错了QAQ。

另外，数据有点不友好，我们没法开到1e9的数组来记录有没有被清扫过。还好我们有伟大的stl！

这里用到了map,建立一个矩阵中第几个格（longlong) 到这个格是否走过的映射。

一个矩阵中第几个格用坐标如何表示可以现场用坐标模拟一下。QAQ。

细节：起点肯定是被扫过的，起点的map设为1。但是起点也不一定是1啊，开始写成cnt[1]=1...

代码中mul(）函数是64位大整数乘法，亲测用不用时间差别不大。QAQ。

code

 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<map>

 using namespace std;

 typedef long long ll;
 int len;
 ll n,m,k,x,y,fin;
 map<ll,bool> cnt;

 ll mul(ll a,ll b)
 {
     ll ans=;
     while(b)
     {
         if(b&) ans=ans+a;
         b>>=;
         a=a*;
     }
     return ans;
 }

 int main()
 {
     scanf("%lld%lld%lld%d%lld%lld",&n,&m,&k,&len,&x,&y);
     char ch=getchar();cnt[m*(x-)+y]=;//不要想成特殊，一般化 QAQ
     for(ll i=;i<=len;i++)
     {//移动和清扫是不一样的 QAQ  明确操作
         scanf("%c",&ch);
         if(ch=='U')
         {
             if(x==) printf("AWaDa!\n");
             else x--;
         }
         if(ch=='L')
         {
             if(y==) printf("AWaDa!\n");
             else y--;
         }
         if(ch=='R')
         {
             if(y==m) printf("AWaDa!\n");
             else y++;
         }
         if(ch=='D')
         {
             if(x==n) printf("AWaDa!\n");
             else x++;
         }
         if(i%k==)
         {
             if(cnt[m*(x-)+y]) printf("AKTang!\n");
             else cnt[m*(x-)+y]=,fin++;
         }
     }
     printf("%lld\n",mul(m,n)-fin-);
     //用不用mul()差别不大 QAQ
     return ;
 }

可以用并查集求出联通块个数。最后答案就是m^联通块个数（根据加法原理）。

并查集+快速幂

code

 #include<bits/stdc++.h>

 using namespace std;
 typedef long long ll;
 int n,m,T;
 ll ans;
 ll moder=;
 int fa[];

 int getf(int p)
 {
     if(fa[p]==p) return p;
     else
     {
         fa[p]=getf(fa[p]);
         return fa[p];
     }
 }

 void merge(int p,int q)
 {
     int pp=getf(p);
     int qq=getf(q);
     if(qq!=pp) fa[qq]=pp;
 }

 ll ksm(ll a,ll b)
 {
     ll tot=;
     while(b)
     {
         if(b&) tot=tot*a%moder;
         b>>=;
         a=a*a%moder;
     }
     return tot%moder;
 }

 int main()
 {
     scanf("%d%d%d",&n,&m,&T);
     for(int i=;i<=n;i++) fa[i]=i;
     for(int i=;i<=T;i++)
     {
         int x=,y=;
         scanf("%d%d",&x,&y);
         merge(x,y);
     }
     for(int i=;i<=n;i++) if(fa[i]==i) ans++;
     printf("%lld",ksm(m,ans));
     return ;
  } 

直接上sol好了...另外不能分1，1肯定是没有贡献的。

这题还得打个高精。难受。

code

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 int T;
 ll R;
 int ans[],now[];
 void mul(int x)
 {
     memset(now,,sizeof(now));
     for(int i=;i<=ans[];i++)
     {
         now[i]+=ans[i]*x%;
         now[i+]+=ans[i]*x/;
         now[i+]+=now[i]/;
         now[i]%=;
     }
     for(int i=;i<=ans[];i++)
      ans[i]=now[i];
     if(now[ans[]+])
     {
         ans[]++;
         ans[ans[]]=now[ans[]];
     }
 }
 int main()
 {
     scanf("%d",&T);
     for(int i=;i<=T;i++)
     {
         scanf("%lld",&R);
         ans[]=ans[]=;
         int tmp=R/;
         if(R%==)
         {
             for(int j=;j<=tmp;j++)
              mul();
         }
         if(R%==)
         {
             for(int j=;j<=tmp-;j++)
              mul();
             mul();
         }
         if(R%==)
         {
             for(int j=;j<=tmp;j++)
              mul();
             mul();
         }
         for(int i=ans[];i>=;i--)
          printf("%d",ans[i]);
         printf("\n");
         memset(ans,,sizeof(ans));
     }
     return ;
  }