Noip蒟蒻专用模板

最新推荐文章于 2024-02-05 14:57:07 发布
最新推荐文章于 2024-02-05 14:57:07 发布
阅读量62 收藏
点赞数
原文链接：http://www.cnblogs.com/ifmyt/p/9909218.html
版权

目录

模板

数论

线性筛素数

#include <bits/stdc++.h>
using namespace std;
int n,notp[20000000],pri[2000000],tot;
void get(){
    notp[1]=1;
    for(int i=2;i<=n;i++){
        if(!notp[i]) pri[++tot]=i;
        for(int j=1;j<=tot&&i*pri[j]<=n;j++){
            notp[i*pri[j]]=1;
            if(i%pri[j]==0) break;
        }
    }
}
int k;
int main(){
    scanf("%d%d",&n,&k);
    get();
    for(int i=1;i<=k;i++){
        int a;
        scanf("%d",&a);
        if(!notp[a])puts("Yes");
        else puts("No");
    }
}

线性筛欧拉

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
typedef long long LL;
int notp[500000],pri[500000],cnt,phi[500000],n;
void get(){
    notp[1]=1;
    for(int i=2;i<=n;i++){
        if(!notp[i]) pri[++cnt]=i,phi[i]=i-1;
        for(int j=1;j<=cnt && i*pri[j]<=n;j++){
            notp[i*pri[j]]=1;
            if(i%pri[j]!=0)phi[i*pri[j]]=phi[i]*(pri[j]-1);
            if(i%pri[j]==0){
                phi[i*pri[j]]=phi[i]*pri[j];
                break;
            }
        }
    }
}
int main(){
    scanf("%d",&n);
    get();
    for(int i=1;i<=n;i++)printf("%d ",phi[i]);
}

裴蜀定理

#include<bits/stdc++.h>
using namespace std;
int n;
int gcd(int x,int y)
{
    return !y ? x : gcd(y,x%y);
}
int a , ans;
int main()
{
    cin >> n;
    cin >> ans;
    if(ans <0 )ans = -ans;
    for(int i = 2;i <= n;i ++)
    {
        cin >> a;
        if(a <0 )
            a = -a;
        ans = gcd(ans , a);
    }
    cout << ans;
}

卢卡斯定理

#include <cstdio>
using namespace std;
typedef long long LL;
int n,m,p;
LL inv[200011],fac[200101];
void get() {
    inv[1]=1;
    fac[0]=1;
    inv[0]=1;
    for(int i=1; i<=m+n; i++)fac[i]=fac[i-1]*i%p;
    for(int i=2; i<=m+n; i++)inv[i]=(p-p/i)%p*inv[p%i]%p;
    for(int i=2; i<=m+n; i++)inv[i]=inv[i-1]*inv[i]%p;
}
LL lucas(int x,int y) {
    if(x<y) return 0;
    else if(x<p) return fac[x]*inv[y]%p*inv[x-y]%p;
    else return lucas(x/p,y/p)%p*lucas(x%p,y%p)%p;
}
int main() {
    int T;
    scanf("%d",&T);
    while(T--) {
        scanf("%d%d%d",&n,&m,&p);
        get();
        printf("%lld\n",lucas(n+m,m)%p);
    }
}

矩阵快速幂

#include<iostream>
#include<cstring>
#define LL long long
using namespace std;
const int  mod = 1000000007;
LL n,k;
struct edge
{
    LL a[101][101];
};
edge A,B;
edge multi(edge x,edge y)
{
    edge C;
    memset(C.a,0,sizeof(C.a));
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= n; j++)
            for(int k = 1; k <= n; k ++)
                C.a[i][j]+=(x.a[i][k]*y.a[k][j])%mod,C.a[i][j]%=mod;
    return C;
}
int main()
{
    cin >> n >> k;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= n; j ++)
            cin >> A.a[i][j];
    for(int i = 1; i <= n; i ++)
        B.a[i][i]=1;
    while(k)
    {
        if(k&1)B=multi(B,A);
        A=multi(A,A);
        k>>=1;
    }
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= n; j ++)
            cout << B.a[i][j] << ' ';
        cout << endl;
    }
}

逆元

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;
long long A[5000000];
int n,p;
int main() {
    A[1]=1;
    cin >> n >> p;
    for(int i=2; i<=n; i++) {
        A[i]=((p-p/i)*A[p%i]%p+p)%p;
    }
    for(int i=1; i<=n; i++)printf("%d\n",A[i]);
}

高斯消元

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cmath>
#include <cstdio>
#define eps 1e-10
using namespace std;
double a[200][200];
int n;
void guass() {
    for(int i=1; i<=n; i++) {
        int wz=0;
        for(int j=i; j<=n; j++)
            if(fabs(a[j][i])>eps) {
                wz=j;
                break;
            }
        if(wz==0) {
            puts("No Solution");
            exit(0);
        }
        if(wz!=i)swap(a[i],a[wz]);
        double tmp=a[i][i];
        for(int j=1; j<=n+1; j++)a[i][j]/=tmp;
        for(int j=i+1; j<=n; j++) {
            double tmp=a[j][i];
            for(int k=1; k<=n+1; k++)a[j][k]-=a[i][k]*tmp;
        }
    }
    for(int i=n; i>=1; i--)
        for(int j=i+1; j<=n; j++) 
            if(fabs(a[i][j])>eps)
                a[i][n+1]-=a[j][n+1]*a[i][j],a[i][j]=0;
}
int main() {
//  freopen("a.in","r",stdin);
    cin >> n;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n+1; j++)
            cin >> a[i][j];
    guass();
    for(int i=1; i<=n; i++)printf("%.2lf\n",a[i][n+1]);
}

图论

割点

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
typedef long long LL;
const int N = 20010,M = 200010;
struct edge {
    int next,to;
} e[M];
int head[N],tot;
void add(int x,int y) {
    e[++tot].next = head[x];
    head[x] = tot;
    e[tot].to = y;
}
int n,m,low[N],dfn[N],cnt,vis[N];
void tarjan(int x,int f) {
    int num=0;
    dfn[x]=++cnt;
    low[x]=cnt;
    for(int i=head[x]; i; i=e[i].next) {
        int v=e[i].to;
        if(v == f)continue;
        if(!dfn[v]) {
            num++;
            tarjan(v,x);
            low[x]=min(low[x],low[v]);
            if(f!=0 && low[x]>=dfn[x]) vis[x]=1;
        } else low[x]=min(low[x],dfn[v]);
    }
    if(f==0 && num>=2) vis[x]=1;
}
int main() {
    scanf("%d%d",&n,&m);
    for(int i=1; i<=m; i++) {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b),add(b,a);
    }
    int ans=0;
    for(int i=1; i<=n; i++)
        if(!dfn[i])tarjan(i,0);
    for(int i=1;i<=n;i++) if(vis[i]) ans++;
    printf("%d\n",ans);
    for(int i=1; i<=n; i++) if(vis[i]) printf("%d\n",i);
}

最小生成树

#include<iostream>
#include<cstring>
#include<cstdio>
#define N 5001
using namespace std;
int n,m;
int a,b,c,ans;
int flag[N],map[N][N],dis[N];
int main()
{
    memset(map,0x3f,sizeof(map));
    memset(dis,0x3f,sizeof(dis));
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>a>>b>>c;
        map[a][b]=min(map[a][b],c);
        map[b][a]=map[a][b];
    }
    dis[1]=0;
    int k;
    for(int i=1;i<=n;i++)
    {
        k=0;
        for(int j=1;j<=n;j++)
            if(!flag[j]&&dis[j]<dis[k])
                k=j;
        flag[k]=1;
        for(int j=1;j<=n;j++)
            if(!flag[j]&&map[k][j]<dis[j])
                dis[j]=map[k][j];
    }
    for(int i=1;i<=n;i++)
    {
        if(!flag[i])
        {
            cout<<"orz";
            return 0;
        }
        ans+=dis[i];
    }
    cout<<ans;
}

倍增

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;
const int N = 500100;
struct edge {
    int next,to;
} e[N<<1];
int head[N],tot;
void add(int x,int y) {
    e[++tot].next=head[x];
    head[x]=tot;
    e[tot].to=y;
}
int n,m,rt;
int f[N][32],deep[N];
void dfs(int x,int fa) {
    f[x][0]=fa;
    deep[x]=deep[fa]+1;
    for(int i=1; i<=21; i++)f[x][i]=f[f[x][i-1]][i-1];
    for(int i=head[x]; i; i=e[i].next) {
        int v=e[i].to;
        if(v == fa) continue;
        dfs(v,x);
    }
}
int LCA(int x,int y) {
    if(deep[x]<deep[y]) swap(x,y);
    int delta=deep[x]-deep[y];
    for(int i=21; i>=0; i--) 
        if(delta >= (1<<i)) {
            delta-=(1<<i);
            x=f[x][i];
        }
    for(int i=21;i>=0;i--){
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    }
    if(x!=y) x=f[x][0];
    return x;
}
int main() {
    scanf("%d%d%d",&n,&m,&rt);
    for(int i=1; i<=n-1; i++) {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    deep[rt]=1;
    dfs(rt,0);
    while(m--){
        int a,b;
        scanf("%d%d",&a,&b);
        printf("%d\n",LCA(a,b));
    }
}

SPFA

#include<bits/stdc++.h>
using namespace std;
queue<int>q;
struct edge
{
    int next,to,dist;
} e[500007];
int head[500007],tot;
inline void add(int x,int y,int z)
{
    e[++tot].next=head[x];
    e[tot].to=y;
    e[tot].dist=z;
    head[x]=tot;
}
int n,m,s;
int f,g,w;
long  vis[500007],dis[500010];
void spfa()
{
    while(!q.empty())q.pop();
    for(int i=1; i<=n; i++)dis[i]=2147483647;
    dis[s]=0;
    q.push(s);
    vis[s]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u],v; v=e[i].to,i; i=e[i].next)
            if(e[i].dist+dis[u]<dis[v])
            {
                dis[v]=dis[u]+e[i].dist;
                if(!vis[v])
                    vis[v]=1,q.push(v);
            }
    }
}
int main()
{
    cin>>n>>m>>s;
    for(int i=1; i<=m; i++)cin>>f>>g>>w,add(f,g,w);
    spfa();
    for(int i=1;i<=n;i++)cout<<dis[i]<<' ';
    return 0;
}

负环

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define N 20000
using namespace std;
struct edge {
    int next , to , dist;
} e[N];
int head[N] , tot , vis[N] , dis[N] , T , n , m , num[N];
inline void add(int x,int y,int z) {
    e[++tot].next = head[x];
    e[tot].to = y;
    e[tot].dist = z;
    head[x] = tot;
}
bool spfa(int s) {
    memset(dis,0x3f3f,sizeof(dis));
    queue<int>q;
    vis[s] = 1;
    q.push(s);
    num[s]++;
    dis[s]=0;
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for(int i = head[u],v; i,v=e[i].to; i=e[i].next)
            if(dis[v]>dis[u]+e[i].dist) {
                num[v]++;
                if(num[v]>=n)return true;
                dis[v] = dis[u]+e[i].dist;
                if(!vis[v])
                    vis[v] = 1,q.push(v);
            }
    }
    return false;
}
int main() {
    cin >> T;
    while(T--) {
        scanf("%d%d",&n,&m);
        memset(vis,0,sizeof(vis));
        memset(num,0,sizeof(num));
        memset(head,0,sizeof(head));
        tot = 0;
        for(int i = 1; i <= m; i ++) {
            int a , b , w;
            scanf("%d%d%d",&a,&b,&w);
            if(w>=0) {
                e[++tot].next = head[a];
                e[tot].to = b;
                e[tot].dist = w;
                head[a] = tot;
                e[++tot].next = head[b];
                e[tot].to = a;
                e[tot].dist = w;
                head[b] = tot;
            } else {
                e[++tot].next = head[a]
                                ;
                e[tot].to = b;
                e[tot].dist = w;
                head[a] = tot;
            }
        }
        if(spfa(1))
            printf("YE5\n");
        else printf("N0\n");
    }
}

堆优化迪杰斯特拉

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long LL;
const int N = 100010,M = 200020;
struct edge {
    int next,to,dis;
} e[M];
struct node {
    int id,dis;
    node() {}
    node(int a,int b) {
        id=a,dis=b;
    }
};
priority_queue<node>q;
bool operator <(const node &a,const node &b) {
    return a.dis>b.dis;
}
int n,m,st,dis[N],head[N],tot;
void add(int x,int y,int z) {
    e[++tot].next = head[x];
    head[x] = tot;
    e[tot].to = y;
    e[tot].dis = z;
}
void dijkstra(int s) {
    memset(dis,0x3f,sizeof(dis));
    dis[s]=0;
    q.push(node(s,0));
    while(!q.empty()) {
        node x=q.top();
        q.pop();
        int u=x.id,d=x.dis;
        if(dis[u]!=d) continue;
        for(int i=head[u]; i; i=e[i].next) {
            int v=e[i].to;
            if(dis[v]>dis[u]+e[i].dis) {
                dis[v]=dis[u]+e[i].dis;
                q.push(node(v,dis[v]));
            }
        }
    }
}
int main() {
    scanf("%d%d%d",&n,&m,&st);
    for(int i=1; i<=m; i++) {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    dijkstra(st);
    for(int i=1; i<=n; i++)printf("%d ",dis[i]);
}

匈牙利

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long LL;
const int N = 2000;
int n,m,M;
int _map[N][N],result[N],vis[N];
bool dfs(int u) {
    for(int v=1; v<=m; v++)
        if(!vis[v]&&_map[u][v]) {
            vis[v]=1;
            if(!result[v]||dfs(result[v])) {
                result[v]=u;
                return true;
            }
        }
    return false;
}
int solve() {
    int ans=0;
    for(int u=1; u<=n; u++) {
        memset(vis,0,sizeof(vis));
        if(dfs(u))ans++;
    }
    return ans;
}
int main() {
    scanf("%d%d%d",&n,&m,&M);
    for(int i=1; i<=M; i++) {
        int a,b;
        scanf("%d%d",&a,&b);
        _map[a][b]=1;
    }
    printf("%d\n",solve());
}

数据结构

树状数组

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 500001;
int tree[N],n,m;
int lowbit(int x)
{
    return x&(-x);
}
void add(int x,int y)
{
    while(x<=n)
    {
        tree[x]+=y;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int ans=0;
    while(x!=0)
    {
        ans+=tree[x];
        x-=lowbit(x);
    }
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++)
    {
        int a;
        scanf("%d",&a);
        add(i,a);
    }
    for(int i=1; i<=m; i++)
    {
        int opt,x,y;
        scanf("%d%d%d",&opt,&x,&y);
        if(opt==1)add(x,y);
        else if(opt==2)printf("%d\n",sum(y)-sum(x-1));
    }
}

ST表

#include <bits/stdc++.h>
using namespace std;
int n,m,ST[100010][30];
void work(){
    for(int j=1;j<=21;j++){
        for(int i=1;i+(1<<j)-1<=n;i++)
            ST[i][j]=max(ST[i][j-1],ST[i+(1<<(j-1))][j-1]);
    }
}
int find(int l,int r){
    int k=log2(r-l+1);
    return max(ST[l][k],ST[r-(1<<k)+1][k]);
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&ST[i][0]);
    work();
    for(int i=1;i<=m;i++){
        int a,b;
        scanf("%d%d",&a,&b);
        printf("%d\n",find(a,b));
    }
}

线段树

#include<bits/stdc++.h>
using namespace std;
long long n,p,a,b,m,x,y,ans;
struct node {
    long long l,r,w,f;
} tree[500000];
inline void build(int k,int ll,int rr) {
    tree[k].l=ll,tree[k].r=rr;
    if(tree[k].l==tree[k].r) {
        cin>>tree[k].w;
        return;
    }
    int m=(ll+rr)/2;
    build(k<<1,ll,m);
    build(k<<1|1,m+1,rr);
    tree[k].w=tree[k<<1].w+tree[k<<1|1].w;
}
inline void down(int k) {
    tree[k<<1].f+=tree[k].f;
    tree[k<<1|1].f+=tree[k].f;
    tree[k<<1].w+=tree[k].f*(tree[k<<1].r-tree[k<<1].l+1);
    tree[k<<1|1].w+=tree[k].f*(tree[k<<1|1].r-tree[k<<1|1].l+1);
    tree[k].f=0;
}
inline void ask_interval(int k) {
    if(tree[k].l>=a&&tree[k].r<=b) {
        ans+=tree[k].w;
        return;
    }
    if(tree[k].f) down(k);
    int m=(tree[k].l+tree[k].r)/2;
    if(a<=m) ask_interval(k<<1);
    if(b>m) ask_interval(k<<1|1);
}
inline void change_interval(int k) {
    if(tree[k].l>=a&&tree[k].r<=b) {
        tree[k].w+=(tree[k].r-tree[k].l+1)*y;
        tree[k].f+=y;
        return;
    }
    if(tree[k].f) down(k);
    int m=(tree[k].l+tree[k].r)/2;
    if(a<=m) change_interval(k<<1);
    if(b>m) change_interval(k<<1|1);
    tree[k].w=tree[k<<1].w+tree[k<<1|1].w;
}
int main() {
    cin>>n>>m;
    build(1,1,n);
    for(int i=1; i<=m; i++) {
        cin>>p;
        ans=0;
        if(p==1) {
            cin>>a>>b>>y;
            change_interval(1);
        }
        if(p==2) {
            cin>>a>>b;
            ask_interval(1);
            cout<<ans<<endl;
        }
    }
}

字符串

kmp

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
char s1[2000000],s2[2000000];
int kmp[2000000];
int main() {
    cin >> s1 >> s2;
    int len1=strlen(s1);
    int len2=strlen(s2);
    int k=0;
    for(int i=1; i<len2; i++) {
        while(k&&s2[k]!=s2[i])k=kmp[k];
        kmp[i+1]=(s2[k]==s2[i])?++k:0;
    }
    k=0;
    for(int i=0; i<len1; i++) {
        while(k&&s1[i]!=s2[k])k=kmp[k];
        (s1[i]==s2[k])?++k:0;
        if(k==len2) printf("%d\n",i+1-k+1);
    }
    for(int i=1; i<=len2; i++)printf("%d ",kmp[i]);
}

DP

最长公共子序列

// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
int n,a[200000],b[200000];
int dp[2000][2000];
int main()
{
    cin>>n;
    for(int i=1; i<=n; i++)
        cin>>a[i];
    for(int i=1; i<=n; i++)
        cin>>b[i];
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
        {
            dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            if(a[i]==b[j])
                dp[i][j]=max(dp[i][j],dp[i-1][j-1])+1;
        }
    cout<<dp[n][n];
}

转载于:https://www.cnblogs.com/ifmyt/p/9909218.html

weixin_30765475
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
NOIP基础算法综合-91页 PPT PDF版.pdf
06-10
NOIP基础算法综合-91页 PPT PDF版.pdf
NOIP初赛复习资料
11-27
NOIP初赛复习资料
KOJ系统常用功能介绍 OJ部署定制快速入门 c++ python 在线自动评测判题 信息奥赛一本通 G E S P CSP NOIP 等考题库 OJ使用
最新发布
u010896438的博客
02-05 1028
KOJ搭建
CSP-J1 CSP-S1 初赛 第1轮 第三章 阅读程序 第2节 普及篇 13、NOIP2007
青少年趣味编程
07-26 242
CSP-J1 CSP-S1 初赛 第1轮 第三章 阅读程序 第2节 普及篇 13、NOIP2007
2021 noip信息学学习
lck19930315的专栏
11-02 390
链接：https://pan.baidu.com/s/1aaFLUGEsPxwOWfhYp9iUrw 提取码：kivm --来自百度网盘超级会员V6的分享
NOIP基础知识分类全解
01-17
NOIP复习必备，很好用的，覆盖面广。
NOIP基本算法模板
10-22
NOIP 信息学 竞赛 普及组 提高组c++基本算法模板。信息学算法
NOIP模板1.zip
05-12
【标题】"NOIP模板1.zip"所包含的是用于全国奥林匹克信息学竞赛（NOIP）的编程模板。这些模板是作者在参加比赛期间积累并整理的，旨在帮助参赛者理解和解决竞赛中的常见问题，提高解题效率。 【描述】中的"NOIP...
noip模板整理
11-04
马上就退役了……这一路走来，风风雨雨，真的挺艰难的……希望noip能取得好成绩！！ 模板有密码，不过文件名已给出密码……正如密码所写的……自己的模板才是最好的，所以我给出的模板设置了一些权限，目的是希望...
NOIP算法模板（pascal版）
05-30
欢迎各位参加NOIP的同学们查看（早年总结的一些算法的模板），C++\C 的同学们也可以参考一下。
NOIP 2018 提高组模板大全
10-22
NOIP 2018即将来临，这里整理了一份常用的算法与数据结构模板，推荐各位下载。
YYH的王国（NOIP模拟赛Round 6）
weixin_30344995的博客
06-01 88
题目描述 YYH拥有一个有n个城市的国家，编号为1~n。其中城市i到城市j的路径长度为i和j的最小公倍数。现在YYH想建一些高速公路，使得任意两座城市都能通过高速公路直接或间接到达。建造一条高速公路的代价为这条高速公路的长度，他想知道最小代价是多少？ 输入输出格式 输入格式： 第一行输入一个整数，T，表示有T组数据。 接下来T行每行输出一个整数n，表示有n个国家 输出格式： ...
noip模拟测试17 2019-08-11 考后反思
weixin_30823227的博客
08-11 80
35+60+8 T1暴力，没有想到二维前缀和搞了个四维数组硬刚没敢开大，开大没有MLE多了15分; T2贪心正解，然而没开两倍边，dfs时候sd的只压了叶子？60->75->100 T3 rand数。。。 不行啊，差距太大了，时间分配不均，思维太傻，，，T1一点感觉没有，T2想了将近1个小时多，而且暴力打的慢，T1暴力打了将近一个小时。。。。。。T3想打状压来着的，权...
Noip 2014 senior 复赛 生活大爆炸版石头剪刀布（rps）
07-16 97
Noip 2014 senior 复赛 生活大爆炸版石头剪刀布（rps） 【问题描述】 石头剪刀布是常见的猜拳游戏：石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一 样，则不分胜负。在《生活大爆炸》第二季第 8 集中出现了一种石头剪刀布的升级版游戏。 升级版游戏在传统的石头剪刀布游戏的基础上，增加了两个新手势： 斯波克：《星际迷航》主角之一。 蜥蜴人：《星际迷航》中的反面角色...
备战NOIP——模板复习10
十甫-Blogs
11-01 130
这里只有模板，并不作讲解，仅为路过的各位做一个参考以及用做自己复习的资料，转载注明出处。 最短路算法 Dijkstra + 堆优化 /*Copyright: Copyright (c) 2018 *Created on 2018-11-1 *Author: 十甫 *Version 1.0 *Title: Dijkstra + heap *Time: 10 mins */ #inclu...
Jzoj5455【NOIP2017提高A组冲刺11.6】拆网线
扩展の灰(Extended Ash/Cooevjnz)
11-06 503
企鹅国的网吧们之间由网线互相连接，形成一棵树的结构。现在由于冬天到了，供暖部门缺少燃料，于是他们决定去拆一些网线来做燃料。但是现在有K只企鹅要上网和别人联机游戏，所以他们需要把这K只企鹅安排到不同的机房（两只企鹅在同一个机房会吵架），然后拆掉一些网线，但是需要保证每只企鹅至少还能通过留下来的网线和至少另一只企鹅联机游戏。 所以他们想知道，最少需要保留多少根网线？ 今天考场上又zz了，只切了第二
noip不知道哪年 货车运输
10-02 64
题意：最大生成树上找 q组两个点的lca 然后求出u->lca->v这条路径上的最小边 倍增大法好 # include <iostream> # include <stdio.h> # include <stdlib.h> # include <algorithm> # include <strin...
noip2018 洛谷 P5020 货币系统
weixin_30389003的博客
03-22 86
关键： 要使m最小，(m,b)中的数不能用（n,a）中的数表示出来 对于 3 19 10 6 19=10+3+3+3 6=3+3 只有3 和 10 不能被（n，a）中的数表示 所以m=2 只需要计算出存在多少个能被其它数组成的数计算出来就行了。 法一：完全背包 一个数只能被比它小的数字组成而不能被比它大的数字组成。 可以首先对数组排序，然后对...
NOIP大纲整理：（十三）基础算法详解
liusu201601的博客
08-07 2210
知识点罗列： 一、倍增思维： 1、倍增算法； 2、树上的LCA（最近公共祖先） ；3、快速幂 二、分治思维：1、二分查找；2、归并排序； 3、快速排序 三、贪心思维： 四、搜索：1、三种不同的问题； 2、两种不同的方法：bfs、dfs；3、优化搜索的技巧     一、倍增算法： 定义：用f[i][j]表示从i位置出发的2j个位置的信息综合（状态） 一个小小的问题：为什么是2j而不...
noip信息学竞赛常用模板
10-07
NOIP（全国青少年信息学奥林匹克竞赛）是中国一年一度的最高水平的信息学竞赛。参加NOIP竞赛的学生需要在规定的时间内解决一系列的算法和编程问题。为了更高效地解决这些问题，竞赛选手可以使用一些常用的模板。 一、输入输出模板： 在竞赛中常常需要读取大量的输入和输出结果，使用输入输出模板可以非常方便地处理这些操作。包括读取多个整数、多个字符串、多行数据等等，同时还需要注意输出格式的调整。 二、算法模板： 在NOIP竞赛中，常用的一些算法模板是必备的，例如贪心算法、动态规划、深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法、最小生成树算法等等。熟练使用这些算法模板可以帮助竞赛选手更快速地解决问题。 三、数据结构模板： 在NOIP竞赛中，常常需要使用一些数据结构来存储和处理数据，比如数组、链表、栈、队列、堆、哈希表、树、图等等。掌握这些数据结构的使用方法，可以在竞赛中更好地组织和处理数据。 四、模拟模板： 在竞赛中，模拟常常被用来解决一些简单的问题，例如处理字符串、模拟某些实际情境下的操作过程等等。使用模拟的方法可以使问题的解决更加直观和简单。 综上所述，这些NOIP信息学竞赛常用模板是竞赛选手们解决问题的有力工具。这些模板可以帮助选手更高效地解决问题，提高竞赛成绩。然而，模板的使用仅仅是一个辅助手段，还要求竞赛选手们具备扎实的算法和数据结构知识，并能够根据实际情况灵活运用模板解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值