kmp
#include<stdio.h>
#include<string.h>
using namespace std;
typedef long long ll;
const int mc=1e4+5;
const int maxn=1e6+5;
char str[maxn],pattern[mc];
int PI[mc];void cpf(char *p) //设置Next数组{
int m=strlen(p);
PI[0]=-1,PI[1]=0;
for(int i=1;i<m;i++)
{
int j=PI[i];
while(j>0&&p[i]!=p[j])
j=0;
if(p[i]==p[j])
PI[i+1]=j+1;
else PI[i+1]=0;
}
}void kmp(char *s,char *p){
int num=0;
int slen=strlen(s),plen=strlen(p);
int j=0;
cpf(p);
for(int i=0;i<slen;i++)
{
while(j>0&&p[j]!=s[i]) //匹配失效
j=PI[j];
if(p[j]==s[i]) j++;
if(j==plen)
{
num++;
}
}printf("%d\n",num);
}int main(){
int Test;
scanf("%d",&Test);
while(Test--)
{
memset(PI,0,sizeof(PI));
scanf("%s%s",pattern,str);
kmp(str,pattern);
}
return 0;
}
LIS模板:
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 5;
int v[1010];
double a[1005];
int dp[1005];
int Dp[1005];
int ans=0;
int main()
{
int n;
cin >> n;
for (int i = 1; i <= n; i++)
scanf("%lf",&a[i]);
for (int i = 1; i <=n; i++) //最长上升
{
dp[i] = 1;
for (int j = 1; j < i; j++)
{
if (a[i] > a[j])
dp[i] = max(dp[i], dp[j] + 1);
// else dp[i] = max(dp[i], dp[j]);
}
//cout << dp[i] << ' ';
}
// cout << endl;
for (int i = n ; i >= 1; i--) //最长下降
{
Dp[i] = 1;
for (int j = n; j > i; j--)
{
if (a[i] > a[j])
Dp[i] = max(Dp[i], Dp[j] + 1);
// else Dp[i] = max(Dp[i], Dp[j]);
}
// cout << Dp[i] << endl;
}
for(int i=1;i<=n;i++){
for(int j=i+1;j<=n;j++){
ans=max(ans,dp[i]+Dp[j]);
}
}
cout << n-ans << endl;
return 0 ;
}
Dijkstra模板：
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <limits.h>
#include <algorithm>
#include <iostream>
#include <ctype.h>
#include <set>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#define left (now<<1)
#define right ((now<<1)+1)#define mid ((l+r)>>1)
#define fst first
#define snd secondusing namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e2+5;
typedef long long lint;
int n, m;
int dis[maxn];bool vis[maxn];struct edge {
int form, to, w;
edge(int a, int b, int c) {
form = a;
to = b;
w = c;
}
};
struct node {
int id, distance;
node(int a, int b) { id = a; distance = b; };
bool operator <(const node& a)const
{
return distance > a.distance;
}
};int S, T;
vector<edge> e[maxn];
void dijkstra(){
int s = 1;
memset(dis, INF, sizeof(dis));
memset(vis, 0, sizeof(vis));
dis[S] = 0;
priority_queue<node> Q;
Q.push(node(S, dis[S])); //1 , 0入队
while (!Q.empty())
{
node u=Q.top(); //id为节点 diantance为dis 距离
Q.pop();
if (vis[u.id]) // u.id 队列首指示的点
continue;
vis[u.id] = 1;
for (int i = 0; i <e[u.id].size(); i++)
{
if (dis[e[u.id][i].to] > u.distance+e[u.id][i].w) //更新节点
{
Q.push(node(e[u.id][i].to,u.distance+e[u.id][i].w));
dis[e[u.id][i].to] = u.distance + e[u.id][i].w;
}
}
}
if (dis[T] == INF)
cout << -1 << endl;
else
cout << dis[T] << endl;
}
int main(){
while (cin >> n >> m && m + n)
{
for (int i = 0; i < maxn; i++)
e[i].clear();
for (int i = 1; i <= m; i++)
{
int a, b, d;
cin >> a >> b >> d;
e[a].push_back(edge(a, b, d));
e[b].push_back(edge(b, a, d));
}
cin >> S >> T;
dijkstra();
}
return 0;
}
线段树板子（区间最大值）
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
#define INF 0x3f3f3f3f
#define lson 2*i
#define rson 2*i+1
#define LS l,mid,lson
#define RS mid+1,r,rson
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 1000005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
#define lowbit(x) (x&-x)
int n, m;
const int maxn = 100005;
int a[maxn<<2],t[maxn<<2]; //a为原来区间，t为线段树
inline void Pushup(int k){ //更新函数，这里是实现最大值 ，同理可以变成，最小值，区间和等
t[k] = t[k << 1] + t[k << 1 | 1];
}
//递归方式建树 build(1,1,n);
void build(int k,int l,int r){ //k为当前需要建立的结点，l为当前需要建立区间的左端点，r则为右端点
if(l == r) //左端点等于右端点，即为叶子节点，直接赋值即可
t[k] = a[l];
else{
int m = l + ((r-l)>>1); //m则为中间点，左儿子的结点区间为[l,m],右儿子的结点区间为[m+1,r]
build(k<<1,l,m); //递归构造左儿子结点
build(k<<1|1,m+1,r); //递归构造右儿子结点
Pushup(k); //更新父节点
}
}
//递归方式更新 updata(p,v,1,n,1);
inline void updata(int p,int v,int l,int r,int k){ //p为下标，v为要加上的值，l，r为结点区间，k为结点下标
if(l == r) //左端点等于右端点，即为叶子结点，直接加上v即可
a[k] += v,t[k] += v; //原数组和线段树数组都得到更新
else{
int m = l + ((r-l)>>1); //m则为中间点，左儿子的结点区间为[l,m],右儿子的结点区间为[m+1,r]
if(p <= m) //如果需要更新的结点在左子树区间
updata(p,v,l,m,k<<1);
else //如果需要更新的结点在右子树区间
updata(p,v,m+1,r,k<<1|1);
Pushup(k); //更新父节点的值
}
}
//递归方式区间查询 query(L,R,1,n,1);
inline int query(int L,int R,int l,int r,int k){ //[L,R]即为要查询的区间，l，r为结点区间，k为结点下标
if (L <= l && r <= R) //如果当前结点的区间真包含于要查询的区间内，则返回结点信息且不需要往下递归
{
/* cout << k << endl;*/
return t[k];
}
int res = 0; //返回值变量，根据具体线段树查询的什么而自定义
int mid = l + ((r-l)>>1); //m则为中间点，左儿子的结点区间为[l,m],右儿子的结点区间为[m+1,r]
if (L <= mid) //如果左子树和需要查询的区间交集非空
// res = max(res, query(L,R,l,m,k<<1));
//if(R > m) //如果右子树和需要查询的区间交集非空，注意这里不是else if，因为查询区间可能同时和左右区间都有交集
// res = max(res, query(L,R,m+1,r,k<<1|1));
//return res; //返回当前结点得到的信息
res += query(L, R, l, mid, k << 1);
if (R > mid)
res += query(L, R, mid+1, r, k << 1 | 1);
return res;
}
int lazy[maxn];
void Pushdown(int k){ //更新子树的lazy值，这里是RMQ的函数，要实现区间和等则需要修改函数内容
if(lazy[k]){ //如果有lazy标记
lazy[k<<1] += lazy[k]; //更新左子树的lazy值
lazy[k<<1|1] += lazy[k]; //更新右子树的lazy值
t[k<<1] += lazy[k]; //左子树的最值加上lazy值
t[k<<1|1] += lazy[k]; //右子树的最值加上lazy值
lazy[k] = 0; //lazy值归0
}
}
//递归更新区间 updata(L,R,v,1,n,1);
inline void update(int L,int R,int v,int l,int r,int k){ //[L,R]即为要更新的区间，l，r为结点区间，k为结点下标
if(L <= l && r <= R){ //如果当前结点的区间真包含于要更新的区间内
lazy[k] += v; //懒惰标记
t[k] += v; //最大值加上v之后，此区间的最大值也肯定是加v
}
else{
Pushdown(k); //重难点，查询lazy标记，更新子树
int m = l + ((r-l)>>1);
if(L <= m) //如果左子树和需要更新的区间交集非空
update(L,R,v,l,m,k<<1);
if(m < R) //如果右子树和需要更新的区间交集非空
update(L,R,v,m+1,r,k<<1|1);
Pushup(k); //更新父节点
}
}
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
build(1, 1, n);
while (m--)
{
int A;
cin >> A;
if (A == 1)
{
int b, c, d;
scanf("%d%d%d", &b, &c, &d);
for (int i = b; i <= c; i++)
updata(i, d, 1, n, 1);
}
if (A == 2)
{
int b, c;
scanf("%d%d", &b, &c);
int p = query(b, c, 1, n, 1);
cout << p << endl;
}
}
return 0;
}
线段树区间和板子
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
#define INF 0x3f3f3f3f
#define lson 2*i
#define rson 2*i+1
#define LS l,mid,lson
#define RS mid+1,r,rson
#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
#define gcd(a,b) __gcd(a,b)
#define LL long long
#define N 1000005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EXP 1e-8
#define lowbit(x) (x&-x)
int n, m;
const int maxn = 1000005;
long long a[maxn],t[maxn]; //a为原来区间，t为线段树
inline void Pushup(int k){ //更新函数，这里是实现最大值 ，同理可以变成，最小值，区间和等
t[k] = t[k << 1] + t[k << 1 | 1];
}
//递归方式建树 build(1,1,n);
void build(int k,int l,int r){ //k为当前需要建立的结点，l为当前需要建立区间的左端点，r则为右端点
if(l == r) //左端点等于右端点，即为叶子节点，直接赋值即可
t[k] = a[l];
else{
int m = l + ((r-l)>>1); //m则为中间点，左儿子的结点区间为[l,m],右儿子的结点区间为[m+1,r]
build(k<<1,l,m); //递归构造左儿子结点
build(k<<1|1,m+1,r); //递归构造右儿子结点
Pushup(k); //更新父节点
}
}
//递归方式更新 updata(p,v,1,n,1);
inline void updata(int p,int v,int l,int r,int k){ //p为下标，v为要加上的值，l，r为结点区间，k为结点下标
if(l == r) //左端点等于右端点，即为叶子结点，直接加上v即可
a[k] += v,t[k] += v; //原数组和线段树数组都得到更新
else{
int m = l + ((r-l)>>1); //m则为中间点，左儿子的结点区间为[l,m],右儿子的结点区间为[m+1,r]
if(p <= m) //如果需要更新的结点在左子树区间
updata(p,v,l,m,k<<1);
else //如果需要更新的结点在右子树区间
updata(p,v,m+1,r,k<<1|1);
Pushup(k); //更新父节点的值
}
}
LL lazy[maxn];
void Pushdown(LL k,LL l,LL r){ //更新子树的lazy值，这里是RMQ的函数，要实现区间和等则需要修改函数内容
LL mid = (l + r) / 2;
lazy[k << 1] += lazy[k];
t[k<<1] =t[k<<1]+lazy[k] * (mid - l + 1);
t[k << 1 | 1] = t[k << 1 | 1] + lazy[k] * (r - mid);
lazy[k << 1 | 1] += lazy[k];
lazy[k] = 0;
}
//递归方式区间查询 query(L,R,1,n,1);
inline long long query(int L,int R,int l,int r,int k){ //[L,R]即为要查询的区间，l，r为结点区间，k为结点下标
if (L <= l && r <= R) //如果当前结点的区间真包含于要查询的区间内，则返回结点信息且不需要往下递归
{
/* cout << k << endl;*/
return t[k];
}
Pushdown(k, l, r);
long long res = 0; //返回值变量，根据具体线段树查询的什么而自定义
int mid = l + ((r-l)>>1); //m则为中间点，左儿子的结点区间为[l,m],右儿子的结点区间为[m+1,r]
if (L <= mid) //如果左子树和需要查询的区间交集非空
// res = max(res, query(L,R,l,m,k<<1));
//if(R > m) //如果右子树和需要查询的区间交集非空，注意这里不是else if，因为查询区间可能同时和左右区间都有交集
// res = max(res, query(L,R,m+1,r,k<<1|1));
//return res; //返回当前结点得到的信息
res += query(L, R, l, mid, k << 1);
if (R > mid)
res += query(L, R, mid+1, r, k << 1 | 1);
return res;
}
//递归更新区间 updata(L,R,v,1,n,1);
inline void update(int L,int R,int v,LL l,LL r,int k){ //[L,R]即为要更新的区间，l，r为结点区间，k为结点下标
if(L <= l && r <= R){ //如果当前结点的区间真包含于要更新的区间内
lazy[k] += v; //懒惰标记
t[k] += v*(r-l+1); //最大值加上v之后，此区间的最大值也肯定是加v
return;
}
else{
Pushdown(k,l,r); //重难点，查询lazy标记，更新子树
LL m = l + ((r-l)>>1);
if(L <= m) //如果左子树和需要更新的区间交集非空
update(L,R,v,l,m,k<<1);
if(m < R) //如果右子树和需要更新的区间交集非空
update(L,R,v,m+1,r,k<<1|1);
Pushup(k); //更新父节点
}
}
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; i++)
scanf("%lld", &a[i]);
build(1, 1, n);
while (m--)
{
int A;
cin >> A;
if (A == 1)
{
int b, c;
LL d;
scanf("%d%d%lld", &b, &c, &d);
update(b, c, d, 1, n, 1);
}
if (A == 2)
{
int b, c;
scanf("%d%d", &b, &c);
LL p = query(b, c, 1, n, 1);
cout << p << endl;
}
}
return 0;
}
837
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
