比赛地址：https://www.luogu.com.cn/contest/143650

P1319 压缩技术

https://www.luogu.com.cn/problem/P1319
简单的签到模拟题

#include <iostream>//c++标准库
using namespace std;
int main(){int a,n,t=0,i=0,b,s=0;//t判断有没有回车，i判断输出什么，s判断有没有输完cin>>n;while(s<n*n){cin>>a;//循环输入a；i++;for(b=a;b>=1;b--){if(t==n){cout<<endl;t=0;}//判断是否需要回车，回车后t要清零if(i%2==1)cout<<0;else cout<<1;//判断是否i不被2整除，输出0，否则输出1，注意不要回车t++;s++;//t与s加一}}cout<<endl;return 0;
}

P8598 [蓝桥杯 2013 省 AB] 错误票据

https://www.luogu.com.cn/problem/P8598
这道题是判断输入的数字是否连续和重复的，那肯定是要让数字从小到大排序才能找到中断和重复数字。那排序复杂度最少是O(nlgn)，是否有更快的方法？

因为输入的数字不是按照大小排序的，非常自然的想到哈希表去处理。用哈希表h记录出现的数字的次数，最后去遍历，如果出现了0次，说明中断了，如果出现了1次以上，说明重复了。

题目中给的数据范围是：正整数（不大于$10^5$），因此哈希表的大小是1e5 + 5。

另外要注意，如果从头遍历哈希表，前面可能有许多0，要判断更多的情况，因此可以记录下输入的最大值amax和最小值amin，在这个边界[amin,amax]里去找0和大于1的值对应的下标。

#include<bits/stdc++.h>
using namespace std;const int K = 1e5 + 5;
int h[K];
int main() {int N;cin >> N;int amin = 1e5;int amax = 0;int m, n; int x;while (N--) {while (cin >> x) {if (++h[x] > 1) n = x;amin = min(amin, x);amax = max(amax, x);}}for (int i = amin; i <= amax; i++) {if (h[i] == 0) m = i;}cout << m << " " << n;return 0;
}

P1115 最大子段和

https://www.luogu.com.cn/problem/P1115
一道经典的考研及面试题，有许多解法

要求找出连续字串的最大和，那就需要确定左右区间[l,r]，再计算这个区间和。

1.暴力

我们要枚举所有情况，也就是枚举出所有的区间情况，那么l取值是[0,len(s))，r取值是[i,len(s))，两层for循环。确定区间后，还要遍历区间所有数字计算和，那么整体的复杂度就是O(n^3)。这个复杂度非常高。

2.前缀和

上面的暴力求解中，第三步计算区间和，我们理所当然的对应前缀和的知识点，可以用前缀和通过O(1)的时间去计算区间所有数字计算和。

#include<bits/stdc++.h>
using namespace std;int maxSubarraySum(vector<int>& nums) {int n = nums.size();vector<int> prefixSum(n + 1, 0); // 前缀和数组，prefixSum[i]表示前i个元素的和for (int i = 1; i <= n; i++) {prefixSum[i] = prefixSum[i - 1] + nums[i - 1];}int maxSum = INT_MIN; // 最大和for (int i = 0; i < n; i++) {for (int j = i + 1; j <= n; j++) {int sum = prefixSum[j] - prefixSum[i]; // 计算从第i个元素到第j个元素的和maxSum = max(maxSum, sum);}}return maxSum;
}int main() {int n;cin >> n;vector<int> nums(n);for (int i = 0; i < n; i++) {cin >> nums[i];}int maxSum = maxSubarraySum(nums);cout << maxSum;return 0;
}

但是用前缀和虽然把时间复杂度降到了O(n^2)，但是依旧有的测试点过不了，我们还需要复杂度更低的代码。

3.贪心

考虑更低的复杂度，我们思考如何用O(n)的时间解决，也就是遍历一遍这个数组。

采用贪心的思想，记录最大和maxSum（当前为止最大的子串和）和当前和currentSum（当前为止选择的连续子串和）

遍历每个数时更新这两个变量。maxSum=max(maxSum,currentSum)这个没什么好说的。在更新currentSum时，如果$currentSum<0$，就说明从之前的起点$l$到当前下标$i$这段$[l,i]$的和$su{m}_{[l,i]}<0$。往后再加后面的数字$a[i+1]$时，如果$l$不变，有$su{m}_{[l,i]}+a[i+1]<a[i+1]$，那我们肯定是要舍弃$[l,i]$这一段的，从$i+1$开始重新计算，也就是令$l=i+1,currentSum=0$。

#include<bits/stdc++.h>
using namespace std;int maxSubarraySum(vector<int>& nums) {int n = nums.size();int maxSum = INT_MIN; // 最大和int currentSum = 0; // 当前和for (int i = 0; i < n; i++) {currentSum += nums[i];if (currentSum > maxSum) {maxSum = currentSum;}if (currentSum < 0) {currentSum = 0;}}return maxSum;
}int main() {int n;cin >> n;vector<int> nums(n);for (int i = 0; i < n; i++) {cin >> nums[i];}int maxSum = maxSubarraySum(nums);cout << maxSum;return 0;
}

降低复杂度之后可以通过全部的样例点。

4.动态规划

另一种思路是动态规划。

可以令$dp[i]$表示：以$i$结尾的连续子串最大和。

那么考虑所有的情况，结果应该是：$res=ma{x}_{1\le i\le n}dp[i]$。

重点是状态转移方程。遍历到$i$时，因为要求区间连续，只有两种情况：用$[l,i-1]$和不用$[l,i-1]$。如果用的话，那新的区间是$[l,i]$；如果不用，那新的区间是$[i,i]$。因此有：$dp[i]=max(dp[i-1]+a[i],a[i])$。

另外由于$dp[i]$只跟$dp[i-1]$有关，dp数组可以用滚动数组优化空间。

时间复杂度是$O(n)$，空间复杂度是$O(1)$，与贪心相同。

#include<bits/stdc++.h>
using namespace std;int main() {int n;cin >> n;int ans = INT_MIN;int dp = 0;for (int i = 1; i <= n; i++) {int x;cin >> x;dp = max(x, dp + x);ans = max(ans, dp);}cout << ans;return 0;
}

P1002 [NOIP2002 普及组] 过河卒

https://www.luogu.com.cn/problem/P1002
首先这道题如果用搜索，每个节点两种状态，需要用dfs递归很多层。因此看看能不能用动态规划去优化重复子问题。

动态规划，每个位置只能从上面或右面走到，对应两个状态转移：
$$dp[i][j]=dp[i-1][j]+dp[i][j-1]$$
另外要注意，马对应上面的位置下标有可能越界，为了方便起见，我们将所有的坐标对应的+2

#include<bits/stdc++.h> using namespace std;
long long int dp[40][40], ma[40][40];
int n, m, a, b;
int main() {cin >> n >> m >> a >> b;n += 2, m += 2, a += 2, b += 2;ma[a][b] = 1;ma[a - 1][b + 2] = 1;ma[a - 1][b - 2] = 1;ma[a + 1][b - 2] = 1;ma[a + 1][b + 2] = 1;ma[a + 2][b - 1] = 1;ma[a + 2][b + 1] = 1;ma[a - 2][b - 1] = 1;ma[a - 2][b + 1] = 1;dp[1][2] = 1;for (int i = 2; i <= n; i++) {for (int j = 2; j <= m; j++) {if (ma[i][j] == 1) {continue;}else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];}}cout << dp[n][m];return 0;
}