#include using namespace std; int arr[10]; int main(void){ for(int i = 0; i <= 9; i ++){ arr[i] = 2021; } int i; int flag = 0; for(i = 1; ; i ++){ int t = i; while(t){ int r = t % 10; arr[r] --; t /= 10; if(arr[r] < 0){ flag = 1; break; } } if(flag) break; } cout << i - 1; return 0; }

1. 当时想到一条直线可以表示成y = kx + b无非就是斜率k和截距b两个参数便可确定，使用map去重，便可得答案。but ,but，这些斜线的斜率不一定就是整数啊，即便我们用double存储，也会有精度误差，如何判断两斜线是否为同一条？即我们判断的标准何在？？判断两个数的差<10^-8次方便可认为两数相等
2. y = kx+b, 漏掉了斜率不存在的直线。最后需要加上。
3. 补充一点，我们需要拍一下序的，跟他的上一个数比较是否重复即可。

#include #include using namespace std; const int N = 200000; struct Line{ double k, b; }l[N]; bool cmp(Line a, Line b){ if(a.k != b.k) { return a.k < b.k; } return a.b < b.b; } int main(void){ int n; for(int x1 = 0; x1 < 20; x1 ++){ for(int y1 = 0; y1 < 21; y1 ++){ for(int x2 = 0; x2 < 20; x2 ++){ for(int y2 = 0; y2 < 21; y2 ++){ if(x1 != x2){ double k = (double)(y1-y2)/(x1-x2); double b = y1 - k * x1; l[n ++] = {k, b}; } } } } } sort(l, l + n, cmp); int res = 1; for(int i = 1; i < n; i ++){ if(fabs(l[i].k - l[i-1].k) > 1e-8 || fabs(l[i].b - l[i-1].b) > 1e-8){ res ++; } } cout << res + 20 << endl; return 0; }

1. 像这种题，当时直接想的暴力三重循环，开的unsigned long long。。。当时的我 艰辛 坚信只要我在循环里加足了条件，努力不让他溢出，加足了break，就会运行出来。。嗷嗷，显然，这个想法是不成熟的。。
   
2. 害，其实， 只要我们稍加优化，即把这么长的数的因子全部存起来，最后一个三重循环（长宽高）符合条件直接++即可。
   
3. 其实我们不难想到用一个数组来存，但是达不到去重的效果。是不是这个理？连续的两个三，我们第一层循环若是代表的长，我们会使用两遍3，那么长是3对应的可行方案数，也会重复，， 嗷嗷，细细品味，也到别有一番滋味
   
4. int(按照四字节计算)存储的最大正整数：21 4748 3647即21亿多点。long long （按照8字节计算）存储的最大正整数：922 3372 0368 5477 5807, 一共19位。
   

#include #include using namespace std; typedef pairPII; setst; int main(void){ long long n, i; int cnt = 0; n = 2021041820210418; for(i = 1; i * i <= n; i ++){ if(n % i == 0){ st.insert({i, 1}); st.insert({n/i, 1}); } } long longans = 0; for(auto it : st){ for(auto it2 : st){ for(auto it3 : st){ if((it.first) * (it2.first)* (it3.first) == n){ ans ++; } } } } cout << ans; return 0; }

#include #include using namespace std; vector vec; int main(void){ long long n = 2021041820210418; for(long long i = 1; i * i <= n; i ++){ if(n % i == 0){ vec.push_back(i); if(n / i != i) vec.push_back(n/i); } } int res = 0; for(auto a:vec){ for(auto b:vec){ for(auto c:vec){ if(a*b*c == n) res ++; } } } cout << res << endl; return 0; }

#include #include #include using namespace std; const int Inf = 0x3f3f3f3f; int arr[2050][2050]; int dis[2050]; //存储距离 int book[2050]; //标记数组 int gcd(int i, int j){ return i % j == 0 ? j : gcd(j, i % j); }void dijkstra(){ memset(dis, 0x3f, sizeof(dis)); dis[1] = 0; for(int i = 1; i <= 2021; i ++){ int t = -1; for(int j = 1; j <= 2021; j ++){ if(book[j] == 0 && (t == -1 || dis[t] > dis[j])) t = j; } if(t == -1) break; book[t] = 1; for(int j = 1; j <= 2021; j ++){ dis[j] = min(dis[j], dis[t] + arr[t][j]); } } } int main(void){ for(int i = 2021; i > 0; i --){ for(int j = i; j > 0; j --){ if(i - j > 21){ arr[i][j] = arr[j][i] = Inf; } else{ arr[i][j] = arr[j][i] = i / gcd(i, j) * j; } } } dijkstra(); cout << dis[2021]; return 0; }

1. 首先进行自我抨击，emmmm，我当时连1s = 1000ms,都是由样例推出来的（我还是比较纳闷，1小时等于60分钟，一分钟等于60s，为何1s = 1000ms，而不是60ms）,见笑了见笑了。。
2. 如果还是要强调的话，那便是格式化输出吧。printf("%02d:%02d:%02d\n", hh, mit, sec); 保证了均以两位输出，不足两位在数字前补上0.

#include #include using namespace std; int main(void){ long long sum; cin >> sum; sum /= 1000; //得出有多少秒 //我们想要的只是这一天的时间表示， //那必然总毫秒数应该小于24小时*60*60一天的总秒数 sum %= (24 * 60 * 60); int hh = sum / (60 * 60); sum -= (hh * 60 * 60); int mit = sum / 60; sum -= (mit * 60); int sec =sum % 60; printf("%02d:%02d:%02d\n", hh, mit, sec); return 0; }

1. 当时想着双重循环，一左一右，再加一个map记录所有的数量，最后输出map大小即可。。是啊，想法不成熟，两重循环，如何记录？双指针等在我脑子里砰砰乱跳，然而并没什么卵用。。实际上，这道题咔嚓考察的为动态规划。
   
2. 我们认为放左边为正数，不放为0，放右边为负数，每种砝码三种选择。本质为有限制的选择问题(背包问题)
   
3. 状态表示：f[i][j]表示，只从前i个物品中选，总重量为j的所有方案的集合，我们在意的是这个值是否为1【即属性值是否为为bool值】
   
4. 状态计算：f[i][j]可以由三部分构成不选w[i]（对应的为f[i-1][j]）, 选wi, 选-w[i] (放在天平右边)（对应的f[i-1][j+w[i]] 上述三种只要有一种为1，f[i][j]便为1.
   建议大家把这些状态带入定义中，便会有种豁然开朗的feel。
   设我们的输入的砝码总重量为m，最后答案便是，f[n][1到m]有多少个1即可。
   
5. 代码中需要考虑的一个小细节：当我们把所有砝码放在天平右边时，根据上述所说，对应的应该为-m,而我们的下标不能为负，所以加上一个偏移量，为砝码最大总重量。
   

#include #include using namespace std; const int N = 200010, B = N/ 2; int n, m; int w[N]; int f[110][N]; int main(void){ cin >> n; for(int i = 1; i <= n; i ++){ cin >> w[i]; m += w[i]; } f[0][B] = 1; for(int i = 1; i <= n; i ++){ for(int j = -m; j <= m; j ++){ f[i][j + B] = f[i - 1][j + B]; if(j - w[i] >= -m) f[i][j + B] |= f[i - 1][j - w[i] + B]; if(j + w[i] <= m) f[i][j + B] |= f[i - 1][j + w[i] + B]; } } int res = 0; for(int j = 1; j <= m; j ++){ if(f[n][j + B]) res ++; } cout << res; return 0; }

1. 对于杨辉三角，我们一贯的作风便是使用数组模拟，但是此题数据范围过大，使用数组会溢出，据了解，当设置的数组太大不合理时，编译失败，直接0分处理。当时我最后做的这道题,想到每行都比上一行多一个数，直接把二维数组转换成对应的一维数组，感觉很是麻烦，并且时间也不够，但依旧满足不了所有样例需要，直接枚举的1-20中的位置，悄悄的得了20%的分数。。。sure， 我还懵了一个奇偶数的规律，，，菜的也是十分安详了。。。
2. 嗯，这道题是一个规律题。

#include #include using namespace std; typedef long long LL; int n; //定义一个求组合数的函数（每个斜线的第一个数） LL C(int a, int b){ LL res = 1; for(int i = a, j = 1; j <= b; i --, j ++){ res = res * i / j; if(res > n) return res; //放置爆 long long } return res; } bool check(int k){ LL l = k * 2,r = n; //下限是2 *k, 上限是n while(l < r){ LL mid = l + r >> 1; if(C(mid, k) >= n) r = mid; else l = mid + 1; } if(C(r, k) != n) return false; cout << r * (r + 1) / 2 + k + 1; return true; } int main(void){ cin >> n; if(n == 1){ cout << 1 << endl; return 0; } for(int k = 16; ; k --){ if(check(k)){ break; } } return 0; }

1. 最简单粗暴的写法，便是对于每个输入均以sort处理，显然，对于数据量过大的会超时，但会得点分。。
2. 其实，我们很容易想到，当我们需要排序的次数很多时，难免会有几段序列不用排序却反复处理了，但具体细节的处理以及代码的落实就不是轻飘飘的几句话就可以的。
3. 我们简单的概括一下题意：一共两个操作（1-n）的排列，将某前缀降序排列，将某后缀升序。共m个操作。
   （1）对于连续的降序或升序操作，我们保留最长的一个操作即可。有效操作必然是左右交替的
   （2）我们本来输入的序列就是升序的，第一个有效操作必然是降序操作
   （3）当左侧区间长度大于上一个对左端操作时，含重复操作的区间了，我们只需要操作后一个（长度范围更大的）左区间操作即可。如下图所示：1、2操作可省去。
   
   文章图片
   
   字有些丑，行大事者不拘小节
   如果前缀操作的长度比上一个前缀操作的区间更大的话，被包含的左操作及与其对应的后缀操作可删掉。
   更加具体点说的话，我们的左操作、右操作在严格变小。每次操作，都是将（两次反转区间）的交集反转。当交集为空的话，便是填满了整个序列。

1. 我们用一个pair来存，第一个参数表示具体哪个操作，第二个参数表示下标
2. 具体细节可参见代码中注释

#include #include #include #define x first #define y second using namespace std; typedef pair PII; const int N = 100010; int n, m; PII stk[N]; int ans[N]; int main(void){ cin >> n >> m; int top = 0; while(m --){ int p, q; scanf("%d%d",&p, &q); if(!p){ //前缀操作 //两个连续的左操作 while(top && stk[top].x == 0) q = max(q, stk[top --].y); //删掉前边比当前操作小的左端操作及其对应的右端操作 while(top >= 2 && stk[top - 1].y <= q) top -= 2; stk[++ top] = {0, q}; } else if(top){ //当第一个操作为右端操作时，没有必要处理 while(top && stk[top].x == 1) q = min(q, stk[top --].y); while(top >= 2 && stk[top - 1].y >= q) top -= 2; stk[++ top] = {1, q}; } } int k = n, l = 1, r = n; //从前往后遍历所有操作 for(int i = 1; i <= top; i ++){ //第一个操作为前缀降序操作，该区间右端的数是可以固定的了。 if(stk[i].x == 0) while(r > stk[i].y && l <= r) ans[r --] = k --; else while(l < stk[i].y && l <= r) ans[l ++] = k --; if(l > r) break; } if(top % 2){ //做完了右区间，还剩一个左区间。 //剩下的左区间操作为降序，我们从左边开始填。 while(l <= r) ans[l ++] = k --; } else{ while(l <= r) ans[r --] = k --; } for(int i = 1; i <= n; i ++){ printf("%d ", ans[i]); } return 0; }

1. 首先进行自我抨击，，呜呜呜呜呜。。也是菜的不行不行了。。我当时不成熟的思路是这样的，输入的一段序列计算出左右括号的差，这便是最少需要插入的个数了，然后进行搜索，对于每个插完指定位数的序列，进行括号是否配对检验，即写一个check函数（栈的应用嘛），然后ans++； 啪啪打脸，写出一个死循环不说，像这种序列)))(((计算出的差为0，是不是就不需要插入括号了？！ 想法很是幼稚。。
   
2. 慌的一批，这题咔嚓的是动态规划。。。且听我慢慢道来
   
3. 一个合法括号序列满足：左右括号数量相同 和任何一个前缀中，左括号数量不小于右括号数
   
4. 我们不会同时添加一对左右括号，因为在一个合法括号配对序列中，去掉某对括号，剩下的还是合法的、配对的。因此，我们添加左右括号是独立的。
   
5. 从前往后扫描，当前左括号比右括号多几个，当cnt小于0时，我们必须添加一个左括号cnt=0，最后添加的右括号数量=cnt，添加的左括号可用一个另变量存储。两个相加，就是最少添加的括号数量。
   
6. 方案数可以独立来看，先添加左括号，再添加右括号。左括号最少添加数量对应的方案数，右括号最少添加数量的方案数相乘即可。（我们考虑左右括号添加是否会有干扰，当添加的位置（相对原序列而言）在同一个空隙里添加左括号、右括号，一定是))((右括号在前，左括号在右； 因为如果是()左括号在前右括号在右，这就是一对匹配的括号，当我们去掉这一对时，不会有影响，但把原序列变成合法后插入的括号数就不是最少的了， 因此左右括号插入是独立的）
   
7. 如果只添加左括号，如何保证不重复呢？将序列按照右括号分割可以分成若干段，每段而言，不同的便是左括号的数量。最后一段内一定不会加左括号,因为最后一段满足cnt>0
   ，因此我们在添加左括号的时候，规定只能在右括号前添加左括号，这样就能保证不重复。
   
8. 状态表示：f[i][j] 表示只考虑前i个括号，左括号比右括号多j个的所有方案的集合。f[i][j] = k k表示方案数量
   
9. 保证添加的括号数最少，f[n][0]...f[n][n]一直枚举即可 。左括号比右括号最多多n个嘛。一定至少会有一个非空集合。
   
10. 状态计算：
    (1)f[i][j]当前是左括号s[i]=’(’, f[i][j] = f[i - 1][j - 1]
    (2)当前是右括号，可以考虑往这个右括号前面加左括号，可以是0-j+1个（根据定义，左括号比右括号多j个，这个位置又是一个右括号所以需要再+1，嘛），f[i][j] = f[i - 1][j + 1] + f[i-1][j] + f[i-1][j - 1] .... + f[i-1][0] 类似于完全背包，f[i][j - 1] = f[i - 1][j] + f[i-1][j - 1] + ...f[i-1][0] 所以：f[i][j] = f[i][j-1] + f[i - 1][j+1]
    

#include #include #include using namespace std; typedef long long LL; const int N = 5010, MOD = 1e9 + 7; int n; char str[N]; int f[N][N]; LL calc(){ memset(f, 0, sizeof(f)); f[0][0] = 1; for(int i = 1; i <= n; i ++){ if(str[i] == '(') { for(int j = 1; j <= n; j ++){ f[i][j] = f[i-1][j-1]; } } else{ f[i][0] = (f[i-1][0] + f[i-1][1]) % MOD; for(int j = 1; j <= n; j ++){ f[i][j] = (f[i - 1][j + 1] + f[i][j - 1]) % MOD; } } } for(int i = 0; i <= n; i ++){ if(f[n][i]) return f[n][i]; } return -1; }int main(void){ scanf("%s", str+1); n = strlen(str+1); LL l = calc(); //左括号的做法 reverse(str + 1, str+n+1); //右括号的做法，将整个序列反转，左括号变成右括号，调用相同函数即可。 for(int i = 1; i <= n; i ++){ if(str[i] == '(') str[i] = ')'; else str[i] = '('; } LL r = calc(); printf("%lld", l * r % MOD); return 0; }

推荐阅读

• 

  翻车|“苹果 iPhone13 拍照翻车自带炫屏”上热搜
• 

  【龙撼乾坤】第二十四章|【龙撼乾坤】第二十四章 炼制丹药
• 

  java工厂模式主要代码 java中的工厂模式的面试题
• 

  持续多久不抽烟，才算戒烟成功了呢？医生给你准确答案
• 

  priceline盈利模式分析
• 

  yy直播频道内所应用加载失败
• 

  干香菇泡太久的危害
• 

  我搞微商的,有什么软件可以批量添加微信好友？
• 

  还要有多久
• 

  另一个伊甸61章空中城郭伊斯亚攻略 另一个伊甸61章空中城郭伊斯亚怎么过
• 

  长期服用火麻仁有什么副作用 火麻茶的功效与作用
• 

  Unreal|Unreal Engine 4 C++ UMG自定义控件
• 

  中国笔画最多的汉字大合集 笔画最多的字
• 

  电竞专业包括什么 电竞专业主要学什么的
• 

  iPhone天线门解析 手机体验是什么软件
• 

  下载发音
• 

  仪表盘上的normal 汽车仪表盘normal是什么意思
• 

  安卓应用后台,如何在手机充电状态下关闭应用?
• 

  如何找到孩子的兴趣点 如何找到孩子的兴趣，如何找到孩子的兴趣和擅长的事
• 

  南京贿赂公职人员怎么定罪，贿赂公职人员什么罪

• 数据结构之究竟什么是树
• 笔记|volatility安装、内存取证常见知识点及例题讲解(已进行两次更新)
• 2021年施工员-市政方向-通用基础(施工员)找解析及施工员-市政方向-通用基础(施工员)试题及解析
• 2021年质量员-市政方向-通用基础(质量员)免费试题及质量员-市政方向-通用基础(质量员)考试技巧
• 毕业设计|基于springboot的学生毕业选题管理系统
• linux|ubuntu20.04安装微信和QQ,腾讯会议,以及一些其他实用软件
• 笔记|单调栈详解-基于LeetCode的题目
• 笔记|LeetCode每日一题题解（1189. “气球” 的最大数量）
• 笔记|LeetCode每日一题题解（917. 仅仅反转字母-双指针-python和C++）