include include include include using namespace std; int N, A, B; vector K; vector visited; int min_steps = INT_MAX; // 记录全局最优解 void dfs(int current_floor, int steps) { // 1. 剪枝：如果当前步数已经超过已知最优解，没必要继续 if (steps >= min_steps) { return; } // 2. 结束条件：到达目标 if (current_floor == B) { min_steps = min(min_steps, steps); return; } // 3. 获取当前楼层的“魔力数字” int step_size = K[current_floor]; // 如果当前楼层数字为0，无法移动，死胡同 if (step_size == 0) return; // --- 尝试上升 --- int next_up = current_floor + step_size; if (next_up = 1 && !visited[next_down]) { visited[next_down] = true; // 标记 dfs(next_down, steps + 1); visited[next_down] = false; // 回溯 } } int main() { // 输入 cin >> N >> A >> B; K.resize(N + 1); // 1-based indexing for (int i = 1; i > K[i]; } // 初始化 visited.resize(N + 1, false); visited[A] = true; // 标记起点已访问 // 开始搜索 dfs(A, 0); // 输出 if (min_steps == INT_MAX) { cout << -1 << endl; } else { cout << min_steps << endl; } return 0; }

```cpp #include <bits/stdc++.h> using namespace std; #define ll long long int main() { string s; if (!(cin >> s)) return 0; int ans = 0; int lzone = 0, mzone = 0, szone = 0; for (int i = 0; i < s.length(); i++) { if (s[i] == 'L') lzone++; else if (s[i] == 'M') mzone++; else szone++; } int lstart = 0, lend = lzone - 1; int mstart = lzone, mend = lzone + mzone - 1; int sstart = lzone + mzone, send = (int)s.length() - 1; int minl = 0, sinl = 0, linm = 0, sinm = 0, lins = 0, mins = 0; for (int i = lstart; i <= lend; i++) { if (s[i] == 'M') minl++; else if (s[i] == 'S') sinl++; } for (int i = mstart; i <= mend; i++) { if (s[i] == 'L') linm++; else if (s[i] == 'S') sinm++; } for (int i = sstart; i <= send; i++) { if (s[i] == 'M') mins++; else if (s[i] == 'L') lins++; } ans += min(lins, sinl) + min(linm, minl) + min(sinm, mins); // 每三本形成一个环的书需要两次交换 ans += (abs(lins - sinl) + abs(linm - minl) + abs(sinm - mins)) / 3 * 2; cout << ans; return 0; } ``` 本质上就是先按L,M,S分块，本来在对应块里的不用动，优先换互相占了对方位置的书，这样换一次就能使两本书到对应位置，剩下的书每三本成环，每个环要交换两次

include using namespace std; int main(){ ios::sync_with_stdio(false); cin.tie(nullptr); string s,t;//定义string类型的变量s和t，s用来输入数字序列，t用来存放后续提取的子串 int sd;//sd用来将提取的数字子串转换为数字，对应上26个字母的下标 cin>>s; char zm[27]={'0','A','B','C','D','E','F','G','H','I','J','K','L','M', 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}; //创建字母数组，注意A从下标为1的地方开始 for(int i=0;i =1&&sd<=26)//判断如果数字在1-26之间，那我们可以直接输出这个数字下标对应的字母 { cout<<zm[sd]; i++;//完成之后i要加1,因为进入这个if条件意味着我们提取的是两位数字字符 //之后for循环里面也还要加1，下一个子串从已经提取过后的剩下的子串的第一位开始提取 } else//如果提取的两位字符转为数字后超出了字母的下标范围 { t=s.substr(i,1);//这时我们只提取一位数字字符放入t当中 sd=stoi(t);//将其转换为数字 cout<<zm[sd];//输出其对应下标的字母 } } return 0; }

include using namespace std; int main(){ ios::sync_with_stdio(false); cin.tie(nullptr); int n,c,t; cin>>n; vector a[n+1];//创建了n+1个vector对象，也就是一维数组a的每个元素都是vector for(int i=1;i >c;//输入数组的大小 while(c--)//利用while循环c次，将对应的数组元素推入每一个数组 { cin>>t; a[i].push_back(t); } sort(a[i].begin(),a[i].end());//每完成一次就先将当前数组排序 } sort(a+1,a+n+1);//按字典序对n个数组进行排序，因为数组一旦创建，下标就是从0开始的 //而我们在存数据的时候是从1开始的，所以要使用a+1,至于a+n+1,因为C++的 sort(first, last) 排序范围是 [first, last)， //包含first，不包含last,所以sort的第二个参数要指向最后一个元素的下一个位置，是 a+n+1 for(int i=1;i<=n;i++) { for(int j=0;j<a[i].size();j++) { cout<<a[i][j]<<" ";//输出数组元素 //i代表是第i组数组，j代表是第i组数组的第j个元素 } cout<<endl; } return 0; }

include using namespace std; bool check(int num) { while(num>0) { if(num%10==2||num%10==4) { return false; } num/=10; } return true; } int main() { int count=0; for(int i=1;i i for(int j=i+1;j j,同时利用数学关系k=2019-i-j，不需要第三层循环 int k=2019-i-j; //必须保证k>j，否则会出现重复或者数字相同的情况 if(k<=j) break; if(check(k)) { count++; } } } cout<<count<<endl; return 0; }

```cpp #include <bits/stdc++.h> using namespace std; int main(){ ios::sync_with_stdio(false); cin.tie(nullptr); string str1; char ch; getline(cin,str1);//如果用cin的话就只能通过90% cin>>ch; for(int i=0;i<str1.length();i++) { if(str1[i]!=ch) cout<<str1[i]; } return 0; } ```

```cpp // 请把代码粘贴在这里 ``` include using namespace std; int n,k; int maxn; int H[100010]; int W[100010]; int l,r,mid; int sum,ans; /猜想：二分难道是从11到以小明所拥有的最大巧克力的较小边为边长的正方形， 以1为左端点，以上述正方形的边长为右端点？取mid值，判断是否能切出等大的K块正方形巧克力， 如果可以，则将左指针向右移一位，再取mid,如果不可以，右指针向左移动一位，取mid, 要设置变量ans存储mid值，直到左指针>右指针,最后一次二分ans保留的值，即为最大边长/ / 问题：可最大边一定不行，除非是正方形，并且这n块巧克力必须全这么大，不剪枝吗，等等，难道是担心这两条边之间的边长可能符合要求？ 回答：在二分查找里，右边界表示的是：搜索范围的上限，而不是答案可能的最大值 / bool check(int x) { //注意：sum要清0 sum=0; for(int i=0;i =k) { return true; }else{ return false; } } int main() { cin>>n>>k; for(int i=0;i >H[i]>>W[i]; maxn=max(H[i],maxn); maxn=max(W[i],maxn); //不断更新最大边，存入maxn } l=1; r=maxn; while(l<=r) { mid=(l+r)/2; if(check(mid)) { ans=mid; l=mid+1; }else { r=mid-1; } } cout<<ans<<endl; return 0; }

emmmm既然要最后两个数组一样 那么他们的长度必须一样，而且只能有合并操作，那么合并一次长度减一，在第二个数组不进行合并的情况下，直接用两个数组长度相减就是答案。而且由题目可以得到，第二个数组不进行任何操作的情况也是正解 ``` #include<bits/stdc++.h> using namespace std; typedef long long ll; typedef struct point{ int x; int y; }point; int main(){ int n,m; cin>>n>>m; int arr[n+10]; int brr[m+10]; for(int i=1;i<=n;i++) cin>>arr[i]; for(int j=1;j<=m;j++) cin>>brr[j]; cout<<abs(n-m)<<endl; return 0; } ```

动态规划+前后缀预处理优化 dp[i][j] 为，匹配到t串的第i个字符，且当前在s串下标j的最小路程和，（转为滚动数组） ``` #include <bits/stdc++.h> using namespace std; const int INF = 1e9; int main() { ios::sync\_with\_stdio(false); cin.tie(nullptr); cout.tie(nullptr); ios::sync\_with\_stdio(false); int n, m, l; string s, t; cin >> n >> m >> l; cin >> s >> t; vector<vector<int>> mp(26); for (int i = 0; i < n; ++i) { mp[s[i] - 'a'].push\_back(i); } // 初始化滚动数组 vector<int> prev\_dp(n, INF); int first\_char = t[0] - 'a'; for (int pos : mp[first\_char]) { prev\_dp[pos] = 0; } int ans = 1; // 至少能匹配第一个字符 for (int i = 1; i < m; ++i) { int curr\_c = t[i] - 'a'; int prev\_c = t[i-1] - 'a'; auto& prev\_pos = mp[prev\_c]; auto& curr\_pos = mp[curr\_c]; if (prev\_pos.empty() || curr\_pos.empty()) break; // 预处理前缀最小值和后缀最小值 int k\_prev = prev\_pos.size(); vector<int> prefix\_min(k\_prev, INF); vector<int> suffix\_min(k\_prev, INF); // 计算前缀最小值（dp[p] - p） int min\_val = INF; for (int k = 0; k < k\_prev; ++k) { int p = prev\_pos[k]; min\_val = min(min\_val, prev\_dp[p] - p); prefix\_min[k] = min\_val; } // 计算后缀最小值（dp[p] + p） min\_val = INF; for (int k = k\_prev - 1; k >= 0; --k) { int p = prev\_pos[k]; min\_val = min(min\_val, prev\_dp[p] + p); suffix\_min[k] = min\_val; } vector<int> curr\_dp(n, INF); bool found = false; for (int j : curr\_pos) { // 寻找最大的k <= j auto it = upper\_bound(prev\_pos.begin(), prev\_pos.end(), j); int idx = it - prev\_pos.begin() - 1; int left\_cost = INF; if (idx >= 0) { left\_cost = prefix\_min[idx] + j; } // 寻找最小的k >= j it = lower\_bound(prev\_pos.begin(), prev\_pos.end(), j); int idx2 = it - prev\_pos.begin(); int right\_cost = INF; if (idx2 < k\_prev) { right\_cost = suffix\_min[idx2] - j; } int best = min(left\_cost, right\_cost); if (best <= l) { curr\_dp[j] = best; found = true; } } if (found) { ans = i + 1; // 更新最大匹配长度 prev\_dp.swap(curr\_dp); } else { break; // 无法继续匹配，提前终止 } } cout << ans << '\\n'; return 0; } ```