CSP集训错题集 第三周
F
这一题如果采用O(n^2)暴搜，显然TLE。如果你知道前缀和，爆搜前缀和，一样TLE。
然后——有什么办法呢？这就是知识储备和经验的问题了。这题采用的是同余的方法。
我们可以推导：如果Ai到Aj是k倍区间，那么Sj-S(i-1)也是k倍区间，那么(Sj-S(i-1))%k==0。
能想到这一步，信息量就很大了。如果我们所有的前缀和都对k取模，那么需要满足Sj＝＝S(i-1)。
但是怎么计算总和呢？这也是个独立的技巧——我们需要一个计数器数组a，出现了s[i]，那么a[s[i]]++，代表遍历到s[i]这个数，数在前面出现了几次。
举个例子：假设前面出现了3次SpSqSm，那么现在又来一次Sn，这次的n和p、q、m相减，都能得到k倍区间，所以k倍区间多了原来的a[s[i]]次。
这样遍历就可以把复杂度降成O(n)。
Code
#include<iostream>
using namespace std;
long long n,k,cnt=0;
long long a=0,b[100005]={0},c[100005]={0};
int main()
{ios::sync_with_stdio(0);cin.tie(0);cin>>n>>k;for(int i=1;i<=n;i++){cin>>a;b[i]=(b[i-1]+a)%k; //找余数 }for(int i=0;i<=n;i++){//要带上0 cnt+=c[b[i]];//b[i]是同余数本身，求和先前同余的数量 c[b[i]]++;}cout<<cnt<<endl;return 0;
}H
这题就是显然的区间覆盖问题。在每一个[si,ti]区间内覆盖了bi的内容。
我一开始的思路，居然是想着排序，按照si优先的原则遍历每一条数据。做成了不记数的纯覆盖问题。这题行不通。
这题实际上应该按照时间顺序遍历。时间本来就只有 0－1000这么小一个区间！
这需要一个算法：差分。
毕竟仔细想想，si就是开头，后面的时间都得加上bi；ti结束，后面的都得减去bi。
差分的意思就是在一个数组a里，把si标上+bi，ti+1标上-bi，然后对这个数组求前缀和做b数组，那么b是a的前缀和，a是b的差分。这是互逆运算。
Code
#include<iostream>
#include<algorithm>
using namespace std;
int n,s,t,b;
int bucket[1005]={0};int main()
{ios::sync_with_stdio(0);cin.tie(0);cin>>n;for(int i=1;i<=n;i++){cin>>s>>t>>b;bucket[s]+=b;bucket[t]-=b;}int nowbkt=0,ans=0;for(int i=0;i<=1001;i++){nowbkt+=bucket[i];ans=max(ans,nowbkt);}cout<<ans<<endl;return 0;
}
J
这个函数实现起来就按照题意就行，考验编写递归函数的水平。
但是，如果这么多测试用例，每个用例都来递归，那么是吃不消的。所以需要一个“记忆化搜索”。
我理解到的意思就是把结果存进数组，递归调用时，如果之前已经算过，那么直接return数组存的结果；如果之前没算过，那就递归算下去传回来，然后把这个点的结果存到数组里，再return。数组就是 三位数组a[25][25][25]，不会爆内存。
这些我自己都想到了，可是偏偏又倒在一个神奇的点——函数的参数类型必须是long long。因为我找到了一个测试用例，2147483647 1 1。然后测试发现穿进去的从正数变成了负数，应该是int参数的一个什么原理。
Code
#include<iostream>
using namespace std;
long long n,k,x,y,z;
long long m[25][25][25]={0};
long long dfs(long long a, long long b, long long c);
int main()
{ios::sync_with_stdio(0);cin.tie(0);m[0][0][0]=1;cin>>x>>y>>z;while( !(x==-1&&y==-1&&z==-1) ){cout<<"w("<<x<<", "<<y<<", "<<z<<") = "<<dfs(x,y,z)<<endl;cin>>x>>y>>z;}return 0;
}
long long dfs(long long a, long long b, long long c){//输入参数也得long long //cout<<a<<' '<<b<<' '<<c<<endl;if( a<=0 || b<=0 || c<=0 ){if(a>=0&&b>=0&&c>=0) m[a][b][c]=1;return m[0][0][0];}else if( a>20 || b>20 || c>20 ){if(m[20][20][20])return m[20][20][20];elsereturn dfs(20,20,20);}else if(a<b&&b<c){if(!m[a][b][c-1]){dfs(a,b,c-1);}//平行，不加else if(!m[a][b-1][c-1]){dfs(a,b-1,c-1);}if(!m[a][b-1][c]){dfs(a,b-1,c);}m[a][b][c]=m[a][b][c-1]+m[a][b-1][c-1]-m[a][b-1][c];return m[a][b][c];}else {if(!m[a-1][b][c]){dfs(a-1,b,c);}if(!m[a-1][b-1][c]){dfs(a-1,b-1,c);}if(!m[a-1][b][c-1]){dfs(a-1,b,c-1);}if(!m[a-1][b-1][c-1]){dfs(a-1,b-1,c-1);}m[a][b][c]=m[a-1][b][c]+m[a-1][b-1][c]+m[a-1][b][c-1]-m[a-1][b-1][c-1];return m[a][b][c];}return 1;
}
L
这一题我一开始想的是纯二分dfs，然后求每一段的最大连续区间，但是它不能正确处理横跨左右两半区的无重复子数组。
正确解法还是记忆化搜索，开一个pos数组记录上一个a[i]的位置。如果遇到冲突了，回溯到上一个位置的下一处位置，继续遍历，记住i的值是需要改回去的。
如果你还不理解，可以用这么一个测试点来举例：
7
3 2 1 2 4 5 6
如果你搜索到了第4个位置的2，之前已经被读过了，那么你需要回退到上一个2的右边一个位置，也就是1的位置。如果不开记忆化搜索，那么可能就从这个2开始往下找了，而没法带上前面的1。
Code
#include<iostream>
#include<cstring>
using namespace std;
long long n,l,r,ans=0;
long long a[100005]={0},pos[100005]={0};
bool b[100005]={0};int main()
{ios::sync_with_stdio(0);cin.tie(0);cin>>n;for(int i=1;i<=n;i++){cin>>a[i];} l=1;for(int i=1;i<=n;i++){if(b[a[i]]){ans=max(i-l,ans);i=pos[a[i]]+1;//从本位置开始 l=i;memset(b,0,sizeof(b));}b[a[i]]=1; pos[a[i]]=i;//记忆上一个位置的指针 }ans=max(n+1-l,ans);cout<<ans;return 0;
}