PAT A 1108 1109 1110 1111

这些题都需要仔细读题，很多错误都是因为题意不清导致的。

1108 字符串

题目大意：
real numbers：实数
accurate up to：精确到
2 decimal places：两位小数
给N个实数 ，计算符合条件的数的平均值。
符合条件的数是范围在[-1000,1000]并且精确到两位小数 的数字。
思路：
用sscanf, sprintf是个好方法，具体可以参考：柳婼 の blog
scanf("%s", a);
sscanf(a, "%lf", &temp);
sprintf(b, "%.2lf",temp);
但是这样做也没啥意思了，于是平时练习用复杂的方法做一遍。

#include
#include
#include
using namespace std;
int main(){
    int n; // n<=100
    cin>>n;
    int count = 0;
    double sum = 0.0;
    for(int i=0;i>s;
        bool flag = true;
        bool exist = false;
        double num = 0.0;
        double k = 1;
        bool fuhao = true, ex_fu = false;
        for(int j=0;j='0' && s[j]<='9')) && s[j]!='.') || (s[j] == '.' && exist == true)){
                flag = false;
                break;
            }else if(s[j] == '.' && exist == false && j != 0){
                exist = true;
            }else if(s[j] == '.' && exist == false && j == 0){// .2是不正确的 
                flag = false;
                break;
            }else{
                if(exist == false){
                    num = num*10 + s[j] - '0';
                }else{
                    k = k*0.1;
                    num = num + (s[j] - '0')*k;
                    if(k < 0.01){
                        flag = false;
                        break;
                    }
                }
            }
        }
        if(fuhao == false) num = -num;
        if(!(num>=-1000 && num<=1000) ){
            flag = false;
        }
        if(flag){
            count++;
            sum+=num;
        }else{
            cout<<"ERROR: "<

1109 逻辑题

题目大意： N个人，排列成k队。
排队规则：
1、每列有n/k个人（向下取整），多余的人站最后一列
2、后排的人数必须>=前排的人数
3、 最高的人站在（m/2+1）的位置
4、其他人先矮后高又矮。假设左相对于右高
5、同样的高度，根据姓名的字母表排序，姓名没有重复
见到这种很复杂的输入，又有排序。必定用vector的sort,参数多就定义结构体。

#include
#include
#include
using namespace std;

typedef struct node{
    string name;
    int height;
}node;

bool cmp(node a, node b){
    if(a.height == b.height){
        return a.name > b.name;
    }
    return a.height < b.height;
}

int main(){
    int n ,k;
    cin>>n>>k; 
    vector v;
    for(int i=0;i>n>>h;
        node temp;
        temp.name = n;
        temp.height = h;
        v.push_back(temp);
    }
    sort(v.begin(), v.end(), cmp);
    
    int m = n / k; //每排几个人 
    int y = n % k; //余数 
    int count = n-1;
    int hang = 0;
    
    vector< vector > ans(k+1);
    
    vector temp(m+y);  //最后一排 
    int p,q;
    temp[(m+y)/2] = v[count--].name;
    for(p = (m+y)/2-1, q = (m+y)/2+1; p>=0 && q temp(m); 
        int p,q;
        temp[(m)/2] = v[count--].name;
        for(p = (m)/2-1, q = (m)/2+1; p>=0 && q

1110 树

题目大意： 给一个树，求是否是是一个完全二叉树

#include
#include

1111 最短路径

题目大意： 给出起点和终点，找出最短路和最快路
一个求最短路径（如果相同求时间最短的那条），一个求最快路径（如果相同求结点数最小的那条）
思路： 两次狄更斯+DFS即可。

#include
#include
#include
#define inf 99999999
using namespace std;

int n, m;
int cost[505][505],time0[505][505];
int dis[505];
bool visit[505];
vector temppath,path, pathcopy;
vector pre[510];
int minnode, mintime;
int s,d; 

void dfscost(int v){
    //cout<0; i--){
            int id = temppath[i], nextid = temppath[i-1];
            tempcost += time0[id][nextid];
        }
        if(tempcost < mintime){
            mintime = tempcost;
            path = temppath;
        }
        temppath.pop_back();
        return;
    }
    for(int i = 0;i>n>>m;
    
    fill(cost[0],cost[0]+505*505,inf);
    fill(time0[0],time0[0]+505*505,inf);
    fill(dis, dis+505, inf);
    
    for(int i=0;i>u>>v>>flag>>l>>t;
        cost[u][v] = l;
        time0[u][v] = t;
        if(flag == 0){
            cost[v][u] = l;
            time0[v][u] = t;
        }
    }   
    cin>>s>>d;
    
    pre[s].push_back(s);
    dis[s] = 0;
    for(int i=0;i dis[u] + cost[u][v]){
                    dis[v] = dis[u]+cost[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }else if(dis[v] == dis[u] + cost[u][v]){
                    pre[v].push_back(u);
                }
            }
        }
    }
    mintime = inf;
    dfscost(d); 
    pathcopy = path;
    int disans = dis[d];
    
    fill(dis, dis+505, inf);
    fill(visit, visit+505, false);
    for(int i=0;i<510;i++){
        pre[i].clear();
    }
    temppath.clear();
    path.clear();
    pre[s].push_back(s);
    dis[s] = 0;
    for(int i=0;i dis[u] + time0[u][v]){
                    dis[v] = dis[u] + time0[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }else if(dis[v] == dis[u] + time0[u][v]){
                    pre[v].push_back(u);
                }
            }
        }
    }
    minnode = inf;
    dfstime(d); 
    
    cout<<"Distance = "<=0; i--){
            if( i != pathcopy.size()-1){
                cout<<" -> ";
            }
            cout<=0; i--){
        if( i != path.size()-1){
            cout<<" -> ";
        }
        cout<