北京大学OJ题目分类
python常见oj题目
在Python中，常见的在线判题（Online Judge，简称OJ）题目包括以下几种类型：
1.基本语法和数据类型：这类题目主要考察学生对Python基础语法的掌握程
度，例如定义变量、条件语句、循环语句等。
2.函数和模块：题目会要求学生定义函数、理解模块和包的使用，以及参数
传递等。
3.文件操作：涉及文件的读写、目录操作等题目。
4.数据结构和算法：这是OJ中最常见的题目类型，涉及各种数据结构（如数
组、链表、栈、队列、树、图等）和算法（如排序、搜索、动态规划等）。
5.高阶函数和面向对象编程：这类题目会考察学生对Python高阶函数（如
lambda函数、map/reduce等）以及面向对象编程的理解，如类和继承等。
6.网络编程和多线程/多进程：涉及socket编程、多线程或多进程的题目。
7.数据库操作：涉及数据库的增删改查等操作。
8.系统编程：涉及到操作系统的基本知识，例如进程管理、内存管理、并发
编程等。
在刷OJ题目时，可以从简单题目入手，逐渐挑战难度，并不断总结和复习，以全面提升编程能力。
oj分治法题目
以下是OJ分治法题目：
二分查找算法：给定一个有序数组，请你在数组中查找指定元素。
二分查找扩展：给定一个有序数组和一个目标值，请你在数组中查找目标值，并返回其索引。
如果目标值不存在于数组中，则返回-1。
归并排序算法：给定一个无序数组，请将其按照升序排序并输出。
快速排序算法：给定一个无序数组，请将其按照升序排序并输出。
判断回文数组：给定一个数组，判断该数组是否为回文数组。
如果是回文数组，则返回true；否则返回false。
寻找旋转排序数组中的最小值：给定一个旋转排序数组，请找出其中的最小值及其索引。
寻找数组中第k大的元素：给定一个未排序数组和一个整数k，请找出数组中第k大的元素。
判断子序列：给定两个有序数组，判断第一个数组是否为第二个数组的子序列。
如果是，则返回true；否则返回false。
寻找峰值：给定一个单调递增的整数数组，请找出其中的峰值。
寻找两数之和：给定一个整数数组和一个目标值，请找出数组中和为目标值的两个整数，并返回它们的下标。
以上题目都是OJ分治法的经典题目，难度较高。
需要通过将问题分解为更小的子问题来求解。
需要有一定的数据结构和算法基础才能解答这些题目。
北大ACM训练课程点
ACM/ICPC竞赛中用到的大量算法，包括：组合数学、数论、图论、计算几何、高级数据结构等。
北京大学
课程内容共八个专题，除理论知识外还包括精选例题讲解：
7.14 数据结构（一）: 线段树，树状数组，二维线段树
7.15 数学题：组合数学，数论等
7.16 数据结构（二）: 并查集, DFA, Trie图等
7.17 若干图论问题：最小生成树最短路强连通分量、桥和割点等
7.21 计算几何：线与线求交，线与面求交，求凸包，半平面求交等
7.22 搜索：深搜，广搜，剪枝，A*算法
7.24 动态规划
7.24 网络流算法：基本的网络流算法，Dinic算法，带上下界的网络流，最小费用
流。
oj传统题
oj传统题全文共四篇示例，供读者参考第一篇示例：随着计算机技术的飞速发展，越来越多的人开始关注到算法竞赛，而OJ 传统题作为算法竞赛的重要一环，也吸引着越来越多的人参与其中。
OJ，全称Online Judge，即在线评测系统，是一个用于测试和评测程序员编写代码的在线平台。
在OJ 上，开设有各种不同类型的题目，包括传统题、专题题、模拟题等等。
传统题是算法竞赛中最基础、最常见的类型之一，通常涉及各种经典的算法和数据结构。
传统题是算法竞赛中最基础、最常见的类型之一，通常包含一些常用的算法和数据结构的应用，如搜索、排序、动态规划、贪心等。
这些题目涵盖了算法竞赛中的基础知识，对于提高算法编程能力和解决实际问题具有重要的意义。
在传统题中，常见的题目包括最短路径算法、最小生成树算法、字符串处理、图论、数学等等。
这些题目具有一定的难度，需要程序员熟练掌握各种算法和数据结构才能解决。
在解决这些题目的过程中，程序员需要考虑到算法的时空复杂度以及代码的简洁性和鲁棒性。
传统题对于算法竞赛的参与者有着重要的意义。
传统题可以帮助程序员巩固基础知识，提高算法编程能力。
传统题涵盖了算法竞赛中常见的问题类型，可以帮助参与者更好地熟悉比赛题型。
传统题还可以锻炼程序员的解决问题的能力和思维模式，培养其对于问题的分析和解决能力。
在OJ 平台上，有许多知名的传统题目，如著名的ACM-ICPC比赛、Codeforces比赛等。
这些传统题目既有经典的题目，也有一些新颖的题目，吸引了众多程序员的参与和研究。
参与者可以通过解决这些传统题目来提升自己的算法竞赛水平，学习到更多的算法和数据结构知识。
传统题在算法竞赛中具有重要的地位和作用。
它不仅可以帮助程序员提高算法编程能力，还可以促进程序员之间的交流和学习。
通过解决传统题，程序员可以更好地应对算法竞赛中的挑战，取得更好的成绩。
我们鼓励更多的人参与到传统题的学习和解决中，共同提高算法竞赛水平，推动计算机科学的发展。
ACM入门题(北大oj)
1000#include<stdio.h>int main(){int a,b,c;while(scanf("%d%d",&a,&b)!=EOF){c=a+b;printf("%d\n",c);}}1067#include<stdio.h>#include<math.h>#include<stdlib.h>int main(){int a,b;while(scanf("%d%d",&a,&b)!=EOF){if(a>b){int t=a;a=b;b=t;}int k=b-a;int a0=(int)(k*(1+sqrt(5.0))/2);if(a0==a) printf("0\n");else printf("1\n");}}1080#include<stdio.h>#include<stdlib.h>int a[5][5]={5,-1,-2,-1,-3,-1,5,-3,-2,-4,-2,-3,5,-2,-2,-1,-2,-2,5,-1,-3,-4,-2,-1,0};int main(){int ca;scanf("%d",&ca);while(ca--){int n,m,i,j,max[105][105],b[105],d[105];char s[105],c[105];scanf("%d%s",&n,s);scanf("%d%s",&m,c);for(i=1;i<=n;i++){if(s[i-1]=='A') b[i]=0;if(s[i-1]=='C') b[i]=1;if(s[i-1]=='G') b[i]=2;if(s[i-1]=='T') b[i]=3;}for(i=1;i<=m;i++){if(c[i-1]=='A') d[i]=0;if(c[i-1]=='C') d[i]=1;if(c[i-1]=='G') d[i]=2;if(c[i-1]=='T') d[i]=3;}max[0][0]=0;for(i=1;i<=n;i++)max[i][0]=max[i-1][0]+a[b[i]][4];for(i=1;i<=m;i++)max[0][i]=max[0][i-1]+a[4][d[i]];for(i=1;i<=n;i++)for(j=1;j<=m;j++){max[i][j]=max[i-1][j-1]+a[b[i]][d[j]];if(max[i-1][j]+a[b[i]][4]>max[i][j])max[i][j]=max[i-1][j]+a[b[i]][4];if(max[i][j-1]+a[4][d[j]]>max[i][j])max[i][j]=max[i][j-1]+a[4][d[j]];}printf("%d\n",max[n][m]);}}1013#include<stdio.h>#include<algorithm>#include<math.h>#include<stdlib.h>#define PI 3.141592653using namespace std;struct point{double x;double y;}p[30005],res[30005];int cmp(point p1,point p2){return p1.y<p2.y||(p1.y==p2.y&&p1.x<p2.x);}bool ral(point p1,point p2,point p3){if((p2.x-p1.x)*(p3.y-p1.y)<=(p2.y-p1.y)*(p3.x-p1.x)) return true;return false;}double dis(point p1,point p2){return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));}int main(){int n,m;while(scanf("%d%d",&n,&m)!=EOF){int i,j;for(i=0;i<n;i++)scanf("%lf%lf",&p[i].x,&p[i].y);sort(p,p+n,cmp);res[0]=p[0];res[1]=p[1];int top=1;for(i=2;i<n;i++){while(top&&ral(res[top-1],res[top],p[i]))top--;res[++top]=p[i];}int len=top;res[++top]=p[n-2];for(i=n-3;i>=0;i--){while(top!=len&&ral(res[top-1],res[top],p[i]))top--;res[++top]=p[i];}double t=0;for(i=0;i<top;i++)t=t+dis(res[i],res[i+1]);printf("%.lf\n",t+2*PI*m);}}1149#include<iostream>#include<cstring>using namespace std;#define inf 0x5fffffffint a[105][105],f[1005],ct[1005],pre[205],n,m,q[105]; int bfs(){int flow=inf,qh=0,qe=1,i;memset(pre,-1,sizeof(pre));q[1]=0;pre[0]=-1;while(qh<qe){int t=q[++qh];for(i=1;i<=n+1;i++)if(pre[i]==-1&&a[t][i]>0){pre[i]=t;if(a[t][i]<flow) flow=a[t][i];if(i==n+1) return flow;q[++qe]=i;}}return -1;}void maxflow(){int res=0,ans,t;while((ans=bfs())!=-1){res=res+ans;t=n+1;while(t)a[pre[t]][t]-=ans;a[t][pre[t]]+=ans;t=pre[t];}}printf("%d\n",res);}int main(){while(scanf("%d%d",&m,&n)!=EOF){memset(f,-1,sizeof(f));memset(a,0,sizeof(a));int i,j,k,t;for(i=1;i<=m;i++)scanf("%d",&ct[i]);for(i=1;i<=n;i++){scanf("%d",&k);for(j=1;j<=k;j++){scanf("%d",&t);if(f[t]!=-1) a[f[t]][i]=inf;else a[0][i]=a[0][i]+ct[t];f[t]=i;}scanf("%d",&k);a[i][n+1]=k;}maxflow();}}1157#include<stdio.h>#include<stdlib.h>int a[105][105],b[105][105];int main(){int max(int x,int y);int n,m;while(scanf("%d%d",&n,&m)!=EOF){for(i=1;i<=n;i++)for(j=1;j<=m;j++)scanf("%d",&a[i][j]);b[1][1]=a[1][1];for(i=2;i<=m-n+1;i++){if(a[1][i]<b[1][i-1]) b[1][i]=b[1][i-1];else b[1][i]=a[1][i];}for(i=2;i<=n;i++)for(j=i;j<=i+m-n;j++){a[i][j]=a[i][j]+b[i-1][j-1];if(i==j) b[i][j]=a[i][j];else{if(a[i][j]>b[i][j-1]) b[i][j]=a[i][j];else b[i][j]=b[i][j-1];}}printf("%d\n",b[n][m]);}}1200#include<stdio.h>#include<string.h>bool flag[20000000];int a[300];char s[20000000];int main(){int n,m;while(scanf("%d%d",&n,&m)!=EOF){memset(flag,0,sizeof(flag));scanf("%s",s);int i,j=0,len=strlen(s);memset(a,0,sizeof(a));for(i=0;i<len;i++)a[s[i]]=1;for(i=0;i<256;i++)if(a[i]==1) a[i]=j++;int mod=1,res=0;for(i=0;i<n-1;i++)mod=mod*m;for(i=0;i<n;i++)res=res*m+a[s[i]];flag[res]=1;for(i=n;i<len;i++){res=res%mod*m+a[s[i]];flag[res]=1;}int count=0;mod=mod*m;for(i=0;i<=mod;i++)if(flag[i]==1) count++;printf("%d\n",count);}}1207#include<stdio.h>#include<stdlib.h>int main(){int b,c,i,j,max=0,k,t,r;while(scanf("%d%d",&b,&c)!=EOF){if(b>c){t=b;r=c;}else{t=c;r=b;}max=0;for(i=r;i<=t;i++){j=1;k=i;while(k!=1){j++;if(k%2==0) k=k/2;else k=3*k+1;}if(j>max) max=j;}printf("%d %d %d\n",b,c,max);}//system("pause");}1273#include<iostream>#include<cstring>#include<queue>using namespace std;#define inf INT_MAXint n,m,a[205][205],pre[205],lev[205],num[205]; void bfs(){queue<int>Q;memset(lev,-1,sizeof(lev));memset(num,0,sizeof(num));Q.push(n);lev[n]=0;num[0]=1;while(!Q.empty()){int t=Q.front(),i;Q.pop();for(i=1;i<=n;i++)if(lev[i]==-1&&a[i][t]>0){lev[i]=lev[t]+1;num[lev[i]]++;Q.push(i);}}}int maxflow(){int flow=0,i,ans,cur=1;bfs();while(lev[cur]<n){if(cur==n){ans=inf;while(cur!=1){if(a[pre[cur]][cur]<ans) ans=a[pre[cur]][cur];cur=pre[cur];}cur=n;while(cur!=1){a[pre[cur]][cur]-=ans;a[cur][pre[cur]]+=ans;cur=pre[cur];}flow=flow+ans;}for(i=1;i<=n;i++)if(a[cur][i]>0&&lev[cur]==lev[i]+1){pre[i]=cur;cur=i;break;}if(i>n){lev[cur]=n+1;num[lev[cur]]--;if(num[lev[cur]]==0) break;for(i=1;i<=n;i++)if(a[cur][i]>0&&lev[i]+1<lev[cur]) lev[cur]=lev[i]+1;num[lev[cur]]++;if(cur!=1) cur=pre[cur];}}return flow;}int main(){while(scanf("%d%d",&m,&n)!=EOF){int i,j;memset(a,0,sizeof(a));for(i=0;i<m;i++){int b,c,d;scanf("%d%d%d",&b,&c,&d);a[b][c]+=d;}printf("%d\n",maxflow());}}1285#include<stdio.h>#include<string.h>int num[55];unsigned __int64 f[55][55];int main(){int n,m,ct=0;while(scanf("%d%d",&n,&m)!=EOF){if(n==0&&m==0) break;int i,j,a,k;memset(num,0,sizeof(num));for(i=0;i<n;i++){scanf("%d",&a);num[a]++;}memset(f,0,sizeof(f));f[0][0]=1;for(i=0;i<50;i++)for(j=0;j<=50;j++)for(k=0;k<=num[i+1];k++)f[i+1][j+k]=f[i+1][j+k]+f[i][j];printf("Case %d:\n",++ct);for(i=0;i<m;i++){scanf("%d",&a);printf("%I64d\n",f[50][a]);}}}1364#include <iostream>#include <queue>#include <cstring>using namespace std;int v[105],pre[105],w[105],h[105],flag[105],ct[105],d[105],n,m,num; void add(int a,int b,int c){v[num]=b;pre[num]=h[a];w[num]=c;h[a]=num++;}bool spfa(){int i;queue<int> Q;for(i=0;i<=n;i++){Q.push(i);flag[i]=1;d[i]=0;}while(!Q.empty()){int t=Q.front();Q.pop();flag[t]=0;for(i=h[t];i>=0;i=pre[i]){int p=v[i];if(d[t]+w[i]<d[p]){d[p]=d[t]+w[i];ct[p]++;if(flag[p]==0){Q.push(p);flag[p]=1;}}if(ct[p]>n) return false;}}return true;}int main(){while(cin>>n){if(n==0) break;cin>>m;int a,b,c;char s[3];num=0;memset(flag,0,sizeof(flag));memset(ct,0,sizeof(ct));memset(h,-1,sizeof(h));for(int i=1;i<=m;i++){cin>>a>>b>>s>>c;if(strcmp(s,"gt")==0) add(a-1,a+b,-1-c);else add(a+b,a-1,c-1);}if(spfa()) cout<<"lamentable kingdom"<<endl;else cout<<"successful conspiracy"<<endl;}return 0;}1384#include<stdio.h>#include<stdlib.h>int b[10005],a[600][2];int main(){int ca;scanf("%d",&ca);while(ca--){int M1,M2,M,n,i,j,value;scanf("%d%d",&M1,&M2);M=M2-M1;scanf("%d",&n);for(i=0;i<n;i++)scanf("%d%d",&a[i][0],&a[i][1]);for(i=0;i<=M;i++)b[i]=-1;b[0]=0;for(i=0;i<n;i++)for(j=0;j+a[i][1]<=M;j++)if(b[j]!=-1){value=b[j]+a[i][0];if(value<b[j+a[i][1]]||b[j+a[i][1]]==-1)b[a[i][1]+j]=value;}if(b[M]==-1) printf("This is impossible.\n");elseprintf("The minimum amount of money in the piggy-bank is %d.\n",b[M]);}}1473#include<stdio.h>#include<math.h>#include<stdlib.h>#include<string.h>int main(){char S[300],c[300][100];int count1=0;while(scanf("%s",S)!=EOF){if(strcmp(S,"END")==0) break;int len=strlen(S),i,count=0,j=0,d;for(i=0;i<len;i++){if(S[i]!=','&&S[i]!='.'){c[count][j]=S[i];j++;}else{c[count][j]='\0';j=0;count++;}}int nw=0,ne=0,sw=0,se=0,n=0,s=0,e=0,w=0;for(i=0;i<count;i++){char cc[10];sscanf(c[i],"%[0-9]",cc);sscanf(cc,"%d",&d);if(strlen(c[i])==strlen(cc)+1){if(c[i][strlen(cc)]=='N') n+=d;if(c[i][strlen(cc)]=='S') s+=d;if(c[i][strlen(cc)]=='E') e+=d;if(c[i][strlen(cc)]=='W') w+=d;}if(strlen(c[i])==strlen(cc)+2){if(c[i][strlen(cc)]=='N'&&c[i][strlen(cc)+1]=='W')nw+=d;if(c[i][strlen(cc)]=='N'&&c[i][strlen(cc)+1]=='E') ne+=d;if(c[i][strlen(cc)]=='S'&&c[i][strlen(cc)+1]=='W') sw+=d;if(c[i][strlen(cc)]=='S'&&c[i][strlen(cc)+1]=='E') se+=d;}}double x=e-w+((ne+se-nw-sw)*sqrt(2))/2;double y=n-s+((nw+ne-sw-se)*sqrt(2))/2;double ss=sqrt(x*x+y*y);count1++;printf("Map #%d\n",count1);printf("The treasure is located at (%.3lf,%.3lf).\n",x,y);printf("The distance to the treasure is %.3lf.\n",ss);printf("\n");}}1505#include<stdio.h>#include<string.h>#include<stdlib.h>int a[510],s[510],t[505][505],num[505],flag[505];int ma(int x,int y){if(x<y) return y;return x;}int main(){int ca;scanf("%d",&ca);while(ca--){int n,m,i,j,k,res;scanf("%d%d",&n,&m);for(i=1;i<=n;i++)scanf("%d",&a[i]);s[0]=0;for(i=1;i<=n;i++)s[i]=s[i-1]+a[i];for(i=1;i<n;i++)t[1][i]=s[i];memset(flag,0,sizeof(flag));for(i=2;i<m;i++)for(j=i;j<n;j++){res=1000000000;for(k=i-1;k<=j-1;k++)if(res>ma(t[i-1][k],s[j]-s[k])) res=ma(t[i-1][k],s[j]-s[k]);t[i][j]=res;}res=s[n];for(i=m-1;i<n;i++)if(ma(t[m-1][i],s[n]-s[i])<res) res=ma(t[m-1][i],s[n]-s[i]);num[0]=n;for(i=1;i<m;i++){int ti=0;for(j=num[i-1];j>m-i;j--){ti=ti+a[j];if(ti>res) break;}num[i]=j;flag[j]=1;}for(i=1;i<n;i++){if(flag[i]==0) printf("%d ",a[i]);else printf("%d / ",a[i]);}printf("%d\n",a[i]);}}1511#include<iostream>#include<cstring>#include<cstdio>#include<queue>#define inf 2000000000using namespace std;int ct,pre[1000005],len[1000005],v[1000005],h[1000005],n,m,vis[1000005],l[1000005]; int a[1000005],b[1000005],c[1000005];queue<int> Q;void add(int a,int b,int c){pre[ct]=h[a];len[ct]=c;v[ct]=b;h[a]=ct++;}void spfa(){int i;memset(vis,0,sizeof(vis));Q.push(1);vis[1]=1;for(i=1;i<=n;i++)l[i]=inf;l[1]=0;while(!Q.empty()){int t=Q.front();for(i=h[t];i!=-1;i=pre[i])if(l[t]+len[i]<l[v[i]]){l[v[i]]=l[t]+len[i];if(vis[v[i]]==0){vis[v[i]]=1;Q.push(v[i]);}}Q.pop();vis[t]=0;}}int main(){int ca;scanf("%d",&ca);while(ca--){scanf("%d%d",&n,&m);int i,j;__int64 res=0;ct=0;memset(h,-1,sizeof(h));for(i=0;i<m;i++){scanf("%d%d%d",&a[i],&b[i],&c[i]);add(a[i],b[i],c[i]);}spfa();for(i=2;i<=n;i++)res=res+l[i];ct=0;memset(h,-1,sizeof(h));for(i=0;i<m;i++)add(b[i],a[i],c[i]);spfa();for(i=2;i<=n;i++)res=res+l[i];printf("%I64d\n",res);}}1609#include<stdio.h>#include<stdlib.h>int a[105][105];int main(){int n;while(scanf("%d",&n)!=EOF){if(n==0){printf("*\n");break;}int i,j;for(i=0;i<101;i++)for(j=0;j<101;j++)a[i][j]=0;for(i=0;i<n;i++){int m,k;scanf("%d%d",&m,&k);a[m][k]=a[m][k]+1;}for(i=1;i<101;i++)for(j=1;j<101;j++)if(i*j!=1){if(a[i][j-1]>=a[i-1][j])a[i][j]=a[i][j]+a[i][j-1];elsea[i][j]=a[i][j]+a[i-1][j];}printf("%d\n",a[100][100]);}}1611#include<iostream>using namespace std;int f[30005],cont[30005];int findf(int a){if(f[a]!=a) f[a]=findf(f[a]);return f[a];}void com(int a,int b){int x=findf(a);int y=findf(b);if(x==y) return;if(cont[x]<=cont[y]){f[x]=y;cont[y]=cont[x]+cont[y];}else{f[y]=x;cont[x]=cont[x]+cont[y];}}int main(){int m,n;while(scanf("%d%d",&n,&m)!=EOF&&n){int num,st,i,j,ed;for(i=0;i<n;i++){f[i]=i;cont[i]=1;}for(i=0;i<m;i++){scanf("%d%d",&num,&st);for(j=1;j<num;j++){scanf("%d",&ed);com(st,ed);}}printf("%d\n",cont[findf(0)]);}}1651#include<stdio.h>#include<stdlib.h>long a[105],i,s[105][105],j,t,k;int main(){int n;while(scanf("%d",&n)!=EOF){for(i=0;i<n;i++)scanf("%ld",&a[i]);for(i=0;i<n-1;i++)s[i][i+1]=0;for(j=2;j<n;j++)for(i=0;i+j<n;i++){t=100000000;for(k=i+1;k<i+j;k++)if(s[i][k]+s[k][i+j]+a[i]*a[k]*a[i+j]<t)t=s[i][k]+s[k][i+j]+a[i]*a[k]*a[i+j];s[i][i+j]=t;}printf("%ld\n",s[0][n-1]);}}1753#include<iostream>using namespace std;int t[]={19,39,78,140,305,626,1252,2248,4880,10016,20032,35968,12544,29184,58368,51200}; #define SIZE 65535int BFS(int state){int visited[SIZE],d[SIZE],u,v,i;int Qu[SIZE],rear,front;memset(visited,0,sizeof(visited));visited[state]=1;d[state]=0;rear=front=0;Qu[++rear]=state;while(rear!=front){u=Qu[++front];for(i=0;i<16;++i) {v=u^t[i];if(v==0 || v==65535) return d[u]+1;if(visited[v]==0){visited[v]=1;d[v]=d[u]+1;Qu[++rear]=v;}visited[u]=-1;}return -1;}int main(){char ch[5][5];int i,j,start;start=0;for(i=0;i<4;++i)scanf("%s",ch[i]);for(i=0;i<4;++i)for(j=0;j<4;++j)if(ch[i][j]=='b') start^=(1<<((3-i)*4+(3-j)));if(start==0||start==65535) printf("0\n");else{int result=BFS(start);if(result==-1) printf("Impossible\n");else printf("%d\n",result);}}1797#include<stdio.h>#include<string.h>int a[1005][1005],vis[1005],len[1005];int mm(int a,int b){return a<b?a:b;}int main(){int ca,ct=0;scanf("%d",&ca);while(ca--){int n,m;scanf("%d%d",&n,&m);int i,j;memset(a,0,sizeof(a));for(i=1;i<=m;i++)int r,t,l;scanf("%d%d%d",&r,&t,&l);a[r][t]=l;a[t][r]=l;}memset(vis,0,sizeof(vis));for(i=2;i<=n;i++)len[i]=a[1][i];vis[1]=1;for(i=1;i<n;i++){int mmax=0,k;for(j=2;j<=n;j++)if(vis[j]==0&&len[j]>mmax){mmax=len[j];k=j;}vis[k]=1;if(k==n) break;for(j=2;j<=n;j++)if(vis[j]==0){int length=mm(len[k],a[k][j]);if(length>len[j]) len[j]=length;}}printf("Scenario #%d:\n%d\n\n",++ct,len[n]);}}1845#include<iostream>#include<cstring>using namespace std;#define mod 9901__int64 pri[7505],a[100],num[100];void prime(){memset(pri,0,sizeof(pri));int i,j;for(i=2;i<=90;i++)for(j=2;i*j<=7500;j++)j=0;for(i=2;i<=7500;i++)if(pri[i]==0) pri[j++]=i;}__int64 yu(__int64 a,__int64 b){__int64 res=1,c=mod;while(b){if(b%2==0){a=(a%c)*(a%c)%c;b=b/2;}else{res=res*a%c;b--;}}return res;}__int64 f(__int64 a,__int64 b){if(b==0) return 1;if(b==1) return (1+a)%mod;if(b%2==0) return (yu(a,b/2)+(1+yu(a,b/2+1))*f(a,b/2-1))%mod;return ((1+yu(a,b/2+1))*f(a,b/2))%mod;}int main(){prime();int n,m;while(scanf("%d%d",&n,&m)!=EOF){int i,j=0;if(n==0){printf("1\n");continue;}for(i=0;pri[i]*pri[i]<=n;i++)if(n%pri[i]==0){int t=0;while(n%pri[i]==0){t++;n=n/pri[i];}a[j]=pri[i];num[j++]=t;}if(n!=1){a[j]=n;num[j++]=1;}__int64 res=1;for(i=0;i<j;i++)res=res*f(a[i],num[i]*m)%mod;printf("%I64d\n",res);}}1941#include<stdio.h>#include<string.h>int h[22],s[22];char c[1025][2050],ss[1025][2050];void solve(int m){int i,j;if(m==1){h[m]=4;s[m]=2;c[1][1]=' ';c[1][4]=' ';c[1][2]='/';c[1][3]='\\';c[2][1]='/';c[2][2]='_';c[2][3]='_';c[2][4]='\\';memcpy(ss,c,sizeof(c));}if(m!=1){memset(c,' ',sizeof(c));solve(m-1);h[m]=h[m-1]*2;s[m]=s[m-1]*2;for(i=s[m-1]+1;i<=s[m];i++)for(j=1;j<=h[m-1];j++)c[i][j]=c[i][j+h[m-1]]=ss[i-s[m-1]][j];for(i=1;i<=s[m-1];i++)for(j=h[m-1]/2*3;j>h[m-1]/2;j--){c[i][j]=ss[i][j-h[m-1]/2];c[i][j-h[m-1]/2]=' ';}memcpy(ss,c,sizeof(c));}}int main(){int n,i,j,k;h[0]=2;solve(10);while(scanf("%d",&n)!=EOF&&n){for(i=1;i<=s[n];i++){for(j=h[9]-h[n]/2+1;j<=h[9]+i;j++)printf("%c",c[i][j]);printf("\n");}printf("\n");}}1947#include<iostream>#include<algorithm>using namespace std;#define big 10000000int num[155],flag[155],son[155][155],step[155][155],n,m,root; void dsf(int v)int i,j,k;if(v!=root) step[v][1]=num[v]+1;else step[v][1]=num[v];for(i=0;i<num[v];i++){dsf(son[v][i]);for(j=m-1;j>=1;j--)if(step[v][j]<big){for(k=1;k+j<=m;k++)step[v][k+j]=min(step[v][k+j],step[v][j]+step[son[v][i]][k]-2);}}}int main(){while(scanf("%d%d",&n,&m)!=EOF){memset(num,0,sizeof(num));memset(flag,0,sizeof(flag));int i,a,b,j;for(i=1;i<n;i++){scanf("%d%d",&a,&b);flag[b]=1;son[a][num[a]++]=b;}for(i=1;i<=150;i++)for(j=1;j<=150;j++)step[i][j]=big;for(i=1;i<=n;i++)if(flag[i]==0){root=i;dsf(i);break;}int res=big;for(i=1;i<=n;i++)if(step[i][m]<res) res=step[i][m];printf("%d\n",res);}}1964#include<stdio.h>#include<string.h>char s[1005][1005][2];int a[1005][1005],pre[1005],next[1005];int main(){int ca;scanf("%d",&ca);while(ca--){int n,m,i,j,k,res=0;scanf("%d%d",&n,&m);for(i=0;i<n;i++)for(j=0;j<m;j++)scanf("%s",s[i][j]);for(i=0;i<m;i++)if(strcmp(s[0][i],"F")==0) a[0][i]=1;else a[0][i]=0;for(i=1;i<n;i++)for(j=0;j<m;j++)if(strcmp(s[i][j],"F")==0) a[i][j]=a[i-1][j]+1;else a[i][j]=0;for(i=0;i<n;i++){memset(pre,-1,sizeof(pre));for(j=1;j<m;j++)for(k=j-1;k!=-1;k=pre[k])if(a[i][k]<a[i][j]){pre[j]=k;break;}for(j=0;j<m;j++)next[j]=m;for(j=m-2;j>=0;j--)for(k=j+1;k!=m;k=next[k])if(a[i][k]<a[i][j]){next[j]=k;break;}for(j=0;j<m;j++)if((next[j]-pre[j]-1)*a[i][j]>res) res=(next[j]-pre[j]-1)*a[i][j];}printf("%d\n",res*3);}}。
北京大学POJ 1003-1006参考代码
1006 题中国乘剩定理#include<stdio.h>#define N 100int main(){int day,p,e,i,d;int n,j=0;while(scanf("%d%d%d%d",&p,&e,&i,&d)==4&&(p!=-1||e!=-1||i!=-1||d!=-1)){day=(1288*i+14421*e+5544*p-d+21252)%21252;if(!day)day=21252;printf("Case %d: the next triple peak occurs in %d days.\n",++j,day);}return 0;}1005 求园面积和点的问题要用到勾股定理#include<stdio.h>#include<math.h>#define N 200#define PI 3.141592653589793int main(){int n,i;float arr[N][3];while(scanf("%d",&n)==1){for(i=0;i<n;i++){scanf("%f%f",&arr[i][0],&arr[i][1]);arr[i][2]=ceil((pow(arr[i][0],2)+pow(arr[i][1],2))*PI/100);}for(i=0;i<n;i++)printf("Property %d: This property will begin eroding in year %1.0f.\n",i+1,arr[i][2]);printf("END OF OUTPUT.\n");}return 0;}1004 求平均值的问题#include<stdio.h>int main(){int i,mid;float arr[12],sum;sum=0.0;for(i=0;i<12;i++){scanf("%f",&arr[i]);sum+=arr[i];}sum/=12.0;printf("$%0.2f\n",(int)(sum*100+0.5)/100.0);return 0;}1003 求卡片的问题#include<stdio.h>int count(float );int main(){float h;while(scanf("%f",&h)!=EOF&&h){ printf("%d card(s)\n",count(h));}return 0;}int count(float h){float sum=0.0;int n=2;while(sum<h){sum+=1.0/n;n++;}return n-2;}。
oj传统题
oj传统题
"OJ" 通常指的是在线判题系统（Online Judge），它是用于自动判断和测试编程题目答案正确性的系统。
在OJ上，有许多不同难度级别的编程题目，从简单的基础题目到复杂的算法题目都有。
"传统题" 可能指的是一些经典的、常见的编程题目类型，比如：
1.数组和字符串操作：这类题目通常涉及对数组或字符串的基本
操作，如排序、查找、替换等。
2.数学和算法：包括各种数学和算法问题，如最大公约数、最小
公倍数、动态规划、图论等。
3.数据结构：如链表、栈、队列、树、图等数据结构的应用。
4.模拟和模拟题：这类题目通常模拟某种现实场景或过程，需要
理解和分析题目背景，然后编写代码来模拟这个过程。
5.图形和算法可视化：这类题目可能涉及图形算法、路径查找、
图像处理等。
由于“传统题”并没有一个明确的定义，以上只是一些可能包含在传统题范围内的例子。
具体的题目内容和难度可能会因OJ平台、比赛或课程而异。
最新北大ACM-题型分类
11、排序 (4)22、搜索、回溯、遍历 (4)33、历法 (5)44、枚举 (5)55、数据结构的典型算法 (6)66、动态规划 (6)77、贪心 (8)88、模拟 (8)99、递归 (8)1010、字符串处理 (9)1111、数论 (9)1212、几何有关的题目 (9)1313、任意精度运算、数字游戏、高精度计算 (10)1414、概率统计 (10)1515、小费用最大流、最大流 (10)1616、压缩存储的DP (11)1717、最长公共子串（LCS） (11)1818、图论及组合数学 (11)1919、博弈类 (16)2020、简单、模拟题 (17)2121、匹配 (24)2222、经典 (24)2323、趣味 (25)2424、很繁的题 (26)2525、难题 (27)2626、多解题 (27)2727、Note: (28)282930主流算法：32331.搜索//回溯34352.DP（动态规划）36373.贪心384.图论//Dijkstra、最小生成树、网络流39405.数论//解模线性方程41426.计算几何//凸壳、同等安置矩形的并的面积与周长43447.组合数学//Polya定理45468.模拟47489.数据结构//并查集、堆495010.博弈论5153541、排序55561423, 1694, 1723, 1727, 1763, 1788, 1828, 1838, 1840, 2201, 2376, 2377, 572380, 1318, 1877,58591928, 1971, 1974, 1990, 2001, 2002, 2092, 2379,60611002（需要字符处理，排序用快排即可） 1007（稳定的排序） 2159（题意较62难懂） 2231 2371（简单排6364序） 2388（顺序统计算法） 2418（二叉排序树）65662、搜索、回溯、遍历67681022 1111 1118 1129 1190 1562 1564 1573 1655 2184 2225 2243 2312 2362 692378 238670711010,1011,1018,1020,1054,1062,1256,1321,1363,1501，72731650,1659,1664,1753,2078,2083,2303,2310,232974简单：1128, 1166, 1176, 1231, 1256, 1270, 1321, 1543, 1606, 1664, 1731, 761742, 1745, 1847,77781915, 1950, 2038, 2157, 2182, 2183, 2381, 2386, 2426,79不易：1024, 1054, 1117, 1167, 1708, 1746, 1775, 1878, 1903, 1966, 2046, 802197, 2349,81推荐：1011, 1190, 1191, 1416, 1579, 1632, 1639, 1659, 1680, 1683, 1691, 821709, 1714, 1753,83841771, 1826, 1855, 1856, 1890, 1924, 1935, 1948, 1979, 1980, 2170, 2288, 852331, 2339,86872340,1979（和迷宫类似） 1980（对剪枝要求较高）88893、历法90911008 2080 （这种题要小心）92934、枚举94951012，1046， 1387， 1411， 2245， 2326， 2363， 2381，1054（剪枝要求96较高），1650 （小数的精9798度问题）991005、数据结构的典型算法101102容易：1182, 1656, 2021, 2023, 2051, 2153, 2227, 2236, 2247, 2352, 2395, 103不易：1145, 1177, 1195, 1227, 1661, 1834,104推荐：1330, 1338, 1451, 1470, 1634, 1689, 1693, 1703, 1724, 1988, 2004, 1052010, 2119, 2274,1061071125(弗洛伊德算法) ，2421（图的最小生成树）1081096、动态规划1101111037 A decorative fence、1121131050 To the Max、1141151088 滑雪、1161171125 Stockbroker Grapevine、1181191141 Brackets Sequence、1201211159 Palindrome、1221231160 Post Office、1241251163 The Triangle、1261271458 Common Subsequence、1281291579 Function Run Fun、1301311887 Testing the CATCHER、1321331953 World Cup Noise、1341352386 Lake Counting1361377、贪心1381391042, 1065, 1230, 1323, 1477, 1716, 1784,1328 1755（或用单纯形方法），1402054，1017， 1328，1411421862， 1922 ，2054， 2209， 2313， 2325， 2370。
北大 poj acm题目推荐50题
-北大poj acm题目推荐50题POJ == 北京大学ACM在线评测系统/JudgeOnline1. 标记难和稍难的题目大家可以看看，思考一下，不做要求，当然有能力的同学可以直接切掉。
2. 标记为A and B 的题目是比较相似的题目，建议大家两个一起做，可以对比总结，且二者算作一个题目。
3. 列表中大约有70个题目。
大家选做其中的50道，且每类题目有最低数量限制。
4. 这里不少题目在BUPT ACM FTP 上面都有代码，请大家合理利用资源。
5. 50个题目要求每个题目都要写总结，养成良好的习惯。
6. 这50道题的规定是我们的建议，如果大家有自己的想法请与我们Email 联系。
7. 建议使用C++ 的同学在POJ 上用G++ 提交。
8. 形成自己编写代码的风格，至少看上去美观，思路清晰(好的代码可以很清楚反映出解题思路)。
9. 这个列表的目的在于让大家对各个方面的算法有个了解，也许要求有些苛刻，教条，请大家谅解，这些是我们这些年的经验总结，所以也请大家尊重我们的劳动成果。
10. 提交要求：一个总文件夹名为bupt0xx (即你的比赛帐号), 这个文件夹内有各个题目类别的子目录(文件夹)，将相应的解题报告放入对应类别的文件夹。
在本学期期末，小学期开始前，将该文件夹的压缩包发至buptacm@。
对于每个题目只要求一个POJxxxx.cpp 或POJxxxx.java (xxxx表示POJ该题题号) 的文件，注意不要加入整个project 。
11. 如果有同学很早做完了要求的题目，请尽快和我们联系，我们将指导下一步的训练。
下面是一个解题报告的范例：例如：POJ1000.cpp//考查点：会不会编程序。
//思路：此题要求输入两个数，输出两个数的和，我用scanf 和printf。
//提交情况：Wrong Answer 1次，忘了写printf()。
Compile Error 2次，选错了语言，由于C++ 和G++ 在iostream.h 的不用引用方法；少一个大括号。
北大ACM题分类
北大ACM-题型分类经典1011（搜索好题）1012（学会打表）10131019（它体现了很多此类问题的特点）1050（绝对经典的dp）1088（dp好题）1157（花店经典的dp）1163（怎么经典的dp那么多呀）1328（贪心）1458（最长公共子序列）1647（很好的真题考临场分析准确和下手迅速）1654（学会多边形面积的三角形求法）1655（一类无根树的dp问题）1804（逆序对）2084（经典组合数学问题）2187（用凸包求最远点对求出凸包后应该有O(N)的求法可我就是调不出来）2195（二分图的最佳匹配）2242（计算几何经典）2295（等式处理）2353（dp 但要记录最佳路径）2354（立体解析几何）2362（搜索好题）2410（读懂题是关键）2411（经典dp）趣味1067（很难的数学但仔细研究是一片广阔的领域）1147（有O(n)的算法需要思考）1240（直到一棵树的先序和后序遍历那么有几种中序遍历呢dp）1426（是数论吗错是图论！）1648（别用计算几何用整点这个特点绕过精度的障碍吧）1833（找规律）1844（貌似dp或是搜索其实是道有趣的数学题）1922（贪心哈哈）22312305（不需要高精度噢）2328（要仔细噢）2356（数论知识）2359（约瑟夫问题变种）2392（有趣的问题）很繁的题100110081087（构图很烦还有二分图的最大匹配）1128（USACO）124513291550（考的是读题和理解能力）1649（dp）2200（字符串处理+枚举）2358（枚举和避免重复都很烦）2361（仔细仔细再仔细）难题1014（数学证明比较难但有那种想法更重要）1037（比较难的dp）1405（高精度算法也分有等级之分不断改进吧）2002（不知道有没有比O(n^2*logn)更有的算法）2054（极难很强的思考能力）2085（组合数学）2414（dp 但要剪枝）2415（搜索）2423（计算几何+统计）多解题1002（可以用排序也可以用统计的方法）1338（搜索和dp都可以）1664（搜索和dp都练一练吧）2082（这可是我讲的题噢）2352（桶排和二叉树都行）Note:1011: 很经典的剪支1014: 难在数学上1017: 严格的数学证明貌似不容易1021: 有点繁考察对图形进行各种旋转的处理1083: 巧妙的思考角度1150: 分奇偶讨论 lg(n)算法1218: 三行就够了虽然简单但也有优劣之别1505: 二分加贪心1654: 做法也许很多吧本人用有向面积做的1674: 计算圈的个数(算是graph 吧) 1700: 数学证明不容易1742: O(m*n)的算法1863: 要耐心地慢慢写…^_^1988: 并查集2051: 堆2078: 不难但剪支可以做到很好2082::O(n) 你想到了吗？2084: 卡特兰数2182: 线段树2195: 最小费用最大流2234: 经典博弈算法2236: 并查集2299: 二分思想2395: Kruskal 最小生成树的拓展2406: KMP2411: 用二进制串来表示状态。
各大OJ题目归类
各大OJ题目归类—————————–最优化问题————————————- ———————-动态规划SOJ1162 I-KeyboardSOJ2096 Maximum SubmatrixSOJ2111 littleken bgSOJ2505 The County FairSOJ2818 QQ音速SOJ2469 Exploring PyramidsSOJ1833 Base NumbersSOJ2009 Zeros and OnesSOJ2032 The Lost HouseSOJ2289 A decorative fenceSOJ2089 lykooSOJ2440 The days in fzkSOJ2718 BookshelfSOJ2722 Treats for the Cows(二维状态，0维决策)SOJ2726 Deck of CardsSOJ2729 Space ElevatorSOJ2730 Lazy CowsSOJ2702 AlannaSOJ2713 Cut the SequenceSOJ2768 BombSOJ2779 Find the max (I) (最大M子段和问题)SOJ2796 Letter Deletion(DP基础题，最长公共子序列问题) SOJ2800 三角形SOJ2804 Longest Ordered Subsequence (II)SOJ2896 Alphacode (动态规划简单题)SOJ2930 积木城堡SOJ3037 Painting the ballsSOJ3104 Game(注意大数运算，高精度)SOJ3264 Evil GameSOJ3300 Stockholm Coins(背包问题)SOJ3360 Buying Hay(背包问题)SOJ3531 Number Pyramids(背包问题)—————-状态DPSOJ2089 lykooSOJ2819 AderSOJ2842 The TSP problemSOJ3025 Artillery(状态DP)SOJ3088 windy’s cake VIIISOJ3259 Counting numbersSOJ3262 Square Fields(二分+状态DP)SOJ3371 Mixed Up Cows—————最优化之排序(思考两个元素之间的先后关系，以此得出一个二元比较关系，并验证此关系可传递,反对称，进而排序)SOJ2509 The Milk QueueSOJ2547 cardsSOJ2850 Protecting the FlowersSOJ2957 Setting ProblemsSOJ3167 ComputerSOJ3331 Cards(2547加强版)SOJ3327 Dahema’s Computer(通过此题学会排序)—————–最优化之必要条件枚举(思考最优解所具有的性质，得出最优解的一个强必要条件，在此基础上枚举）SOJ3317 FGJ’s PlaneSOJ3429 Food portion sizes——————————–贪心—————————————SOJ1078 BlueEyes’ ScheduleSOJ1203 Pass-MurailleSOJ1673 Gone FishingSOJ2645 Buy One Get One FreeSOJ2701 In a CycleSOJ2876 Antimonotonicity(经典模型O(n)算法)SOJ3343 Tower——————————–搜索—————————————SOJ1626 squareSOJ2061 8 puzzleSOJ2485 SudokuSOJ1045 SticksSOJ2736 FliptileSOJ2771 Collecting StonesSOJ2715 Maze BreakSOJ2829 binary strings(双向BFS)SOJ3330 Windy’s Matrix(BFS)——————————–DFA—————————————-—————状态矩阵+DFA：SOJ1826 Number SequenceSOJ2552 Number of TilingsSOJ2919 Matrix Power Series (学习矩阵的快速乘法从此开始)SOJ2920 Magic BeanSOJ3021 Quad TilingSOJ3046 Odd Loving BakersSOJ3176 E-stringSOJ3246 Tiling a Grid With DominoesSOJ3323 K-Satisfied NumbersSOJ3337 Wqb’s Word—————-DFA+DPSOJ1112 Repeatless Numbers(DFA+二分)SOJ2913 Number SubstringSOJ2826 Apocalypse SomedaySOJ3030 DNA Sequence(AC自动机+矩阵二分)SOJ3128 windy和水星—水星数学家1SOJ3182 Windy numbers———————————图论———————————————————–最短路+最小生成树+强连通SOJ2832 Mars city(强连通分支，算法多多)SOJ2198 HighwaysSOJ3427 Dark roads(最小生成树，kruskal：快排+并查集)SOJ3346 Best Spot（最短路，N^3放心的写）SOJ3013 tree(树的最大—最小划分问题，二分+贪心，勉强算在图论里面吧。
pythonoj题目
pythonoj题目PythonOJ（Python Online Judge）是一个在线的Python编程练习平台，提供了各种编程题目供用户练习和测试。
以下是一些关于PythonOJ题目的问题，我将从多个角度进行回答。
1. PythonOJ平台上的题目类型有哪些？PythonOJ平台上的题目类型非常丰富，涵盖了编程基础、算法与数据结构、字符串处理、数学计算、文件操作、网络编程等多个领域。
具体的题目类型包括但不限于，基础语法练习、条件与循环、函数与模块、列表与字典、文件与异常处理、递归与迭代、排序与查找、图与树等。
2. PythonOJ上的题目难度如何？PythonOJ上的题目难度各不相同，从简单到困难都有涵盖。
初学者可以选择一些简单的题目进行练习，逐渐提升编程能力。
对于有一定经验的程序员，PythonOJ也提供了一些挑战性较高的题目，可以帮助他们深入学习和掌握Python编程。
3. 如何在PythonOJ上提交代码并查看结果？在PythonOJ上提交代码非常简单。
首先，你需要选择一道题目进行解答。
然后，你可以在网页上看到题目的描述、输入输出样例等信息。
你可以在本地编写代码，并将其复制粘贴到PythonOJ的代码编辑器中。
完成后，点击提交按钮即可。
系统会自动编译和运行你的代码，并给出相应的结果，包括通过或失败以及运行时间等信息。
4. PythonOJ上的题目是否有解析或参考答案？是的，PythonOJ上的一些题目提供了解析或参考答案。
解析可以帮助你理解题目的解题思路和方法，参考答案可以供你对比和学习。
然而，为了真正提升编程能力，建议在尝试解答题目之前先自己思考和尝试，尽量避免直接查看解析或答案。
5. 如何在PythonOJ上提升编程能力？在PythonOJ上提升编程能力的关键是多做练习和不断挑战自己。
可以选择不同难度的题目进行练习，从简单到困难逐步提升。
同时，可以参考解析和参考答案，学习其他人的解题思路和方法，扩展自己的编程思维。
北大强基面试题目
北大强基面试题目
北大强基面试题目是北大计算机系为了选拔优秀学生而设计的一系列面试题目。
以下是一些常见的北大强基面试题目：
1. 数据结构和算法方面：
- 请解释什么是动态规划，并举一个实际应用的例子。
- 请解释什么是哈希表，并说明其在解决问题中的作用。
- 请实现一个快速排序算法，并分析其时间复杂度和空间复杂度。
2. 编程语言方面：
- 请解释面向对象编程的概念，并说明其与面向过程编程的区别。
- 请写出一个使用递归实现的斐波那契数列的函数。
- 请解释什么是异常处理，并说明其在程序开发中的重要性。
3. 计算机网络方面：
- 请解释什么是TCP/IP协议，并说明其在网络通信中的作用。
- 请解释什么是HTTP协议，并说明其与HTTPS协议的区别。
- 请解释什么是DNS，并说明其在互联网中的作用。
4. 操作系统方面：
- 请解释什么是进程和线程，并说明它们之间的区别。
- 请解释什么是死锁，并提供一个实际例子以及如何避免死锁的方法。
- 请解释什么是虚拟内存，并说明它的作用和优缺点。
以上只是一些常见的北大强基面试题目示例，实际面试中可能会有更多的题目
涵盖更多的领域。
希望这些问题的回答能够帮助你更好地准备面试。
北大计算机信息学题库
北大计算机信息学题库
1. 算法和数据结构：涉及到算法的时间复杂度、空间复杂度、排序、查找、图论等方面的知识。
2. 计算机网络：涉及到网络协议、TCP/IP、HTTP、DNS等方
面的知识。
3. 操作系统：涉及到进程管理、线程管理、内存管理、文件系统等方面的知识。
4. 编程语言：涉及到C/C++、Java、Python、JavaScript等编程语言的语法、特性、数据类型、函数、对象等方面的知识。
5. 数据库：涉及到关系型数据库、非关系型数据库、SQL语言、事务管理等方面的知识。
6. 计算机组成与结构：涉及到计算机体系结构、指令集、CPU、存储器、输入输出设备等方面的知识。
7. 系统设计和分析：涉及到软件工程、系统架构、需求分析、设计模式等方面的知识。
8. 人工智能和机器学习：涉及到机器学习算法、神经网络、自然语言处理等方面的知识。
9. 数据科学和大数据：涉及到数据分析、可视化、数据挖掘、大数据技术等方面的知识。
10. 软件开发实践：涉及到软件开发流程、代码管理、测试、持续集成等方面的知识。
oj基础题
oj基础题
OJ基础题是指在线判题系统（Online Judge）中的基础题目，通常是针对编程初学者或用于入门级的编程练习。
这些题目相对简单，旨在测试和锻炼编程者的基本编程技能和算法理解能力。
以下是两个OJ基础题的举例：
1.两数相加：给定两个非空的整数，每个数字都只包含数字0-9，编写一个函
数来计算这两个整数的和。
例如，输入为 "2,5" 和 "7,4"，输出为 "9,9"。
2.3的幂：给定一个非负整数 n，判断它是否为 3 的幂。
如果是，返回 true；
否则，返回false。
例如，输入为1、2、3、4、5，输出为true、true、true、false、false。
这两个题目都是非常基础的问题，第一个问题涉及到字符串处理和基本数学运算，第二个问题涉及到对数字进行逻辑判断。
在OJ系统中，还有许多其他类似的题目，涵盖了不同的编程语言和算法知识领域。
总结来说，OJ基础题是指在线判题系统中的一些简单题目，用于测试和锻炼编程者的基本技能和算法理解能力。
通过解决这些基础题目，可以提高编程能力和对算法的掌握程度。
北大数据结构上机考题总结(1)
1. 编一C程序，它能读入集合A的一串整数（以-9999为结束标记，整数个数小于1000）和集合B 的一串整数（以-9999为结束标记，整数个数小于1000），计算并以从小到大的次序输出A-B 的所有元素(为A或B输入时，同一个数可能出现多次，而A与B的差集中同一个数不能出现多次)。
（注：程序的可执行文件名必须是 e1.exe）（注：程序的可执行文件名必须是 e4.exe）*/#include <stdio.h>void BubbleSort(int r[],int n){//冒泡排序(有小到大)int i,j,k;int exchange;for(i=0;i<=n;i++){exchange=0;for(j=n-1;j>=i;j--)if(r[j+1]<r[j]){k=r[j+1];r[j+1]=r[j];r[j]=k;exchange=1;}if(!exchange)break;}}int DisaSameYs(int r[],int n){//消除数组r[]中的重复元素,并返回消除后数组剩余的元素个数int w,x,y;for(w=0;w<=n;w++){for(x=w+1;x<=n;x++){if(r[w]==r[x]){n--;for(y=x;y<=n;y++){r[y]=r[y+1];}//endforx--;}//endif}//endfor}//endforreturn n;}int cha(int m[],int n[],int l[],int Countaa,int Countbb){//求差集int i=0,j=0,k=0;int exch;while(i<=Countaa){exch=0;//交换变量为0for(j=0;j<=Countbb;j++){//用集合的第一个元素分别和另一个集合的各元素相比较//然后再用第二个元素(直到最后一个元素)和另一个集合的各元素相比较 if(m[i]==n[j]){//如果相同，交换变量变为1exch=1;break;}//endif}//endforif(!exch){//如果没有相同的就保存m[i]到l[]中l[k]=m[i];k++;}i++;}//endwhilereturn k;}/*void testds(int r[],int n){//测试消除数组中的重复元素的效果用下列循环输出int z;for(z=0;z<=n;z++)printf("%d",r[z]);}printf("\n");}*/void main(){int a[1000], b[1000],c[2000];int exchange=0;int i,j,k,CountA,CountB,CountC;printf("input a\n");for(i=0;i<=1000;i++){scanf("%d",&a[i]);if(a[i]==-9999)break;}CountA=i-1;BubbleSort(a,CountA);CountA=DisaSameYs(a,CountA);// testds(a,CountA);printf("\ninput b\n");for(i=0;i<=1000;i++){scanf("%d",&b[i]);if(b[i]==-9999)break;}CountB=i-1;BubbleSort(b,CountB);CountB=DisaSameYs(b,CountB);//testds(b,CountB);CountC=cha(a,b,c,CountA,CountB);printf("\n\n");for(i=0;i<=CountC-1;i++)printf("%d ",c[i]);}printf("\n");}模式匹配#include <stdio.h>#include <string.h>typedef struct{// int ch[2000];char ch[2000];int length;}SeqString;int NaiveStrMatch(SeqString T,SeqString P) {int i,j,k;int m=P.length;int n=T.length;for(i=0;i<=n-m;i++){j=0;k=i;while(j<m&&T.ch[k]==P.ch[j]){k++;j++;}if(j==m)return i;}//endforreturn -1;}//NaiveStrMatchSeqString CreatStr(SeqString R){int i;printf("input data\n");for(i=0;i<2000;i++){// scanf("%d",&R.ch[i]);// if(R.ch[i]==-9999)scanf("%s",&R.ch[i]);if(!(strcmp(&R.ch[i],"-9999")))break;}R.length=i-1;return R;}void main(){int n;SeqString Str1;Str1=CreatStr(Str1);SeqString Str2;Str2=CreatStr(Str2);n=NaiveStrMatch(Str1,Str2);printf("%d\n",n);}2、编一C程序，它能读入集合A的一串整数（以-9999为结束标记，整数个数小于1000）和集合B的一串整数（以-9999为结束标记，整数个数小于1000），计算出A与B的交集，并以由小到大的次序输出A与B的交集中的所有整数（输入整数时，相邻的两个用空格隔开。
BUPT2018级计算机院OJ习题与个人解答[链表一][附加测试样例]
![BUPT2018级计算机院OJ习题与个人解答[链表一][附加测试样例]](https://img.taocdn.com/s3/m/7e4f5310640e52ea551810a6f524ccbff121ca4f.png)
BUPT2018级计算机院OJ习题与个⼈解答[链表⼀][附加测试样例]Name: The Answer Of OJ Of BUPT SCS[LinkList 1][附加测试样例]Author: Chengmin ZhangDate: 2019-03-21 WEDTitle: 链表⼀测试样例下载（点击下⽅蓝字）Questions List:A.实验11_4_初识链表B.实验11_10_链表排序C.实验11_11_链表匹配D.实验11_13_链表交换A.实验11_4_初识链表运⾏时间限制: 1000 运⾏内存限制: 65536参考答案运⾏时间: 5 参考答案运⾏内存: 796题⽬描述:已知⼀个正整数序列，个数未知，但⾄少有⼀个元素，你的任务是建⽴⼀个单链表,并使⽤该链表存储这个正整数序列，然后统计这个序列中元素的最⼤值与最⼩值，计算序列全部元素之和。
正整数的输⼊⽤ -1作为结束标志，注意-1不算这个正整数序列中的元素（不要统计 -1）。
输⼊与输出要求:输⼊⼀个正整数序列，正整数序列元素的个数未知，但以输⼊“-1”结束，输⼊“-1”前⾄少输⼊⼀个正整数。
序列中的元素范围在1—999999999之间。
输出三个正整数，即最⼤值、最⼩值、所有元素之和。
数据最多的测试⽤例节点数在1000这个数量级，所有整数可以⽤int型存储。
请注意输⼊输出格式。
输⼊样例1 4 99 21 50 61 32 4 -1输出样例The maximum,minmum and the total are:99 1 272参考代码#include <stdio.h>#include <stdlib.h>// 1 Define the Node struct (the Body of the LinkList)typedef struct Node {int number;struct Node *next;} Node;// 2 Define the LinkList struct (the Head of the LinkList)// Including the headPtr and the length of linkListtypedef struct LinkList {struct Node *next;int length;} LinkList;// 3 InitTheLinkList// FunctionName: InitTheLinkList// ParameterList: LinkList *linkList// ReturnValue: voidvoid InitTheLinkList(LinkList *linkList) {linkList->length = 0;Node *headNode = (Node *)malloc(sizeof(Node));linkList->next = headNode;headNode->number = 0;headNode->next = NULL;}// 4 Input Array Thourgh scanf(!!USING THE Iterative Method!!)// FunctionName: InputLinkListByScanf// ParameterList: LinkList *linkList, Node *lastNode// ReturnValue: Node *newlastNode (if input equals -1 then return NULL) // Explaination: The number input will be set in the end of linkList Node *InputLinkListByScanf(LinkList *linkList, Node *lastNode) {Node *newlastNode = (Node *)malloc(sizeof(Node));newlastNode->next = NULL;scanf("%d", &newlastNode->number);if (newlastNode->number == -1) {return NULL;} else {lastNode->next = newlastNode;linkList->length += 1;InputLinkListByScanf(linkList, newlastNode);}}// 5 Print the LinkList// FunctionName: PrintLinkList// ParameterList: LinkList *linkList// ReturnValue: voidvoid PrintLinkList(LinkList *linkList) {Node *node = linkList->next;node = node->next;if (node == NULL) {printf("The linkList is empty!\n");linkList->length = 0;return;}for (int i = 0; i < linkList->length; i++) {printf("%d ", node->number);node = node->next;}}// 6 Return the MAX MIN SUM of LinkList// FunctionName: TheMAXMINSUMofLinkList// ParameterList: LinkList *linkList// ReturnValue: int *arrayint *TheMAXMINSUMofLinkList(LinkList *linkList) {int *theReturnArray = (int *)malloc(sizeof(int) * 3);for (int i = 0; i < 3; i++)theReturnArray[i] = 0;Node *node = linkList->next;node = node->next;if (node == NULL) {printf("The linkList is empty!\n");linkList->length = 0;return theReturnArray;}theReturnArray[1] = node->number;for (int i = 0; i < linkList->length; i++) {if (node->number > theReturnArray[0]) {theReturnArray[0] = node->number;}if (node->number < theReturnArray[1]) {theReturnArray[1] = node->number;}theReturnArray[2] += node->number;node = node->next;}return theReturnArray;}// 7 Clear the LinkList// FunctionName: ClearLinkList// ParameterList: LinkList *linkList// ReturnValue: voidvoid ClearLinkList(LinkList *linkList) {Node *node = linkList->next;node = node->next;Node *nextNode;while (node) {nextNode = node->next;free(node);node = nextNode;}free(linkList->next);}int main() {LinkList linkList;InitTheLinkList(&linkList);InputLinkListByScanf(&linkList, linkList.next);// PrintLinkList(&linkList);int *theReturn = TheMAXMINSUMofLinkList(&linkList);printf("The maximum,minmum and the total are:%d %d %d\n", theReturn[0],theReturn[1], theReturn[2]);ClearLinkList(&linkList);return 0;}B.实验11_10_链表排序题⽬描述运⾏时间限制: 1000 运⾏内存限制: 65536参考答案运⾏时间: 6 参考答案运⾏内存: 792问题描述：问题描述：已知⼀个正整数组成的⽆序序列，个数未知，但⾄少有⼀个元素，你的任务是建⽴⼀个单链表，并使⽤该链表存储这个正整数序列，然后将这个链表进⾏排序，使得排序后的链表为递增序列。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
ACM 题型算法分类题目均来自：/JudgeOnline/主流算法：1.搜索//回溯2.DP（动态规划）3.贪心4.图论//Dijkstra、最小生成树、网络流5.数论//解模线性方程6.计算几何//凸壳、同等安置矩形的并的面积与周长7.组合数学//Polya定理8.模拟9.数据结构//并查集、堆10.博弈论1、排序1423, 1694, 1723, 1727, 1763, 1788, 1828, 1838, 1840, 2201, 2376, 2377, 2380,1318, 1877, 1928, 1971, 1974, 1990, 2001, 2002, 2092, 2379,1002（需要字符处理，排序用快排即可） 1007（稳定的排序） 2159（题意较难懂） 2231 2371（简单排序） 2388（顺序统计算法） 2418（二叉排序树）2、搜索、回溯、遍历1022 1111d 1118 1129 1190 1562 1564 1573 1655 2184 2225 2243 2312 2362 2378 2386 1010,1011,1018,1020,1054,1062,1256,1321,1363,1501，1650,1659,1664,1753,2078,2083,2303,2310,2329简单：1128, 1166, 1176, 1231, 1256, 1270, 1321, 1543, 1606, 1664, 1731, 1742,1745, 1847, 1915, 1950, 2038, 2157, 2182, 2183, 2381, 2386, 2426,不易：1024, 1054, 1117, 1167, 1708, 1746, 1775, 1878, 1903, 1966, 2046, 2197,2349,推荐：1011, 1190, 1191, 1416, 1579, 1632, 1639, 1659, 1680, 1683, 1691, 1709,1714, 1753, 1771, 1826, 1855, 1856, 1890, 1924, 1935, 1948, 1979, 1980, 2170,2288, 2331, 2339, 2340,1979（和迷宫类似） 1980（对剪枝要求较高）3、历法1008 2080 （这种题要小心）4、枚举1012，1046， 1387， 1411， 2245， 2326， 2363， 2381，1054（剪枝要求较高），1650 （小数的精度问题）5、数据结构的典型算法容易：1182, 1656, 2021, 2023, 2051, 2153, 2227, 2236, 2247, 2352, 2395, 不易：1145, 1177, 1195, 1227, 1661, 1834,推荐：1330, 1338, 1451, 1470, 1634, 1689, 1693, 1703, 1724, 1988, 2004, 2010,2119, 2274, 1125(弗洛伊德算法) ，2421（图的最小生成树）6、动态规划1037 A decorative fence、1050 To the Max、1088 滑雪、1125 Stockbroker Grapevine、1141 Brackets Sequence、1159 Palindrome、1160 Post Office、1163 The Triangle、1458 Common Subsequence、1579 Function Run Fun、1887 Testing the CATCHER、1953 World Cup Noise、2386 Lake Counting7、贪心1042, 1065, 1230, 1323, 1477, 1716, 1784,1328 1755（或用单纯形方法），2054，1017， 1328，1862， 1922 ，2054， 2209， 2313， 2325， 2370。
8、模拟容易：1006, 1008, 1013, 1016, 1017, 1169, 1298, 1326, 1350, 1363, 1676, 1786,1791, 1835, 1970, 2317, 2325, 2390,不易：1012, 1082, 1099, 1114, 1642, 1677, 1684, 1886,1281 1928 2083 2141 20159、递归166410、字符串处理1488, 1598, 1686, 1706, 1747, 1748, 1750, 1760, 1782, 1790, 1866, 1888, 1896,1951, 2003, 2121, 2141, 2145, 2159, 2337, 2359, 2372, 2406, 2408, 1016 1051 1126 1318 1572 1917 1936 2039 2083 2136 2271 2317 2330，2121 240311、数论1006,1014,1023,1061,1152,1183,1730,226212、几何有关的题目凸包：1113, 1228, 1794, 2007, 2187,1113 wall，2187 beauty contest容易：1319, 1654, 1673, 1675, 1836, 2074, 2137, 2318,不易：1685, 1687, 1696, 1873, 1901, 2172, 233313、任意精度运算、数字游戏、高精度计算1001 1023 1047 1060 1079 1131 1140 1142 1207 1220 1284 1289 1306 1316 1338 1405 1454 1503 1504 1519 1565 1650 1969 2000 2006 2081 2247 2262 2305 2316 23891001, 1220, 1405, 1503,1001（高精度乘法） 2413(高精度加法，还有二分查找)14、概率统计1037,105015、小费用最大流、最大流2195 going home2400 supervisor, supervisee1087 a plug for UNIX1149 PIGS1273 drainage ditches 1274 the perfect stall 1325 machine schedule 1459 power network2239 selecting courses16、压缩存储的DP1038 bugs integrated inc 1185 炮兵阵地2430 lazy cow17、最长公共子串（LCS）1080 human gene functions 1159 palindrome1458 common subsequence 2192 zipper18、图论及组合数学2421 Constructing Roads、2369 Permutations、2234 Matches Game、2243 Knight Moves、2249 Binomial Showdown、2255 Tree Recovery、2084 Game of Connections、1906 Three powers、1833 排列、1850 Code、1562 Oil Deposits、1496 Word Index、1306 Combinations、1125 Stockbroker Grapevine、1129 Channel Allocation、1146 ID Codes、1095 Trees Made to Order、找规律2247 Humble Numbers、2309 BST、2346 Lucky tickets、2370 Democracy in danger、2365 Rope、2101 Honey and Milk Land2028 When Can We Meet?、2084 Game of Connections、1915 Knight Moves、1922 Ride to School、1941 The Sierpinski Fractal、1953 World Cup Noise、1958 Strange Towers of Hanoi、1969 Count on Canton、1806 Manhattan 2025、1809 Regetni、1844 Sum、1870 Bee Breeding、1702 Eva\'s Balance、1728 A flea on a chessboard、1604 Just the Facts、1642 Stacking Cubes、1656 Counting Black、1657 Distance on Chessboard、1662 CoIns、1663 Number Steps、1313 Booklet Printing、1316 Self Numbers、1320 Street Numbers、1323 Game Prediction、1338 Ugly Numbers、1244 Slots of Fun、1250 Tanning Salon、1102 LC-Display、1147 Binary codes、1013 Counterfeit Dollar19、博弈类1067 取石子游戏、1740 A New Stone Game、2234 Matches Game、1082 Calendar Game 、2348 Euclid\'s Game、2413 How many Fibs?、2419 Forest20、简单、模拟题1001 Exponentiation 、1002 487-3279、1003 Hangover 、1701 Dissatisfying Lift、2301 Beat the Spread!、2304 Combination Lock、2328 Guessing Game、2403 Hay Points 、2406 Power Strings、2339 Rock, Scissors, Paper、2350 Above Average、2218 Does This Make Me Look Fat?、2260 Error Correction、2262 Goldbach\'s Conjecture、2272 Bullseye、2136 Vertical Histogram、2174 Decoding Task、2183 Bovine Math Geniuses、2000 Gold Coins、2014 Flow Layout、2051 Argus、2081 Calendar、1918 Ranking List、1922 Ride to School、1970 The Game、1972 Dice Stacking、1974 The Happy Worm、1978 Hanafuda Shuffle、1979 Red and Black、1617 Crypto Columns、1666 Candy Sharing Game、1674 Sorting by Swapping、1503 Integer Inquiry、1504 Adding Reversed Numbers、1528 Perfection、1546 Basically Speaking、1547 Clay Bully、1573 Robot Motion、1575 Easier Done Than Said?、1581 A Contesting Decision、1590 Palindromes、1454 Factorial Frequencies、1363 Rails、1218 THE DRUNK JAILER、1281 MANAGER、1132 Border、1028 Web Navigation21、初等数学1003 Hangover、1045 Bode Plot、1254 Hansel and Grethel、1269 Intersecting Lines、1401 Factorial、1410 Intersection、2363 Blocks 、2365 Rope、2242 The Circumference of the Circle、2291 Rotten Ropes、2295 A DP Problem、2126 Factoring a Polynomial、2191 Mersenne Composite Numbers、2196 Specialized Four-Digit Numbers、1914 Cramer\'s Rule、1835 宇航员、1799 Yeehaa!、1607 Deck、1244 Slots of Fun、1269 Intersecting Lines、1299 Polar Explorer、1183 反正切函数的应用、22、匹配1274, 1422, 1469, 1719, 2060, 2239,-------------------------------------------------------------------------------------------经典1011（搜索好题）1012（学会打表）10131019（它体现了很多此类问题的特点）1050（绝对经典的dp）1088（dp好题）1157（花店，经典的dp）1163（怎么经典的dp那么多呀？？？）1328（贪心）1458（最长公共子序列）1647（很好的真题，考临场分析准确和下手迅速）1654（学会多边形面积的三角形求法）1655（一类无根树的dp问题）1804（逆序对）2084（经典组合数学问题）2187（用凸包求最远点对，求出凸包后应该有O(N)的求法，可我就是调不出来）2195（二分图的最佳匹配）2242（计算几何经典）2295（等式处理）2353（dp，但要记录最佳路径）2354（立体解析几何）2362（搜索好题）2410（读懂题是关键）2411（经典dp）趣味1067（很难的数学，但仔细研究，是一片广阔的领域）1147（有O(n)的算法，需要思考）1240（直到一棵树的先序和后序遍历，那么有几种中序遍历呢？dp）1426（是数论吗？错，是图论！）1648（别用计算几何，用整点这个特点绕过精度的障碍吧）1833（找规律）1844（貌似dp或是搜索，其实是道有趣的数学题）1922（贪心，哈哈）22312305（不需要高精度噢）2328（要仔细噢）2356（数论知识）2359（约瑟夫问题变种）2392（有趣的问题）很繁的题100110081087（构图很烦，还有二分图的最大匹配）1128（USACO）124513291550（考的是读题和理解能力）1649（dp）2200（字符串处理+枚举）2358（枚举和避免重复都很烦）2361（仔细仔细再仔细）难题1014（数学证明比较难，但有那种想法更重要）1037（比较难的dp）1405（高精度算法也分有等级之分，不断改进吧）2002（不知道有没有比O(n^2*logn)更有的算法？）2054（极难，很强的思考能力）2085（组合数学）2414（dp，但要剪枝）2415（搜索）2423（计算几何+统计）多解题1002（可以用排序，也可以用统计的方法）1338（搜索和dp都可以）1664（搜索和dp都练一练吧）2082（这可是我讲的题噢）2352（桶排和二叉树都行）Note:1011: 很经典的剪支1014: 难在数学上1017: 严格的数学证明貌似不容易1021: 有点繁,考察对图形进行各种旋转的处理1083: 巧妙的思考角度1150: 分奇偶讨论,lg(n)算法1218: 三行就够了,虽然简单,但也有优劣之别1505: 二分加贪心1654: 做法也许很多吧,本人用有向面积做的1674: 计算圈的个数(算是graph 吧)1700: 数学证明不容易1742: O(m*n)的算法1863: 要耐心地慢慢写…^_^1988: 并查集2051: 堆2078: 不难，但剪支可以做到很好2082::O(n),你想到了吗？2084: 卡特兰数2182: 线段树2195: 最小费用最大流2234: 经典博弈算法2236: 并查集2299: 二分思想2395: Kruskal 最小生成树的拓展2406: KMP2411: 用二进制串来表示状态。