排序、二分、栈、队列、DFS、BFS、回溯剪枝

排序、二分、栈、队列、DFS、BFS、回溯剪枝

A1010 Radix	进制转换、二分查找
A1104 Sum of Number Segments	排列组合
A1093 Count PAT’s	排列组合
A1148 Werewolf - Simple Version	枚举
A1048 Find Coins	枚举

A1128 N Queens Puzzle	八皇后问题
A1012 The Best Rank	排序
A1028 List Sorting	排序
A1095 Cars on Campus	排序
A1016 Phone Bills	排序
A1025 PAT Ranking	排序
A1062 Talent and Virtue	排序
A1055 The World’s Richest	排序
A1083 List Grades	排序
A1141 PAT Ranking of Institutions	排序
A1117 Eddington Number	排序
A1080 Graduate Admission	排序
A1113 Integer Set Partition	排序
A1129 Recommendation System	排序
A1075 PAT Judge	排序
A1153 Decode Registration Card of PAT	排序

A1100 Mars Numbers	打表
A1085 Perfect Sequence	二分查找
A1044 Shopping in Mars	二分查找
A1089 Insert or Merge	插入排序、归并排序
A1098 Insertion or Heap Sort	插入排序、堆排序
A1101 Quick Sort	快速排序主元的选取
A1051 Pop Sequence	栈
A1056 Mice and Rice	队列
A1074 Reversing Linked List	链表
A1032 Sharing	链表
A1133 Splitting A Linked List	链表
A1052 Linked List Sorting	链表
A1097 Deduplication on a Linked List	链表、散列
A1076 Forwards on Weibo	BFS
A1103 Integer Factorization	DFS
A1091 Acute Stroke	DFS、BFS
A1013 Battle Over Cities	DFS

A1076 微博转发 BFS

#include<stdio.h>
#include<queue>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
struct node{
    int point;
    int layer;
};
const int maxn=1010;
vector<node>tu[maxn];
int flag[maxn]={0};
int BFS(int v,int L){
    int count=0;
    queue<node>q;
    node start;
    start.point=v;
    start.layer=0;
    q.push(start);
    flag[start.point]=1;
    while(!q.empty()){
        node p=q.front();
        q.pop();
       int u=p.point;
        for(int i=0;i<tu[u].size();i++){
           node next=tu[u][i];
            next.layer=p.layer+1;//这边出错了
            if(flag[next.point]==0&&next.layer<=L){
                q.push(next);
                flag[next.point]=1;
                count++;
            }
        }
    }
    return count;
}
int main()
{
    int n,L,m,k;
    node user;
    scanf("%d %d",&n,&L);
    for(int i=1;i<=n;i++){
        user.point=i;
        scanf("%d",&m);
        for(int j=0;j<m;j++){
            scanf("%d",&k);
            tu[k].push_back(user);
        }
    }
    scanf("%d",&m);
    for(int i=0;i<m;i++){
        scanf("%d",&k);
        fill(flag,flag+maxn,0);
        int count=BFS(k,L);
        printf("%d\n",count);
    }
    return 0;
}

注意一下输入怎么建图，考察BFS

A1013 简单

略

A1103 DFS 求序列题

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<vector>
using namespace std;
int n,k,p;
int maxsumadd=-1;
vector<int>temppath,path,v;
void init(){
    int i=0;
    while(pow(i,p)<=n){
        v.push_back(pow(i,p));
        i++;
    }
}
void DFS(int index,int sumk,int sumpow,int sumadd){
    if(sumk==k&&sumpow==n){
        if(sumadd>maxsumadd){
            maxsumadd=sumadd;
            path=temppath;
        }
        return;
    }
    if(index==0||sumk>k||sumpow>n)return;
    temppath.push_back(index);
    DFS(index,sumk+1,sumpow+v[index],sumadd+index);
    temppath.pop_back();
    DFS(index-1,sumk,sumpow,sumadd);
}
int main()
{
//     freopen("input.txt","r",stdin);
    scanf("%d %d %d",&n,&k,&p);
    init();
    DFS(v.size()-1,0,0,0);
    if(maxsumadd==-1)printf("Impossible\n");
    else{
        printf("%d = ",n);
        for(int i=0;i<path.size();i++){
            printf("%d^%d",path[i],p);
            if(i!=path.size()-1)printf(" + ");
        }
    }
    return 0;
}

一般搜索题，要打表来降低函数执行时的时间复杂度，不然会超时

A1091 不难30分

BFS常规题，注意增量数组的使用

#include<stdio.h>
#include<queue>
using namespace std;
struct node{
    int x,y,z;
}Node;
int n,m,slice,t;
int pixel[1290][130][61];
bool inq[1290][130][61]={0};
int X[6]={0,0,0,0,1,-1};
int Y[6]={0,0,1,-1,0,0};
int Z[6]={1,-1,0,0,0,0};
bool judge(int x,int y,int z){
    if(x>=n||x<0||y>=m||y<0||z>=slice||z<0){
        return false;
    }
    if(pixel[x][y][z]==0||inq[x][y][z]==true)return false;
    return true;
}
int BFS(int x,int y,int z){
    int tot=0;
    queue<node>Q;
    Node.x=x,Node.y=y,Node.z=z;
    Q.push(Node);
    inq[x][y][z]=1;
//     tot++;
    while(!Q.empty()){
        node top=Q.front();
        Q.pop();
        tot++;
        for(int i=0;i<6;i++){
            int newx=top.x+X[i];
            int newy=top.y+Y[i];
            int newz=top.z+Z[i];
            if(judge(newx,newy,newz)){
                Node.x=newx,Node.y=newy,Node.z=newz;
                Q.push(Node);
                inq[newx][newy][newz]=1;
//                 tot++;
            }
        }
    }
    if(tot>=t)return tot;
    else return 0;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&slice,&t);
    for(int z=0;z<slice;z++){
        for(int x=0;x<n;x++){
            for(int y=0;y<m;y++){
                scanf("%d",&pixel[x][y][z]);
            }
        }
    }
    int ans=0;
    for(int z=0;z<slice;z++){
        for(int x=0;x<n;x++){
            for(int y=0;y<m;y++){
                if(pixel[x][y][z]==1&&inq[x][y][z]==0){
                    ans+=BFS(x,y,z);
                }
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

1013图遍历