【PAT刷题】快速产出垃圾——2020-3-2

A1095

没哈希表可能会死，所以先写一半然后抄答案了。解决了输出在范围内时间的问题。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

struct Event{
    char name[10];
    int hh;
    int mm;
    int ss;
    bool status;
    bool valid;
}events[10010],tmp;

struct Pair{
    char name[10];
    int inhh;
    int inmm;
    int inss;
    int outhh;
    int outmm;
    int outss;
}pairs[10010];

struct bao

bool cmp(Event a,Event b){
    if(strcmp(a.name,b.name)!=0) return strcmp(a.name,b.name)<0;
    else if(a.hh!=b.hh) return a.hh<b.hh;
    else if(a.mm!=b.mm) return a.mm<b.mm;
    else return a.ss<b.ss;
}

bool cmp1(Pair a,Event b){
    if(a.inhh!=b.hh) return a.inhh<b.hh;
    else if(a.inmm!=b.mm) return a.inmm<b.mm;
    else return a.inss<=b.ss;
}

bool cmp2(Pair a,Event b){
    if(a.outhh!=b.hh) return a.outhh>b.hh;
    else if(a.outmm!=b.mm) return a.outmm>b.mm;
    else return a.outss>b.ss;
}
int main(){
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++){
        char tmp[10];
        scanf("%s %d:%d:%d %s",events[i].name,&events[i].hh,&events[i].mm,&events[i].ss,tmp);
        if(!strcmp(tmp,"out")) events[i].status = false;
        else events[i].status = true;
    }
    sort(events,events+n,cmp);
//     for(int i=0;i<n;i++){
//         printf("%s %02d:%02d:%02d",events[i].name,events[i].hh,events[i].mm,events[i].ss);
//         if(events[i].status==true){
//             printf(" in\n");
//         }
//         else printf(" out\n");
//     }
    int next=0,io=0,idx=0,index=0;
    while(next<n){
        if(strcmp(events[next+idx].name,events[next+idx-1].name)==0 || idx==0){
            if(events[idx+next].status==true){
                io=1;
            }
            else{
                io++;
                if(io==2){
                    strcpy(pairs[index].name,events[idx+next].name);
                    pairs[index].inhh =events[idx-1+next].hh;
                    pairs[index].inmm =events[idx-1+next].mm;
                    pairs[index].inss =events[idx-1+next].ss;
                    pairs[index].outhh =events[idx+next].hh;
                    pairs[index].outmm =events[idx+next].mm;
                    pairs[index].outss =events[idx+next].ss;
                    index++;
                }
                else{
                    io=3;
                }
            }
            idx++;
        }
        else{
            next=next+idx;
            idx=0;
        }
    }
    for(int i=0;i<k;i++){
        scanf("%d:%d:%d",&tmp.hh,&tmp.mm,&tmp.ss);
        int num=0;
        for(int j=0;j<index;j++){
            if(cmp1(pairs[j],tmp) && cmp2(pairs[j],tmp)) num++;
            //printf("%s %02d:%02d:%02d %02d:%02d:%02d\n",pairs[j].name,pairs[j].inhh,pairs[j].inmm,pairs[j].inss,pairs[j].outhh,pairs[j].outmm,pairs[j].outss);
        }
        printf("%d\n",num);
    }
}

（2）抄一遍答案

答案说对于本题建议先学完配套用书的6.4节的mp的常用方法再来做……所以溜了溜了。能做就是太麻烦了。

 

好像之前散列表的没保存，也没太多值得写的，就算了

 

4.4 贪心

B1020

#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

struct Yuebing{
    double cunlaing;
    double zongjia;
    double danjia;
}yuebings[1010];

bool cmp(Yuebing a,Yuebing b){
    return a.danjia>=b.danjia;
}

int main(){
    int n,d;
    scanf("%d%d",&n,&d);
    for(int i=0;i<n;i++){
        scanf("%lf",&yuebings[i].cunlaing);
    }
    for(int i=0;i<n;i++){
        scanf("%lf",&yuebings[i].zongjia);
        yuebings[i].danjia = yuebings[i].zongjia/yuebings[i].cunlaing;
    }
    sort(yuebings,yuebings+n,cmp);
    double xiaoliang = 0;
    double yingli = 0;
    for(int i=0;i<n;i++){
        xiaoliang += yuebings[i].cunlaing;
        if(xiaoliang<=d){
            yingli+=yuebings[i].zongjia;
        }
        else{
            yingli+=yuebings[i].danjia*(d-xiaoliang+yuebings[i].cunlaing);

            break;
        }
    }
    printf("%.2f",yingli);

}

销量可能是double但是d是正整数，还挺怪的。

 

B1023

#include <cstdio>
#include <algorithm>
using namespace std;

int ins[10];

bool cmp(int a,int b){
    return a<=b;
}

int main(){
    for(int i=0;i<10;i++){
        scanf("%d",&ins[i]);
    }
    int idx =-1;
    for(int i=1;i<10;i++){
        if(ins[i]!=0){
            printf("%d",i);
            idx = i;
            ins[i]--;
            break;
        }
    }
    for(int i=0;i<10;i++){
        for(int j=0;j<ins[i];j++){
            printf("%d",i);
        }
    }
}

白给。

 

区间贪心：所有区间都没有的部分不算数，剩下的就是短的，那么显然选短的。以此类推。从左到右和从右边到左都行，就是先固定一个排序方向然后找短的。

 

A1033

不会做，看答案。

（1）参考答案

贪心的策略就是找最近的比现在便宜的，然后加油到刚好到k，如果没有这样的直接加满，然后在最便宜的地方加油。实际上并不难就是自己想不到。

------------恢复内容开始------------

A1095

没哈希表可能会死，所以先写一半然后抄答案了。解决了输出在范围内时间的问题。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

struct Event{
    char name[10];
    int hh;
    int mm;
    int ss;
    bool status;
    bool valid;
}events[10010],tmp;

struct Pair{
    char name[10];
    int inhh;
    int inmm;
    int inss;
    int outhh;
    int outmm;
    int outss;
}pairs[10010];

struct bao

bool cmp(Event a,Event b){
    if(strcmp(a.name,b.name)!=0) return strcmp(a.name,b.name)<0;
    else if(a.hh!=b.hh) return a.hh<b.hh;
    else if(a.mm!=b.mm) return a.mm<b.mm;
    else return a.ss<b.ss;
}

bool cmp1(Pair a,Event b){
    if(a.inhh!=b.hh) return a.inhh<b.hh;
    else if(a.inmm!=b.mm) return a.inmm<b.mm;
    else return a.inss<=b.ss;
}

bool cmp2(Pair a,Event b){
    if(a.outhh!=b.hh) return a.outhh>b.hh;
    else if(a.outmm!=b.mm) return a.outmm>b.mm;
    else return a.outss>b.ss;
}
int main(){
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++){
        char tmp[10];
        scanf("%s %d:%d:%d %s",events[i].name,&events[i].hh,&events[i].mm,&events[i].ss,tmp);
        if(!strcmp(tmp,"out")) events[i].status = false;
        else events[i].status = true;
    }
    sort(events,events+n,cmp);
//     for(int i=0;i<n;i++){
//         printf("%s %02d:%02d:%02d",events[i].name,events[i].hh,events[i].mm,events[i].ss);
//         if(events[i].status==true){
//             printf(" in\n");
//         }
//         else printf(" out\n");
//     }
    int next=0,io=0,idx=0,index=0;
    while(next<n){
        if(strcmp(events[next+idx].name,events[next+idx-1].name)==0 || idx==0){
            if(events[idx+next].status==true){
                io=1;
            }
            else{
                io++;
                if(io==2){
                    strcpy(pairs[index].name,events[idx+next].name);
                    pairs[index].inhh =events[idx-1+next].hh;
                    pairs[index].inmm =events[idx-1+next].mm;
                    pairs[index].inss =events[idx-1+next].ss;
                    pairs[index].outhh =events[idx+next].hh;
                    pairs[index].outmm =events[idx+next].mm;
                    pairs[index].outss =events[idx+next].ss;
                    index++;
                }
                else{
                    io=3;
                }
            }
            idx++;
        }
        else{
            next=next+idx;
            idx=0;
        }
    }
    for(int i=0;i<k;i++){
        scanf("%d:%d:%d",&tmp.hh,&tmp.mm,&tmp.ss);
        int num=0;
        for(int j=0;j<index;j++){
            if(cmp1(pairs[j],tmp) && cmp2(pairs[j],tmp)) num++;
            //printf("%s %02d:%02d:%02d %02d:%02d:%02d\n",pairs[j].name,pairs[j].inhh,pairs[j].inmm,pairs[j].inss,pairs[j].outhh,pairs[j].outmm,pairs[j].outss);
        }
        printf("%d\n",num);
    }
}

（2）抄一遍答案

答案说对于本题建议先学完配套用书的6.4节的mp的常用方法再来做……所以溜了溜了。能做就是太麻烦了。

 

好像之前散列表的没保存，也没太多值得写的，就算了

 

4.4 贪心

B1020

#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

struct Yuebing{
    double cunlaing;
    double zongjia;
    double danjia;
}yuebings[1010];

bool cmp(Yuebing a,Yuebing b){
    return a.danjia>=b.danjia;
}

int main(){
    int n,d;
    scanf("%d%d",&n,&d);
    for(int i=0;i<n;i++){
        scanf("%lf",&yuebings[i].cunlaing);
    }
    for(int i=0;i<n;i++){
        scanf("%lf",&yuebings[i].zongjia);
        yuebings[i].danjia = yuebings[i].zongjia/yuebings[i].cunlaing;
    }
    sort(yuebings,yuebings+n,cmp);
    double xiaoliang = 0;
    double yingli = 0;
    for(int i=0;i<n;i++){
        xiaoliang += yuebings[i].cunlaing;
        if(xiaoliang<=d){
            yingli+=yuebings[i].zongjia;
        }
        else{
            yingli+=yuebings[i].danjia*(d-xiaoliang+yuebings[i].cunlaing);

            break;
        }
    }
    printf("%.2f",yingli);

}

销量可能是double但是d是正整数，还挺怪的。

 

B1023

#include <cstdio>
#include <algorithm>
using namespace std;

int ins[10];

bool cmp(int a,int b){
    return a<=b;
}

int main(){
    for(int i=0;i<10;i++){
        scanf("%d",&ins[i]);
    }
    int idx =-1;
    for(int i=1;i<10;i++){
        if(ins[i]!=0){
            printf("%d",i);
            idx = i;
            ins[i]--;
            break;
        }
    }
    for(int i=0;i<10;i++){
        for(int j=0;j<ins[i];j++){
            printf("%d",i);
        }
    }
}

白给。

 

区间贪心：所有区间都没有的部分不算数，剩下的就是短的，那么显然选短的。以此类推。从左到右和从右边到左都行，就是先固定一个排序方向然后找短的。

 

A1033

不会做，看答案。

（1）参考答案

贪心的策略就是找最近的比现在便宜的，然后加油到刚好到k，如果没有这样的直接加满，然后在最便宜的地方加油。实际上并不难就是自己想不到。

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 510;
const int INF = 10000000000;

struct station{
    double price,dis;  //价格、与起点的距离。
}st[maxn];

bool cmp(station a,station b){
    return a.dis<b.dis;
}

int main(){
    int n;
    double Cmax,D,Davg;
    scanf("%lf%lf%lf%d",&Cmax,&D,&Davg,&n);
    for(int i=0;i<n;i++){
        scanf("%lf%lf",&st[i].price,&st[i].dis);
    }
    st[n].price = 0;
    st[n].dis =D;
    sort(st,st+n,cmp);
    if(st[0].dis!=0){
        printf("The maximum travel distance = 0.00\n");
    }
    else{
        int now=0;
        double ans =0,nowTank = 0,MAX= Cmax *Davg;
        while(now <n){
            int k=-1;
            double priceMin =INF;
            for(int i =now+1;i<=n && st[i].dis-st[now].dis <=MAX;i++){
                if(st[i].price <priceMin){
                    priceMin = st[i].price;
                    k=i;
                    if(priceMin<st[now].price){
                        break;
                    }
                }
            }
            if(k==-1) break;
            double need = (st[k].dis - st[now].dis)/Davg;
            if(priceMin < st[now].price){
                if(nowTank < need){
                    ans+=(need-nowTank)*st[now].price;
                    nowTank =0; 
                }
                else{
                    nowTank -= need;
                }
            }
            else{
                ans+=(Cmax- nowTank)*st[now].price;
                nowTank = Cmax - need;
            }
            now = k;
        }
        if(now==n){
            printf("%.2f\n",ans);
        }
        else{
            printf("The maximum travel distance = %.2f\n",st[now].dis+MAX);
        }
    }
}

 

A1037

（1）自己尝试

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

bool cmp(int a,int b){
    return a>b;
}

int main(){
    int nc,np;
    int cs[100010],ps[100010];
    scanf("%d",&nc);
    for(int i=0;i<nc;i++){
        scanf("%d",&cs[i]);
    }
    scanf("%d",&np);
    for(int i=0;i<np;i++){
        scanf("%d",&ps[i]);
    }
    sort(cs,cs+nc,cmp);
    sort(ps,ps+np,cmp);
    int sum=0;
    for(int i=0;i<np && i<nc;i++){
        if(cs[i]>0 && ps[i]>0){
            sum+=cs[i]*ps[i];
        }
        if(cs[nc-1-i]<0 && ps[np-1-i]<0){
            sum+=cs[nc-1-i]*ps[np-1-i];
        }
    }
    printf("%d",sum);
}

从后和从前遍历，注意数组别开小了。

 

A1067

这是一道需要认真读题的题，题目的意思其实是只能用0和其他数字交换，第二个参数是交换的次数， 然后是0~N-1的全排列，所以我们的思路应该是回归本位。没什么太好的思路，先抄下答案吧。 

（1）参考答案

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=  100010;
int pos[maxn];
int main(){
    int n,ans=0;
    scanf("%d",&n);
    int left = n-1,num; //left存放除0以外不在本位上的数的个数.
    for(int i=0;i<n;i++){
        scanf("%d",&num);
        pos[num] = i;
        if(num==i && num!=0){
            left--;
        }
    }
    int k=1; 
    while(left>0){
        if(pos[0] == 0){
            while(k<n){
                if(pos[k]!=k){
                    swap(pos[0],pos[k]);
                    ans++;
                    break;
                }
                k++;
            }
        }
        while(pos[0]!=0){
            swap(pos[0],pos[pos[0]]); //将0与Pos[0]交换.
            ans++;
            left--;
            break;
        }
    }
    printf("%d\n",ans);
    return 0;
}

思路：

由于必须使用数字0跟其他数字进行交换，因此直观上可以很容易想到的策略是：如果数字0当前在i号位，则找到数字i当前所在的位置，然后把0和i进行交换。

但是这个策略不能完全解决问题，因为一旦交换过程中（或是初始序列时） 数字0回到了0号位，按上面的算法就不能将其与一个确定的数字交换，这是就要想办法处理这种情况。通过思考该策略，一旦一个非零的数字回到了它原先的位置，在后面的步骤中就不应该再让0去与它交换，否则会让交换次数变多。也就是说，非零的数字回到其“本位”后将不再变动。

这就得到一个启示：如果交换过程中出现数字0在0号位的情况，这就随意选择一个还没有回到“本位”的数字，让其与数字0交换位置。显然，这种交换不会对已经在”本位“的数字产生影响，但却使上边的策略的一致性。

具体实现上，可以使用int型变量left记录除零以外不在本位上的数字的个数，并在读入数据时预处理这些值。

注意点：

（1）在循环中寻找一个不在本位上的数时，如果每次都从开头开始枚举序列的中的数，判断其是否在本位上，则会有两组数据超时（因为复杂度是二次方级的）。更适合的做法是利用每个移回本位的数在后续操作中不再移动的特点，从整体上定义一个变量k，用来保存目前序列中不在本位上的最小数（初始为1），当交换过程中出现0回归本位的情况时，总是从当前的k开始继续增大寻找不在本位上的数，这样就能保证复杂度从整体上是线性级别（k在整个算法过程中最多只能从0增长到n）。

 

总结：反着存是为了减少存储次数，然后使用left和k也是为了减少存储次数。

 这题先过，回头看，很怪。

 

A1038

这道题策略是返回S1+S2>S2+S1，即字符串拼接（想想js的字符串）

（1）参考答案

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

const int maxn=10010;
string str[maxn];
bool cmp(string a,string b){
    return a+b<b+a;
}

int main(){
    int n;
    cin >>n;
    for(int i=0;i<n;i++){
        cin>>str[i];
    }
    sort(str,str+n,cmp);
    string ans;
    for(int i=0;i<n;i++){
        ans+=str[i];
    }
    while(ans.size()!=0 &&ans[0]=='0'){
        ans.erase(ans.begin()); //去除前导0
    }
    if(ans.size()==0) cout<<0;
    else cout << ans;
}

两点，用string，注意处理0的情况。

 

4.5 二分

 

二分查找是基于有序序列的查找算法。时间复杂度是O(logn)

二分查找的过程与序列的下标是从0开始i还是从1开始无关。

需要三个索引。（left，right，mid）

三种二分：找到该数，找到第一个大于等于该数的数，找到第一个大于该数的数。

 

B1030/A1085

（1）自己尝试

#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn= 100010;
int ins[maxn];

bool cmp(int a,int b){
    return a<b;
}

int search(int A[],int left,int right,long long np){
    int mid;
    int i=left;

    while(left<right){
        mid =(left+right)/2;
        if(A[mid]>np){
            right = mid;
        }
        else{
            left=mid+1;
        }
    }
    return left-i;
}

int main(){
    int n,p;
    scanf("%d%d",&n,&p);
    for(int i=0;i<n;i++){
        scanf("%d",&ins[i]);
    }
    sort(ins,ins+n,cmp);
    int max= 0;
    int tmp= 0;
    for(int i=0;i<n;i++){
        tmp = search(ins,i,n,(long long)ins[i]*p);
        if(tmp>max) max = tmp;
    }
    printf("%d",max);
}

考察了二分查找怎么写，mp可能是10*18所以可能越界，需要强制转换，然后在函数传入的时候也得改。

（2）参考答案

可以直接用库的。

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100010;
int n,p,a[maxn];

int main(){
    scanf("%d%d",&n,&p);
    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
    }
    sort(a,a+n); //递增排序。
    int ans=1; //最大长度，初值为1。
    for(int i=0;i<n;i++){
        int j=upper_bound(a+i+1,a+n,(long long)a[i]*p)-a; //这里传入的是指针类型。
        ans = max(ans,j-i);
    }
    printf("%d\n",ans);
    return 0;
}