【SinGularLaRiTy-1044】 Copyright (c) SinGuLaRiTy 2017. All Rights Reserved.

小水塘(lagoon)

题目描述

忘川沧月的小水塘的水面是一片由以下两种图形组成的图案：

<图lagoon-1>

这两种图形都由一个边长为2的正方形和两个半径为1的1/4圆组成，圆心在正方形的两个对角顶点上。
小水塘左上角坐标为(0,0)，右下角坐标为(2*n,2*m)。水面上每一个顶点坐标为偶数的2*2正方形，都是上面两个图形中的一种。如果我们往水塘中的某个位置倒一桶污水，那么这桶污水会像画图中的油漆桶一样扩散开来，占据一片连续的区域，但是在线条边界处会停止扩散。注意如果倒在了线条上，扩散面积为0。
如下图所示，就是一个由4行4列上述图形组成的、左上角坐标(0,0)、右下角坐标(8,8)、某些位置倒了污水的水塘（白色部分为线条边界，线条实际宽度认为是0，为了明显、美观，此处加粗显示）：

<图lagoon-2>

现在给出一个n行m列的由上述两种图形组成的水塘，起初水塘中全部为净水。给定q个往某个坐标上(x,y)倾倒污水的操作，对于每次操作，请求出在(x,y)上倾倒的污水最终会扩散多大的面积。

输入格式

第一行两个整数n、m。
接下来n行每行m个整数，每个整数是0或者1，中间没有空格隔开。0代表此处是<图lagoon-1>中左侧那个2*2的图形，1代表此处是右侧那个图形。例如<图lagoon-2>中的第一行用“0001”表示。
第n+2行是一个整数q。
接下来q行每行两个用空格隔开的整数x、y，表示这一次倾倒污水的坐标。

输出格式

对于每个询问，输出此次倾倒的污水最终扩散的面积，四舍五入保留4位小数。

样例数据

样例输入1 样例输出1
1 2
0 1
4
0 0
2 0
0 1
0 2		 0.7854
4.8584
0.0000
4.8584
样例输入2 样例输出2
3 1
1
0
1
2
3 1
4 2		 7.2876
1.5708

<数据范围>

对于 100% 的数据，1<=n,m,q<=100，0<=x<=2*n，0<=y<=2*m。

解析

看到数据范围很小，自然地考虑用搜索。由于只有两种图案，若进行搜索，需要考虑 2*4=8 种可能的情况。需要注意的是，如图所示，污水若覆盖了A，那么污水可能覆盖了B，也可能没有覆盖B——这就意味着要把这两个区域的vis访问情况分开进行记录。（这题的if串也是没的说了）

Code

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<cstdlib>
  4. #include<algorithm>
  5. #include<cmath>
  6. #include<queue>
  7.  
  8. using namespace std;
  9.  
  10. const double pi=acos(-1.0);
  11. const double big=-0.5*pi;
  12. const double small=0.25*pi;
  13.  
  14. int map[][];
  15. int col[][][]={};
  16. int list[][];
  17.  
  18. double all[];
  19.  
  20. struct P{
  21.     int x,y,k;
  22. }now;
  23. queue<P> q;
  24.  
  25. int n,m,qq;
  26.  
  27. inline void flod(int x,int y,int k,int cnt)
  28. {
  29.     now.x=x;
  30.     now.y=y;
  31.     now.k=k;
  32.     q.push(now);
  33.     while(!q.empty())
  34.     {
  35.         now=q.front();
  36.         q.pop();
  37.         if(col[now.x][now.y][now.k])
  38.             continue;
  39.         col[now.x][now.y][now.k]=cnt;
  40.         if(now.k!=)
  41.             all[cnt]+=small;
  42.         else
  43.             all[cnt]+=big;
  44.         if(map[now.x][now.y]==)
  45.         {
  46.             if(now.k==)
  47.             {
  48.                 if(now.x-)
  49.                 {
  50.                     if(map[now.x-][now.y]==)
  51.                         q.push((P){now.x-,now.y,});
  52.                     else
  53.                         q.push((P){now.x-,now.y,});
  54.                 }
  55.                 if (now.y-)
  56.                 {
  57.                     if(map[now.x][now.y-]==)
  58.                         q.push((P){now.x,now.y-,});
  59.                     else
  60.                         q.push((P){now.x,now.y-,});
  61.                 }
  62.             }
  63.             if(now.k==)
  64.             {
  65.                 if(now.x-)
  66.                 {
  67.                     if(map[now.x-][now.y]==)
  68.                         q.push((P){now.x-,now.y,});
  69.                     else
  70.                         q.push((P){now.x-,now.y,});
  71.                 }
  72.                 if (now.y-)
  73.                 {
  74.                     if(map[now.x][now.y-]==)
  75.                         q.push((P){now.x,now.y-,});
  76.                     else
  77.                         q.push((P){now.x,now.y-,});
  78.                 }
  79.                 if(now.x+<=n)
  80.                 {
  81.                     if(map[now.x+][now.y]==)
  82.                         q.push((P){now.x+,now.y,});
  83.                     else
  84.                         q.push((P){now.x+,now.y,});
  85.                 }
  86.                 if (now.y+<=m)
  87.                 {
  88.                     if(map[now.x][now.y+]==)
  89.                         q.push((P){now.x,now.y+,});
  90.                     else
  91.                         q.push((P){now.x,now.y+,});
  92.                 }
  93.             }
  94.             if(now.k==)
  95.             {
  96.                 if(now.x+<=n)
  97.                 {
  98.                     if(map[now.x+][now.y]==)
  99.                         q.push((P){now.x+,now.y,});
  100.                     else
  101.                         q.push((P){now.x+,now.y,});
  102.                 }
  103.                 if(now.y+<=m)
  104.                 {
  105.                     if(map[now.x][now.y+]==)
  106.                         q.push((P){now.x,now.y+,});
  107.                     else
  108.                         q.push((P){now.x,now.y+,});
  109.                 }
  110.             }
  111.         }
  112.         else
  113.         {
  114.             if(now.k==)
  115.             {
  116.                 if(now.x-)
  117.                 {
  118.                     if(map[now.x-][now.y]==)
  119.                         q.push((P){now.x-,now.y,});
  120.                     else
  121.                         q.push((P){now.x-,now.y,});
  122.                 }
  123.                 if(now.y+<=m)
  124.                 {
  125.                     if(map[now.x][now.y+]==)
  126.                         q.push((P){now.x,now.y+,});
  127.                     else
  128.                         q.push((P){now.x,now.y+,});
  129.                 }
  130.             }
  131.             if(now.k==)
  132.             {
  133.                 if(now.x-)
  134.                 {
  135.                     if(map[now.x-][now.y]==)
  136.                         q.push((P){now.x-,now.y,});
  137.                     else
  138.                         q.push((P){now.x-,now.y,});
  139.                 }
  140.                 if(now.y-)
  141.                 {
  142.                     if(map[now.x][now.y-]==)
  143.                         q.push((P){now.x,now.y-,});
  144.                     else
  145.                         q.push((P){now.x,now.y-,});
  146.                 }
  147.                 if(now.x+<=n)
  148.                 {
  149.                     if(map[now.x+][now.y]==)
  150.                         q.push((P){now.x+,now.y,});
  151.                     else
  152.                         q.push((P){now.x+,now.y,});
  153.                 }
  154.                 if(now.y+<=m)
  155.                 {
  156.                     if(map[now.x][now.y+]==)
  157.                         q.push((P){now.x,now.y+,});
  158.                     else
  159.                         q.push((P){now.x,now.y+,});
  160.                 }
  161.             }
  162.             if(now.k==)
  163.             {
  164.                 if(now.x+<=n)
  165.                 {
  166.                     if(map[now.x+][now.y]==)
  167.                         q.push((P){now.x+,now.y,});
  168.                     else
  169.                         q.push((P){now.x+,now.y,});
  170.                 }
  171.                 if(now.y-)
  172.                 {
  173.                     if(map[now.x][now.y-]==)
  174.                         q.push((P){now.x,now.y-,});
  175.                     else
  176.                         q.push((P){now.x,now.y-,});
  177.                 }
  178.             }
  179.         }
  180.     }
  181. }
  182. int main()
  183. {
  184.     scanf("%d%d",&n,&m);
  185.     for (int i=;i<=n;++i)
  186.         for (int j=;j<=m;++j)
  187.         {
  188.             char ch;ch=getchar();
  189.             while(ch!=''&&ch!='')
  190.                 ch=getchar();
  191.             map[i][j]=ch-'';
  192.         }
  193.     scanf("%d",&qq);
  194.     int cnt=;
  195.     for(int i=;i<=n;++i)
  196.         for(int j=;j<=m;++j)
  197.             for(int k=;k<=;++k)
  198.                 if(!col[i][j][k])
  199.                     flod(i,j,k,++cnt);
  200.     for(int i=;i<=n;++i)
  201.         for(int j=;j<=m;++j)
  202.         {
  203.             int xx=i-,yy=j-;
  204.             if (map[i][j]==)
  205.             {
  206.                 list[xx*][yy*]=col[i][j][];
  207.                 list[xx*+][yy*+]=col[i][j][];
  208.                 list[xx*+][yy*]=col[i][j][];
  209.                 list[xx*][yy*+]=col[i][j][];
  210.                 list[xx*+][yy*+]=col[i][j][];
  211.             }
  212.             if (map[i][j])
  213.             {
  214.                 list[xx*][yy*]=col[i][j][];
  215.                 list[xx*+][yy*+]=col[i][j][];
  216.                 list[xx*+][yy*+]=col[i][j][];
  217.                 list[xx*+][yy*]=col[i][j][];
  218.                 list[xx*][yy*+]=col[i][j][];
  219.             }
  220.         }
  221.     while (qq--)
  222.     {
  223.         int x,y;
  224.         scanf("%d%d",&x,&y);
  225.         if((x%)!=(y%))
  226.         {
  227.             printf("0.0000\n");
  228.             continue;
  229.         }
  230.         printf("%.4f\n",all[list[x][y]]);
  231.     }
  232. }

颂芬梭哈(ptgiving)

题目描述

Alice 和 Mukyu 最近偶然得到了一本写有一种叫做梭哈的扑克游戏的规则的说明书（名为《C████████nd》，中间部分被涂掉了），据其所述，梭哈是一种使用黑桃、红心、梅花、方片的 A 到 K 共 52 张牌(没有大小王）来进行的扑克牌游戏。
不幸的是，规则说明中有关整个游戏的进行方式的部分被撕掉了，Alice 和 Mukyu 从残存的部分只得知了“手牌上限是 5 张”这一消息，所以他们决定每次直接给两人各发 5 张牌，判定谁的手牌比较大，说明书中关于手牌大小判定的信息如下：

“

所有五张牌的组合，按以下秩序，由大至小排行分为不同牌型：
1、同花顺（Straight Flush）：同一花色，顺序的牌。 例： Q♦ J♦ 10♦ 9♦ 8♦；
2、四条（Four of a Kind）：有四张同一点数的牌。 例： 10♣ 10♦ 10♥ 10♠ 9♥；
3、满堂红（Full House）：三张同一点数的牌，加一对其他点数的牌。 例： 8♣ 8♦ 8♠ K♥ K♠；
4、同花（Flush）：五张同一花色的牌。 例： A♠ K♠ 10♠ 9♠ 8♠；
5、顺子（Straight）：五张顺连的牌。 例： K♦ Q♥ J♠ 10♦ 9♦；
6、三条（Three of a kind）：有三张同一点数的牌。 例： J♣ J♥ J♠ K♦ 9♠；
7、两对（Two Pairs）：两张相同点数的牌，加另外两张相同点数的牌。 例： A♣ A♦ 8♥ 8♠ Q♠；
8、一对（One Pair）：两张相同点数的牌。 例： 9♥ 9♠ A♣ J♠ 8♥；
9、无对（Zilch）：不能排成以上组合的牌，以点数决定大小。例： A♦ Q♦ J♠ 9♣ 8♣。
若牌型一样则利用点数和花色决定胜负。（点数优先）
点数的顺序（从大至小）为：A>K>Q>J>10>9>8>7>6>5>4>3>2。（注：当 5 张手牌是 5
4 3 2 A 的时候，A 可以看作最小的牌，此时的牌型仍然为顺子，是顺子里面最小的一个）。
花色的顺序（大至小）为：黑桃(♠)>红心(♥)>梅花(♣)>方块(♦)。
举例说明：
1、Q♦ J♦ 10♦ 9♦ 8♦ > 8♣ 8♥ 8♠ K♥ K♠ （前者牌型为同花顺，比后者大）；
2、9♣ 9♦ 9♠ Q♥ Q♠ > 8♣ 8♦ 8♠ K♥ K♠ （两者牌型均为满堂红，比较牌型中三张同一点数的牌 9 比 8 大）；
3、A♣ A♦ 8♥ 8♠ Q♠ > A♠ A♥ 7♥ 7♠ K♠ （两者牌型均为两对，且最大的对子相同，此时比较次大的对子，8 比 7 大）；
4、A♠ Q♠ J♥ 9♥ 8♥ > A♦ Q♦ J♠ 9♣ 8♣ （两者牌型均为无对，所有数码均相同，此时比较最大牌的花色，A♠ > A♦）。
5、4♠ 4♥ A♦ Q♦ 5♦ > 4♣ 4♦ A♠ Q♠ 5♠ （两者牌型均为一对，所有数码均相同，此时对 4 为牌型里最大的部分，因此比较 4♠ > 4♣）

”

尽管 Alice 和 Mukyu 都可以轻易的判断出结果，他们还是想见识一下现代科技的力量。

输入格式

第一行包含一个正整数 N，表示有 N 组测试数据。
每组测试数据包含 10 行，前 5 行每行用两个整数描述一张 Alice 手上的牌，第一个数表示牌的数码（1 表示 A，13 表示 K），第二个数表示牌的花色（1 表示黑桃，2 表示红心， 3 表示梅花，4 表示方块）。
后 5 行每行用两个整数描述 Mukyu 手上的牌，格式同上。

输出格式

对于每组测试数据，在单独的一行内输出 Alice 或 Mukyu，表示谁能赢。

样例数据

样例输入 样例输出

1
1 3
5 3
4 3
3 3
2 3
6 1
10 4
7 1
8 1
9 2

 Alice

<样例解释>

Alice 的手牌构成同花顺，而 Mukyu 的手牌仅构成普通顺子。

<数据范围>

对于 10%的数据，保证输入的全部牌型都是无对。
对于另外 30%的数据，保证输入的全部牌型都是顺子、同花或同花顺。
对于 100%的数据，保证 N ≤ 100000。
C++选手如果使用 cin 读入数据很可能因此超时，推荐使用 scanf/printf。

解析

模拟：一大堆 if串+函数 考虑每一种牌型比较的情况。

Code

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<cstring>
  4. #include<algorithm> 
  5.  
  6. #define num first
  7. #define col second
  8. #define mp make_pair 
  9.  
  10. using namespace std; 
  11.  
  12. typedef pair<int,int> pii;
  13. const int N=+; 
  14.  
  15. int cnt[]; 
  16.  
  17. inline void getint(int&num){
  18.     char c;num=;
  19.     while((c=getchar())<''||c>'');
  20.     while(c>=''&&c<=''){num=num*+c-;c=getchar();}
  21. } 
  22.  
  23. int T;pii Ail[N],Muk[N];
  24. bool cmp(pii a,pii b){
  25.     if(a.num==b.num)
  26.         return a.col>b.col;
  27.     else return a.num<b.num;
  28. }
  29. bool isone(pii *arr){//同花顺
  30.     memset(cnt,,sizeof cnt);
  31.     for(int i=;i<=;i++){
  32.         if(arr[i].col!=arr[].col)
  33.             return ;
  34.         cnt[arr[i].num]++;
  35.         if(arr[i].num==)
  36.             cnt[]++;
  37.     }
  38.     for(int i=;i<=;i++)
  39.         if(cnt[i]==&&cnt[i+]==&&cnt[i+]==&&cnt[i+]==&&cnt[i+]==)
  40.             return ;
  41.     return ;
  42. }
  43. bool istwo(pii *arr){//四条
  44.     bool f=;
  45.     for(int i=;i<=;i++)
  46.         if(arr[i].num!=arr[].num){
  47.             f=;break ;
  48.         }
  49.     if(f) return ;
  50.     f=;
  51.     for(int i=;i<=;i++)
  52.         if(arr[i].num!=arr[].num){
  53.             f=;break ;
  54.         }
  55.     return f;
  56. }
  57. bool isthree(pii *arr){//满堂红
  58.     if(arr[].num==arr[].num&&arr[].num==arr[].num&&arr[].num==arr[].num)
  59.         return ;
  60.     if(arr[].num==arr[].num&&arr[].num==arr[].num&&arr[].num==arr[].num)
  61.         return ;
  62.     return ;
  63. }
  64. bool isfour(pii *arr){//同花
  65.     for(int i=;i<=;i++)
  66.         if(arr[i].col!=arr[].col)
  67.             return ;
  68.     return ;
  69. }
  70. bool isfive(pii *arr){//顺子
  71.     memset(cnt,,sizeof cnt);
  72.     for(int i=;i<=;i++){
  73.         cnt[arr[i].num]++;
  74.         if(arr[i].num==)
  75.             cnt[]++;
  76.     }
  77.     for(int i=;i<=;i++)
  78.         if(cnt[i]==&&cnt[i+]==&&cnt[i+]==&&cnt[i+]==&&cnt[i+]==)
  79.             return ;
  80.     return ;
  81. }
  82. bool issix(pii *arr){//三条
  83.     if(arr[].num==arr[].num&&arr[].num==arr[].num)
  84.         return ;
  85.     if(arr[].num==arr[].num&&arr[].num==arr[].num)
  86.         return ;
  87.     if(arr[].num==arr[].num&&arr[].num==arr[].num)
  88.         return ;
  89.     return ;
  90. }
  91. bool isseven(pii *arr){//两对
  92.     memset(cnt,,sizeof cnt);
  93.     for(int i=;i<=;i++)
  94.         cnt[arr[i].num]++;
  95.     int tot=;
  96.     for(int i=;i<=;i++)
  97.         if(cnt[i]==) tot++;
  98.     return tot==;
  99. }
  100. bool iseight(pii *arr){//一对
  101.     for(int i=;i<=;i++)
  102.         if(arr[i].num==arr[i-].num)
  103.             return ;
  104.     return ;
  105. }
  106. int check(pii *arr){
  107.     if(isone(arr)) return ;
  108.     else if(istwo(arr)) return ;
  109.     else if(isthree(arr)) return ;
  110.     else if(isfour(arr)) return ;
  111.     else if(isfive(arr)) return ;
  112.     else if(issix(arr)) return ;
  113.     else if(isseven(arr)) return ;
  114.     else if(iseight(arr)) return ;
  115.     else return ;
  116. }
  117. bool cmp1(pii *a,pii *b){//同花顺
  118.     bool f1=,f2=;
  119.     if(a[].num==&&a[].num==) f1=;
  120.     else if(b[].num==&&b[].num==) f2=;
  121.     if(f1!=f2) return f1;
  122.     if(f1&&f2) return a[].col<b[].col; 
  123.  
  124.     if(a[].num==b[].num)
  125.         return a[].col<b[].col;
  126.     else return a[].num>b[].num;
  127. }
  128. bool cmp2(pii *a,pii *b){//四条
  129.     int num_a1,num_a2,col_a;
  130.     if(a[].num==a[].num&&a[].num==a[].num&&a[].num==a[].num){
  131.         num_a1=a[].num,num_a2=a[].num;
  132.         col_a=a[].col;
  133.     }
  134.     else{
  135.         num_a1=a[].num,num_a2=a[].num;
  136.         col_a=a[].col;
  137.     } 
  138.  
  139.     int num_b1,num_b2,col_b;
  140.     if(b[].num==b[].num&&b[].num==b[].num&&b[].num==b[].num){
  141.         num_b1=b[].num,num_b2=b[].num;
  142.         col_b=b[].col;
  143.     }
  144.     else{
  145.         num_b1=b[].num,num_b2=b[].num;
  146.         col_b=b[].col;
  147.     } 
  148.  
  149.     if(num_a1==) num_a1=;
  150.     if(num_a2==) num_a2=;
  151.     if(num_b1==) num_b1=;
  152.     if(num_b2==) num_b2=; 
  153.  
  154.     if(num_a1!=num_b1)
  155.         return num_a1>num_b1;
  156.     else{
  157.         if(num_a2!=num_b2)
  158.             return num_a2>num_b2;
  159.         else return col_a<col_b;
  160.     }
  161. }
  162. bool cmp3(pii *a,pii *b){//满堂红
  163.     for(int i=;i<=;i++)
  164.         if(a[i].num==) a[i].num=;
  165.     for(int i=;i<=;i++)
  166.         if(b[i].num==) b[i].num=;
  167.     sort(a+,a+,cmp);
  168.     sort(b+,b+,cmp); 
  169.  
  170.     int sta1,sta2,stb1,stb2;
  171.     if(a[].num==a[].num&&a[].num==a[].num)
  172.         sta1=,sta2=;
  173.     else sta1=,sta2=; 
  174.  
  175.     if(b[].num==b[].num&&b[].num==b[].num)
  176.         stb1=,stb2=;
  177.     else stb1=,stb2=; 
  178.  
  179.     for(int i=sta1+,j=stb1+;i>=sta1&&j>=stb1;i--,j--){
  180.         if(a[i].num==b[j].num) continue ;
  181.         else return a[i].num>b[j].num;
  182.     } 
  183.  
  184.     for(int i=sta2+,j=stb2+;i>=sta2&&j>=stb2;i--,j--){
  185.         if(a[i].num==) a[i].num=;
  186.         if(b[j].num==) b[j].num=;
  187.         else if(a[i].num==b[j].num) continue ;
  188.         else return a[i].num>b[j].num;
  189.     } 
  190.  
  191.     for(int i=sta1+,j=stb1+;i>=sta1&&j>=stb1;i--,j--){
  192.         if(a[i].col==b[j].col) continue ;
  193.         else return  a[i].col<b[i].col;
  194.     } 
  195.  
  196.     for(int i=sta2+,j=stb2+;i>=sta2&&j>=stb2;i--,j--){
  197.         if(a[i].col==b[j].col) continue ;
  198.         else return  a[i].col<b[i].col;
  199.     } 
  200.  
  201.     return ;
  202. }
  203. bool cmp4(pii *a,pii *b){//同花
  204.     for(int i=;i<=;i++)
  205.         if(a[i].num==) a[i].num=;
  206.     for(int i=;i<=;i++)
  207.         if(b[i].num==) b[i].num=;
  208.     sort(a+,a+,cmp);
  209.     sort(b+,b+,cmp);
  210.     for(int i=;i;i--){
  211.         if(a[i].num==b[i].num) continue ;
  212.         return a[i].num>b[i].num;
  213.     }
  214.     for(int i=;i;i--){
  215.         if(a[i].col==b[i].col) continue ;
  216.         return a[i].col<b[i].col;
  217.     }
  218.     return ;
  219. }
  220. bool cmp5(pii *a,pii *b){//顺子
  221.     if(a[].num==&&a[].num==){
  222.         pii t=a[];t.num=;
  223.         for(int i=;i<=;i++)
  224.             a[i-]=a[i];
  225.         a[]=t;
  226.     }
  227.     if(b[].num==&&b[].num==){
  228.         pii t=b[];t.num=;
  229.         for(int i=;i<=;i++)
  230.             b[i-]=b[i];
  231.         b[]=t;
  232.     }
  233.     /*for(int i=5;i;i--){
  234.         if(a[i].num==b[i].num) continue ;
  235.         return a[i].num>b[i].num;
  236.     }*/
  237.     if(a[].num!=b[].num)
  238.         return a[].num>b[].num;
  239.     for(int i=;i;i--){
  240.         if(a[i].col==b[i].col) continue ;
  241.         return a[i].col<b[i].col;
  242.     }
  243.     return ;
  244. }
  245. bool cmp6(pii *a,pii *b){//三条
  246.     for(int i=;i<=;i++)
  247.         if(a[i].num==) a[i].num=;
  248.     for(int i=;i<=;i++)
  249.         if(b[i].num==) b[i].num=;
  250.     sort(a+,a+,cmp);
  251.     sort(b+,b+,cmp); 
  252.  
  253.     int sta;
  254.     for(int i=;i<=;i++)
  255.         if(a[i].num==a[i-].num&&a[i].num==a[i-].num){
  256.             sta=i-;break ;
  257.         } 
  258.  
  259.     int stb;
  260.     for(int i=;i<=;i++)
  261.         if(b[i].num==b[i-].num&&b[i].num==b[i-].num){
  262.             stb=i-;break ;
  263.         } 
  264.  
  265.     for(int i=sta+,j=stb+;i>=sta&&j>=stb;i--,j--){
  266.         if(a[i].num==b[j].num) continue ;
  267.         else return a[i].num>b[j].num;
  268.     } 
  269.  
  270.     for(int i=,j=;i&&j;i--,j--){
  271.         if(i==sta+) i=sta-;
  272.         if(j==stb+) j=stb-;
  273.         if(a[i].num==b[j].num) continue ;
  274.         else return a[i].num>b[j].num;
  275.     } 
  276.  
  277.     for(int i=sta+,j=stb+;i>=sta&&j>=stb;i--,j--){
  278.         //printf("%d %d\n",a[i].col,b[j].col);
  279.         if(a[i].col==b[j].col) continue ;
  280.         else return a[i].col<b[j].col;
  281.     } 
  282.  
  283.     for(int i=,j=;i&&j;i--,j--){
  284.         if(i==sta+) i=sta-;
  285.         if(j==stb+) j=stb-;
  286.         if(a[i].col==b[j].col) continue ;
  287.         else return a[i].col<b[j].col;
  288.     }
  289.     return ; 
  290.  
  291. }
  292. bool cmp7(pii *a,pii *b){//两对
  293.     for(int i=;i<=;i++)
  294.         if(a[i].num==) a[i].num=;
  295.     for(int i=;i<=;i++)
  296.         if(b[i].num==) b[i].num=;
  297.     sort(a+,a+,cmp);
  298.     sort(b+,b+,cmp); 
  299.  
  300.     pii pa1[],pa2[],pb1[],pb2[];
  301.     bool f1=,f2=;
  302.     bool v1[],v2[];
  303.     memset(v1,,sizeof v1);
  304.     memset(v2,,sizeof v2);
  305.     for(int i=;i<=;i++){
  306.         if(a[i].num==a[i-].num){
  307.             if(f1) pa1[]=a[i],pa1[]=a[i-];
  308.             else pa2[]=a[i],pa2[]=a[i-],f1=;
  309.             v1[i]=v1[i-]=;
  310.         } 
  311.  
  312.         if(b[i].num==b[i-].num){
  313.             if(f2) pb1[]=b[i],pb1[]=b[i-];
  314.             else pb2[]=b[i],pb2[]=b[i-],f2=;
  315.             v2[i]=v2[i-]=;
  316.         }
  317.     }
  318.     if(pa1[].num!=pb1[].num)
  319.         return pa1[].num>pb1[].num; 
  320.  
  321.     if(pa1[].num!=pb1[].num)
  322.         return pa1[].num>pb1[].num; 
  323.  
  324.     if(pa2[].num!=pb2[].num)
  325.         return pa2[].num>pb2[].num; 
  326.  
  327.     if(pa2[].num!=pb2[].num)
  328.         return pa2[].num>pb2[].num; 
  329.  
  330.     for(int i=;i<=;i++)if(!v1[i])
  331.         for(int j=;j<=;j++)if(!v2[j]){
  332.             if(a[i].num!=b[j].num)
  333.                 return a[i].num>b[j].num;
  334.             break ;
  335.         } 
  336.  
  337.     if(pa1[].col!=pb1[].col)
  338.         return pa1[].col<pb1[].col; 
  339.  
  340.     if(pa1[].col!=pb1[].col)
  341.         return pa1[].col<pb1[].col; 
  342.  
  343.     if(pa2[].col!=pb2[].col)
  344.         return pa2[].col<pb2[].col; 
  345.  
  346.     if(pa2[].col!=pb2[].col)
  347.         return pa2[].col<pb2[].col; 
  348.  
  349.     for(int i=;i<=;i++)if(!v1[i])
  350.         for(int j=;j<=;j++)if(!v2[j]){
  351.             if(a[i].col!=b[j].col)
  352.                 return a[i].col<b[j].col;
  353.             break ;
  354.         }
  355.     return ;
  356. }
  357. bool cmp8(pii *a,pii *b){//一对
  358.     for(int i=;i<=;i++)
  359.         if(a[i].num==) a[i].num=;
  360.     for(int i=;i<=;i++)
  361.         if(b[i].num==) b[i].num=;
  362.     sort(a+,a+,cmp);
  363.     sort(b+,b+,cmp); 
  364.  
  365.     int sta;
  366.     for(int i=;i<=;i++)
  367.         if(a[i].num==a[i-].num){
  368.             sta=i-;break ;
  369.         } 
  370.  
  371.     int stb;
  372.     for(int i=;i<=;i++)
  373.         if(b[i].num==b[i-].num){
  374.             stb=i-;break ;
  375.         } 
  376.  
  377.     for(int i=sta+,j=stb+;i>=sta&&j>=stb;i--,j--){
  378.         if(a[i].num==b[j].num) continue ;
  379.         else return a[i].num>b[j].num;
  380.     } 
  381.  
  382.     for(int i=,j=;i&&j;i--,j--){
  383.         if(i==sta+) i=sta-;
  384.         if(j==stb+) j=stb-;
  385.         if(a[i].num==b[j].num) continue ;
  386.         else return a[i].num>b[j].num;
  387.     } 
  388.  
  389.     for(int i=sta+,j=stb+;i>=sta&&j>=stb;i--,j--){
  390.         //printf("%d %d\n",a[i].col,b[j].col);
  391.         if(a[i].col==b[j].col) continue ;
  392.         else return a[i].col<b[j].col;
  393.     } 
  394.  
  395.     for(int i=,j=;i&&j;i--,j--){
  396.         if(i==sta+) i=sta-;
  397.         if(j==stb+) j=stb-;
  398.         if(a[i].col==b[j].col) continue ;
  399.         else return a[i].col<b[j].col;
  400.     }
  401.     return ;
  402. }
  403. bool cmp9(pii *a,pii *b){//无对
  404.     if(a[].num==){
  405.         pii t=a[];t.num=;
  406.         for(int i=;i<=;i++)
  407.             a[i-]=a[i];
  408.         a[]=t;
  409.     }
  410.     if(b[].num==){
  411.         pii t=b[];t.num=;
  412.         for(int i=;i<=;i++)
  413.             b[i-]=b[i];
  414.         b[]=t;
  415.     }
  416.     for(int i=;i;i--){
  417.         if(a[i].num==b[i].num) continue ;
  418.         else return a[i].num>b[i].num;
  419.     }
  420.     for(int i=;i;i--){
  421.         if(a[i].col==b[i].col) continue ;
  422.         else return a[i].col<b[i].col;
  423.     }
  424.     return ;
  425. }
  426. int main(){
  427.     getint(T);
  428.     while(T--){
  429.         for(int i=;i<=;i++)
  430.             getint(Ail[i].num),getint(Ail[i].col);
  431.         for(int i=;i<=;i++)
  432.             getint(Muk[i].num),getint(Muk[i].col);
  433.         sort(Ail+,Ail+,cmp);
  434.         sort(Muk+,Muk+,cmp);
  435.         int t1=check(Ail);
  436.         int t2=check(Muk);
  437.         if(t1==t2){
  438.             bool win;
  439.             if(t1==) win=cmp1(Ail,Muk);
  440.             else if(t1==) win=cmp2(Ail,Muk);
  441.             else if(t1==) win=cmp3(Ail,Muk);
  442.             else if(t1==) win=cmp4(Ail,Muk);
  443.             else if(t1==) win=cmp5(Ail,Muk);
  444.             else if(t1==) win=cmp6(Ail,Muk);
  445.             else if(t1==) win=cmp7(Ail,Muk);
  446.             else if(t1==) win=cmp8(Ail,Muk);
  447.             else if(t1==) win=cmp9(Ail,Muk);
  448.             printf("%s\n",win?"Alice":"Mukyu");
  449.         }
  450.         else printf("%s\n",t1<t2?"Alice":"Mukyu");
  451.     }
  452. }

周年纪念(anniversary)

题目描述

距离著名意大利数学家 Fibonacci 的 900 年诞辰纪念日还剩下不到 60 年。当然，这种重要的纪念日需要很多准备。

Sidepi 认为应当解决以下问题来表达对 Fibonacci 的纪念：给定由 l、l+1、l+2……r 这 r-l+1 个整数构成的集合 A，考虑 A 的所有含有 k 个元素的子集；对于每个子集 B，设 Bi 是 能整除子集中全部 k 个元素的最大整数；i 是所有 Bi 的最大值，求第 i 个 Fibonacci 数 F[i] 是多少。 当然，Sidepi 也没忘记提醒你，F[1]=1，F[2]=1，F[n]=F[n-1]+F[n-2](n>=3)。 Sidepi 有半个多世纪的时间来解决这个问题，但是你只有 3 个半小时。因此你只需要输出 F[i] mod m 的值。

输入格式

四个用空格隔开的整数 m、l、r、k。

输出格式

上述问题的答案 F[i] mod m 的值。

样例数据

样例输入 样例输出
10 1 8 2 3

<数据范围>

对于 50% 的数据，1<=l,r<=10^6；对于 100% 的数据，1<=m<=10^9，1 ≤ l < r ≤ 10^12，2 ≤ k ≤ r - l + 1。

解析

[l,r]间i的倍数的个数等于r/i-(l-1)/i，随着i的增大r/i是减小的，(l-1)/i也是减小的，通过感觉我们知道r/i-(l-1)/i大体上也是减小的，但并不是严格递减，即使用二分+暴力也不能很有效地减小这个范围
注意到从1开始一个个地枚举i是很不明智的，因为即使i++也很有可能不会使r/i和(l-1)/i中任意一项的值改变
所以可以想到对于i来说min(l/(l/i),r/(r/i))是在保证r/i和(l-1)/i不变前提下的更优值，所以我们每次都只用枚举r/i和(l-1)/i一定时i的最优值即可，然后i++如此往复计算出下一个状态的最优值，可以证明在这个过程中我们一定会遍历到使r/i-(l-1)/i>=k成立最大的那个i
这个做法很容易想出来，但是时间复杂度怎么保证呢……
不妨假设在最gg的情况l=r=1e12,k=1
那么i=1,2,3……r/3,r/2,r
注意由于i只能为整数，所以i在一开始是很连续的，但是往后开始就不连续了，我们只要把这个临界点计算出来，然后就可以分段计算出时间复杂度了。

我们可以假设第x次以及以后的分割都是按间隔为1均匀地分布的。
n/x-n/(x-1)=1
n*(x+1)=x*(x+1)+n*x
n=x*(x+1)
x=sqrt(n)
时间复杂度：O(2*sqrt(n))

Code

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. #include<cstdlib>
  5. #include<algorithm>
  6. #include<cmath>
  7.  
  8. using namespace std;
  9.  
  10. typedef long long ll;
  11.  
  12. struct Mat{
  13.     ll s[][];
  14.     ll* operator [](const ll a){
  15.         return s[a];
  16.     }
  17. };
  18. Mat cv={,,,};
  19. Mat fib={,,,};
  20.  
  21. ll m,l,r,w,x=,y;
  22. Mat mul(Mat a,Mat b)
  23. {
  24.     Mat s={,,,};
  25.     for(ll i=;i<;i++)
  26.         for(ll j=;j<;j++)
  27.             for(ll k=;k<;k++)
  28.                 s[i][j]+=a[i][k]*b[k][j]%m;
  29.     return s;
  30. }
  31. Mat power(Mat a,ll b)
  32. {
  33.     Mat s={,,,};
  34.     while(b)
  35.     {
  36.         if(b&)
  37.             s=mul(s,a);
  38.         a=mul(a,a);
  39.         b/=;
  40.     }
  41.     return s;
  42. }
  43. int main()
  44. {
  45.     cin>>m>>l>>r>>w;
  46.     l--;
  47.     while(x<=r)
  48.     {
  49.         if((l/x)==)
  50.             x=r/(r/x);
  51.         else
  52.             x=min(l/(l/x),r/(r/x));
  53.         if(r/x-l/x>=w)
  54.             y=x;
  55.         x++;
  56.     }
  57.     cv=power(cv,y);
  58.     fib=mul(fib,cv);
  59.     cout<<fib[][]<<endl;
  60.     return ;
  61. }

Time: 2017-10-29

[SinGuLaRiTy] Nescafe 24杯模拟赛的更多相关文章

  1. Nescafe #29 NOIP模拟赛

    Nescafe #29 NOIP模拟赛 不知道这种题发出来算不算侵权...毕竟有的题在$bz$上是权限题,但是在$vijos$似乎又有原题...如果这算是侵权的话请联系我,我会尽快删除,谢谢~ 今天开 ...

  2. 计蒜客蓝桥杯模拟赛 后缀字符串：STL_map+贪心

    问题描述 一天蒜头君得到 n 个字符串 si​,每个字符串的长度都不超过 10. 蒜头君在想,在这 n 个字符串中,以 si​ 为后缀的字符串有多少个呢? 输入格式 第一行输入一个整数 n. 接下来  ...

  3. [SinGuLaRiTy] NOIP互测模拟赛

    [SinGuLaRiTy-1045] Copyright (c) SinGuLaRiTy 2017. All Rights Reserved. 源文件名 输入输出文件 时间限制 内存限制 淘气的cch ...

  4. 9.27下午考试(Nescafé 29杯模拟赛)

    140pts(100+30+10)Rank3 前几天还考了一场,AK,没什么好总结的,所以就没写博客. 炸: T2,模拟退火突然不会了,写个状压dp,排序边的时候sort的N而不是M. 这个坑经常出! ...

  5. 计蒜客蓝桥杯模拟赛五J. 程序设计：放置守卫

    在一张 n 行 m 列的方格地图上放置一些守卫,每个守卫能守护上.左.右三个方向上相邻的方格和自己所在的方格.如下图,红色的方格放置守卫,绿色的方格为该守卫守护的区域. 现在要求在地图上放置若干个守卫 ...

  6. 蓝桥杯模拟赛-引爆炸弹-DFS+并查集

    今天整理电脑,翻出来了很久以前大佬给的题,贴一下. 引爆炸弹 1000ms 在一个 n×m的方格地图上,某些方格上放置着炸弹.手动引爆一个炸弹以后,炸弹会把炸弹所在的行和列上的所有炸弹引爆,被引爆的炸 ...

  7. 2017-9-10"切题如切菜杯"模拟赛T4 ZZI

    题目 YYH拿到了父亲给的钱欣喜若狂,把这些钱拿来造了n栋房子.现在他要给这些房子通电.他有两种方法:第一种是在房间里搭核电发电机发电,对于不同的房子,他需要花不同的代价Vi:,第二种是将有电的房子i ...

  8. EZ 2018 06 24 NOIP2018 模拟赛（二十）

    很久之前写的一套题了,由于今天的时间太多了,所以记起来就写掉算了. 这一场尽管T2写炸了,但也莫名Rank4涨了Rating.不过还是自己太菜. A. 环游世界 首先我们先排个序,想一下如果不用走回来 ...

  9. BFS 搜索 蓝桥杯模拟赛

    题目链接:https://nanti.jisuanke.com/t/36117 这个题目想不到用广搜来做,一直在想深搜. 广搜的思路呢,是把最外圈不是黑色(不是0)的数 的位置 i 和 j 进队,赋值 ...

随机推荐

  1. Python学习_02_数字和运算

    python具有强大的科学运算功能,python由于支持更加强大的面向对象和动态特性,相比R语言.matlab.mathmatic等传统的科学计算工具具有非常大的优势. Python的数字 pytho ...

  2. Head First设计模式之生成器模式

    一.定义 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.建造者模式是一种对象创建型模式. 二.结构 角色 Builder(抽象建造者):它为创建一个产品Product对象的 ...

  3. swiper轮播问题之一：轮播图内容为动态数据生成时轮播图无法自动轮播

    本人在用H5做移动端项目中使用Swiper遇到的两个问题,因此加深了对Swiper的掌握,分享出来对刚开始接触Swiper的童鞋们或多或少会有帮助.        首先,new Swiper的初始化最 ...

  4. python爬虫——写出最简单的网页爬虫

    在我们日常上网浏览网页的时候,经常会看到一些好看的图片,我们就希望把这些图片保存下载,或者用户用来做桌面壁纸,或者用来做设计的素材.我们可以通过python 来实现这样一个简单的爬虫功能,把我们想要的 ...

  5. .NET Core+MySql+Nginx 容器化部署

    .NET Core容器化@Docker .NET Core容器化之多容器应用部署@Docker-Compose .NET Core+MySql+Nginx 容器化部署 GitHub-Demo:Dock ...

  6. python爬虫知识点三--解析豆瓣top250数据

    一.利用cookie访问import requests headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKi ...

  7. Maven教程（1）--maven的下载、安装与配置

    Maven下载 下载地址:http://maven.apache.org/download.cgi 下载后,解压得到 Maven目录分析: bin文件夹:含有mvn运行的脚本 boot文件夹:含有pl ...

  8. 云计算之路-阿里云上：docker swarm 集群故障与异常

    在上次遭遇 docker swarm 集群故障后,我们将 docker 由 17.10.0-ce 升级为最新稳定版 docker 17.12.0-ce . 前天晚上22:00之后集群中的2个节点突然出 ...

  9. 微信小程序登陆授权

    小程序前端代码 function WXlogin(){ wx.login({ success: function (code) { wx.getUserInfo({ success:function( ...

  10. Eclipse中使用Maven新建 Servlet 2.5的 SpringMVC项目

    1.前言: 最近在学习SpringMVC框架,由于使用Eclipse创建的webAPP项目默认使用的还是比较旧的servlet2.3,而且默认使用的还是JDK1.5,所以便有一次开始了我的配置之路 2 ...