夏令营提高班上午上机测试 Day 3 解题报告

今天的题的确水。T3还是一道NOIP原题。

嘛，多刷点水题也不是什么坏事嘛。

说来也快，夏令营结束了整一星期了呢。大家也都回到了日常的暑假生活呢。

今天学业水平测试出成绩了。。。嗯结果还算满意呢，至少达到了预期目标。

NOIP这边，还要继续努力啊。

还好，这次我找到我的代码了。

除了T3我的代码出了点小意外写炸了。。另外两道题我都把我的代码和std都放出来吧。。。

好了来说一下Day3的题解。

T1：十字架

题目描述

小 D 是虔诚的嘟嘟教徒。现在小 G 送他了一幅著名画家芬达奇的作品。这是一幅 n n 的作品，由”.” 或者”#” 构成，其中”.” 相当于空白。但是现在小 D 怀疑小 G 送给他了一幅赝品。正版芬达奇的画作，是由若干个互不重叠的十字架拼起来的。每个十字架由五个”#” 组成，如下：

.#.

###

.#.

而赝品则不能将所有的”#” 分成若干个互不重叠的十字架，如：

.#..

####

.#..

特别地，如果一幅画里面全都是”.”，这仍然是一幅正品。

你的任务是帮助小 D 判断，小 G 送他的这幅画到底是不是正品。

输入格式

输入文件第一行一个数字 n，含义如题目所述。

第 2 行到第 n + 1 行，每行 n 个’.’ 或者’#’，描述整张画。

输出格式

输出文件一行，如果是正品，输出”YES”；如果是赝品，输出”NO”。

样例输入 1

5

.#...

####.

.####

...#.

.....

样例输出 1

YES

样例输入 2

4

####

####

####

####

样例输出 2

NO

数据范围

40% 数据，1 ≤n≤10

70% 数据，1 ≤n ≤50

100% 数据，1≤n ≤100

名副其实的签到题。n最大就到100.暴力BFS就可以过。但我在考场上想的并不是BFS，注意到n只有最大100，可以考虑n地遍历画面的每一个格子，每遍历到一个#字符就判断以此为中心的四连块是不是都是#并且没有打过标记，如果是这样就把这些#都打上标记 ，代表我们找到了一个十字架。不过我可能写丑了，我只拿了60。。。。。。。。。。。。。

我退群吧.jpg

（据说这题只输出yes或者no就能拿一半分。。

正解并没有像我写的那样去给每个找到的十字架打标记，而是直接把它变成点，这样遍历完之后再判断这个图里头有没有#，要是还有的话那就是NO了。

　　先把我的60分傻逼做法挂出来。。

　　

 #include<iostream>
 #include<queue>
 #include<cstdio>
 #include<cstring>
 #define maxn 233
 #define debug cout << "ok" << endl;
 using namespace std;
 char a[maxn][maxn];
 bool used[maxn][maxn];
 const int dx[] = {,,,-};
 const int dy[] = {,,-,};
 int n;
 bool all_dot = true;
 bool exist_remain_sharp = false;
 bool check_in(int x,int y){
     if (x >= && x<=n && y>= && y <=n)
         return true;
     else
         return false;

 }
 void n2_search(void){
     for (int i=;i<=n;i++)
         for (int j=;j<=n;j++){
             if (a[i][j] == '.' || (a[i][j]=='#' && used[i][j]))
                 continue;
             else{
                 bool now_check_fail = false;
                 for (int k=;k<;k++){
                     if (!check_in(i+dx[k],j+dy[k]) && a[i+dx[k]][j+dy[k]] == '.')
                         now_check_fail = true;

                 }
                 if (!now_check_fail){
                     used[i][j] = true;
                     for (int k = ;k<;k++)
                         used[i+dx[k]][j+dy[k]] =true;
                 }
             }
         }
 }
 int main(){

     freopen("puzzle.in","r",stdin);
     freopen("puzzle.out","w",stdout);
     scanf("%d",&n);
     for (int i=;i<maxn;i++)
         for (int j=;j<maxn;j++)
             a[i][j] = '.';
     for (int i=;i<=n;i++)
         for (int j=;j<=n;j++){
             cin >> a[i][j];
             if (a[i][j]=='#')
                 all_dot =false;
         }
     if (all_dot){
         printf("YES\n");
         return ;
     }
     memset(used,false,sizeof(used));
     n2_search();
     for (int i=;i<=n;i++)
         for (int j=;j<=n;j++){
             if (a[i][j] == '#' && !used[i][j])
                 exist_remain_sharp = true;

         }

     if (exist_remain_sharp)
         printf("NO\n");
     else
         printf("YES\n");
     fclose(stdin);
     fclose(stdout);
     return ;

 }

然后是std：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 using namespace std;

 const int max_n = ;
 int n;
 bool a[max_n][max_n];
 bool is_legal(int x, int y)
 {
     return  <= x && x <= n &&  <= y && y <= n && a[x][y];
 }

 int main()
 {
     freopen("puzzle.in", "r", stdin);
     freopen("puzzle.out", "w", stdout);
     cin >> n;
     for (int i = ; i <= n; i++)
         for (int j = ; j <= n; j++)
         {
             char c;
             scanf(" %c", &c);
             if (c == '#') a[i][j] = true;
         }

     bool is_ok = true;
     for (int i = ; i <= n; i++)
     {
         for (int j = ; j <= n; j++)
             if (a[i][j])
             {
                 if (is_legal(i + , j) && is_legal(i + , j - ) && is_legal(i + , j + ) && is_legal(i + , j))
                 {
                     a[i][j] = false;
                     a[i + ][j] = false;
                     a[i + ][j - ] = false;
                     a[i + ][j + ] = false;
                     a[i + ][j] = false;
                 }
                 else
                 {
                     is_ok = false;
                     break;
                 }
             }
         if (!is_ok) break;
     }

     if (is_ok) cout << "YES" << endl;
     else cout << "NO" << endl;
 }

　　

 

T2：搭积木

题目描述

小 Z 喜欢搭积木。小 Z 一共有 n 块积木，并且积木只能竖着一块一块的摞，可以摞多列。小 Z 的积木都是智能积木，第 i 块积木有一个情绪值 X_i。当摞在该积木上面积木总数超过 X_i 时，i 号积木就会不高兴。小 Z 情商这么高，肯定不希望有积木不高兴。但是他又希望每块积木都被用上，并且摞的积木列的总数最少。你能帮帮萌萌的小 Z 吗？

输入格式

输入文件第一行一个数字 n，含义如题目所述。

第 2 行一共 n 个数，第 i 个数为 X_i，含义如题目所述。

输出格式

输出一个数字，表示最小的积木列数目。

样例输入 1

3

0 0 10

样例输出 1

2

样例输入 2

4

0 0 0 0

样例输出 2

4

数据范围

30% 数据，1 ≤n ≤10

60% 数据，1≤ n ≤100

80% 数据，1≤ n ≤1000

100% 数据，1 ≤n≤ 5000

对于所有数据点，都有 X_i  ≤ n。

“不要让任何一个盒子感到不高兴”。盒子的情绪值指的是在这个盒子上面最多能放多少盒子。我们可以理解为“某一个盒子的载重量”。

搜索是显然的。但只能拿部分分。

这道题可以考虑一个贪心思想。先把所有盒子按照载重量从小到大排序，然后我们依次从小到大考虑每个盒子。考虑一个一般的状态，现在我们有若干列盒子，我们每次拿到一个新的盒子，根据之前排序的策略，这个新的盒子应该是载重量比较大的，那么我们就应该考虑把这个盒子放在某一列的最下面，但我们不能随便放，为了后续策略也最优，我们肯定要把这个盒子放在能放的个数最多的那一列放。我们可以用一个数组记录在第i列上已经有了多少个盒子，每次取一个盒子，找到这一列中盒子数最多的那一列（前提是可以放下），把这个盒子放进去。如果都放不进去了，那就只能开一个新列。

细心的同学会问了，为什么不能从大到小考虑每个盒子然后从底向上放呢？

可以想一下，如果是从大到小考虑每个盒子的贪心策略，肯定是我先拿一个最大的盒子放在底部，然后不断地向上摞小盒子，每次找到一个小盒子我们就放到还能放最多盒子的可行的那一列，若都不行就多开一列。实际上这是不行的。因为每次能不能在某一列摞盒子会受到底部的影响，而我们如果只看顶部还有多少可以放，这就有可能会引起底部的盒子不高兴。比如说盒子序列2,1,1,0,0，我们首先在第一列放了2，然后我们有1，因为2上边可以放两个，我们把1放在2上。然后我们又有1，因为1上边可以放1个，我们把1放在1上。然后有0，因为1上边可以放一个，我们就可以把0放在1上吗？这显然不行的。这样做2会不高兴。

（昨天写的例子错了，抱歉）

（170810更新）

我在考场上的做法和正解类似。首先还是按照盒子的载重量从小到大排序，设立一个vis数组记录第i个盒子是不是被用过了，然后我们从1到n依次考虑每一个没有被用过的盒子，找到一个后，就把它放在新的一列。然后我们从这个盒子的下一个盒子到第n个盒子进行考虑，如果之后检索的盒子没有被使用并且载重量比当前高度大，那就可以放在当前列。所以我们要在循环里记录一下当前列的高度。每次开启新列的时候这个高度就应该被初始化为1。这个算法是和正解等价的。具体请参见代码。

 　　std：

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int max_n = 5e3 + ;
 int n, a[max_n], p[max_n], tot = ;

 inline int get_num()
 {
     int ans = ;
     bool flag = false;
     char c;
     while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
     if (isdigit(c)) ans = c - '';
     else flag = true;
     while (isdigit(c = getchar())) ans = ans *  + c - '';
     return (flag ? - : ) * ans;
 }

 inline void solve()
 {
     for (int i = ; i <= n; i++)
         if (!tot)
             p[++tot] = ;
         else
         {
             int wh = , maxx = ;
             for (int j = ; j <= tot; j++)
                 if (a[i] >= p[j] && p[j] > maxx) maxx = p[j], wh = j;
             if (!wh)
                 p[++tot] = ;
             else
                 p[wh]++;
         }
     cout << tot << endl;
 }

 int main()
 {
     freopen("box.in", "r", stdin);
     freopen("box.out", "w", stdout);
     n = get_num();
     for (int i = ; i <= n; i++) a[i] = get_num();
     sort(a + , a +  + n);

     solve();
 }

　　　　

　　怎么没法对齐了。。

　　我的做法：

　　

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define maxn 5005
 using namespace std;
 int n;
 int a[maxn];
 int vis[maxn];
 int ans = ,m =;

 int main(){
     freopen("box.in","r",stdin);
     freopen("box.out","w",stdout);
     scanf("%d",&n);
     for (int i=;i<=n;i++)
         scanf("%d",&a[i]);
     sort(a+,a+n+);

     memset(vis,,sizeof(vis));
     for (int i=;i<=n;i++)
         if (vis[i]==){
             ans++;
             m = ;
             vis[i] = ;
             for (int j = i+;j<=n;j++)
                 if ((vis[j]==) && (a[j]>=m)){
                     vis[j] = ;
                     m++;
                 }
         }
     printf("%d",ans);
     fclose(stdin);
     fclose(stdout);
 }

　　

T3：分宿舍

题目描述

A 校有着神奇的住宿制度，不分男女宿舍，所有 n 个学生被统一分到两栋宿舍楼中。作为年轻人，学生之间心生爱慕之情是很正常。我们用爱慕值来表示两名学生之间的爱慕程度，如果两名爱慕值为 c 的学生被安排在同一宿舍楼，他们或她们便会在一起，并造成影响力为 c 的早恋事件。

每年年末，身为政教处主任的你会将所有早恋事件按照影响力从大到小排成一个列表，然后上报给校长。公务繁忙的校长只会去看列表中第一个事件的影响力，如果影响很大，他会考虑撤换政教处主任。

在详细考察了 n 个学生之间的爱慕关系后，你觉得压力很大。你要合理的将学生们分到两栋宿舍，以求产生的早恋事件影响力都比较小，以保住自己的官职。假设只要处于同一栋宿舍楼的两个人之间有爱慕关系，他们就一定会在这年的某个时候在一起。

那么，要怎么分配，才能让校长看到的那个早恋事件的影响力最小呢？这个最小值是多少？

输入格式

第一行两个整数 n 和 m，分别表示学生的数目和爱慕关系的对数。

接下来 m 行，每行为 3 个正整数 a_i，b_i，c_i，表示学生 a_i 和 b_i 之间有爱慕关系，爱慕值为 c_i。

数据保证 1 a_ib_in，0 < c_i ≤10⁹，且每对爱慕关系只出现一次。

输出格式

输出一个数，为通过合理安排，校长看到的那个早恋事件的最小影响力。如果没有发生早恋事件，输出 0。

样例输入

4 6

1 4 2534

2 3 3512

1 2 28351

1 3 6618

2 4 1805

3 4 12884

样例输出

3512

数据范围

对于 30% 的数据，n≤15。

对于 70% 的数据，n≤2000，m≤50000。

对于 100% 的数据，n≤20000，m≤100000。

NOIP2010的关押罪犯。。。。

这题要求最大的早恋事件影响力最小，那么很显然我们要考虑尽量把搞事情影响力比较大的俩人拆到两个宿舍里。我们首先对这些搞事情的度排序，然后去模拟着把搞事情度最高的两个人分到不同的宿舍里，只要在拆开两个人的时候发现和已有的拆分相矛盾，那么这肯定就是最小的影响力最大事件了。

这要怎么实现呢？并查集！

这里并查集的应用比较巧妙。如果设有n个人，那么我们的并查集应该开到2n大小。就是网上题解所谓的“补集法”。i表示第i个学生，它的补集i+n表示不能和i在同一个宿舍的人。然后我们每次读入a和b的搞事情程度为c，就把a和b+n所在集合合并，a+n与b所在集合合并。

要注意，每次合并之前都要判断ab是不是在同一集合，如果是，那么这就是最小的最大冲突。

 

还有两种做法。一种是用「加权并查集」，每个节点额外存储一个type，值为0表示和父亲节点在一个宿舍楼，1则不是。有兴趣的读者可以尝试一下。

第二种则是用二分答案+DFS。

 　　在考场上我这题写炸了。。。只拿了10分。。本来该A掉的QAQ

　　那就只贴std吧。。

　　

 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <iostream>
 using namespace std;

 const int max_n =  + ;
 const int max_m = 2e5 + ;
 const int inf = 1e9;

 int prison[max_n];
 int point[max_n], nxt[max_m], v[max_m], c[max_m];
 int tot = ;
 int n, m;
 int ANS;

 inline void add_edge(int x, int y, int cc)
 {
     tot++; nxt[tot] = point[x]; point[x] = tot; v[tot] = y; c[tot] = cc;
     tot++; nxt[tot] = point[y]; point[y] = tot; v[tot] = x; c[tot] = cc;
 }

 bool dfs(int now, int color)
 {
     prison[now] = color;
     for (int i = point[now]; i; i = nxt[i])
     if (c[i] > ANS)
     {
         if (prison[v[i]] == -)
         {
             if (!dfs(v[i], color ^ )) return false;
         }
         else
             if (prison[v[i]] == color) return false;
     }
     return true;
 }

 inline bool check()
 {
     for (int i = ; i <= n; i++) prison[i] = -;
     for (int i = ; i <= n; i++)
         if (prison[i] == -)
             if (!dfs(i, ))
                 return false;
     return true;
 }

 inline int getnum()
 {
     int ans = ;
     bool flag = false; char c;
     while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
     if (c == '-') flag = true; else ans = c - '';
     while (isdigit(c = getchar())) ans = ans *  + c - '';
     return (flag ? - : ) * ans;
 }

 int main()
 {
     freopen("love.in", "r", stdin);
     freopen("love.out", "w", stdout);
     n = getnum(); m = getnum();
     for (int i = ; i <= m; i++)
     {
         int x, y, cc;
         x = getnum(); y = getnum(); cc = getnum();
         add_edge(x, y, cc);
     }
     int l = , r = inf;
     while (l < r)
     {
         int mid = (l + r) >> ;
         ANS = mid;
         if (check())
             r = mid;
         else
             l = mid + ;
     }
     cout << l << endl;
 }