• 2020年第 45 届国际大学生程序设计竞赛（ICPC）亚洲区域赛（上海）

    B Mine Sweeper II

    因为题目要求最多能修改 n * m / 2 向下取整次，我们可以判断 A 和 B 之间有几个不同的位置并统计个数，最终如果不同的个数不超过 n * m / 2，那就可以直接修改。超过了就输出 A 的反图，这样可以证明答案是正确的。可以多举几个例子验证一下，这里不进行严格证明。比赛的时候就要大胆猜结论，同时也要细心考虑到特殊情况。

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. using namespace std;
    7.  
    8. int n, m;
    9. int cnt_a;
    10. int cnt_b;
    11. int cnt;
    12. char a[1010][1010];
    13. char b[1010][1010];
    14.  
    15. int main(){
    16. 	cin >> n >> m;
    17. 	for(int i = 1; i <= n; i++)
    18. 		for(int j = 1; j <= m; j++)
    19. 			cin >> a[i][j];
    20. 		
    21. 	for(int i = 1; i <= n; i++)
    22. 		for(int j = 1; j <= m; j++)
    23. 			cin >> b[i][j];
    24. 	
    25. 	for(int i = 1; i <= n; i++){
    26. 		for(int j = 1; j <= m; j++){
    27. 			if(a[i][j] != b[i][j]) cnt++;
    28. 		}
    29. 	}
    30.  
    31. 	if(cnt <= n * m / 2){
    32. 		for(int i = 1; i <= n; i++){
    33. 			for(int j = 1; j <= m; j++){
    34. 				cout << a[i][j];
    35. 			}
    36. 			cout << '\n';
    37. 		}
    38. 	}
    39. 	else{
    40. 		for(int i = 1; i <= n; i++){
    41. 			for(int j = 1; j <= m; j++){
    42. 				if(a[i][j] == '.') cout << "X";
    43. 				else cout << ".";
    44. 			}
    45. 			cout << '\n';
    46. 		}
    47. 	}
    48. }

    D Walker

    分四种情况，第一种让 A 走完全程，第二种让 B 走完全程，第三种让 A 向右走到头 B 向左走到头，前三种都直接算就可以了。第四种就有些麻烦了，在考虑完之前的情况后，只剩下在 A 和 B 之间有一个分界点，左边让 A 走，右边让 B 走，这种情况了。由于中间的位置很多，我们要利用二分来找到最优的位置（或者三分也可以，这应该是个单峰函数）。每次找到的位置我们都可以计算出左边所用的时间和右边所用的时间，如果左边比右边大，说明左边走的慢可以往左移动一些，反之就是往右。最后注意点精度问题就可以了。

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. using namespace std;
    7.  
    8. int t;
    9. double n, p1, v1, v2, p2;
    10. double ans_1, ans_2, ans_3, ans;
    11.  
    12. int check(double x){
    13.     double t1 = (min(x - p1, p1) + x) / v1;
    14.     double t2 = (min(n - p2, p2 - x) + n - x) / v2;
    15.     ans = min(ans , max(t1, t2));
    16.     if(abs(t1 - t2) <= 0.0000001) return 0;
    17.     if(t1 - t2 < 0) return -1;
    18.     return 1;
    19. }
    20.  
    21. int main(){
    22.     cin >> t;
    23.     while(t--){
    24.         cin >> n >> p1 >> v1 >> p2 >> v2;
    25.         if(p1 > p2){
    26.             swap(p1, p2);
    27.             swap(v1, v2);
    28.         }
    29.         ans_1 = (min(p1, n - p1)  + n) / v1;
    30.         ans_2 = (min(p2, n - p2)  + n) / v2;
    31.         ans_3 = max((n - p1) / v1, p2 / v2);
    32.         ans = min(ans_1, min(ans_2, ans_3));
    33.         double l = p1;
    34.         double r = p2;
    35.         while(r - l >= 0.0000001){
    36.             double mid = (l + r) / 2;
    37.             if(check(mid) < 0) l = mid;
    38.             else r = mid;
    39.         }
    40.         printf("%.10lf\n", ans);
    41.     }
    42.     system("pause");
    43. }

    E The Journey of Geor Autumn

    这道题是个 dp，我们设 dp[n] 表示在 k 的情况下的答案，那么考虑 n 个数中最小的那个数的放置情况，显然只能放在前 k 个数中，于是枚举这个数的位置。那么更新方程为:

    dp[n] = \sum_{i = 1}^{k}dp[n - i]*\textrm{C}_{n - 1}^{i - 1}*(i-1)!

    可以进一步推导一下

    dp[n] = (n-1)!\sum_{i=1}^{k}\frac{dp[n-i]}{(n-i)!}

    这里还要用前缀和优化一下，因为有除数取模，别忘了取逆元。

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. using namespace std;
    7.  
    8. const int mod = 998244353;
    9. const int maxn = 10000100;
    10. int n, k;
    11. int dp[maxn];
    12. int sum[maxn];
    13. int fac[maxn];
    14. int fav[maxn];
    15.  
    16. int q_pow(int a, int b, int p){
    17.     int cnt = 1;
    18.     while(b){
    19.         if(b & 1) cnt = 1ll * cnt * a % mod;
    20.         b >>= 1;
    21.         a = 1ll * a * a % mod;
    22.     }
    23.     return cnt;
    24. }
    25.  
    26. int main(){
    27.     cin >> n >> k;
    28.     dp[0] = dp[1] = 1;
    29.     sum[1] = 1;
    30.     sum[2] = 2;
    31.     fac[0] = 1;
    32.     for(int i = 1; i <= maxn; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
    33.     fav[maxn - 1] = q_pow(fac[maxn - 1], mod - 2, mod);
    34.     for(int i = maxn - 2; i >= 0; i--) fav[i] = 1ll * fav[i + 1] * (i + 1) % mod;
    35.     for(int i = 2; i <= n; i++){
    36.         dp[i] = 1ll * fac[i - 1] * (sum[i] - sum[max(0, i - k)]) % mod;
    37.         sum[i + 1] = (sum[i] + 1ll * dp[i] * fav[i] % mod) %mod;
    38.     }
    39.     dp[n] = (dp[n] + mod) % mod;
    40.     cout << dp[n] << '\n';
    41.     system("pause");
    42. }

    G Fibonacci

    应该是本场签到题，找规律。因为斐波那契数列的构成形式，数字从第一个开始就是：奇奇偶奇奇偶奇奇偶...所以循环节就是 3。我们假设 cnt 表示有多少个完整的循环节，siz 就是多余的奇数的个数。(2 * cnt + siz) * cnt 就是奇数 * 偶数的个数，cnt * (cnt - 1) / 2 就是偶数 * 偶数的个数。

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. using namespace std;
    7.  
    8. #define int long long
    9.  
    10. int n;
    11. int ans;
    12.  
    13. signed main(){
    14.     cin >> n;
    15.     int cnt = n / 3;
    16.     int siz = n % 3;
    17.     ans = cnt * (cnt - 1) / 2 + (2 * cnt + siz) * cnt;
    18.     cout << ans << endl;
    19. }

    I Sky Garden

    题目要我们找到 n 个以原点为圆心的同心圆，被 m 条过原点的直线切割（平分同心圆），使上面的所以交点距离之和最小。

    因为是总的和，所以我们没必要具体统计各个点之间的具体距离，直接一起考虑就可以了。

    在圆上的每个点与原点的距离和为 2 * m * (r1 + r2)

    在不同圆上的两个点的距离和为 2 * m * (r2 - r1)

    在圆上的不同点之间的距离可以分为两类

    1. 经过圆弧

    2. 经过两次半径

    处理完上述步骤后，再计算两圆上的 dis(pi, qj)，其实就是求 dis(pi, pj) + dis(pj, qj)

    最后还要考虑一种特殊情况 m = 1，要把答案减去 n * (n + 1) / 2 * 2

    具体可以看这篇题解

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. using namespace std;
    7.  
    8. const int maxn = 1010;
    9. const double pi = 3.141592654;
    10. int n, m, k;
    11. double ans;
    12.  
    13. double dis[maxn];
    14.  
    15. double cal(int r1, int r2){
    16.     return ((2 * m - 2 * k - 1) * 2 * r1 + pi / m * k * (k + 1) * r1 + (2 * m - 1) * (r2 - r1)) * 2 * m + 2 * m * (r2 - r1); 
    17. }
    18.  
    19. int main(){
    20.     cin >> n >> m;
    21.     k = 2 * m / pi;
    22.     for(int i = 1; i <= n; i++){
    23.         dis[i] = 1.0 * (2 * m - 2 * k - 1)  * i * 2 * m + pi * k * (k + 1) * i + 2 * m * i;
    24.         ans += dis[i];
    25.     } 
    26.     for(int i = 1; i < n; i++)
    27.         for(int j = i + 1; j <= n; j++)
    28.             ans += cal(i, j);
    29.     if(m == 1) ans -= n * (n + 1);
    30.     printf("%.10lf\n", ans);
    31. }

    M Gitignore

    暴力模拟就可以。我们分别从前往后统计 n 个文件路径和 m 个不能删除的文件路径。然后在 n 个里面找能删的地方。如果不能删或者删过就直接略过可以了。

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. using namespace std;
    9.  
    10. #define int long long
    11.  
    12. int n, m, t;
    13. string a, b;
    14. string str;
    15. mapint> mp;
    16. mapint> vis;
    17. vector s[1005];
    18.  
    19.  
    20. signed main(){
    21.    cin >> t;
    22.    while(t--){
    23.        vis.clear();
    24.        mp.clear();
    25.        cin >> n >> m;
    26.        for(int i = 1; i <= n; i++) s[i].clear();
    27.        for(int i = 1; i <= n; i++){
    28.            cin >> a;
    29.            int len = a.size();
    30.            str = "";
    31.            for(int j = 0; j < len; j++){
    32.                if(a[j] != '/') str += a[j];
    33.                else{
    34.                    str += '/';
    35.                    s[i].push_back(str);
    36.                }
    37.                if(j == len - 1) s[i].push_back(str);
    38.            }
    39.        }
    40.        for(int i = 1; i <= m; i++){
    41.             cin >> a;
    42.             int len = a.size();
    43.             str = "";
    44.             for(int j = 0; j < len; j++){
    45.                 if(a[j] != '/') str += a[j];
    46.                 else{
    47.                     str += '/';
    48.                     mp[str] = 1;
    49.                 }
    50.                 if(j == len - 1) mp[str] = 1;
    51.             }
    52.        }
    53.        int ans = 0;
    54.        for(int i = 1; i <= n; i++){
    55.            for(int j = 0; j < s[i].size(); j++){
    56.                if(vis[s[i][j]]) break;
    57.                else{
    58.                    if(mp[s[i][j]]) continue;
    59.                    else{
    60.                        vis[s[i][j]] = 1;
    61.                        ans++;
    62.                        break;
    63.                    }
    64.                }
    65.            }
    66.        }
    67.        cout << ans << '\n';
    68.    }
    69. }

  • 相关阅读:
    Linux学习-59-备份还原数据命令(dump、restore、dd命令)
    锂离子电池充电的系统抖动问题解决方案
    cnpm安装步骤
    MWM触摸屏工控机维修TEM-EV0 EN00-Z312yy-xx
    多肽计算符计算：modlamp 包
    Python算法——最近公共祖先
    6.1 ASP.NET Core Web 入门
    Revit翻模技巧丨怎么一次性翻转所有墙体？
    uniapp subNvue 写的视频播放
    高仿Android网易云音乐OkHttp+Retrofit+RxJava+Glide+MVC+MVVM
  • 原文地址：https://blog.csdn.net/haobowen/article/details/127534191