一、字符串输入
while (true)
{
c=getchar();
if (c=='\n' || c=='\r') break;
l++;
s[l]=c;
}以上效果等同于gets()，getline()；
如果要读单个字符，也可以讲其存在字符数组当中；
二、字符串匹配问题
scanf("%s",s1+1);
scanf("%s",s2+1);
int l1=strlen(s1+1),l2=strlen(s2+1);
1、暴力匹配=find()
for (int a=1;a+l2-1<=l1;a++)
{
bool same=true;
for (int b=0;b<l2;b++)
if (s1[a+b] != s2[b+1])
{
same=false;
break;
}
cout << same << endl;
}2、逆序暴力
for (int a=1;a+l2-1<=l1;a++)
{
bool same=true;
for (int b=l2-1;b>=0;b--)
if (s1[a+b] != s2[b+1])
{
same=false;
break;
}
cout << same << endl;
}以上均为玄学做法，在数据范围较大的时候并没有什么用；
3、字符串Hash
此为半玄学做法，就是将字符串转化为数字进行比较。因为数字可能会很大，因此通常采用%一个数的方法解决，也可以让系统自己%；
（1）系统自模%
#define ull unsigned long long
const int maxn=100010;
const ull base = 10007;
ull bit[maxn];
ull h1[maxn]，h2[maxn];
ull get_hash(int l,int r)
{
return h1[r]-h1[l-1]*bit[r-l+1];
}
cin >> s1+1 >> s2+1;
int l1=strlen(s1+1);
int l2=strlen(s2+1);
bit[0]=1;
for (int a=1;a<=max(l1,l2);a++)
bit[a] = bit[a-1]*base;
for (int a=1;a<=l1;a++)
h1[a] = h1[a-1]*base + s1[a];
for (int a=1;a<=l2;a++)
h2[a] = h2[a-1]*base + s2[a];
for (int a=1;a+l2-1<=l1;a++)
{
//s1[a,a+l2-1]
//s2[1,l2]
ull m=get_hash(a,a+l2-1);
if(m==h2[l2])
{
return ture;
}
}在数据超出long long范围后，系统会自动把数据%2^64，直到小于范围；
（2）单模
const int mo=1000000007;
const int base=10007;
int h[maxn],bit[maxn];
bit[0]=1;
for (int a=1;a<=n;a++)
bit[a]=(long long)bit[a-1]*base%mo;
for (int a=1;a<=n;++a)
h[a]=((long long)h[a-1]*base+s[a])%mo;手动模一个大质数；base即为可以任意定义的进制数，习惯10000左右；
（3）双模
#include<algorithm>const int mo1=1000000007;
const int mo2=1000023837;
const int base1=10086;
const int base2=10086;
pair<int,int> h[maxn],bit[maxn];
bit[0] = make_pair(1,1);
for (int a=1;a<=n;a++)
bit[a] = make_pair((long long)bit[a-1].first*base1%mo1,(long long)bit[a-1].second*base2%mo2)
for (int a=1;a<=n;a++)
h[a] = make_pair(((long long)h[a-1].first*base1+s[a])%mo1,((long long)h[a-1].second*base2+s[a])%mo2);显然就是要模两个大质数。这里调用了二元函数，需要algorithm库。如果不适用此函数，再开两个数组也能实现；
正确性：3>1>2；
运行速度：1>2>3；
正常来说使用系统自模即可，如果是POI即波兰人出的题，可以使用双模；
P3370 【模板】字符串哈希点击打开链接
例1：系统自模
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ull long long
using namespace std;
const int base=10086;
char s[2001];
ull a[20001];
int n;
ull get_hash(char s[],ull x)
{
ull ans=0;
for(int i=0;i<x;i++)
{
ans+=ans*base+(ull)s[i];
}
return ans;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%s",s);
int l=strlen(s);
a[i]=get_hash(s,l);
}
sort(a+1,a+n+1);
int tot=0;
for(int i=2;i<=n;i++)
{
if(a[i]!=a[i-1]) tot++;
}
printf("%d",tot+1);
}例2：单模
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ull long long
using namespace std;
const int base=10086;
const int mo=100000007;
char s[2001];
ull a[20001];
int n;
ull get_hash(char s[],ull x)
{
ull ans=0;
for(int i=0;i<x;i++)
{
ans+=(ans*base+(ull)s[i])%mo;
}
return ans;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%s",s);
int l=strlen(s);
a[i]=get_hash(s,l);
}
sort(a+1,a+n+1);
int tot=0;
for(int i=2;i<=n;i++)
{
if(a[i]!=a[i-1]) tot++;
}
printf("%d",tot+1);
}例3：双模
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ull long long
using namespace std;
const int base=10086;
const int mo1=100000007;
const int mo2=100007643;
const int maxn=20001;
char s[2001];
int n;
pair<ull,ull> a[maxn];
ull get_hash1(char s[],ull x)
{
ull ans=0;
for(int i=0;i<x;i++)
{
ans+=(ans*base+(ull)s[i])%mo1;
}
return ans;
}
ull get_hash2(char s[],ull x)
{
ull ans=0;
for(int i=0;i<x;i++)
{
ans+=(ans*base+(ull)s[i])%mo2;
}
return ans;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%s",s);
int l=strlen(s);
a[i]=make_pair(a[i].first=get_hash1(s,l),a[i].second=get_hash2(s,l));
}
sort(a+1,a+n+1);
int tot=0;
for(int i=2;i<=n;i++)
{
if(a[i]!=a[i-1]) tot++;
}
printf("%d",tot+1);
}
4、KMP
这才是此问题非玄学正常解，但理解起来较为困难......
#include<cstring>
#define MAXN 1000010
using namespace std;
int kmp[MAXN];
char a[MAXN],b[MAXN];
int main()
{
cin>>a+1;
cin>>b+1;
int la,lb,j;
la=strlen(a+1);
lb=strlen(b+1);
for (int i=2;i<=lb;i++)
{
while(j&&b[i]!=b[j+1])//此处判断j是否为0的原因在于，如果回跳到第一个字符就不 用再回跳了
j=kmp[j]; //通过自己匹配自己来得出每一个点的kmp值
if(b[j+1]==b[i])j++;
kmp[i]=j; //i+1失配后应该如何跳
}
j=0;//j可以看做表示当前已经匹配完的模式串的最后一位的位置，也可以理解为j表示模式串匹配到第几位了
for(int i=1;i<=la;i++)
{
while(j>0&&b[j+1]!=a[i])
j=kmp[j]; //如果失配 ，那么就不断向回跳，直到可以继续匹配
if (b[j+1]==a[i])
j++; //如果匹配成功，那么对应的模式串位置++
if (j==lb)
{
cout<<i-lb+1<<endl;
j=kmp[j];//继续匹配
}
}
for (int i=1;i<=lb;i++)
cout<<kmp[i]<<" ";
return 0;
}//此处判断j是否为0的原因在于，如果回跳到第一个字符就不 用再回跳了
j=kmp[j]; //通过自己匹配自己来得出每一个点的kmp值
if(b[j+1]==b[i])j++;
kmp[i]=j; //i+1失配后应该如何跳
}
j=0;//j可以看做表示当前已经匹配完的模式串的最后一位的位置，也可以理解为j表示模式串匹配到第几位了
for(int i=1;i<=la;i++)
{
while(j>0&&b[j+1]!=a[i])
j=kmp[j]; //如果失配 ，那么就不断向回跳，直到可以继续匹配
if (b[j+1]==a[i])
j++; //如果匹配成功，那么对应的模式串位置++
if (j==lb)
{
cout<<i-lb+1<<endl;
j=kmp[j];//继续匹配
}
}
for (int i=1;i<=lb;i++)
cout<<kmp[i]<<" ";
return 0;
}
说明
KMP算法看懂了觉得特别简单，思路很简单，看不懂之前，查各种资料，看的稀里糊涂，即使网上最简单的解释，依然看的稀里糊涂。
我花了半天时间，争取用最短的篇幅大致搞明白这玩意到底是啥。
这里不扯概念，只讲算法过程和代码理解：
KMP算法求解什么类型问题
字符串匹配。给你两个字符串，寻找其中一个字符串是否包含另一个字符串，如果包含，返回包含的起始位置。
如下面两个字符串：
char *str = "bacbababadababacambabacaddababacasdsd";
char *ptr = "ababaca";str有两处包含ptr
分别在str的下标10，26处包含ptr。
“bacbababadababacambabacaddababacasdsd”;\ 
问题类型很简单，下面直接介绍算法
算法说明
一般匹配字符串时，我们从目标字符串str（假设长度为n）的第一个下标选取和ptr长度（长度为m）一样的子字符串进行比较，如果一样，就返回开始处的下标值，不一样，选取str下一个下标，同样选取长度为n的字符串进行比较，直到str的末尾（实际比较时，下标移动到n-m）。这样的时间复杂度是O(n*m)。
KMP算法：可以实现复杂度为O(m+n)
为何简化了时间复杂度：
充分利用了目标字符串ptr的性质（比如里面部分字符串的重复性，即使不存在重复字段，在比较时，实现最大的移动量）。
上面理不理解无所谓，我说的其实也没有深刻剖析里面的内部原因。
考察目标字符串ptr：
ababaca
这里我们要计算一个长度为m的转移函数next。
next数组的含义就是一个固定字符串的最长前缀和最长后缀相同的长度。
比如：abcjkdabc，那么这个数组的最长前缀和最长后缀相同必然是abc。
cbcbc，最长前缀和最长后缀相同是cbc。
abcbc，最长前缀和最长后缀相同是不存在的。
**注意最长前缀：是说以第一个字符开始，但是不包含最后一个字符。
比如aaaa相同的最长前缀和最长后缀是aaa。**
对于目标字符串ptr，ababaca，长度是7，所以next[0]，next[1]，next[2]，next[3]，next[4]，next[5]，next[6]分别计算的是
a，ab，aba，abab，ababa，ababac，ababaca的相同的最长前缀和最长后缀的长度。由于a，ab，aba，abab，ababa，ababac，ababaca的相同的最长前缀和最长后缀是“”，“”，“a”，“ab”，“aba”，“”，“a”,所以next数组的值是[-1,-1,0,1,2,-1,0]，这里-1表示不存在，0表示存在长度为1，2表示存在长度为3。这是为了和代码相对应。
下图中的1，2，3，4是一样的。1-2之间的和3-4之间的也是一样的，我们发现A和B不一样；之前的算法是我把下面的字符串往前移动一个距离，重新从头开始比较，那必然存在很多重复的比较。现在的做法是，我把下面的字符串往前移动，使3和2对其，直接比较C和A是否一样。
代码解析
void cal_next(char *str, int *next, int len)
{
next[0] = -1;//next[0]初始化为-1，-1表示不存在相同的最大前缀和最大后缀
int k = -1;//k初始化为-1
for (int q = 1; q <= len-1; q++)
{
while (k > -1 && str[k + 1] != str[q])//如果下一个不同，那么k就变成next[k]，注意next[k]是小于k的，无论k取任何值。
{
k = next[k];//往前回溯
}
if (str[k + 1] == str[q])//如果相同，k++
{
k = k + 1;
}
next[q] = k;//这个是把算的k的值（就是相同的最大前缀和最大后缀长）赋给next[q]
}
}KMP
这个和next很像，具体就看代码，其实上面已经大概说完了整个匹配过程。
int KMP(char *str, int slen, char *ptr, int plen)
{
int *next = new int[plen];
cal_next(ptr, next, plen);//计算next数组
int k = -1;
for (int i = 0; i < slen; i++)
{
while (k >-1&& ptr[k + 1] != str[i])//ptr和str不匹配，且k>-1（表示ptr和str有部分匹配）
k = next[k];//往前回溯
if (ptr[k + 1] == str[i])
k = k + 1;
if (k == plen-1)//说明k移动到ptr的最末端
{
//cout << "在位置" << i-plen+1<< endl;
//k = -1;//重新初始化，寻找下一个
//i = i - plen + 1;//i定位到该位置，外层for循环i++可以继续找下一个（这里默认存在两个匹配字符串可以部分重叠），感谢评论中同学指出错误。
return i-plen+1;//返回相应的位置
}
}
return -1;
}测试
char *str = "bacbababadababacambabacaddababacasdsd";
char *ptr = "ababaca";
int a = KMP(str, 36, ptr, 7);
return 0;注意如果str里有多个匹配ptr的字符串，要想求出所有的满足要求的下标位置，在KMP算法需要稍微修改一下。见上面注释掉的代码。
复杂度分析
next函数计算复杂度是(m)，开始以为是O(m^2)，后来仔细想了想，cal__next里的while循环，以及外层for循环，利用均摊思想，其实是O(m)，这个以后想好了再写上。
进一步说明
看了评论，大家对cal_next(..)函数和KMP()函数里的
while (k > -1 && str[k + 1] != str[q])
{
k = next[k];
}和
while (k >-1&& ptr[k + 1] != str[i])
k = next[k];这个while循环和k=next[k]很疑惑！
确实啊，我开始看这几行代码，相当懵逼，这写的啥啊，为啥这样写；后来上机跑了一下，慢慢了解到为何这样写了。这几行代码，可谓是对KMP算法本质得了解非常清楚才能想到的。很牛逼！
直接看cal_next(..)函数：
首先我们看第一个while循环，它到底干了什么。
在此之前，我们先回到原程序。原程序里有一个大的for()循环，那这个for()循环是干嘛的？
这个for循环就是计算next[0]，next[1],…next[q]…的值。
里面最后一句next[q]=k就是说明每次循环结束，我们已经计算了ptr的前(q+1)个字母组成的子串的“相同的最长前缀和最长后缀的长度”。（这句话前面已经解释了！） 这个“长度”就是k。
好，到此为止，假设循环进行到 第 q 次，即已经计算了next[q]，我们是怎么计算next[q+1]呢？
比如我们已经知道ababab，q=4时，next[4]=2（k=2，表示该字符串的前5个字母组成的子串ababa存在相同的最长前缀和最长后缀的长度是3，所以k=2,next[4]=2。这个结果可以理解成我们自己观察算的，也可以理解成程序自己算的，这不是重点，重点是程序根据目前的结果怎么算next[5]的）.，那么对于字符串ababab，我们计算next[5]的时候，此时q=5, k=2（上一步循环结束后的结果）。那么我们需要比较的是str[k+1]和str[q]是否相等，其实就是str[1]和str[5]是否相等！，为啥从k+1比较呢，因为上一次循环中，我们已经保证了str[k]和str[q]（注意这个q是上次循环的q）是相等的（这句话自己想想，很容易理解），所以到本次循环，我们直接比较str[k+1]和str[q]是否相等（这个q是本次循环的q）。
如果相等，那么跳出while()，进入if()，k=k+1，接着next[q]=k。即对于ababab，我们会得出next[5]=3。 这是程序自己算的，和我们观察的是一样的。
如果不等，我们可以用”ababac“描述这种情况。 不等，进入while()里面，进行k=next[k]，这句话是说，在str[k + 1] != str[q]的情况下，我们往前找一个k，使str[k + 1]==str[q]，是往前一个一个找呢，还是有更快的找法呢？ （一个一个找必然可以，即你把 k = next[k] 换成k- -也是完全能运行的（更正：这句话不对啊，把k=next[k]换成k–是不行的，评论25楼举了个反例）。但是程序给出了一种更快的找法，那就是 k = next[k]。 程序的意思是说，一旦str[k + 1] != str[q]，即在后缀里面找不到时，我是可以直接跳过中间一段，跑到前缀里面找，next[k]就是相同的最长前缀和最长后缀的长度。所以，k=next[k]就变成，k=next[2]，即k=0。此时再比较str[0+1]和str[5]是否相等，不等，则k=next[0]=-1。跳出循环。
（这个解释能懂不？）
以上就是这个cal_next()函数里的
while (k > -1 && str[k + 1] != str[q])
{
k = next[k];
}最难理解的地方的一个我的理解，有不对的欢迎指出。
复杂度分析：
分析KMP复杂度，那就直接看KMP函数。
int KMP(char *str, int slen, char *ptr, int plen)
{
int *next = new int[plen];
cal_next(ptr, next, plen);//计算next数组
int k = -1;
for (int i = 0; i < slen; i++)
{
while (k >-1&& ptr[k + 1] != str[i])//ptr和str不匹配，且k>-1（表示ptr和str有部分匹配）
k = next[k];//往前回溯
if (ptr[k + 1] == str[i])
k = k + 1;
if (k == plen-1)//说明k移动到ptr的最末端
{
//cout << "在位置" << i-plen+1<< endl;
//k = -1;//重新初始化，寻找下一个
//i = i - plen + 1;//i定位到该位置，外层for循环i++可以继续找下一个（这里默认存在两个匹配字符串可以部分重叠），感谢评论中同学指出错误。
return i-plen+1;//返回相应的位置
}
}
return -1;
}这玩意真的不好解释，简单说一下：
从代码解释复杂度是一件比较难的事情，我们从
这个图来解释。
我们可以看到，匹配串每次往前移动，都是一大段一大段移动，假设匹配串里不存在重复的前缀和后缀，即next的值都是-1，那么每次移动其实就是一整个匹配串往前移动m个距离。然后重新一一比较，这样就比较m次，概括为，移动m距离，比较m次，移到末尾，就是比较n次，O(n)复杂度。 假设匹配串里存在重复的前缀和后缀，我们移动的距离相对小了点，但是比较的次数也小了，整体代价也是O(n)。
所以复杂度是一个线性的复杂度。
来自：https://blog.csdn.net/starstar1992/article/details/54913261
5、Manacher（此版本只能处理长度奇数的）
scanf("%s",s+1);
int l=strlen(s+1);
f[1]=1;
int nowmid = 1, nowright = 1;
for (int a=2;a<=l;a++)
{
if (a <= nowright)
{
int p = 2*nowmid - a;
f[a] = min(f[p], (nowright-a)*2+1);
}
else f[a]=1;
int l=f[a]/2+1;
while ( s[a+l] == s[a-l] )
{
f[a] += 2;
l ++ ;
}
if (a + l -1 > nowright) {
nowright = a+l-1;
nomid = a;
}
}
6、拓展KMP
scanf("%s",s+1);
int l=strlen(s+1);
f[1]=l;
while (s[2+f[2]] == s[1+f[2]])
f[2] ++;
int nowleft = 2, nowright = 2 + f[2] - 1;
for (int a=3;a<=l;a++)
{
if (a <= nowright)
{
int p = a - nowleft + 1;
f[a] = min (f[p], nowright - a + 1);
}
while (s[a+f[a]] == s[1+f[a]])
f[a] ++;
if (a + f[a] - 1 > nowright)
{
nowleft = a;
nowright = a + f[a] - 1;
}
}三、STL库
去这里查询相关内容：www.cplusplus.com
必须要写 using namespace std;
1、STL数据结构
（1）、#include<map>
map<int,int> ma;
ma[233] = 233;
ma[-666] = 123;
ma[2147483647] = 123;
map<string,int> mas;
mas["dms"] = 234;
map<long long,double> mal;
mal[12345678999875432ll] = 23.3;
map<int, map<int,int> > ma;（2）、#include<set>
set<int> se;
se.insert(233);se.insert(233);
se.count(233);
se.erase(233);
se.clear();
se.size();
se.empty();（3）、#include<multiset>
multiset<int> mulse;（4）、没啥用的，了解一下
#include<vector>
#include<list>
#include<deque>
2、STL算法
全部都要加这个头文件：#include<algorithm>
（1）min(a,b);
（2）max(a,b);
（3）swap(a,b);
（4）sort(z+1,z+n+1，cmp);
cmp可有可无，有的话，可以定义sort的排序方式
bool cmp(int a,int b)
{
return a>b;
}
（5）reverse(z+1,z+n+1);
（6）min_element(z+1,z+n+1);
（7）max_element(z+1,z+n+1);
（8）unique(z+1,z+n+1);
如用这个函数，必须先排序，之后调用函数去重；这里的m表示的是去重之后的数组长度；
int z[1000];
sort(z+1,z+n+1);
m=unique(z+1,z+n+1)-z-1;
（9）random_shuffle(z+1,z+n+1);
猴子排序、随机数据、防阴暗出敌人随机搜索顺序
（10）next_permutation(z+1,z+n+1);
可以用它进行全排列；
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
a[i]=i;
}
do
{
for(int i=1;i<=n;i++)
{
printf("%d",a[i]);
}
printf("\n");
}
while(next_permutation(a+1,a+1+n));（11）prev_permutation(z+1,z+n+1);
四、快速读入
int getint()
{
char c = ' ';
while (c<'0' || c>'9')
c=getchar();
int v=0;
while (c>='0' && c<='9')
{
v=v*10+c-'0';
c=getchar();
}
return v;
}五、检查代码
1、输出调试法
输出所有的变量并进行检查；
2、小黄鸭调试法
找一个东西，给它详细的，逻辑严密的讲代码，当讲不明白的时候，可能是代码错了；
3、高端方法（GAB基本操作）
（1）在地址栏输入cmd，回车
（2）在弹出窗中，先输入g++
（3）输入g++ a.cpp -o a.exe -g -Wall -Wextra -Wconversion && size a.exe
（4）size.exe是检测程序内存用的；
（5）bss下显示的程序的内存，单位B；除以1024^2即可换算为MB；
（6）gdb 文件名.exe
（7）输入l，可以显示程序9行，再输l，可以再显示
（8）基本操作：
r 运行程序；p x打印变量x的值 ；b 123 在第123行设置新点；b gg在函数gg设置新点；s 执行下一步；
n 执行下一行（即直接执行完该行）；display x 将x加入常规变量列表；c执行到下一个新点；q退出gdb；
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
