标签：nod iostream odi cst name 必须 快速 mod baidu
（转载于我的洛谷博客）
第一题：P2552 团体操队形
第二题：P3146 248
第三题：P3147 262144
第四题：P1972 花花的项链
第五题：P1484 种树
第六题：P5132 Cozy Glow之拯救小马国
第七题：P1198 最大数
第八题：P2023 维护序列
第九题：P1967 货车运输
第十题：P1313 计算系数
这道题以一个点需要注意——就是梅花桩队形的奇数排列和偶数排列的规律是略有不同的
奇数排列时，相互交叉排列的两行如果展开的话就是一个 相邻两个数之间有一个空格 的数列；但是偶数排列时则不然，它的展开在行（或列）的交际处会空两格格子，所以这里需要注意一下（这就是我评测记录里那一大堆WA的原因了）
以下是源码：
#include<cstdio>
#include<iostream>
using namespace std;
int t,n,x,y,m,r;
void count1(int &hang,int &lie)//处理横竖全满队形
{
hang=1;
hang+=m/r;
lie=m%r;
if(lie==0)lie=r,hang--;
// printf("%d %d\n",hang,lie);
}
void count2(int &hang,int &lie)//处理r为奇数的梅花桩队形
{
hang=1;
hang+=(m/r)*2;
if(m%r!=0)
{
if((m%r)>((r+1)/2))hang++;
lie=((m%r)*2-1)%r;
}
else
{
hang--;
lie=(r*2-1)%r;
}
if(lie==0)lie=r;
// printf("%d %d\n",hang,lie);
}
void count3(int &hang,int &lie)//处理r为偶数的梅花桩队形
{
hang=1;
hang+=(m/r)*2;
if(m%r!=0)
{
if((m%r)>(r/2))
{
hang++;
lie=((m%r)*2)%r;
}
else lie=((m%r)*2-1)%r;
}
else
{
hang--;
lie=(r*2)%r;
}
if(lie==0)lie=r;
}
int main()
{
scanf("%d",&t);
for(int i=1;i<=t;i++)
{
int hang=0,lie=0;
scanf("%d%d%d%d%d",&n,&x,&y,&r,&m);
if(x==1)
{
if(y==1)count1(hang,lie);
else count1(lie,hang);
}
else
{
if(r&1)
{
if(y==1)count2(hang,lie);
else count2(lie,hang);
}
else
{
if(y==1)count3(hang,lie);
else count3(lie,hang);
}
}
printf("%d %d ",hang,lie);
}
return 0;
}感觉这道题是被恶意评到绿题的
这是一个炒鸡水十分经典的区间DP，我不会告诉你我只用了五分钟就把它A了，我也不赘述思路了，直接贴代码：
另外，补充说明一下，此题题干不全，应该加一句话：“如果相邻两个数相同，则可以合并为一个数，新数等于原数加一
#include<cstdio>
#include<string>
using namespace std;
int a[250],n,f[250][250],ans;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
f[i][i]=a[i];
}
for(int i=2;i<=n;i++)//枚举区间长度
for(int j=1;j<=n-i+1;j++)//枚举起点
{
int e=j+i-1;
for(int k=j;k<=e;k++)//枚举断点
{
if(f[j][k-1]==f[k][e])//如果两个点相等
f[j][e]=max(f[j][e],f[j][k-1]+1),ans=max(ans,f[j][e]);
}
}
printf("%d",ans);
return 0;
}如果有兴趣的同学可以去做P3147增强难度版
显然，这题和第二题P3146题面完全一样，但是却并不是P3146的双倍经验题，因为它的数据范围改到了很大，因此，我们不能再使用区间DP的思路了，我们必须另辟蹊径
我们发现，这个题目每次合并的都是相邻且相等的区间，而且原序列的数字大小都不大于40，这说明最大合并出的数字是有上限的，最大是：
1,1,2,3,4,5,6,7,8,9，……，39,40
这样的序列合并出来的最大值是58（别问我为什么，自己去算）
因此，我们可以根据这个特点去构造思路：使用f[i][j]表示能合成出i的 以j为起点的区间 的终点的下标（应该没有辣么绕口）
故，状态转移方程为f[i][j]=f[i-1][f[i-1][j]]
以下是标程：
#include<cstdio>
#include<iostream>
using namespace std;
int f[60][270000],n,a,ans;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a);
f[a][i]=i+1;
}
for(int i=2;i<=58;i++)
for(int j=1;j<=n;j++)
{
if(!f[i][j])f[i][j]=f[i-1][f[i-1][j]];
if(f[i][j])ans=i;
}
printf("%d",ans);
return 0;
}（我是绝对不会告诉你们这个题有双倍经验题SP3267的）
这个题乍一看还以为是前缀和解决，结果
仔细想了想，才发现如果使用前缀和，是无法判断区间里的数字在该区间里是不是只出现了一次，这样就会出现错误
比于这组数据
1,2,1,3
在询问【1,4】区间时，答案是3；
但是在询问【2,4】区间时，由于在此区间里1只出现了一次，所以答案还是3，但前缀和是3-1=2；
于是只能不情愿的使用数据结构了
由于我懒线段树比较浪费空间，我们用树状数组解决这个题
具体处理是，我们使用树状数组来记录该区间内不同数字的个数，其每个节点表示该位置是否有一个不同的数字
还是用上面那组数据，我们发现，在一个询问区间中，出现过一次的数再出现一次时就相当于没有出现。所以我们在第一次碰到一个数字a[j]时，把他加入到树状数组，然后用v[a[j]]记录下它出现的位置j；如果在该询问区间里有相同数字，就把第二个数加入树状数组，把第一个数在树状数组内的值设为0
但是你可能会问，对于上面那组数据，如果询问[1,4]，那么树状数组内的值应为0,1,1,1，那当询问[1,2]时，他不就错了吗？
因此我们就要用一种赖皮的巧妙的方法来避免这种情况。由于这个题是离线的，所以我们对询问区间以右端点为顺序从小到大排序，然后逐次处理。在处理小区间时（比如[1,2])，树状数组并不会把第一次出现的数字设为0，所以我们得到正确答案并记下来；然后在处理较大区间时（比如[1,4]），我们为了节约复杂度，就不让它从头循环了，而是从上一个小区间的右端点处开始循环，这样在循环是确实修改了树状数组内[1,2]的值，但是却不会影响正确答案
好像有点冗长
以下是标程：
#include<cstdio>
#include<algorithm>
using namespace std;
int a[1000010],n,l,r,t,tree[1000010];
int v[1000010],ans[1000010];
struct Query
{
int l,r,pos;
}ask[1000010];
bool cmp(Query x,Query y)
{
return x.r<y.r;
}
int lowbit(int x)
{
return x&(-x);
}
void add(int x,int y)
{
for(x;x<=n;x+=lowbit(x))tree[x]+=y;
}
int query(int x)
{
int ans=0;
for(x;x;x-=lowbit(x))ans+=tree[x];
return ans;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
scanf("%d",&t);
for(int i=1;i<=t;i++)
{
scanf("%d%d",&ask[i].l,&ask[i].r);
ask[i].pos=i;
}
sort(ask+1,ask+1+t,cmp);
int next=1;
for(int i=1;i<=t;i++)
{
for(int j=next;j<=ask[i].r;j++)
{
if(v[a[j]])add(v[a[j]],-1);
add(j,1);
v[a[j]]=j;
}
next=ask[i].r+1;
ans[ask[i].pos]=query(ask[i].r)-query(ask[i].l-1);
}
for(int i=1;i<=t;i++)
printf("%d\n",ans[i]);
return 0;
}又是一道关于堆的灵活运用的题……
题目中的主要思想是如何反悔。我们可以看到，当我们选择a[i]时，如果要反悔，就可以把a[i]的值重新设置为a[i-1]+a[i+1]-a[i]，就相当于记录了这样选可以多获得的利润。我们把这些利润和堆中剩下的数比一比，如果利润更大，就选择利润并加到答案里，这样就相当于反悔并重新选择了a[i-1]和a[i+1]
注意，这个堆并不是用来记录答案的！
以下是标程：
#include<queue>
#include<cstdio>
#include<iostream>
using namespace std;
int n,k,lc[500010],rc[500010];//lc记录左坑的序号，rc记录右坑的序号
bool vis[500010];//记录此坑还能不能用
long long a[500010],ans;//记录权值
struct node//坑
{
int id;//坑的序号
long long w;//坑的权值
bool operator< (node b) const
{
return w<b.w;
}
}t;//中间变量
priority_queue <node> q;//经典的大根堆
int main()
{
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
t.id=i;
t.w=a[i];
lc[i]=i-1;
rc[i]=i+1;
q.push(t);//踢到大根堆里
}
lc[n+1]=n;//完善左右坑的信息
rc[0]=1;
for(int i=1;i<=k;i++)//开始反悔
{
while(vis[q.top().id])q.pop();//在大根堆里清理掉不能用的坑
t=q.top();//取出堆顶元素
q.pop();//踢掉
if(t.w<0)break;//如果最大值都小于零了，那还不如不种
ans+=t.w;//加到答案里
int c=t.id;
a[c]=a[lc[c]]+a[rc[c]]-a[c];//反悔并计算这样做的利润
t.w=a[c];
vis[lc[c]]=vis[rc[c]]=1;//更新该节点的左右坑状态，以遍在下一次循环中在堆中踢掉左右坑
lc[c]=lc[lc[c]];//更新左右坑的位置
rc[c]=rc[rc[c]];
lc[rc[c]]=c;//更新更新后的左右坑的左右坑的位置
rc[lc[c]]=c;
q.push(t);//将反悔利润踢进堆
}
printf("%lld",ans);//输出答案
return 0;
}这个题就是暴力美学的完美体现。看起来这个题的复杂度高得飞起，但是实际上，如果我们把样例的计算式列出来，就会发现根本没有那么麻烦，可以合并的项目太多了，因此这个题，暴力计算就能过。
以下是标程：
#include<cstdio>
#include<iostream>
using namespace std;
int n,a[200010],num;
long long ans;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
scanf("%d",&num);
if(i>j)ans+=(long long)num*min(a[i],a[j]);
}
printf("%lld",ans);
return 0;
}这是一道考察线段树的应用能力题
由于它连序列都没给，因此我们也不用建树了，只写查询和修改函数就行
另外，由于题目中说有负数，所以我们在查询时将ans1,ans2这两个记录答案的变量设的很小以应对负数的情况
一下就是高清无码的标程：
#include<cstdio>
#include<iostream>
using namespace std;
const long long inf=-2147483647;
int n,m;
long long cur,mod,num,t[200001*4];
void modify(int u,int s,int k,int l,int r)//u是已经加入的节点数（就是A操作的次数）
{//s是加入的数字，k、l、r不解释
if(l==r){t[k]=s;return;}
int mid=l+r>>1;
if(mid>=u)modify(u,s,k<<1,l,mid);
if(mid<u)modify(u,s,k<<1|1,mid+1,r);
t[k]=max(t[k<<1],t[k<<1|1])%mod;
}
long long query(int k,int l,int r,int x,int y)
{
if(x<=l&&y>=r)return t[k];
int mid=l+r>>1;
long long ans1=inf,ans2=inf;
if(x<=mid)ans1=query(k<<1,l,mid,x,y);
if(y>mid)ans2=query(k<<1|1,mid+1,r,x,y);
return max(ans1,ans2);
}
int main()
{
scanf("%d%lld",&m,&mod);
char o[2];
for(int i=1;i<=m;i++)
{
scanf("%s %lld",o,&num);
// cout<<o<<"ohhh";
if(o[0]=='A')
{
n++;
// scanf("%lld",&num);
num=(num+cur)%mod;
// printf("test:%lld\n",num);
modify(n,num,1,1,m);//由于一共有m次操作，所以线段树中最多有m个数，因此在调用时让r=m即可
}
else
{
// scanf("%lld",&num);
if(num==0)cur=0;//小小的特判，大大的作用
else cur=query(1,1,m,n-num+1,n);
printf("%lld\n",cur);
}
}
return 0;
}这显然是一道线段树题目，但是只拿模板改一改是不够的，乘法的加入使得问题变复杂了，必须要仔细的思考
我们可以用两个懒标记，一个记录加上的数，一个记录乘上的数
我曾经尝试着把乘法的懒标记和加法的懒标记分开处理，乘就只乘，加就只加，但是这样不对，因为加法的懒标记在乘法处理后会变大，所以不能简单的分开处理。
具体思路见代码：
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
long long t[800010],a[200010],add1[800010],add2[800010],p;
int n,m;
void build(int k,int l,int r)
{
if(l==r){t[k]=a[l];return;}
int mid=l+r>>1;
build(k<<1,l,mid);
build(k<<1|1,mid+1,r);
t[k]=t[k<<1]+t[k<<1|1];
}
void pushdown(int k,int l,int r)
{
if(add1[k]==0&&add2[k]==1)return;
int lc=k<<1,rc=k<<1|1;
if(l!=r)
{
add2[lc]=add2[lc]*add2[k]%p;
add2[rc]=add2[rc]*add2[k]%p;
add1[lc]=(add1[lc]*add2[k]%p+add1[k])%p;
add1[rc]=(add1[rc]*add2[k]%p+add1[k])%p;
}
t[k]=(t[k]*add2[k]%p+add1[k]*(r-l+1)%p)%p;
add1[k]=0;add2[k]=1;
}
long long query(int k,int l,int r,int x,int y)
{
pushdown(k,l,r);
if(l>=x&&y>=r)return t[k];
int mid=l+r>>1;
long long ans=0;
if(x<=mid)ans+=query(k<<1,l,mid,x,y);
ans=ans%p;
if(y>mid)ans+=query(k<<1|1,mid+1,r,x,y);
return ans%p;
}
void modify1(int k,int l,int r,int x,int y,int v)
{
pushdown(k,l,r);
if(l>=x&&y>=r){add1[k]=(add1[k]+v)%p;return;}
int mid=l+r>>1;
if(x<=mid)modify1(k<<1,l,mid,x,y,v);
if(y>mid)modify1(k<<1|1,mid+1,r,x,y,v);
pushdown(k<<1,l,mid);
pushdown(k<<1|1,mid+1,r);
t[k]=(t[k<<1]+t[k<<1|1])%p;
}
void modify2(int k,int l,int r,int x,int y,int v)
{
pushdown(k,l,r);
if(l>=x&&y>=r){add2[k]=add2[k]*v%p;add1[k]=add1[k]*v%p;return;}
int mid=l+r>>1;
if(x<=mid)modify2(k<<1,l,mid,x,y,v);
if(y>mid)modify2(k<<1|1,mid+1,r,x,y,v);
pushdown(k<<1,l,mid);
pushdown(k<<1|1,mid+1,r);
t[k]=(t[k<<1]+t[k<<1|1])%p;
}
int main()
{
scanf("%d%lld",&n,&p);
// p=2147483647;
for(int i=1;i<=n;i++)
scanf("%lld",&a[i]);
build(1,1,n);
scanf("%d",&m);
int b,c,d;
long long e;
for(int i=1;i<=5*n;i++)
add2[i]=1;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&b,&c,&d);
if(b==2)
{
scanf("%lld",&e);
modify1(1,1,n,c,d,e);
}
else if(b==1)
{
scanf("%lld",&e);
modify2(1,1,n,c,d,e);
}
else
{
printf("%lld\n",query(1,1,n,c,d));
}
}
return 0;
}这个题，我一开始看到的时候就想到了floyd，但是一看这坑爹的数据范围，floyd就被pa掉了
但是这么大的数据范围要怎么处理呢？暴力建图肯定不行。那要怎么办呢（为之奈何？）。我们发现，有一些载重很小的路是不会通过的，因此我们就想到了最大生成树。在建完最大生成树后，我们需要找出树上两个点的距离，这时就会用到LCA，因此这个题的思路就是最大生成树+LCA啦！
（LCA详解请看本博客的第十四题）
代码如下：
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int fa[10010],head[10010],cnt,n,m,t,num;
int f[10010][21],dep[10010],w[10010][21];
bool vis[10010];
struct Edge
{
int dis,to,from;
}edge[50010];
struct Tree
{
int nst,dis,to;
}tree[100010];
bool cmp(Edge a ,Edge b)
{
return a.dis>b.dis;
}
int find(int x)
{
if(fa[x]==x)return x;
return fa[x]=find(fa[x]);
}
void build(int a,int b,int c)
{
edge[++num].from=a;
edge[num].to=b;
edge[num].dis=c;
}
void add(int a,int b,int c)
{
tree[++cnt].nst=head[a];
tree[cnt].to=b;
tree[cnt].dis=c;
head[a]=cnt;
}
void kruskal()
{
sort(edge+1,edge+m+1,cmp);
for(int i=1;i<=n;i++)
fa[i]=i;
for(int i=1;i<=m;i++)
{
int u=edge[i].from,v=edge[i].to;
if(find(u)!=find(v))
{
fa[find(u)]=find(v);
add(u,v,edge[i].dis);
add(v,u,edge[i].dis);
}
}
}
void dfs(int u)
{
vis[u]=true;
for(int i=head[u];i;i=tree[i].nst)
{
int v=tree[i].to;
if(vis[v])continue;
dep[v]=dep[u]+1;
f[v][0]=u;
w[v][0]=tree[i].dis;
dfs(v);
}
return;
}
int lca(int x,int y)
{
if(find(x)!=find(y))return -1;
int ans=2147483647;
if(dep[x]>dep[y])swap(x,y);
for(int i=20;i>=0;i--)
{
if(dep[f[y][i]]>=dep[x])
{
ans=min(ans,w[y][i]);
y=f[y][i];
}
}
if(x==y)return ans;
for(int i=20;i>=0;i--)
{
if(f[x][i]!=f[y][i])
{
ans=min(ans,min(w[x][i],w[y][i]));
x=f[x][i];
y=f[y][i];
}
}
ans=min(ans,min(w[x][0],w[y][0]));
return ans;
}
int main()
{
scanf("%d%d",&n,&m);
int a,b,c;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&a,&b,&c);
build(a,b,c);
}
kruskal();
// printf("^-^");
for(int i=1;i<=n;i++)
{
if(!vis[i])
{
dep[i]=1;
dfs(i);
f[i][0]=i;
w[i][0]=2147483647;
}
}
for(int i=1;i<=20;i++)
for(int j=1;j<=n;j++)
{
f[j][i]=f[f[j][i-1]][i-1];
w[j][i]=min(w[j][i-1],w[f[j][i-1]][i-1]);
}
scanf("%d",&t);
for(int i=1;i<=t;i++)
{
scanf("%d%d",&a,&b);
printf("%d\n",lca(a,b));
}
return 0;
}身为一个合格的蒟蒻，我是不会二项式定理的推广式的（就只能手推了）
一看到这个题，我的头就是一大，于是我拿出了草稿纸一算——好吧并不难（建议大家自己算一算，并没有你们想象的那么麻烦）
我们首先发现，在每个式子的展开式里，a的指数总等于x的指数，b的指数总等于y的指数，而且，x^n*y^m的常数系数就是一个指定的组合数c[k][n]（详情参见二项式定理）
那么，我们就可以使用杨辉三角预处理出组合数，再用快速幂计算a和b的乘方，最后把他们乘起来就好了
以下是标程：
#include<cstdio>
#include<iostream>
using namespace std;
int a,b,k,n,m,c[1010][1010],p=10007;
void couple()//计算杨辉三角
{
c[0][0]=1;
c[1][0]=c[1][1]=1;
for(int i=2;i<=k;i++)
for(int j=0;j<=i;j++)
{
if(j==0||j==i){c[i][j]=1;continue;}
c[i][j]=(c[i-1][j]+c[i-1][j-1])%p;//看到很多人总喜欢每一项都%，其实是不用的，只要把已经%过的数的和或积再%一下就好了，多%就是浪费时间复杂度
}
}
long long qpow(int a,int b)//快速幂
{
long long ret=1%p;
while(b)
{
if(b&1)ret=ret*a%p;
b>>=1;
a=a*a%p;
}
return ret;
}
int main()
{
scanf("%d%d%d%d%d",&a,&b,&k,&n,&m);
a=a%p;b=b%p;
couple();
long long ans=(c[k][n]*(qpow(a,n)*qpow(b,m))%p)%p;//简单粗暴的输出
printf("%lld",ans);
return 0;
}标签：nod iostream odi cst name 必须 快速 mod baidu
原文地址：https://www.cnblogs.com/xsx-blog/p/11286994.html
