PAT 刷题模板

最新推荐文章于 2022-05-03 16:59:30 发布
最新推荐文章于 2022-05-03 16:59:30 发布
阅读量172 收藏 2
点赞数 1
分类专栏： PAT 甲级 题库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a123456chj/article/details/110097137
版权

贪心

//区间选点贪心问题
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=110;
struct Interval{
    int x,int y;
}I[maxn];
int main()
{
    int n;
    while(scanf("%d",&n),n!=0){
        for(int i=0;i<n;i++){
            scanf("%d%d",&I[i].x,&I[i].y]);
        }
        sort(I,I+n,cmp);
        int ans=1,lastx=I[0].x;
        for(int i=1;i<n;i++){
            if(I[i].y<=lastx){
                lastx=I[i].x;
                ans++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

二分

//二分查找
#include<stdio.h>
int binarySearch(int A[],int left,int right,int x){
    int mid;
    while(left<=right){
        mid=(left+right)/2;
        if(A[mid]=x)return mid;
        else if(A[mid]>x){
            right=mid-1;
        }else {
            left==mid+1;
        }
    }
    return -1;//查找失败
}
//寻找有序序列第一个满足某条件的元素的位置模板
int solve(int left,int right){
    int mid;
    while(left<right){
        mid=(left+right)/2;
        if(条件成立){
            right=mid;
        }else {
            left=mid+1;
        }
    }
    return left;
}

双指针

//双指针合并两序列
int merge(int A[],int B[],int C[],int n,int m){
    int i=0,j=0,index=0;
    while(i<n&&j<m){
        if(A[i]<=B[i]){
            C[index++]=A[i++];
        }else{
            C[index++]=B[j++];
        }
    }
    while(i<n)C[index++]=A[i++];
    while(j<m)C[index++]=B[j++];
    return index;
}

最大公约数

int gcd(int a,int b){
    if(b==0)return a;
    else return gcd(b,a%b);
}

分数四则运算

//分数表示
struct Fraction(){
    int up,down;
};
//分数的化简
Fraction(Fraction result){
    if(result.down<0){
        result.up=-result.up;
        result.down=-result.down;
    }
    if(result.up==0){
        result.down=1;
    }else{
        int d=gcd(abs(result.up),abs(result.down));
        result.up/=d;
        result.down/=d;
    }
    return result;
}
//加法
Fraction add(Fraction f1,Fraction f2){
    Fraction result;
    result.up=f1.up*f2.down+f2.up*f1.down;
    result.down=f1.down*f2.down;
   	return reduction(result);
}
//减法
Fraction minu(Fraction f1,Fraction f2){
    Fraction result;
    recult.up=f1.up*f2.down-f2.up*f1.down;
    result.down=f1.down*f2.down;
    return reduction(result);
}
//乘法
Fraction multi(Fraction f1,Fraction f2){
    Fraction result;
    result.up=f1.up*f2.up;
    result.down=f1.down*f2.down;
    return reduction(result);
}
Fraction divide(Fraction f1,Fraction f2){
    Fraction result;
    result.up=f1.up*f2.down;
    result.down=f1.down*f2.up;
    return reduction(result);
}
//输出
void showresult(Fraction r){
    r=reduction(r);
    if(r.down==1)printf("%lld",r.up);
    else if(abs(r.up)>abs(r.down)){
      	printf("%d %d/%d",r.up/r.down,abs(r.up)%r.down,r.down);
    }else{
        printf("%d/%d",r.up,r.down);
    }
}

素数

int isprime(int a){
	if(n<=1)return 0;
	for(int i=2;i*i<=a;i++){
		if(a%i==0)return 0;
	}
	return 1;
}//如果a很大，接近n，会溢出，应采用开根号的办法  int sqr=(int)sqrt(1.0*n);
用此方法打印素数表 n最多为10的5次方

质因子分解

struct factor{
    int c,cnt;
}fac[10];
int sqr=(int)sqrt(1.0*n);
for(int i=0;i<pNum&&prime[i]<=sqr;i++){    //pNum为素数表的容量
    if(n%prime[i]==0){
        fac[num].x=primr[i];
        fac[num].cnt=0;
        while(n%prime[i]==0){
            fac[num].cnt++;
            n/=prime[i];
        }
        num++;
    }
    if(n==1)break;
}
if(n!=1){
    fac[num].x=n;
    fac[num++].cnt=1;
}

大整数运算

邻接表存储图外层索引与邻接矩阵一样，指向对应的点，内层索引则只表示个数，要找一个路径的第二点要进入图结构体里面找

对一些数据量大的题目可能不是用常规思路解决的，先打一下表找找规律。

优先队列

//大元素优先
priority_queue<int,vector<int>,less<int>>q;等价于priority_queue<int>q;
//小元素优先
priority_queue<int,vector<int>,greater<int>>q;
//结构体排序设置
struct fruit{
    string name;
    int price;
    friend bool operator < (fruit f1,fruit f2){
        return f1.price<f2.price;                //价高优先级高 跟sort的cmp相反
    }
}
priority_queue<fruit>q;

静态链表

//定义静态链表
struct Node{
    int add;
   	typename data;
   	int next;
    XXX;      //节点的某个性质  一般给出的节点会有无效节点，需要遍历一遍再根据这个性质进行排序
}node[100010];
//初始化
for(int i=0;i<maxn;i++){
    node[i].XXX=0;
}
int p=begin,count=0;   //比如计数
while(p!=-1){
    XXX=1;
    count++;
    p=node[p].next;
}

DFS

vector<int>temp,ans;
void DFS(int index,int nowK,int sum,int sumSqu){
    if(nowK==k&&sum==x){
        if(sumSqu>maxSumSqu){
            maxSumSqu=sumSqu;
            ans=temp;
        }
        return;
    }
    if(index==n||nowK>k||sum>x)return;
    temp.push_back(A[index]);
    DFS(index+1,nowK+1,sum+S[index],sumSqu+A[index]*index);
    temp.pop_back();
    DFS(index+1,nowK,sum,sumSqu);
}

BFS

void BFS(int s){
    queue<int>q;
    q.push(s);
    设置已入队;
    while(!q.empty()){
       取出队首元素top;
       访问队首元素top;
       将队首元素出队;
       将top的下一层结点中未曾入队的结点全部入队，并设置为已入队;
    }
}

二叉树

strcut node{
    typename data;
    node* lchild;
    node* rchild;
};
node* root=NULL;
//新建节点
node* newnode(int v){
    node* Node=new node;
    Node->data=v;
    Node->lchild=Node->rchild=NULL;
    return Node;
}
//查找
void search(node* root,int x,int newdata){
    if(root==NULL){
        return;
    }
    if(root->data==x){
        root->data=newdata;
    }
    search(root->lchild,x,newdata);
    search(root->rchild,x,newdata);
}
//插入
void insert(node* &root,int x){
    if(root==NULL){
        root=newnode(x);
        return;
    }
    if(......){
        insert(root->lchild,x);
    }else{
      	insert(root->rchild,x);
    }
}
//建立
node* Craete(int data[],int n){
    node* root=NULL;
    for(int i=0;i<n;i++){
        insert(root,data[i]);
    }
    return root;
}
//先序遍历
void preorder(node* root){
    if(root==NULL){
        return;
    }
    printf("%d\n",root->data);
    preorder(root->lchild);
    preorder(root->rchild);
}
//层序遍历
void layerorder(node* root){
    queue<node*>q;
    q.push(root);
    while(!q.empty()){
        node* now=q.front();
        q.pop();
        printf("%d\n",now->data);
        if(now->lchild!=NULL)q.push(now->lchild);
        if(now->rchild!=NULL)q.push(now->rchild);
    }
}
//记录层次层序遍历
struct node{
    int data;
    int layer;
    node* lchild;
    node* rchild;
};
void layerorder(node* root){
    queue<node*>q;
    root->layer=1;
    q.push(root);
    while(!q.empty()){
     	node* now=q.front();
        q.pop();
        printf("%d ",now->data);
        if(now->lchild!=NULL){
            now->lchild->layer=now->layer+1;
            q.push(now->lchild);
        }
        if(now->rchild!=NULL){
            now->rchild->layer=now->layer+1;
            q.push(now->rchild);
        }
    }
}
//前中序构建二叉树
node* create(int prel,int prer,int inl,int inr){
    if(prel>prer){
        return NULL;
    }
    node* root=new node;
    root->data=pre[prel];
    int k=0;
    while(in[k]!=pre[prel])k++;
    int numleft=k-inl;
    root->lchild=create(prel+1,prel+numleft,inl,k-1);
    root->rchild=create(prel+numleft+1,prer,k+1,inr);
    return root;
}

二叉树静态实现

//定义
strcut node{
   	typename data;
    int lchild,rchild;
}Node[maxn];
// 建立新节点
int index=0;
int newNode(int v){
    Node[index].data=v;
    Node[index].lchild=-1;
    Node[index].rchild=-1;
    return index++;//指针返回的是节点指针
}
//查找
void search(int root,int x,int newdata){
    if(root==-1){
        return;
    }
    if(Node[root].data==x){
        Node[root].data=newdata;
        return;
    }
    search(Node[root].lchild,x,newdata);
    search(Node[root].rchild,x,newdata);
}
//插入
void insert(int &root,int x){
   	if(root==-1){
        root=newnode(x);
        return;
    }
    if(-------){
        insert(Node[root].lchild,x);
    }
    else{
        insert(Node[root].rchild,x);
    }
}
//建立
int Create(int data[],int n){
    int root=-1;
    for(int i=0;i<n;i++){
        insert(root,data[i]);
    }
    return root;
}
//先序遍历
void preorder(int root){
    if(root==-1){
        return;
    }
    printf("%d\n",Node[root].data);
    preorder(Node[root].lchild);
    preorder(Node[root].rchild);
}
//层序遍历
void layerorder(int root){
    queue<int>q;
    q.push(root);
    while(!q.empty()){
        int now=q.front();
        q.pop();
        printf("%d\n",Node[now].data);
        if(Node[now].lchild!=-1)q.push(Node[now].lchild);
        if(Node[now].rchild!=-1)q.push(Node[now].rchild);
    }
}

树的静态写法

//定义节点
struct node{
    typename data;
    vector child;
}Node[maxn];
//新建节点
int index=0;
int newNode(int v){
    Node[index].data=v;
    Node[index].child.clear();
    return index++;
}
//层序遍历
void Layerorder(int root){
    queue<int>q;
    q.push(root);
    Node[root].layer=0;
    while(!q.empty()){
        int now=q.front();
        q.pop();
        printf("%d\n",Node[now].data);
        for(int i=0;i<Node[now].child.size();i++){
            Node[Node[now].child[i]].layer=Node[now].layer+1;
            q.push(Node[now].child[i]);
        }
    }
}

对所有合法的DFS求解过程，都可以把它画成树的形式

二叉查找树

//查找
void search(node* root,int x){
    if(root==NULL){
        return;
    }
    if(x==root->data){
        printf("%d\n",root->data);
    }
   	else if(x<root->data){
        search(root->lchild,x);
    }
    else if(x>root->data){
        search(root->rchild,x);
    }
}
//插入
省略;
//建立
node* Create(int data[],int n){
    node* root=NULL;
    for(int i=0;i<n;i++){
        insert(root,data[i]);
    }
    return root;
}
//寻找最大权值节点
node* findmax(node* root){
    while(root->lchild!=NULL){
      	root=root->child;
    }
    return root;
}
//删除节点
void deletenode(node* &root,int x){
    if(root==NULL)return;
    if(root->data==x){
        if(root->lchild==NULL&&root->rchild==NULL){
            root=NULL;
        }else if(root->lchild!=NULL){
            node* pre=findmax(root->lchild);
            root->data=pre->data;
            deletenode(root->lchild,pre->data);
        }else if(root->rchild!=NULLL){
            node* next=finmin(root->rchild);
            root->data=next->data;
            deletenode(root->rchild,next->data);
        }
    }else if(root->data>x)deletenode(root->lchild,x);
    else if(root->data<x)deletenode(root->rchild,x);
}

并查集

int father[N];
for(int i=1;i<=N;i++){
	father[i]=i;
}
//查找
int findfather(int x){
	if(x==father[x])return x;
	else return findfather(father[x]);
}
//查找加路径压缩
int findfather(int v){
	if(v==father[v])return v;
	else{
		int F=findfather(father[v]);
		father[v]=F;
		return F;
	}
}
//合并
void Union(int a,int b){
	int fA=findfather(a);
	int fB=findfather(b);
	if(fA!=fB){
		father[fA]=fB;                   //可以通过比较让小的值作为父亲，则最后的并查集的父节点为整个并查集的最小值
	}
}

堆

const int maxn=100;
int heap[maxn];
//向下调整
void downAdjust(int low,int high){
    int i=low,j=i*2;
    while(j<=high){
        if(j+1<=high&&heap[j+1]>heap[j]){
            j=j+1;
        }
        if(heap[j]>heap[i]){
            swap(heap[j],heap[i]);
            i=j;
            j=i*2;
        }else{
            break;
        }
    }
}
//建堆
void createheap(){
    for(int i=n/2;i>=1;i--){
        downAdjust(i,n);
    }
}
//删除堆顶元素
void deletetop(){
    heap[1]=heap[n--];
    downAdjust(1,n);
}
//向上调整
void upAdjust(int low,int high){
    int i=high,j=i/2;
    while(j>=low){
        if(heap[j]<heap[i]){
            swap(heap[j],heap[i]);
            i=j;
            j=i/2;
        }else{
            break;
        }
    }
}
//添加元素
void insert(int x){
    heap[++n]=x;
    upAdjust(1,n);
}
//堆排序
void heapSort(){
    createheap();
    for(int i=n;i>1;i--){
        swap(heap[i],heap[1]);
        downAdjust(1,i-1);
    }
}

图遍历

//遍历图伪代码
DFS(u){
    vis[u]=true;
    for(从u出发能到达的所有顶点v){
        if(vis[v]==0){
            DFS(v);
        }
    }
}
DFSTrave(G){
    for(G的所有顶点){
        if(vis[u]==0){
            DFS(u);
        }
    }
}
//邻接矩阵版
int n;
int G[maxn][maxn];
int vis[maxn]={0};
void DFS(int u,int depth){
    vis[u]=1;
    for(int v=0;v<n;v++){
        if(vis[v]==0&&G[u][v]!=INF){
            DFS(v,depth+1);
        }
    }
}
void DFSTrave(){
    for(int u=0;u<n;u++){
        if(vis[u]==0){
          	DFS(u,1);
        }
    }
}
//BFS邻接矩阵版
void BFS(int u){
    queue<int>q;
    q.push(u);
    vis[u]=1;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int v=0;v<n;v++){
            if(vis[v]==0&&G[u][v]!=INF){
                q.push(v);
                vis[v]=1;
            }
        }
    }
}
......

最短路径

//邻接矩阵Dijkstra 最短距离
int n;
int G[maxn][maxn],d[maxn];
int vis[maxn];
void Dijkstra(int s){
    fill(d,d+maxn,INF);
    d[s]=0;
    for(int i=0;i<n;i++){
    	int u=-1,min=INF;
        for(int j=0;j<n;j++){
            if(vis[j]==0&&d[j]<min){
                u=j;
                min=d[j];
            }
        }
        if(u==-1)return;
        vis[u]=1;
        for(int v=0;v<n;v++){
            if(vis[v]==0&&G[u][v]!=INF&&d[u]+G[u][v]<d[v]){
                d[v]=d[u]+G[u][v];
            }
        }
    }
}
//最短路径 Dijkstra+DFS
const int maxn=1010;
const int INF=1000000000;
vector<int>pre[maxn];
int n;
int G[maxn][maxn],d[maxn];
int vis[maxn];
void Dijkstra(int s){
    fill(d,d+maxn,INF);
    d[s]=0;
    for(int i=0;i<n;i++){
        int u=-1,min=INF;
        for(int j=0;j<n;j++){
            if(vis[j]==0&&d[j]<min)[
                u=j;
                min=d[j];
            ]
        }
        if(u==-1)return;
        vis[u]=1;
        for(int v=0;v<n;v++){
            if(vis[v]==0&&G[u][v]!=INF){
                if(d[u]+G[u][v]<d[v]){
                    d[v]=d[u]+G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if(d[u]+G[u][v]==d[v]){
                    pre[v].push_back(u);
                }
            }
        }
    }
}

int optvalue=0;
vector<int>path,temppath;
void DFS(int v){
    if(v==s){
        temppath.push_back(v);
//需要自己写的地方
//         点权
        int value=0;
        for(int i=temppath.size()-1;i>=0;i--){
            int id=temppath[i];
            value+=w[id];
        }
//         边权
        int value=0;
        for(int i=temppath.size()-1;i>0;i--){
            int id1=temppath[i],id2=temppath[i-1];
            value+=G[id1][id2];
        }
//         
        if(value>optvalue){
            optvalue=value;
            path=temppath;
        }
        temppath.pop_back;
        return;
    }
    temppath.push_back(v);
    for(int i=0;i<pre[v].size();i++){
        DFS(pre[v][i]);
    }
    temppath.pop_back();
}
//输出路径时要逆序输出

拓扑排序

//拓扑排序
vector<int<G[maxn];
int n,m,indegree[maxn];
bool topologicalsort(){
    int num=0;
    queue<int>q;
    for(int i=0;i<n;i++){
        if(indegree[i]==0){
            q.push(i);
        }
    }
    while(!q.empty()){
        int u=q.front();
        //访问
        q.pop();
        for(int i=0;i<G[u].size();i++){
            int v=G[u][i];
            indegree[v]--;
            if(indegree[v]==0){
                q.push(v);
            }
        }
        G[u].clear();     //可不写，看情况
        num++;
    }
    if(num==n)return ture;
    else return false;
}
呆2222222
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pat 甲级考试 算法模板 第一版
01-09
跟随mooc课程,方便大家学习。 甲级考试 算法模板，这是第一版，希望大家多提意见
PAT刷题模板——堆
weixin_41194846的博客
05-23 179
堆 堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆分为大根堆与小根堆。 大根堆定义： 大根堆是一棵完全二叉树 根节点的元素均大于（等于）子节点的元素。 任意一颗子树也均满足1和2的定义 堆的操作–以大根堆为例（基于C++语言） 堆的定义(以下均分为数组定义方式和STL定义方式） int heap[MAXN]; vector<int> heap(MAXN); 建堆 void downAdjust(int heap[], int low, int high){ // heap的in
PAT算法问题模板
CSlerner的博客
07-17 619
这里写自定义目录标题常用语法for语句，范围forstl模板库vector​​​​​​​定义使用常见算法树1.前序和中序遍历建树Hash表1.平方探测法建表查询欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建...
【转载】PAT考试大纲, 刷题方法, 模版
weixin_45855916的博客
11-04 297
原文链接： https://timtingwei.github.io/2018/08/13/20180813-01/ ref: https://blog.csdn.net/yinghuoai/article/details/78510094 考试大纲 乙级（Basic Level） 考生应具备以下基本能力： 1· 基本的C/C++的代码设计能力，以及相关开发环境的基本调试技巧； 2· 理...
PAT100分模板（主要的套路模板）
QQ2352的博客
07-24 619
一、基础知识 b1018 有时直接输出结果更简单，不需要寄存结果 A1046上述情况的反例，有时需要预处理才能避免超时 string 类不能存放字符串类型以外的类型 %02d 不够两位则左边补零 string t = s.substr(1, i-1);//子串位置1-到i-1 int n = stoi(s.substr(i+1));//stoi字符串计算 ...
刷pat和leetcode-PAT-Leetcode:浙大PAT&Leetcode刷题笔记
07-07
同时又希望在PAT和Leetcode刷题以及玩Human Resource Machine这件事不要三分钟热度。 所以我给自己定了计划:刷完100个Leetcode和浙大PAT乙级题库之后就去收割我的相机！ 做此项目记录刷题笔记及心得，祝我好运。 ...
程序员刷题judge-PAT:拍
07-07
记录PAT刷题过程中的心得体会，以及涉及到的陌生知识点。 Table Of Contents 入门 简单模拟 简单按题目说的作，考察代码能力 查找元素 给定一些元素，然后查找某个满足条件的元素。 * 如果需要在一个比较小范围的...
PAT乙级题解.pdf
最新发布
04-19
### PAT乙级题解知识点概览 #### 1001. 害死人不偿命的(3n+1)猜想 **卡拉兹(Callatz)猜想简介：** 卡拉兹猜想是一个数学猜想，由Lothar Collatz在1937年提出，也被称为3n+1猜想、角谷猜想等。该猜想描述了一个简单...
PAT:按<>的顺序 模块刷pat
05-16
描述中提到的"PAT分类刷题，算法笔记的顺序"，说明了刷题时应该按照不同主题或难度来组织学习路径。具体顺序为： 1. "3.1算法入门"：这部分可能涵盖了基础的编程概念，如循环、条件语句、函数等，以及基础的算法思想...
PAT 数学问题模板
qq_39876147的博客
04-28 137
文章目录一、最大公约数与最小公倍数1.1 最大公因式1.2 最小公倍数二、素数2.1 素数判断2.2 素数表获取三、质因子分解四、分数的四则运算4.1 分数的表示4.2 分数的化简4.3 分数加法4.4 分数减法4.5 分数乘法4.6 分数除法4.7 分数的输出五、进制转换5.1 任意进制转换为十进制5.2 十进制转换为其他进制5.2.1 方法一5.2.2 方法二六、大整数运算6.1 大整数存储6.2 比较大小6.3 高精度加法6.4 高精度减法6.5 高精度与低精度的乘法6.6 高精度与低精度的除法 一、
PAT甲级练习题155道分类（xmind）
07-26
PAT甲级练习题155道分类（xmind）。在【笔记】下可以看见各个分类下的习题，提高练习效率，进行专项训练，提炼出自己的代码模板。也可【大纲】下进行查看。（）括号里数字为每个分类的题目个数，可看出PAT考试的重要知识点。
PAT刷题技巧
艾与代码
12-29 6259
PAT刷题技巧PAT 刷题技巧PAT 是什么PAT 注意事项PAT 题型PAT 代替机试PAT 刷题技巧PAT刷题模板写在后面 PAT 刷题技巧 PAT 是什么 计算机程序设计能力考试（Programming Ability Test，简称PAT）旨在通过统一组织的在线考试及自动评测方法客观地评判考生的算法设计与程序设计实现能力，科学地评价计算机程序设计人才，为企业选拔人才提供参考标准。目前PA...
PAT刷题模板——LCA最近公共祖先
weixin_41194846的博客
05-23 194
前序+中序找某两个节点的最近公共祖先 根据前序+中序建树的思想找LCA void lca(int root, int start, int end, int a, int b){ // root: pre的根下标 start:中序起始下标 end:中序结束下标 // a和b是需要找到的公共节点 if(start > end) return; // pos定义为map<int, int>, 是值与中序下标之间的映射 int i = pos[pre[root]
PAT甲级备考模板持续整理中。。。
weixin_46055626的博客
09-10 238
拖了很久，我终于来写了。
PAT 甲级1003 [java] 刷题
hihiztc的博客
09-24 462
题目： 1003 Emergency (25 分) As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue te...
pat刷题记录
qq_41455096的博客
08-02 319
8.1 甲级1002，不一定用链表。可用数组解决问题。 乙级1027，审题：沙漏右边没有空格 8.2 甲级1005，CPP中用string来处理数字 string n； cin &amp;gt;&amp;gt;n; int i = n.size(); int j; int sum = 0; for(j=0;j&amp;lt;i;j++){ sum += n[j] - '0'; } 甲级1007，...
PAT（甲级）用到的模板以及知识点整理
m0_53193030的博客
05-03 90
//将数 取余 到1-mod n=(n-1)%mod+1 //惯用将问题分成两部分 d1=sum-d2 //两个正数之和相加等于负数表示发生了正溢出 //两个负数之和相加等于正数表示发生了负溢出 //模拟输出就先进行模拟分配 //进制转换模板 do{ arr.push_back(n%mod); n/=mod; } while(n!=0); ...
PAT刷题第一天。。。
Scarlett4795的博客
04-24 1211
纪念一下刷题第一天，刷了11题，应该是最简单了，发现自己还好许多要学习的地方，加油 给定不超过6的正整数A，考虑从A开始的连续4个数字。请输出所有由它们组成的无重复数字的3位数。 #include int main() { int m,n,k,l; scanf("%d",&m); n=m+1; k=n+1; l=k+1; printf("%d %d %d %d %d
PAT写作模板（给自己看的啦）
Sqssq的博客
12-31 188
Sample Input Sample Output 思路： 代码 就为了以后写文章方便一点。。。 大家加油！！！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值