A Eshag Loves Big Arrays

题目大意

给定一个长度为 n 的正整数数组 a ，现在可执行若干次操作（可为 0）

具体操作为：选定某个序列，删除严格大于序列的平均数的元素

请问最多能删去多少个元素

主要思路

最多能删去除最小值元素以外的所有元素，所以统计最小值个数即可

  1. #include <iostream>
  2. #include <cstring>
  3. #include <string>
  4. #include <algorithm>
  5. #include <stack>
  6. #include <string>
  7. #include <unordered_map>
  8. #include <set>
  9. #include <queue>
  10. using namespace std;
  12. #define int long long
  13. #define debug(a) cout << #a << " = " << a << endl;
  14. #define x first
  15. #define y second
  16. typedef pair<int, int> P;
  18. const int N = 200010;
  19. int n, a[N];
  20. int st[N];
  22. signed main(void)
  23. {
  24.     ios::sync_with_stdio(false);
  25.     int T;
  26.     cin >> T;
  27.     while(T--)
  28.     {
  29.         memset(st, 0, sizeof st);
  30.         cin >> n;
  31.         for(int i = 0; i < n; i++) cin >> a[i], st[a[i]]++;
  32.         int maxa = 0, ans = 0;
  33.         for(int i = 1; i <= 100; i++)
  34.         {
  35.             if(st[i])
  36.             {
  37.                 maxa = st[i];
  38.                 break;
  39.             }
  40.         }
  41.         cout << n - maxa << endl;
  42.     }
  43.     return 0;
  44. }

B Sifid and Strange Subsequences

题目大意

先有一个长度为 n 的数组，定义“奇怪数组”：数组中任意两个元素的绝对值差值大于等于数组中的最大值，即 |ai−aj|>=Max ，请问由原数组中最大能选出多少个元素构成“奇怪数组”

主要思路

首先先找性质，发现该数列至多有一个正数，反证法假设该数列存在两个正数x, y那么|x - y|一定小于max(x, y)，所以至多存在一个正数，所以我们先统计出小于等于0的数的个数，并且维护所有小于等于0的数差的最小值，判断最小的正数是否满足性质即可

  1. #include <iostream>
  2. #include <cstring>
  3. #include <string>
  4. #include <algorithm>
  5. #include <stack>
  6. #include <string>
  7. #include <unordered_map>
  8. #include <set>
  9. #include <queue>
  10. using namespace std;
  12. #define int long long
  13. #define debug(a) cout << #a << " = " << a << endl;
  14. #define x first
  15. #define y second
  16. typedef pair<int, int> P;
  18. const int N = 200010;
  19. int n, a[N];
  20. int st[N];
  21. int b[N];
  23. signed main(void)
  24. {
  25.     ios::sync_with_stdio(false);
  26.     int T;
  27.     scanf("%lld", &T);
  28.     while(T--)
  29.     {
  30.         memset(b, 0, sizeof(b));
  31.         scanf("%lld", &n);
  32.         int res = 0;
  33.         int mina = 1e9+1;
  35.         for(int i = 0; i < n; i++)
  36.         {
  37.             scanf("%lld", &a[i]);
  38.             if(a[i] <= 0) b[res++] = a[i];
  39.             else mina = min(mina, a[i]);
  40.         }
  41.         sort(b, b + res);
  42.         int cnt = 1e9;
  43.         for(int i = 1; i < res; i++) cnt = min(cnt, b[i] - b[i - 1]);
  45.         if(cnt >= mina && res < n) res++;
  47.         printf("%lld\n", res);
  48.     }
  49.     return 0;
  50. }

C Parsa’s Humongous Tree

题目大意

给你一棵树，树上的每个节点 i 都有一个值域 [li,ri] ，我们需要从值域中确定一个值 ai∈[li,ri] ，而 (u,v)(u,v) 边权值则为∣au−av∣ 。我们的目的就是要让所有的边权值之和最大。求出最大权值之和。

主要思路

树形dp，首先考虑性质，我们发现在中间的数不管选取区间内任意一个点与左右两点距离和都相同，所以我们只需考虑选取左端点和右端点，dp[i] [0]表示当前i这个点选取左端点且由后面子树更新的最大值，dp[i] [1]表示当前i这个点选取右端点且由后面子树更新的最大值。

  1. #include <iostream>
  2. #include <cstring>
  3. #include <string>
  4. #include <algorithm>
  5. #include <stack>
  6. #include <string>
  7. #include <unordered_map>
  8. #include <set>
  9. using namespace std;
  10. #define int long long
  11. const int N = 1e6 + 50;
  12. typedef long long LL;
  14. int e[N], ne[N], h[N], idx;
  16. void add(int a, int b)
  17. {
  18.     e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
  19. }
  21. int l[N], r[N];
  23. int t, n;
  25. int dp[N][2];
  28. void dfs(int u, int father)
  29. {
  30.     for(int i = h[u]; ~i; i = ne[i])
  31.     {
  32.         int j = e[i];
  33.         if(j == father) continue;
  34.         dfs(j, u);//递归，由子树更新父元素
  35.         dp[u][0] += max(dp[j][0] + abs(l[u] - l[j]), dp[j][1] + abs(l[u] - r[j]));
  36.         dp[u][1] += max(dp[j][0] + abs(r[u] - l[j]), dp[j][1] + abs(r[u] - r[j]));
  37.     }
  38. }
  40. signed main()
  41. {
  42.     cin >> t;
  43.     while (t -- ) {
  44.         memset(h, -1, sizeof h);
  45.         memset(dp, 0, sizeof dp);
  46.         scanf("%lld", &n);
  47.         for (int i = 1; i <= n; i ++ ) scanf("%lld%lld", &l[i], &r[i]);
  48.         for (int i = 0; i < n - 1; i ++ ) {
  49.             int a, b;
  50.             scanf("%lld%lld", &a, &b);
  51.             add(a, b);
  52.             add(b, a);
  53.         }
  54.         dfs(1, -1);
  55.         printf("%lld\n", max(dp[1][0], dp[1][1]));
  56.     }
  57.     return 0;
  58. }

D Kavi on Pairing Duty

给你一个长度n，数轴上有2n个点，定义一个好的配对，满足一下两个条件中一个即可：

  • 其中一部分A和B完全位于另一部分内部。
  • A和B长度相同。

问长度为n时，好的配对数量是多少

主要思路

设 dpi 为 2i点的良好配对数。
显然，答案是 dpn 。

dp[i] = i的约数+dp前i-1个数的和

当所有区间长度相同时，方案数是i的约数

当所有区间长度不同时，由不同长度的方案转移到长度为i的方案一定都不相同

  1. #include <iostream>
  2. #include <cstring>
  3. #include <string>
  4. #include <algorithm>
  5. #include <stack>
  6. #include <string>
  7. #include <unordered_map>
  8. #include <set>
  9. #include <queue>
  10. using namespace std;
  12. #define int long long
  13. #define debug(a) cout << #a << " = " << a << endl;
  14. #define x first
  15. #define y second
  16. typedef pair<int, int> P;
  18. const int N = 1000010, mod = 998244353;
  19. int n, dp[N];
  21. signed main(void)
  22. {
  23.     ios::sync_with_stdio(false);
  24.     cin >> n;
  25.     for(int i = 1; i <= n; i++)//计算i这个数是哪个数的约数
  26.     {
  27.         for(int j = i; j <= n; j += i) dp[j]++;
  28.     }
  29.     //刚开始dp[i]表示i这个数的约数个数
  30.     int s = 0;//初始化从1开始dp[i]的和
  31.     dp[0] = 1;//初始化dp[0] = 1
  32.     for(int i = 1; i <= n; i++)
  33.     {
  34.         dp[i] = (dp[i] + s) % mod;
  35.         s = (s + dp[i]) % mod;
  36.     }
  37.     cout << dp[n] << endl;
  38.     return 0;
  39. }