codeforce Round #599(Div.2)

题目传送门

A. Maximum Square

题目意思是给你n个长条，每个长条的高度是num[i](0 < i < n)，每一条的宽度都是 1 ；然后求这些长条可以组成的最大面积的正方形的宽度是多少，将它输出来。

题目分析 ：因为要求的是正方形，而且面积是最大的，所以既要看它的宽度也要看它的高度。因为多余的面积可以删除掉，所以我们只需要知道min（长，宽）。

所以可以将所有的长度排个序，然后从大到小历经一遍就可以了。

 #include <iostream>
 #include <algorithm>
 #include <string>
 #include <cstdio>

 using namespace std;
 const int ma = 2e5 + ;
 int num[];
 int n;

 int main()
 {
     int k;
     scanf("%d",&k);
     while(k--)
     {
         scanf("%d",&n);
         for(int i = ;i <= n;i++)
             scanf("%d",&num[i]);
         sort(num+,num+n+,greater<int>());//从大到小排序
         int maxn = ;
         for(int i = ;i <= n;i++)
         {
             maxn = max(maxn,min(num[i],i));//i代表着宽度，maxn是最终的答案。
         }
         printf("%d\n",maxn);
     }
     return ;
 }

B1. Character Swap (Easy Version)

题目意思：给你两个字符串s和t，它们具有相同的长度n，给你一个操作：你可以在s中选择一个下标i [1,n],然后在t中选择一个下标j [1, n],将它们进行交换，即swap(s[i],t[j])。但是你的操作数只有一次，要使得交换后的s与t相同。并且他是要从前往后进行操作的。（当然交换次数也可以是0）

题目分析：因为操作数只有一次，（这个一定要知道，我就是因为没有看到这个条件而wa了一发，还浪费了时间去找其他错误去了，我太菜了）所以要输出YES的话，就只有一种状态可以满足，那就是只有两组不同（我将具有相同下标的s[i] 和t[i]的两个字符看成一组），而且在这四个字符中，只有两个不同的字符，最重要的是两个组的上下的字符也要相同，只有这样才可以输出YES。其它情况下都不行。

看代码：

 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <string>
 #include <cstdio>

 using namespace std;
 const int ma = 2e4 + ;
 const int mm = ;
 char s[ma],t[ma];
 int n,num[mm];
 int dig[mm][mm];

 int main()
 {
     int k;
     scanf("%d",&k);
     while(k--)
     {
         scanf("%d",&n);
         scanf(" %s",&s);
         scanf(" %s",&t);
         memset(num,,sizeof(num));
         for(int i = ; i < n; i++)
             num[s[i] - 'a']++,num[t[i] - 'a']++;//num数组是用来储存出现在s和t中字母的次数
         bool f = ;
         for(int i = ; i < ; i++)
         {
             if(num[i] & )
             {
                 f = ;//如果出现的次数是奇数的话，那肯定是不行的，因为它都不能平均的分配
                 break;
             }
         }
         if(f)
         {
             printf("No\n");
             continue;
         }
         for(int i = ; i < n; i++)
         {
             if(s[i] == t[i])
                 continue;
             dig[s[i] - 'a'][t[i] - 'a']++;//dis数组是记录是s[i] 和 t[i] 出现的次数，如果可以输出YES的话那么只有一个有值并且它的值为2；因为
             //它只能要小于等于不同的两组
         }
         int nu = ;
         for(int i = ; i < ; i++)
         {
             for(int j = ; j < ; j++)
             {
                 nu += dig[i][j];//nu是记录次数的
                 if((dig[i][j] & ) || nu > )
                 {
                     f = ;
                     break;
                 }
             }
             if(f)
                 break;
         }
         if(f)
             printf("No\n");
         else
             printf("Yes\n");
         for(int i = ;i < ;i++)
             for(int j = ;j < ;j++)
                 dig[i][j] = ;//还要将dig数组清零
     }
     return ;
 }

B2. Character Swap (Hard Version)

题目意思：跟b1类似，但是它可以执行的操作数增加的变成了小于等于2 * n了，那肯定可以完成。

题目分析：因为执行的次数足够了，所以只有当在字符串s和t中的字符出现了奇数次的时候输出NO，其他情况都可以输出YES，因为我们要从前往后进行操作，所以要先将前面的字符先让它们相等

先拿出s中最前面的那个未操作的字符s[i]，在后面的s中找，看是否可以找到s[j]，可以的话就交换它们(交换s[j]和t[i]），然后将他们的下标记录下，没有的话，就从t中找，找到t[j]之后先让它跟上面的交换一下(t[j] 和 s[j]）再让t[j] 和 t[i] 交换，然后记录下他们的位置，最后将他们的位置输出来就可以了；

看代码：

 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <cstdio>
 #include <vector>

 using namespace std;
 const int ma = ;
 char s[],t[];
 int ans[][];
 int nu[ma],k;
 struct node
 {
     char s1,t1;
     int index;
 };
 vector<node> v;

 int main()
 {
     scanf("%d",&k);
     while(k--)
     {
         int n;
         scanf("%d",&n);
         scanf(" %s",&s);
         scanf(" %s",&t);
         memset(nu,,sizeof(nu));
         for(int i = ; i < n; i++)
             nu[s[i] - 'a']++,nu[t[i] - 'a']++;//记录在s和t字母出现的次数
         bool f = ;
         for(int i = ; i < ; i++)
             if(nu[i] & )
             {
                 f = ;//如果为奇数就输出NO
                 break;
             }
         if(f)
         {
             puts("No");
             continue;
         }
         int in = ;
         bool f1 = ;
         for(int i = ; i < n; i++)
         {
             if(s[i] == t[i])
                 continue;
             node a;
             a.s1 = s[i],a.t1 = t[i],a.index = i + ;//将上下两个不同的储存在v中，
             v.push_back(a);
         }
         int len = v.size(),cnt = ;//len代表着有多少组是不同的
         for(int i = ; i < len; i++)
         {
             for(int j = i + ; j < len; j++)
             {
                 if(v[i].s1 == v[j].s1)
                 {
                     swap(v[i].t1,v[j].s1);
                     ans[++cnt][] = v[j].index,ans[cnt][] = v[i].index;//在s的后面找，看是否有跟v[i].s1相同的，有的话就记录下位置，并且要记得交换它们。
                     break;
                 }
                 if(v[i].s1 == v[j].t1)
                 {
                     swap(v[j].t1,v[j].s1);
                     swap(v[j].s1,v[i].t1);
                     ans[++cnt][] = ans[cnt][] = v[j].index;
                     ans[++cnt][] = v[j].index,ans[cnt][] = v[i].index;
                     break;
                 }
             }
         }
         puts("YES");
         printf("%d\n",cnt);
         for(int i = ; i <= cnt; i++)
         {
             printf("%d %d\n",ans[i][],ans[i][]);
             ans[i][] = ans[i][] = ;
         }
         v.clear();//记得要清零
     }
     return ;
 }