PTA实验

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

typedef long long ll;

typedef unsigned long long ull;

struct Node{

int l, u;

} item1[1009], item2[1009];

int c[3000];

int d[3000];

int main(){

int m, n;

int index = -1;

int cnt1 = 0, cnt2 = 0;

scanf("%d", &n);

for(int i = 0; i < n; i++){

int left, up;

scanf("%d%d", &left, &up);

item1[cnt1].l = left;

item1[cnt1++].u = up;

c[up] += left;

index = (index > up) ? index : up;

}

scanf("%d", &m);

for(int i = 0; i < m; i++){

int left, up;

scanf("%d%d", &left, &up);

item2[cnt2].l = left;

item2[cnt2++].u = up;

c[up] += left;

index = (index > up) ? index : up;

}

int indexxx = item1[0].u + item2[0].u;

for(int i = 0; i < cnt1; i++){

for(int j = 0; j < cnt2; j++){

d[item1[i].u + item2[j].u] += item1[i].l * item2[j].l;

}

}

int flag = 0;

if(cnt1 == 0 || cnt2 == 0) printf("0 0\n");

else {

for(int i = indexxx; i >= 0; i--){

if(d[i]) {

if(flag) printf(" ");

printf("%d %d", d[i], i);

flag = 1;

}

}

if(flag == 0) printf("0 0");

printf("\n");

}

flag = 0;

for(int i = index; i >= 0; i--){

if(c[i]) {

if(flag)

printf(" ");

printf("%d %d", c[i], i);

flag = 1;

}

}

if(flag == 0) printf("0 0");

return 0;

}

#include <stdio.h>

#include <stdlib.h>

int main()

{

int zi,xi,flag=0;

while(scanf("%d %d",&xi,&zi)==2&&xi*zi){

if(flag)

printf(" ");

else flag=1;

printf("%d %d",xi*zi,zi-1);

}

if(!flag)

printf("0 0");

return 0;

}

#include<bits/stdc++.h>

using namespace std;

int main ()

{

queue<int> res;

int n,a[1004], b[1001], peo, j = 0, k = 0;

cin >> n;

for(int i = 0; i < n; i++)

{

cin >> peo;

if(peo %2 == 0)

b[k++] = peo;

else

a[j++] = peo;

}

int lenA = j, lenB = k;

j = 0;

k = 0;

for(j = 0; j < lenA && k < lenB; j++)

{

res.push(a[j]);

if(j % 2 == 1)

res.push(b[k++]);

}

if(j < lenA)

{

for( ; j < lenA; j++)

res.push(a[j]);

}

if(k < lenB)

{

for( ; k < lenB; k++)

res.push(b[k]);

}

while(!res.empty())

{

int t = res.front();

res.pop();

cout << t;

if(!res.empty())

cout << " ";

}

cout << endl;

return 0;

}

#include<iostream>

using namespace std;

const int N=1005,M=20;

struct ll{

int t,p;

}q[N];

int main(){

int l,r,n,k;

cin>>n;

l=r=0;

for(int i=0;i<n;i++){

cin>>q[r].t>>q[r].p;

if(q[r].p>60)q[r].p=60;

r++;

}

cin>>k;

int sumwait=0,lenwait=0,wait=0;

int sum[M]={0},winnum[M]={0};

while(l<r){

int flag=0,minn=99999,imin=0;

for(int i=0;i<k;i++){

if(sum[i]<=q[l].t){

sum[i]=q[l].t+q[l].p;

winnum[i]++;

flag=1;

l++;

break;

}

if(minn>sum[i]){

minn=sum[i];

imin=i;

}

}

if(!flag){

wait=minn-q[l].t;

if(lenwait<wait)lenwait=wait;

sumwait+=wait;

sum[imin]=minn+q[l].p;

winnum[imin]++;

l++;

}

}

int last=0;

for(int i=0;i<k;i++)if(last<sum[i])last=sum[i];

printf("%.1lf %d %d\n",1.0*sumwait/n,lenwait,last);

for(int i=0;i<k;i++){

if(i!=0)cout<<' ';

cout<<winnum[i];

}cout<<endl;

return 0;

}

//哈夫曼树

#include<bits/stdc++.h>

using namespace std;

int main(){

priority_queue <int,vector<int>,greater<int> > q;//优先队列 中 升序队列

int N,i,j,k,a[10000],d[10000],sum=0;

scanf("%d",&N);

for(i=0;i<N;i++){

scanf("%d",&a[i]);

}

for(i=0;i<N;i++){

q.push(a[i]);

}

while(!q.empty()&&q.size()!=1){

int temp1= q.top();//先访问 再弹出

q.pop();

int temp2= q.top();

q.pop();

int temp=temp1+temp2;

sum+=temp;

q.push(temp);

}

printf("%d",sum);

}

#include<iostream>

#include<algorithm>

using namespace std;

typedef struct TNode{

bool type;

string name;

struct TNode *Child_file[500];

struct TNode *Child_mulu[500];

int file;

int mulu;

}TNode,*Root;

int n;

Root root;

TNode *Search(Root Node,string s){

for(int i = 0;i < Node->mulu;i++)

if(Node->Child_mulu[i]->name == s)return Node->Child_mulu[i];

return NULL;

}

TNode *Creat_Mulu(Root &head,string s){

TNode *p = new TNode;

p->name = s;

p->type = true;

p->mulu = 0;

p->file = 0;

head->Child_mulu[head->mulu++] = p;

return p;

}

void Creat_File(Root &head,string s){

TNode *p = new TNode;

p->name = s;

p->type = false;

head->Child_file[head->file++] = p;

}

void Deal(string s){

string str = "";

TNode *Pre = root;

int Time = 0;

Root head = root;

for(int i = 0;i < s.size();i++){

if(s[i] != '\\')str += s[i];

else {

Pre = Search(head,str);

if(!Pre)head = Creat_Mulu(head,str);

else head = Pre;

str = "";

}

}

if(s[s.size() - 1] != '\\'){

Pre = Search(head,str);

if(!Pre)Creat_File(head,str);

}

}

void Initial(){

root = new TNode;

root->name = "root";

root->file = 0;

root->mulu = 0;

root->type = true;

cin>>n;

for(int i = 0;i < n;i++){

string s;

cin>>s;

Deal(s);

}

}

bool cmp(TNode *a,TNode *b){

return a->name < b->name;

}

void Show(Root head,int n){

for(int j = 0;j < n;j++)cout<<" ";

cout<<head->name<<endl;

if(head->type == false)return;

sort(head->Child_file,(head->Child_file) + head->file,cmp);

sort(head->Child_mulu,(head->Child_mulu) + head->mulu,cmp);

for(int i = 0;i < head->mulu;i++)Show(head->Child_mulu[i],n + 1 );

for(int i = 0;i < head->file;i++)Show(head->Child_file[i],n + 1);

}

int main(){

Initial();

Show(root,0);

}

#include <iostream>

#include <algorithm>

#include <cstring>

using namespace std;

typedef pair<int,int> PII;

const int N = 510;

int g[N][N];

int n,m,s,d;

int dist[N];

int w[N],t[N][N];

bool st[N];

void dijkstra(){

memset(dist, 0x3f, sizeof dist);

dist[s] = 0;

for(int i=0;i<n;i++){

int k = -1;

for(int j = 0;j<n;j++)

if(!st[j] && (k == -1 || dist[k] > dist[j]))

k = j;

st[k] = true;

for(int j=0;j<n;j++){

if(!st[j] && dist[j] > dist[k] + g[k][j]){

dist[j] = dist[k] + g[k][j];

w[j] = w[k] + t[k][j];//随时更新金额

}

else if(!st[j] && dist[j] == dist[k] + g[k][j] && w[j] > w[k] + t[k][j])

w[j] = w[k] + t[k][j];

}

}

}

int main(){

scanf("%d%d%d%d",&n,&m,&s,&d);

memset(g, 0x3f, sizeof g);

memset(t, 0x3f, sizeof t);

for(int i=1;i<=m;i++){

int a,b,c,f;

scanf("%d%d%d%d",&a,&b,&c,&f);

g[a][b] = c;

g[b][a] = c;

t[a][b] = f;

t[b][a] = f;

}

//for(int i=0;i<n;i++) w[i] = t[s][i];

dijkstra();

printf("%d %d\n",dist[d],w[d]);

return 0;

}

#include<iostream>

#include<algorithm>

using namespace std;

int f[1001];

typedef struct Node{

int aa;

int bb;

int fei;

}Node;

bool cmp(Node a,Node b){

return a.fei < b.fei;

}

int getf(int x){

if(f[x] == x)

return f[x];

f[x] = getf(f[x]);

return f[x];

}

int merge(int x,int y){

int tx = getf(x);

int ty = getf(y);

if(tx != ty){

f[ty] = tx;

return 1;

}

return 0;

}

void init(int n){

for(int i = 1;i <= n;i++)

f[i] = i;

return;

}

int main(){

int n,m,a,b,fee,sum,cnt;

Node p[3001];

scanf("%d%d",&n,&m);

init(n);

for(int i = 0;i < m;i++){

scanf("%d%d%d",&a,&b,&fee);

p[i].aa = a;

p[i].bb = b;

p[i].fei = fee;

}

sort(p,p + m,cmp);

sum = 0,cnt = 0;

for(int i = 0;i < m;i++)

if(merge(p[i].aa,p[i].bb)){

sum += p[i].fei;

cnt++;//统计边数

}

if(cnt == n- 1)

printf("%d\n",sum);

else

printf("-1\n");

return 0;

}

#include<bits/stdc++.h>

using namespace std;

int m[10010];

map<string,int> mp;

int sort(string s,int p){

int len = s.size() - 1;

stack<int> stk;

if(len == 0) return (s[0] - 'A') % p;

if(len == 1) return ((s[0] - 'A')*32+(s[1] - 'A')) % p;

for(int i = 1;i <= 3;i++)stk.push(s[len--] - 'A');

int n = 0;

for(int i = 0;i < 3;i++){

n = n * 32 + stk.top();

stk.pop();

}

return n % p;

}

int check(int pos,int p){

if(m[pos] == -1)return pos;

else {

int i = 1;

while(true){

if(m[(pos + i * i) % p] == -1)return (pos + i * i) % p;

else if(m[(pos - i * i + p) % p] == -1)return (pos - i * i + p) % p;

++i;

}

}

}

int main(){

int n,p,key;

cin>>n>>p;

queue<int>q;

for(int i = 0;i < p;i++)m[i] = -1;

for(int i = 0;i < n;i++){

string s;

cin>>s;

if(mp[s] == 0)mp[s] = key = check(sort(s,p),p);

else key = mp[s];

if(i == 0)cout<<key;

else cout<<" "<<key;

m[key] = 0;

}

}

#include<stdio.h>

#include<cstdlib>

#include<iostream>

#include<bits/stdc++.h>

using namespace std;

int a[1000100];

bool cmp(int a,int b)

{

return a>b;

}

int main()

{

int n,m;

scanf("%d %d",&n,&m);

int i,j,k,l;

for(i=0; i<n; i++)

{

scanf("%d",&a[i]);

}

sort(a,a+n,cmp);

m=min(n,m);

for(i=0; i<m; i++)

{

if(i==m-1)

{

printf("%d\n",a[i]);

}

else

{

printf("%d ",a[i]);

}

}

return 0;

}

#include <iostream>

#include <queue>

#include <algorithm>

struct Country {

int goldMedals;

int medals;

int population;

int standingList[4];

};

using namespace std;

template<typename CMP>

void ranking(vector<Country*>& c, const int& pos, CMP cmp) {

if (c.empty())return;

sort(c.begin(), c.end(), cmp);

int rank = 1;

c[0]->standingList[pos] = rank;

for (int i = 1; i < c.size(); i++) {

if (cmp(c[i - 1], c[i]))

rank = i + 1;

c[i]->standingList[pos] = rank;

}

return;

}

int main() {

int n, m, t;

cin >> n >> m;

vector<Country> countrys(n);

vector<Country*> id(n);

for (int i = 0; i < n; i++) {

cin >> countrys[i].goldMedals >> countrys[i].medals >> countrys[i].population;

id[i] = &countrys[i];

}

ranking(id, 0,

[](Country*& a, Country*& b) {

return a->goldMedals > b->goldMedals;

});

ranking(id, 1,

[](Country*& a, Country*& b) {

return a->medals > b->medals;

});

ranking(id, 2,

[](Country*& a, Country*& b) {

return a->goldMedals / (double)a->population > b->goldMedals / (double)b->population;

});

ranking(id, 3,

[](Country*& a, Country*& b) {

return a->medals / (double)a->population > b->medals / (double)b->population;

});

for (int i = 0; i < m; i++) {

cin >> t;

int minIndex = 0;

for (int j = 1; j < 4; j++)

if (countrys[t].standingList[j] < countrys[t].standingList[minIndex])

minIndex = j;

cout << (i ? " " : "") << countrys[t].standingList[minIndex] << ":" << minIndex + 1;

}

return 0;

}

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#define MAXN 100000

#define MAXS 10

typedef struct node

{

char s[MAXS+1];

int num;

} Message;

typedef struct Node

{

Message *Element;

int size;

}*MinHeap;

MinHeap Intial()//初始化堆

{

MinHeap H;

H=malloc(sizeof(struct Node));

H->Element=malloc(sizeof(Message)*MAXN);

H->size=-1;

return H;

}

void Insert(MinHeap H,Message item)//因为堆的下标从0开始，所以子节点i的父节点为2*i+1，父节点i的子节点为(i-1)/2

{

int i;

if(H->size==-1)

{

++H->size;

strcpy(H->Element[H->size].s,item.s);

H->Element[H->size].num=item.num;

}

else

{

++H->size;

i=H->size;

for(; i>0&&H->Element[(i-1)/2].num>item.num; i=(i-1)/2)

{

strcpy(H->Element[i].s,H->Element[(i-1)/2].s);

H->Element[i].num=H->Element[(i-1)/2].num;

}

strcpy(H->Element[i].s,item.s);

H->Element[i].num=item.num;

}

}

void Delete(MinHeap H)

{

int parent,child;

Message temp;

if(-1==H->size)

{

printf("EMPTY QUEUE!\n");

return;

}

printf("%s\n",H->Element[0].s);//输出堆的根节点

strcpy(temp.s,H->Element[H->size].s);

temp.num=H->Element[H->size--].num;

for(parent=0; (parent*2+1)<=H->size; parent=child)

{

child=2*parent+1;

if((child<H->size)&&H->Element[child].num>H->Element[child+1].num)

child++;

if(temp.num<=H->Element[child].num)

break;

else

{

strcpy(H->Element[parent].s,H->Element[child].s);

H->Element[parent].num=H->Element[child].num;

}

}

strcpy(H->Element[parent].s,temp.s);

H->Element[parent].num=temp.num;

}

int main()

{

int N,i;

MinHeap H=Intial();

Message X;

char s[4];

scanf("%d",&N);

for(i=0; i<N; i++)

{

scanf("%s",s);

if(strcmp("PUT",s)==0)

{

scanf("%s %d",X.s,&X.num);

Insert(H,X);

}

else

Delete(H);

}

return 0;

}