PAT甲级考前整理一:https://www.cnblogs.com/jlyg/p/7525244.html,主要讲了131题的易错题及坑点

PAT甲级考前整理二:https://www.cnblogs.com/jlyg/p/10364696.html,主要讲了考前注意以及一些常用算法。

1132题:用字符串接收会毕竟快,使用atoi函数转成数字,注意a*b会超出int32。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std; int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif
int t;
scanf("%d",&t);
while(t--)
{
char str[];
scanf("%s",str);
char str1[],str2[];
int len = strlen(str);
strncpy(str1,str,len/);
str1[len/]='\0';
strcpy(str2,str+len/);
int a = atoi(str1),b=atoi(str2);
int c = atoi(str);
//a*b超出int32
if(a*b<=||c%(a*b)) printf("No\n");
else printf("Yes\n");
}
return ;
}

1133题:因为k是正数,用3个vector存储就ok了,v0表示存储负数,v1表示存储小于等于k的,v2表示存储大于k的。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
#define N (100010)
struct ST
{
int addr;
int val;
int next;
};
ST sts[N];
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif
int startaddr,n,k;
scanf("%d%d%d",&startaddr,&n,&k);
for(int i=;i<n;++i)
{
ST st;
scanf("%d%d%d",&st.addr,&st.val,&st.next);
sts[st.addr] = st;
}
vector<ST> vs;
for(int addr=startaddr;addr!=-;addr=sts[addr].next)
vs.push_back(sts[addr]);
vector<ST> vs0/*负数*/,vs1/*比k小或等于的正数*/,vs2/*比k大的正数*/;
for(int i=;i<vs.size();++i)
{
if(vs[i].val < ) vs0.push_back(vs[i]);
else if(vs[i].val<=k) vs1.push_back(vs[i]);
else if(vs[i].val>k) vs2.push_back(vs[i]);
} {
vs = vs0;
for(int i=;i<vs1.size();++i) vs.push_back(vs1[i]);
for(int i=;i<vs2.size();++i) vs.push_back(vs2[i]); for(int i=;i<vs.size();++i)
{
if(i!=vs.size()-)
printf("%05d %d %05d\n",vs[i].addr,vs[i].val,vs[i+].addr);
else
printf("%05d %d -1\n",vs[i].addr,vs[i].val);
}
} return ;
}

1134题:题意有点难懂,顶点覆盖,即所有边的(边有两个顶点,任一一个顶点)某个顶点必须是在已给的顶点集合中。如果用遍历会超时,所以要用hash的想法。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
#define N (10010)
struct Edge //记录边的两个端点
{
int a;
int b;
};
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif
int n,m;
vector<Edge> ve;
scanf("%d%d",&n,&m);
for(int i=;i<m;++i)
{
Edge edge;
scanf("%d%d",&edge.a,&edge.b);
ve.push_back(edge);
}
int k;
scanf("%d",&k);
while(k--)
{
int nv;
scanf("%d",&nv);
bool flag = true;//是否是顶点覆盖
bool V[N];
memset(V,,sizeof(V)); //下标表示定点,值表示是否有无改点
for(int i=;i<nv;++i)
{
int a;
scanf("%d",&a);
V[a] = true;
} for(int i=;i<ve.size();++i)
{
flag = V[ve[i].a]||V[ve[i].b];
if(flag==false)
break;
}
if(flag) printf("Yes\n");
else printf("No\n");
}
return ;
}

1135题:红黑树的题目,给出先序(插入顺序)构造红黑树,然后判断是否是红黑树。可以看我写的另一篇博客:

https://www.cnblogs.com/jlyg/p/7542409.html

1136题:简单题,大数加法加字符串反转

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
string Add(string str1,string str2)
{
int len = str1.length();
int add = ;
string res = "";
for(int i=len-;i>=;--i)
{
int k = str1[i]-''+str2[i]-'' + add;
add = k/;
res += (k%+'');
}
if(add) res += (add+'');
reverse(res.begin(),res.end());
return res;
}
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
char temp[];
scanf("%s",temp);
string str = temp,str2=temp;
for(int i=;i<;++i)
{
reverse(str2.begin(),str2.end());
if(strcmp(str.c_str(),str2.c_str())==)
{
printf("%s is a palindromic number.\n",str.c_str());
return ;
}
string str3 = Add(str,str2);
printf("%s + %s = %s\n",str.c_str(),str2.c_str(),str3.c_str());
str = str2 = str3;
}
printf("Not found in 10 iterations.\n");
return ;
}

1137题:简单题,Gm若是大于Gf,则G=(0.4*Gm+0.6*Gf+0.5),否则G = Gf; Gp<200和G<60的不记录。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
struct ST
{
string id;
int Gp;
int Gm;
int Gf;
int G;
ST(){Gp=Gm=Gf=G=-;}
void UpdateG()
{
if(Gm > Gf) G = int(Gm*0.4f+Gf*0.6f+0.5f);
else G = Gf;
}
bool IsUseful()
{
if(Gp<) return false;
if(G<) return false;
return true;
}
};
int cmp(const ST& st1,const ST& st2)
{
if(st1.G != st2.G) return st1.G>st2.G;
return strcmp(st1.id.c_str(),st2.id.c_str())<;
}
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE int p,m,n;
scanf("%d%d%d",&p,&m,&n);
map<string,ST> mss;
for(int i=;i<p;++i)
{
char strid[];
int g;
scanf("%s%d",strid,&g);
mss[strid].Gp = g;
mss[strid].id = strid;
}
for(int i=;i<m;++i)
{
char strid[];
int g;
scanf("%s%d",strid,&g);
mss[strid].Gm = g;
mss[strid].id = strid;
}
for(int i=;i<n;++i)
{
char strid[];
int g;
scanf("%s%d",strid,&g);
mss[strid].Gf = g;
mss[strid].id = strid;
}
vector<ST> vs;
for(map<string,ST>::iterator it = mss.begin();it!=mss.end();it++)
{
it->second.UpdateG();
if(it->second.IsUseful())
vs.push_back(it->second);
}
sort(vs.begin(),vs.end(),cmp);
for(int i=;i<vs.size();++i)
{
printf("%s %d %d %d %d\n",vs[i].id.c_str(),vs[i].Gp,vs[i].Gm,vs[i].Gf,vs[i].G);
}
return ;
}

1138题:简单题,先序和中序求后序第一个元素的值。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
int FindFirst(int* pre,int* inorder,int n)
{
if(n==) return *pre;
int val = *pre;
int iIndex;
for(iIndex=;iIndex<n;++iIndex)
{
if(val == inorder[iIndex])
{
break;
}
}
if(iIndex>)
{
return FindFirst(pre+,inorder,iIndex);
}
else
{
return FindFirst(pre+iIndex+,inorder+iIndex+,n-iIndex-);
}
}
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int n;
scanf("%d",&n);
int pre[n],inorder[n];
for(int i=;i<n;++i)
scanf("%d",&pre[i]);
for(int i=;i<n;++i)
scanf("%d",&inorder[i]);
printf("%d\n",FindFirst(pre,inorder,n));
return ;
}

1139题:有点难度,注意两点:1)0000是男生,-0000是女生。2)使用递归dfs最后一个case会超时,老老实实写几层循环去遍历吧!

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
#define N (10010)
int cmp(const vector<int>& v1,const vector<int>& v2)
{
if(v1[] != v2[]) return v1[] < v2[];
return v1[] < v2[];
}
vector<int> vssame[N]; //相同
vector<int> vsdif[N]; //不同
bool bVis[N];
int thepeo1,thepeo2;
bool bSame;
vector<vector<int> > res;
void dfs()
{
res.clear();
memset(bVis,,sizeof(bVis));
bVis[thepeo1] = true;
for(int i=;i<vssame[thepeo1].size();++i)
{
int id1 = vssame[thepeo1][i];
//printf("1:%04d\n",id1);
if(!bVis[id1]&&id1!=thepeo2)
{
bVis[id1] = true;
vector<int> *pvs;
if(bSame) pvs = &(vssame[id1]);
else pvs = &(vsdif[id1]);
for(int j=;j<pvs->size();++j)
{
int id2 = (*pvs)[j];
//printf(" 2:%04d\n",id2);
if(!bVis[id2]&&id2!=thepeo2)
{
bVis[id2] = true;
for(int k=;k<vssame[id2].size();++k)
{
int id3 = vssame[id2][k];
//printf(" 3:%04d\n",id3);
if(id3==thepeo2)
{
vector<int> vi;
vi.push_back(id1);
vi.push_back(id2);
res.push_back(vi);
break;
}
}
bVis[id2] = false;
} }
bVis[id1] = false;
}
}
}
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE int n,m;
scanf("%d%d",&n,&m);
for(int i=;i<m;++i)
{
char str1[],str2[];
scanf("%s%s",str1,str2);
int id1 = abs(atoi(str1)),id2=abs(atoi(str2));
if(str1[]=='-'&&str2[]=='-'
||str1[]!='-'&&str2[]!='-')
{
vssame[id1].push_back(id2);
vssame[id2].push_back(id1);
}
else
{
vsdif[id1].push_back(id2);
vsdif[id2].push_back(id1);
}
}
int t;
scanf("%d",&t);
while(t--)
{
char str1[],str2[];
scanf("%s%s",str1,str2);
if(str1[]=='-'&&str2[]=='-'||str1[]!='-'&&str2[]!='-')
{
bSame = true;
}
else
{
bSame = false;
}
thepeo1 = abs(atoi(str1));
thepeo2 = abs(atoi(str2));
dfs();
sort(res.begin(),res.end(),cmp);
printf("%d\n",res.size());
for(int i=;i<res.size();++i)
{
vector<int>& vi = res[i];
for(int j=;j<vi.size();++j)
{
if(j) printf(" ");
printf("%04d",vi[j]);
}
printf("\n");
}
}
return ;
}

1140题:题意很难理解。。。一句话后面数字是前面数字的描述。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<algorithm>
using namespace std;
string getstr(string str)
{
string res="";
int len = str.length();
char c= str[],cnt=;
for(int i=;i<len;++i)
{
if(c==str[i]) ++cnt;
else if(c!=str[i])
{
res += c;
char strcnt[];
sprintf(strcnt,"%d",cnt);
res +=strcnt;
c = str[i];
cnt = ;
}
if(i==len-)
{
res += c;
char strcnt[];
sprintf(strcnt,"%d",cnt);
res +=strcnt;
}
}
return res;
}
//题意:后面的数字是对前面数字的描述
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
char a[];
int n;
scanf("%s%d",&a,&n);
string str = a;
for(int i=;i<n;++i)
str=getstr(str);
printf("%s\n",str.c_str());
return ;
}

1142题:要求最大团:团是一组顶点,每个顶点两两可以组成边,最大团就是没有另外一个顶点与团里的点都能组成边。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define N (250)
int Map[N][N];
int nv,ne;
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
scanf("%d%d",&nv,&ne);
for(int i=;i<ne;++i)
{
int a,b;
scanf("%d%d",&a,&b);
Map[a][b] = Map[b][a] = ;
}
int t;
scanf("%d",&t);
while(t--)
{
int k;
scanf("%d",&k);
int a[k];
for(int i=;i<k;++i)
scanf("%d",&a[i]);
bool bClique = true;
for(int i=;i<k;++i)
for(int j=;j<k;++j)
{
//要求每条边两两相交
if(i!=j&&Map[a[i]][a[j]]==)
{
bClique = false;
break;
}
}
if(bClique)
{
bool bMax = true;
for(int i=;i<=nv;++i)
{
int j;
for(j=;j<k;++j)
{
if(Map[i][a[j]]==)
break;
}
if(j==k)
{
bMax = false;
break;
}
}
if(bMax) printf("Yes\n");
else printf("Not Maximal\n");
}
else printf("Not a Clique\n");
}
return ;
}

1143题:用map存储出现过的点,用于判断是否点存在。通过遍历先序,第一个出现满足a,b在val左右两边的就是他们的父节点。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
map<int,bool> Map;
int m,n;
scanf("%d%d",&m,&n);
int pre[n];
for(int i=;i<n;++i)
{
scanf("%d",&pre[i]);
Map[pre[i]] = true;
}
while(m--)
{
int a,b;
scanf("%d%d",&a,&b);
bool aexits = Map[a],bexits = Map[b];
if(!aexits&&!bexits) printf("ERROR: %d and %d are not found.\n",a,b);
else if(aexits&&bexits)
for(int i=;i<n;++i)
{
int val = pre[i];
if(val>a&&val<b || val<a&&val>b)
{
printf("LCA of %d and %d is %d.\n",a,b,val);
break;
}
else if(val==a|| val==b)
{
printf("%d is an ancestor of %d.\n",val==a?a:b,val==a?b:a);
break;
}
}
else printf("ERROR: %d is not found.\n",!aexits?a:b);
}
return ;
}

1144题:简单题,注意全部小于0是,应该输出1

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std; int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int n;
scanf("%d",&n);
int a[n];
for(int i=;i<n;++i)
scanf("%d",&a[i]);
sort(a,a+n);
for(int i=,j=;j<n;++i)
for(;j<n;++j)
{
if(a[j]==i) break;
else if(a[j]>i)
{
printf("%d\n",i);
return ;
}
}
printf("%d\n",max(a[n-]+,));
//printf("%d\n",a[n-1]);
return ;
}

1145题:hash的二次探测,题目比较坑 ,算查找的总次数,一般二次探测0到size-1次没找到就好了,但是它而要多加一,所以循环要写到0到size;

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
bool isPrime(int n)
{
for(int i=;i*i<=n;++i)
if(n%i==) return false;
return true;
}
int getsize(int n)
{
while(!isPrime(n)) ++n;
return n;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int msize,n,m;
scanf("%d%d%d",&msize,&n,&m);
msize = getsize(msize);
int Hash[msize];
memset(Hash,,sizeof(Hash));
for(int i=;i<n;++i)
{
int a;
scanf("%d",&a);
int j;
for(j=;j<msize;++j)
if(Hash[(a+j*j)%msize]==)
{
Hash[(a+j*j)%msize] = a;
break;
}
if(j>=msize) printf("%d cannot be inserted.\n",a);
}
int t = m,cnt=;
while(t--)
{
int a;
scanf("%d",&a);
for(int i=;i<=msize;++i)
{
if(++cnt&&(Hash[(a+i*i)%msize]==a||(Hash[(a+i*i)%msize]==)))
break;
}
}
printf("%.1lf\n",1.0*cnt/m);
return ;
}

1146题:拓扑排序,了解拓扑排序的原理就行了。学习拓扑排序必须知道什么是入度,有向图中有边:顶点a到顶点b,则b的入度是1。所以拓扑排序是每次输出入度为0的顶点,并且把该顶点相连的边的另一个顶点的入度减一。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
#define N (1100)
int Map[N][N];
int indegree[N];
int n,m;
bool isTopuSort(int* a)
{
int temp_indegree[N];
memcpy(temp_indegree,indegree,sizeof(temp_indegree));
for(int i=;i<n;++i)
{
if(temp_indegree[a[i]]!=) return false;
for(int j=;j<=n;++j) if(Map[a[i]][j]) --temp_indegree[j];
}
return true;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE scanf("%d%d",&n,&m);
for(int i=;i<m;++i)
{
int a,b;
scanf("%d%d",&a,&b);
++indegree[b];
Map[a][b] = ;
}
int T;
scanf("%d",&T);
bool bFirst = true;
for(int t=;t<T;++t)
{
int a[n];
for(int i=;i<n;++i)
{
scanf("%d",&a[i]);
}
if(isTopuSort(a)==false)
{
if(bFirst) bFirst= false;
else printf(" ");
printf("%d",t);
}
}
printf("\n");
return ;
}

1147题:简单题,可以用不构造树的方式做。(当然构树也行,只是会麻烦一点~) heap tree。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define LEFT(i) (2*i+1)
#define RIGHT(i) (2*i+2)
bool isMaxHeap(int* a,int curI,int n)
{
if(curI>=n) return true;
int il = LEFT(curI),ir = RIGHT(curI);
if(il<n&&a[curI]<a[il]) return false;
if(ir<n&&a[curI]<a[ir]) return false;
return isMaxHeap(a,il,n)&&isMaxHeap(a,ir,n);
}
bool isMinHeap(int* a,int curI,int n)
{
if(curI>=n) return true;
int il = LEFT(curI),ir = RIGHT(curI);
if(il<n&&a[curI]>a[il]) return false;
if(ir<n&&a[curI]>a[ir]) return false;
return isMinHeap(a,il,n)&&isMinHeap(a,ir,n);
}
bool bFirst;
void post_travel(int* a,int curI,int n)
{
if(curI>=n) return;
post_travel(a,LEFT(curI),n);
post_travel(a,RIGHT(curI),n);
if(bFirst) bFirst = false;
else printf(" ");
printf("%d",a[curI]);
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int t,n;
scanf("%d%d",&t,&n);
while(t--)
{
int a[n];
for(int i=;i<n;++i)
scanf("%d",&a[i]);
if(isMaxHeap(a,,n)) printf("Max Heap\n");
else if(isMinHeap(a,,n)) printf("Min Heap\n");
else printf("Not Heap\n");
bFirst = true;
post_travel(a,,n);
printf("\n");
}
return ;
}

1148题:题目不好理解,有两个狼人,所有人中只有一狼一人说谎,输出两个狼人。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
int main(){
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int n;
scanf("%d",&n);
int a[n+];
for(int i=;i<=n;++i)
scanf("%d",&a[i]);
for(int i=;i<=n;++i){
for(int j=i+;j<=n;++j){
int bwolf[n+];
memset(bwolf,,sizeof(bwolf));
bwolf[i] = bwolf[j] = ; //i,j为狼
bool bOK = (a[i]>)==bwolf[abs(a[i])]&&(a[j]<)==bwolf[abs(a[j])]||
(a[i]<)==bwolf[abs(a[i])]&&(a[j]>)==bwolf[abs(a[j])];
for(int k=,lie=;k<=n&&bOK;++k){
if(i==k||j==k) continue;
if((a[k]>)==bwolf[abs(a[k])]){
++lie;
if(lie>) bOK = false;
}
}
if(bOK){
printf("%d %d\n",i,j);
return ;
}
}
}
printf("No Solution\n");
return ;
}

1149题:简单题,两个物品放一起会爆炸,给出一串东西,判断这些东西有没有危险。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
set<int> misi[];
int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int n,m;
scanf("%d%d",&n,&m);
for(int i=;i<n;++i)
{
int a,b;
scanf("%d%d",&a,&b);
misi[a].insert(b);
misi[b].insert(a);
}
while(m--)
{
int k;
scanf("%d",&k);
vector<int> vi;
bool bOK = true;
for(int i=;i<k;++i)
{
int a;
scanf("%d",&a);
if(bOK)
{
set<int>& sidag=misi[a];
for(int j=;j<vi.size();++j)
{
if(sidag.find(vi[j])!=sidag.end())
{
bOK = false;
break;
}
}
vi.push_back(a);
}
}
printf("%s\n",bOK?"Yes":"No");
}
return ;
}

1150题:简单题

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std; int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int n,m;
scanf("%d%d",&n,&m);
int Map[n+][n+];
memset(Map,,sizeof(Map));
for(int i=;i<m;++i)
{
int a,b,l;
scanf("%d%d%d",&a,&b,&l);
Map[a][b] = Map[b][a] = l;
}
int T;
int minLen = <<;
int minPath = -;
scanf("%d",&T);
for(int t=;t<=T;++t)
{
printf("Path %d: ",t);
int cn;
scanf("%d",&cn);
int istart,iend;
bool bVis[n+];
memset(bVis,,sizeof(bVis));
bool bSimple = true;
int cnt = ,pre,len=;
int bNA = false;
for(int i=;i<cn;++i)
{
int a;
scanf("%d",&a);
if(i&&Map[pre][a]==) bNA = true;
else if(i) len += Map[pre][a];
if(i==) istart = a;
if(i==cn-) iend = a;
pre = a;
if(bVis[a]==)
{
bVis[a] = ;
++cnt;
}
else if(i!=cn-) bSimple = false;
}
if(bNA) printf("NA ");
else printf("%d ",len);
if(cnt!=n||bNA||istart!=iend) printf("(Not a TS cycle)\n");
else
{
if(minLen > len)
{
minLen = len;
minPath = t;
}
printf("(%s)\n",bSimple?"TS simple cycle":"TS cycle");
}
}
printf("Shortest Dist(%d) = %d\n",minPath,minLen);
return ;
}

1151题:用两个map,一个是把val转换成编号(从1开始,0表示没有),一个是把编号转换成val。中序输入的时候通过把val转换成编号,中序就是从小到大排序的,所以该树就变成搜索二叉树了。然后通过pre数组记录先序的编号,通过先前记录的map吧val转换成编号。所以该数时关于编号的搜索二叉树。然后接下来的做法就跟1143题一模一样了。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std; int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int m,n;
scanf("%d%d",&m,&n);
map<int,int> valtoid;
map<int,int> idtoval;
int pre[n];
for(int i=;i<n;++i)
{
int a;
scanf("%d",&a);
valtoid[a] = i+;
idtoval[i+] = a;
}
for(int i=;i<n;++i)
{
int a;
scanf("%d",&a);
pre[i] = valtoid[a];
}
while(m--)
{
int a,b;
scanf("%d%d",&a,&b);
int aexits=valtoid[a],bexits=valtoid[b];
if(!aexits&&!bexits) printf("ERROR: %d and %d are not found.\n",a,b);
else if(!aexits||!bexits) printf("ERROR: %d is not found.\n",!aexits?a:b);
else
{
for(int i=;i<n;++i)
{
int ia = valtoid[a],ib = valtoid[b];
if(pre[i]<ia&&pre[i]>ib||pre[i]<ib&&pre[i]>ia)
{
printf("LCA of %d and %d is %d.\n",a,b,idtoval[pre[i]]);
break;
}
else if(pre[i]==ia||pre[i]==ib)
{
printf("%d is an ancestor of %d.\n",pre[i]==ia?a:b,pre[i]==ia?b:a);
break;
}
}
}
}
return ;
}

1152题:简单题,题目的tip也很详细。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
#define L (1010)
bool isPrime(long long int a)
{
if(a==) return false;
for(long long int i=;i*i<=a&&i*i>;++i) if(a%i==) return false;
return true;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int l,k;
scanf("%d%d",&l,&k);
char str[L];
scanf("%s",&str);
string res="";
for(int i=;i<l;++i)
{
res += str[i];
if(i+>=k)
{
if(res.length()>k) res = res.substr(,k);
long long int a = atoll(res.c_str());
if(isPrime(a))
{
printf("%s\n",res.c_str());
return ;
}
}
}
printf("404\n");
return ;
}

1153题:简单题,不要每次搜索1类型的时候都去排序,不然会超时。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
struct PAT
{
string str;
int sorce;
string type; //考试类型
string sitnum;
string date;
string testeenum;
void init(string str,int sorce)
{
this->str = str;
this->sorce =sorce;
int i = ;
sitnum = date = testeenum = "";
type = str[i++];
for(;i<;++i) sitnum += str[i];
for(;i<;++i) date += str[i];
for(;i<;++i) testeenum+=str[i];
}
};
int sitnum[];
PAT pats[];
int sitcmp(const int& a,const int& b)
{
if(sitnum[a]!=sitnum[b]) return sitnum[a]>sitnum[b];
return a<b;
}
int cmp(const int& a,const int& b)
{
PAT p1 = pats[a],p2=pats[b];
if(p1.sorce!=p2.sorce) return p1.sorce>p2.sorce;
return strcmp(p1.str.c_str(),p2.str.c_str())<;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif // ONLINE_JUDGE
int n,m;
scanf("%d%d",&n,&m);
map<string,vector<int> > searchmap[];
for(int i=;i<n;++i)
{
char str[];
int sorce;
scanf("%s%d",str,&sorce);
pats[i].init(str,sorce);
searchmap[][pats[i].type].push_back(i);
searchmap[][pats[i].sitnum].push_back(i);
searchmap[][pats[i].date].push_back(i); }
set<string> bsort; //关于1对应key的序列是否排序好了
for(int i=;i<m;++i)
{
int opt;
char str[];
scanf("%d%s",&opt,str);
printf("Case %d: %d %s\n",i+,opt,str);
vector<int> &vi = searchmap[opt-][str];
memset(sitnum,,sizeof(sitnum));
if(vi.size())
{
if(opt==&&bsort.find(str)==bsort.end()) sort(vi.begin(),vi.end(),cmp),bsort.insert(str);
int tsorce = ;
for(int j=;j<vi.size();++j)
{
int index = vi[j];
if(opt==) printf("%s %d\n",pats[index].str.c_str(),pats[index].sorce);
else if(opt==) tsorce += pats[index].sorce;
else if(opt==) ++sitnum[atoi(pats[index].sitnum.c_str())];
}
if(opt ==) printf("%d %d\n",vi.size(),tsorce);
else if(opt==)
{
vector<int> sitvc;
for(int j=;j<;++j)
if(sitnum[j]) sitvc.push_back(j);
sort(sitvc.begin(),sitvc.end(),sitcmp);
for(int j=;j<sitvc.size();++j)
printf("%03d %d\n",sitvc[j],sitnum[sitvc[j]]);
}
}
else printf("NA\n");
}
return ;
}

1154题:简单题

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std; int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif
int n,m;
scanf("%d%d",&n,&m);
vector<int> Map[n];
for(int i=;i<m;++i)
{
int a,b;
scanf("%d%d",&a,&b);
Map[a].push_back(b);
}
int t;
scanf("%d",&t);
while(t--)
{
set<int> si;
int color[n];
for(int i=;i<n;++i)
{
scanf("%d",&color[i]);
si.insert(color[i]);
}
bool bOK = true;
for(int i=;i<n&&bOK;++i)
for(int j=;j<Map[i].size();++j)
if(color[i]==color[Map[i][j]])
{
bOK = false;
break;
}
if(bOK) printf("%d-coloring\n",si.size());
else printf("No\n");
}
return ;
}

1155题:简单题,跟1147一样是heap tree。估计题目有点想出堆排序,但是又怕没人会堆排序所以搞成这样吧。。

#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<iterator>
#include<algorithm>
#include<cstring>
using namespace std;
#define LEFT(i) (2*i+1)
#define RIGHT(i) (2*i+2)
struct Node
{
int val;
Node* left;
Node* right;
Node(){left=right=NULL;}
};
Node* Build(int *a,int i,int n)
{
if(i >= n) return NULL;
Node* node = new Node();
node->val = a[i];
node->left = Build(a,LEFT(i),n);
node->right = Build(a,RIGHT(i),n);
return node;
}
void travel(Node* node,vector<Node*> vn)
{
vn.push_back(node);
if(!node->left&&!node->right)
{
for(int i=;i<vn.size();++i)
{
if(i) printf(" ");
printf("%d",vn[i]->val);
}
printf("\n");
}
if(node->right) travel(node->right,vn);
if(node->left) travel(node->left,vn);
}
bool bMaxHeap(int* a,int i,int n)
{
if(i>=n) return true;
if(LEFT(i)<n&&a[i]<a[LEFT(i)]) return false;
if(RIGHT(i)<n&&a[i]<a[RIGHT(i)]) return false;
return bMaxHeap(a,LEFT(i),n)&&bMaxHeap(a,RIGHT(i),n);
}
bool bMinHeap(int* a,int i,int n)
{
if(i>=n) return true;
if(LEFT(i)<n&&a[i]>a[LEFT(i)]) return false;
if(RIGHT(i)<n&&a[i]>a[RIGHT(i)]) return false;
return bMinHeap(a,LEFT(i),n)&&bMinHeap(a,RIGHT(i),n);
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("test.txt","r",stdin);
#endif
int n;
scanf("%d",&n);
int a[n];
for(int i=;i<n;++i)
scanf("%d",&a[i]);
Node* root = Build(a,,n);
vector<Node*> vn;
travel(root,vn);
if(bMaxHeap(a,,n)) printf("Max Heap\n");
else if(bMinHeap(a,,n)) printf("Min Heap\n");
else printf("Not Heap\n");
return ;
}

PAT甲级考前整理(2019年3月备考)之三,持续更新中.....的更多相关文章

  1. PAT甲级考前整理(2019年3月备考)之二,持续更新中.....

    PAT甲级考前整理之一网址:https://www.cnblogs.com/jlyg/p/7525244.html,主要总结了前面131题的类型以及易错题及坑点. PAT甲级考前整理三网址:https ...

  2. PAT甲级考前整理(2019年3月备考)之一

       转载请注明出处:https://www.cnblogs.com/jlyg/p/7525244.html 终于在考前,刷完PAT甲级131道题目,不容易!!!每天沉迷在刷题之中而不能超脱,也是一种 ...

  3. IDEA 2019.2破解激活教程(激活到2089年8月,亲测有效,持续更新中...)

    本来笔者这边是有个正版激活码可以使用的,但是,2019.9月3号的时候,一些小伙伴反映这个注册码已经失效了,于是拿着自己的 IDEA, 赶快测试了一下,果不其然,已然是不能用了. 好在,笔者又找到了新 ...

  4. IntelliJ IDEA 2019.2.1 破解教程, 最新激活码(激活到2089年8月,亲测有效,持续更新中...)

    当前最新版本 IDEA 2019.2.1 本来笔者这边是有个正版激活码可以使用的,但是,2019.9月3号的时候,一些小伙伴反映这个注册码已经失效了,于是拿着自己的 IDEA, 赶快测试了一下,果不其 ...

  5. 系列文章:老项目的#iPhone6与iPhone6Plus适配#(持续更新中,更新日期2014年10月12日 星期日 )

    本文永久地址为http://www.cnblogs.com/ChenYilong/p/4020399.html ,转载请注明出处. ********************************** ...

  6. 一些JavaSE学习过程中的思路整理(主观性强,持续更新中...)

    目录 一些JavaSE学习过程中的思路整理(主观性强,持续更新中...) Java书写规范 IDEA的一些常用快捷键 Java类中作为成员变量的类 Java源文件中只能有一个public类 Java中 ...

  7. 常见 git 需求整理(持续更新中)

    首发于 语雀文档 突然感觉自己对 git 还是挺熟悉的,因为团队里新来的七八号应届生来问我 git 问题,基本没有答不上的情况,但为了能更好地对知识进行整理,还是记录一下为好. (希望能)持续更新.. ...

  8. 2019年5月训练记录(更新ing)

    前言 \(ZJOI\)正式结束了. 但期中考试只考了年级\(216\),退役既视感... 于是就被抓回去补文化课了. 下半个学期可能要以文化课为主了吧! 但周三.周日应该还是会正常参加训练的,但其他时 ...

  9. 【PAT甲级】1119 Pre- and Post-order Traversals(前序后序转中序)

    [题目链接] [题意] 根据二叉树的前序和后序序列,如果中序序列唯一,输出Yes,如果不唯一输出No,并输出这个中序序列. [题解] 众所周知,二叉树是不能够根据前序和中序建立的,为什么呢?首先需要明 ...

随机推荐

  1. 下载Youku视频观看

    所需工具: 1.chorme内核浏览器,如Chorme.Firefox等等 2.vlc视频播放器 准备工作完成,开始工作 1.打开优酷的随便一个视频 2.按下F12选择Network(网络)选择Med ...

  2. js闭包的本质

    js之所以会有闭包,是因为js不同于其他规范的语言,js允许一个函数中再嵌套子函数,正是因为这种允许函数嵌套,导致js出现了所谓闭包. function a(){ function b(){ }; b ...

  3. 高负载linux调优

    调整Linux内核参数: # vi /etc/sysctl.conf# tells the Kernel it's ok if services bind to non-existant IP ADD ...

  4. adbi命令【转】

    本文转载自:https://zmywly8866.github.io/2015/01/24/all-adb-command.html   ADB很强大,记住一些ADB命令有助于提高工作效率. 获取序列 ...

  5. POJ1733 Parity game —— 种类并查集

    题目链接:http://poj.org/problem?id=1733 Parity game Time Limit: 1000MS   Memory Limit: 65536K Total Subm ...

  6. POSTMAN模拟数组数据

    有时候写接口,需要传入数据数据.比如购物车中的一组商品.它们的数量是不固定的,只能用数组才能更好的处理. 怎么用POSTMAN模拟呢? 万能的POSTMAN.

  7. linux下的git安装及配置

    一.yum安装方式 1.安装 $ yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel $ yum -y ...

  8. 并不对劲的bzoj4560:p3269:[JLOI2016]字符串覆盖

    题目大意 \(T\)(\(T\leq10\))组询问 每组询问给出一个字符串\(A\)(\(|A|\leq10^4\)),\(n\)(\(n\leq4\))个\(A\)的子串\(B_1,B_2,B_3 ...

  9. Linux网络协议栈(二)——套接字缓存(socket buffer)

    Linux网络核心数据结构是套接字缓存(socket buffer),简称skb.它代表一个要发送或处理的报文,并贯穿于整个协议栈.1.    套接字缓存skb由两部分组成:(1)    报文数据:它 ...

  10. C++实现从尾到头打印链表(不改变链表结构)

    /* * 从尾到头打印链表.cpp * * Created on: 2018年4月7日 * Author: soyo */ #include<iostream> #include<s ...