PAT 1011----1020

最新推荐文章于 2024-07-09 22:37:42 发布
最新推荐文章于 2024-07-09 22:37:42 发布
阅读量192 收藏
点赞数
文章标签： c++ 算法 图论 深度优先 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42445051/article/details/128771881
版权

1011

#include<iostream>
using namespace std;
#include<iostream>
#include<cstdio>
using namespace std;
int main(){
    double a,b,c,res=1;
    for(int i=0;i<3;i++){
        if(i!=0)  cout<<' ';
        cin>>a>>b>>c;
        if(a>b&&a>c) {cout<<'W';res=res*a;}
        if(b>a&&b>c) {cout<<'T';res=res*b;}
        if(c>a&&c>b) {cout<<'L';res=res*c;}
    }
    res=res*0.65*2-2;
    printf(" %.2f",res);
}

1012

//C-C语言成绩;  M-数学成绩； E-英语成绩; A-平均成绩
//N-学生个数; M-想检查其等级的人数
//
//对于M个学生，输出其最好的等级，以及其代表的最好等级的科目
//如果多个科目等级一样，优先输出A,C,M,E等级
//两个同学的最好科目等级一样，输出等级为最小的等级
//如果某同学不存在，输出N/A

#include<iostream>
#include<string>
#include<algorithm>
#include<map>
using namespace std;

struct student {
    string ID;
    int Score[4];//
    int rank[4];//0-4分别代表C,M,E,A等级
    int best;
    char best_c;
};
map<int, char> index_to_char;//0-4分别代表E,M,C,A
student a[2000];
int N, M;
bool cmp_E(student x, student y) { return x.Score[0] > y.Score[0]; }
bool cmp_M(student x, student y) { return x.Score[1] > y.Score[1]; }
bool cmp_C(student x, student y) { return x.Score[2] > y.Score[2]; }
bool cmp_A(student x, student y) { return x.Score[3] > y.Score[3]; }

void init_sort() {
    sort(a, a + N, cmp_E);
    a[0].rank[0] = 1;
    for (int i = 1; i < N; i++) {
        if (a[i].Score[0] == a[i - 1].Score[0]) a[i].rank[0] = a[i - 1].rank[0];
        else a[i].rank[0] = i + 1;
    }
    sort(a, a + N, cmp_M);
    a[0].rank[1] = 1;
    for (int i = 1; i < N; i++) {
        if (a[i].Score[1] == a[i - 1].Score[1]) a[i].rank[1] = a[i - 1].rank[1];
        else a[i].rank[1] = i + 1;
    }

    sort(a, a + N, cmp_C);
    a[0].rank[2] = 1;
    for (int i = 1; i < N; i++) {
        if (a[i].Score[2] == a[i - 1].Score[2]) a[i].rank[2] = a[i - 1].rank[2];
        else a[i].rank[2] = i + 1;
    }


    sort(a, a + N, cmp_A);
    a[0].rank[3] = 1;
    for (int i = 1; i < N; i++) {
        if (a[i].Score[3] == a[i - 1].Score[3]) a[i].rank[3] = a[i - 1].rank[3];
        else a[i].rank[3] = i + 1;
    }

}
int main() {
    index_to_char[0] = 'E'; index_to_char[1] = 'M'; index_to_char[2] = 'C'; index_to_char[3] = 'A';
    cin >> N >> M;
    int j, k, l;
    for (int i = 0; i < N; i++) {
        
        cin >> a[i].ID >> j >> k >> l;//EMCA
        a[i].Score[2] = j; a[i].Score[1] = k; a[i].Score[0] = l; a[i].Score[3] = (j+k+l)/3;
    }
    init_sort();
    for (int i = 0; i < N; i++) {
        int min = 99999;
        for (int j = 0; j < 4; j++) {
            if (a[i].rank[j] <= min) {//顺便按照A，C，M，E的优先级输出
                min = a[i].rank[j]; a[i].best = a[i].rank[j];
                a[i].best_c = index_to_char[j];               
            }
        }
    }
    map<string, int> ID_to_index;
    for (int i = 0; i < N; i++) {
        ID_to_index[a[i].ID] = i;
    }
    for (int i = 0; i < M; i++) {
        string s;
        cin >> s;
        
        //iterator find(const KEY_TYPE & key);

        auto temp = ID_to_index.find(s);
        if (temp != ID_to_index.end()) {
            int j = ID_to_index[s];
            cout << a[j].best << ' ' << a[j].best_c << endl;
        }
        else {
            cout << "N/A" << endl;
        }
        
        
    }
}

1013

//N-城市数量，M-道路数量,K-要考虑的被破坏的城市的数量
#include<iostream>
#include<vector>
using namespace std;
vector<int> road[1000];//从下标为1开始存储地图节点
bool visited[1000];
int N, M, K;
void DFS(int id, int q_city) {
    //访问id城市
    visited[id] = true;//id号城市已经被访问
    if (id == q_city) return;

    for (int i = 0; i < road[id].size(); i++) {
        int j = road[id][i];//j是id的临近城市
        if (!visited[j]&&j!=q_city)
            DFS(j, q_city);
    }
}
int main()
{
    cin >> N >> M >> K;
    for (int i = 0; i < M; i++) {
        int p, q;
        cin >> p >> q;
        road[p].push_back(q); road[q].push_back(p);
    }
    while (K--) {
        int q_city;
        cin >> q_city;

        for (int i = 1; i <= N; i++) visited[i] = false;
        int num = 0;
        for (int i = 1; i <= N; i++) {
            if (!visited[i])//i城市还没有访问
            {
                DFS(i, q_city);//利用深度优先遍历统计连通子图的个数
                num++;
            }
        }

        cout << num-2 << endl;
    }
    return 0;
}

1014

//N-窗户数量（20）；M-每个窗口队伍黄线前的容量（10）；
//K-客户数量（1000），客户从1到K进行了编号
//Q-客户咨询的数量（1000）

#include<iostream>
#include<queue>
#include<cstdio>
#include<string>
using namespace std;
int N, M, K, Q;
struct guest {
    int process;
    int end = 0;
};
guest a[1001];//数组下标即是他的编号
queue<int> q[20];//有多少个窗口，就有多少个队伍

int main() {
    cin >> N >> M >> K >> Q;
    for (int i = 1; i <= K; i++) {
        cin >> a[i].process;
    }
    int max_guest_id = 0;//代表当前黄线前面没有一个人
    
    for (int time = 480; time < 1020; time++) {
        //1,处理出队的人
        for (int j = 0; j < N; j++) {
            if (q[j].size() && a[q[j].front()].end == time)//该队伍的第一人满足条件就可以出队了
            {
               
                q[j].pop();
            }
        }

        //2,处理入队的人
        for (int s = 0; s < M; s++)
        {
            for (int j = 0; j < N; j++)
            {
                if (K > max_guest_id)//说明黄线外面还有人
                {
                    if (q[j].size() < M)
                    {
                        max_guest_id += 1;
                        q[j].push(max_guest_id);
                    } 
                }

            }
        }

        
        //3,接待接下来要接待的人
        for (int j = 0; j < N; j++) {
            if (q[j].size()&&a[q[j].front()].end == 0) { //对头的客户没有正在接待中，从此刻开始接待
                a[q[j].front()].end = time + a[q[j].front()].process;
            }
        }
    }
    for (int i = 0; i < Q; i++) {
        int ask;
        cin >> ask;
        if (a[ask].end == 0)cout << "Sorry" << endl;
        else {
                printf("%02d:%02d\n", a[ask].end / 60, a[ask].end % 60);
        }
    }
}

1015

#include<iostream>
#include<string>
using namespace std;

bool Isprime(int n) {
    if (n < 2)return 0;
    for (int i = 2; i * i < n; i++) {
        if (n % i == 0)return 0;
    }
    return 1;
}

int Other_to_Decimal(string s, int D) {
    int sum = 0;
    for (int i = s.size() - 1, unit = 1; i >= 0; i--) {
        sum += (s[i] - '0') * unit;
        unit = unit * D;
    }
    return sum;
}
int main() {
    while (1) {
        int N, D;
        cin >> N;
        if (N < 0)break;
        cin >> D;
        bool flag = Isprime(N);
        if (!flag) cout << "No" << endl;
        else {
            string res = "";
            while (N != 0) {
                res += '0' + N % D;
                N = N / D;
            }
            int temp = Other_to_Decimal(res, D);
            if (Isprime(temp))
                cout << "Yes" << endl;
            else
                cout << "No" << endl;
        }
    }
}

1016

//24小时的计费单价
//N行记录（客户名字，时间及其日期，记录的状态）
//按照时间顺序on-line与off-line的一对记录数据配对
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cstdio>
#include<map>
using namespace std;
struct record {
    int month;
    int day;
    int h;
    int m;
    int data;//用一个int综合表示所有时间
    string tag;

};
double pirce[24];
double day_pirce = 0;
int N;
map<string, vector<record>> bill;
bool cmp(record x, record y) {
    return x.data < y.data;
}
int main() {

    for (int i = 0; i < 24; i++) {
        cin >> pirce[i];
        day_pirce += pirce[i];
    }
    cin >> N;
    while (N--) {
        string s, statue;
        int a, b, p, q;
        char c;
        cin >> s >> a >> c >> b >> c >> p >> c >> q >> statue;
        record temp;
        temp.month = a; temp.day = b; temp.h = p; temp.m = q;
        temp.data = q + p * 60 + b * 1440;
        temp.tag = statue;
        bill[s].push_back(temp);
    }
    for (auto it = bill.begin(); it != bill.end(); it++) {
        vector<record> temp = it->second;
        int num = temp.size();
        sort(temp.begin(), temp.end(), cmp);
        double total = 0;
        for (int i = 0; i < num; i++) {
            
            if (temp[i].tag == "on-line") {
                if (i+1<temp.size()&&temp[i + 1].tag == "off-line") {
                    if (!total) {
                        cout << it->first << ' ';
                        printf("%02d\n", temp[0].month);
                    }
                    int minute = temp[i + 1].data - temp[i].data;
                    double pp = 0;
                    for (int time = temp[i].data; time < temp[i + 1].data; time++) {
                        pp += pirce[(time%1440)/60];
                    }
                    printf("%02d:%02d:%02d %02d:%02d:%02d %d $%.2f\n", temp[i].day, temp[i].h, temp[i].m, temp[i + 1].day, temp[i + 1].h, temp[i + 1].m, minute, pp/100);
                    total += pp;
                    i++;
                }
            }
        }
        if (total) {
            printf("Total amount: $%.2f\n", total / 100);
        }
    }
}

1017


//N-客户总数；K-窗户个数；T-客户到达时间；P-服务客户时间
#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
struct people {
    int process;
    int come_time;//到达时间
    int end;
    int wait = -1;
};
people guest[10000];
int window_index[100];//K个窗户前都没有人
bool cmp(people x, people y) {
    return x.come_time < y.come_time;
}
int main() {
    int N, K;
    cin >> N >> K;
    for (int i = 0; i < N; i++) {
        char c;
        int hh, mm, ss;
        cin >> hh >> c >> mm >> c >> ss >> guest[i].process;
        guest[i].come_time = ss + mm * 60 + hh * 60 * 60;
        guest[i].process = 60 * guest[i].process;
    }
    for (int i = 0; i < K; i++) {
        window_index[i] = -1;//下标代表第几个窗口，值代表该窗口服务的客人id
    }
    sort(guest, guest + N, cmp);//将顾客按照时间先来后到的顺序排列
    int next = 0;//接下来要服务客户的id
    int wait_total = 0;

    for (int time = 8 * 3600; guest[next].come_time <= 17 * 3600; time++) {
        //送客
        for (int i = 0; i < K; i++) {
            if (window_index[i] >= 0)//窗户前有人
            {
                int index = window_index[i];
                if (guest[index].end == time)
                    window_index[i] = -1;
            }
        }
        //接客
        for (int i = 0; i < K; i++) {
            if (next < N && window_index[i] == -1 && guest[next].come_time <= time) {
                window_index[i] = next;
                guest[next].wait = time - guest[next].come_time;
                wait_total += guest[next].wait;
                guest[next].end = time + guest[next].process;
                next++;
            }
        }
        if (next >= N) break;//来的人都能处理完，就可以退出循环
    }

    double ave = wait_total / (next);
    printf("%.1f", ave / 60);
}

1018

#include<iostream>
#include<vector>
using namespace std;

vector<int> road[501];//对于i号车站，存储其所有临近车站的id
int dist[501][501];//存储所有路的长度

vector<int> path;
int min_dist[501];//存储从0到任意节点的最短路径的长度
int S_num[501];//存储从1到N号车站的目前车数
int C, N, Sp, M;//分别代表车站的容量，车站的总数，问题车站的编号，路数
vector<int> final_path;
int final_send;
int final_back;

void DFS(int id, int length,int send,int back) {
	if (min_dist[id] < length) return;
	path.push_back(id);
	if (id == Sp) {//访问到了Sp
		if (min_dist[Sp] > length||(min_dist[Sp]==length&&send<final_send)|| (min_dist[Sp] == length && send == final_send&&back<final_back)) {
			min_dist[Sp] = length;
			final_send = send;
			final_back = back;
			final_path = path;
		}
	}
	else {//还没有访问到Sp
		if (min_dist[id] > length) {
			min_dist[id] = length;
		}
		for (int i = 0; i < road[id].size(); i++) {
			int next_id = road[id][i];
			int next_length = length + dist[id][next_id];
			int next_send, next_back;
			if (back + S_num[next_id] < C / 2)//本车站的多余车给下一车站以后还是不够
			{
				next_send = send + (C / 2 - (back + S_num[next_id]));
				next_back = 0;
				DFS(next_id, next_length, next_send, next_back);
			}
			else {//本车站的多余车给下一站以后够了
				next_send = send;
				next_back = back + S_num[next_id] - C / 2;
				DFS(next_id, next_length, next_send, next_back);

			}

		}
		
	}
	path.pop_back();
}
int main() {
	cin >> C >> N >> Sp >> M;
	for (int i = 1; i <= N; i++) {//输入1号车站到N号车站的目前车数
		cin >> S_num[i];
	}
	for (int i = 0; i < M; i++) {
		int a, b, c;
		cin >> a >> b >> c;
		road[a].push_back(b);
		road[b].push_back(a);
		dist[a][b] = c;
		dist[b][a] = c;
	}

	for (int i = 0; i < 501; i++)min_dist[i] = 99999999;
	DFS(0, 0,0,0);
	cout << final_send << ' ';
	cout << final_path[0];
	for (int i = 1; i < final_path.size(); i++) {
		cout <<"->"<<final_path[i];
	}
	cout<< ' ' << final_back;

}

1019

#include<iostream>
#include<vector>
#include<string>
#include<map>
using namespace std;
int N, b;
vector<int> ans;
bool Is_Palindromic()//判断a数组是不是一个回文子串
{
    bool flag = true;
    for (int i = 0; i < ans.size() / 2; i++)
    {
        int j = ans.size() - (i + 1);
        if (ans[i] != ans[j]) flag = false;
    }
    return flag;
}
void N_to_ans(int b) {
    while (N != 0) {
        int x = N % b;
        ans.push_back(x);
        N = N / b;
    }//注意，得到的vector-ans是倒序存储b进制的数字N的
    //但是我们要判断他是不是回文，所以其倒序也能判断
}

int main() {
    cin >> N >> b;
    N_to_ans(b);
    int flag = Is_Palindromic();
    map<int, string> p;
    p[0] = "No";
    p[1] = "Yes";
    cout << p[flag] << endl;
    for (int i = ans.size() - 1; i >= 0; i--) {
        if (i != ans.size() - 1)cout << ' ';
        cout << ans[i];
    }
}

1020

#include<iostream>
#include<queue>
using namespace std;
struct node {
    int id;
    node* left = nullptr;
    node* right = nullptr;
};

int a[31];
int b[31];
int N;
node* build_tree(int h1, int t1, int h2, int t2) {
    if (h1 > t1) return NULL;
    node* p = new node;
    p->id = a[t1];
    int index;
    for (index = h2; b[index] != a[t1]; index++);
    p->left = build_tree(h1, index - 1 - h2 + h1, h2, index - 1);
    p->right = build_tree(index - h2 + h1, t1 - 1, index + 1, t2);
    return p;
}
int main() {
    cin >> N;
    for (int i = 0; i < N; i++) {
        cin >> a[i];
    }
    for (int i = 0; i < N; i++) {
        cin >> b[i];
    }
    node*root = build_tree(0, N-1, 0, N-1);
    queue<node*> tree;
    tree.push(root);
    int i = 0;
    while (!tree.empty()) {
        if (i != 0)cout << ' ';
        node* temp = tree.front();
        tree.pop();
        cout <<temp ->id;
        if (temp->left != nullptr)tree.push(temp->left);
        if (temp->right != nullptr)tree.push(temp->right);
        i++;
    }
}
橡秄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【算法】【PAT】1011-1020
Ashe_1994的博客
05-16 438
目录1011 World Cup Betting(20)题目题解1012 The Best Rank（25）推荐：1星题目分析要点题解1013 Battle Over Cities (25分) 推荐：经典题目分析题解1014 Waiting in line(30) 推荐：2星题目分析要点知识点题解1015 Reversible Primes (20分) 推荐：2星题目分析题解1016 Phone Bills (25分) 推荐指数：2星题目分析要点知识点题解1017 Queueing at Bank (25分
PaT Plot-开源
04-27
【标题】"PaT Plot-开源" 在信息技术领域，数据可视化是至关重要的工具，它能够帮助研究人员和分析师更好地理解和解释复杂的数据集。PaT Plot（可能是Procedure and Treatment Plot的缩写）是一个开源软件，专为...
pat1011-1020
diankeng5481的博客
05-10 70
一开始几道题写到吐血，真的自己现在好弱 1011 水题不说了 #include<bits/stdc++.h> using namespace std; const int N = 105; typedef unsigned long long ll; const int MOD = 1e9+7; int c[5]; int main() { d...
gss的pat乙级记录1011-1020
pat乙级记录
02-13 170
11.长整型A+B比较 #include &amp;lt;stdio,h&amp;gt; #define max 100 int main(){ int num; scanf(&quot;%d&quot;,&amp;amp;num) long a[max]; for(in i=0;i&amp;lt;num*3;i++)scanf(&quot;%ld&quot;,&amp;amp;a[i]); int count =
PAT乙级1011-1020
qq_36095512的博客
02-25 157
1011A+B和C，注意要使用longlong类型，因为两个32位相加有可能超出范围导致符号反转#include&lt;iostream&gt; #include&lt;vector&gt; using namespace std; int main(int argc, char*argv[]) { int sum; cin &gt;&gt; sum; vector&lt;vector&...
PAT 1011-1020 题解
biaobiaoqi的老博客
08-03 3839
早期部分代码用Java实现。由于PAT虽然支持各种语言，但只有C/C++标程来限定时间，许多题目用Java读入数据就已经超时，后来转投C/C++。浏览全部代码：请戳 本文谨代表个人思路，欢迎讨论;) 1011. World Cup Betting (20) 题意 给定一个3*3的矩阵，找到每行的最大值，格式化输出一个运算结果。 分析 非常简单的模拟题。
PAT乙级 1011-1020
西瓜霜的博客
02-28 230
1011 A+B和C (15) 1012 数字分类 (20) 1013 数素数 (20) 1014 福尔摩斯的约会 (20) 1015 德才论 (25) 1016 部分A+B (15) 1017 A除以B (20) 1018 锤子剪刀布 (20) 1019 数字黑洞 (20) 1020 月饼 (25)
PAT-Basic刷题1011-1020
fancyZT的博客
06-13 203
1011 A+B 和 C #include<iostream> #include<cstdio> using namespace std; int main(void){ int n; cin>>n; for(int i=1;i<=n;i++){ long long int a,b,c; scanf("%lld%lld%lld",&a,&b,&c); printf("Ca
PAT (Basic Level) 1011-1020
weixin_47224527的博客
04-08 674
PAT (Basic Level) 1011-1020
PAT甲级刷题记录（1011-1020）
weixin_45848585的博客
09-27 79
PAT1011-1020
Intel FB-Patcher 1.5.9
11-05
Intel FB-Patcher1.5.9最新版，找了很久，现在共享出来CSDN的上版本已经很老了。
lora-l101-pAT-demo-V1.0.rar
04-20
标题 "lora-l101-pAT-demo-V1.0.rar" 暗示这是一个关于LoRa技术的软件演示版本，版本号为V1.0，且与lora-l101-pAT模块有关。描述 "lora-l101-pAT-demo-V1.0" 是对压缩包内容的简单重复，没有提供额外信息。标签 ...
PAT-乙级-1001
05-27
vs2010写的代码 语言c++ 1001 害死人不偿命的(3n+1)猜想 使用if语句和while语句
generator-pat-marionette
05-12
generator-pat-marionette generatorGetting Started全局安装 yeoman、grunt-cli、bowernpm install -g yonpm install -g grunt-clinpm install -g bower由于当前generator没有注册到gurnt上去，所以你要先把源文件...
c++习题08-计算星期几
码到成龚的博客
07-03 606
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初探究（2）
最新发布
Frenemy__的博客
07-09 1089
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 926
Android 开发中 C++ 和Java 日志调试方法小结
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 929
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
pat7-107-10 公路村村通
06-10
这道题是一道最小生成树的经典问题。题目描述为：有n个村庄需要修路相连，给出每个村庄之间修路的代价，求使得所有村庄都联通的最小代价。 解决这个问题的算法有很多，其中一个经典的算法是Kruskal算法。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值