PAT团体程序设计天梯赛 - 模拟赛

由于本人愚笨，最后一题实在无力AC，于是只有前14题的题解Orz

总的来说，这次模拟赛的题目不算难，前14题基本上一眼就有思路，但是某些题写起来确实不太容易，编码复杂度有点高~

L1-1 N个数求和

设计一个分数类，重载加法运算符，注意要约分，用欧几里得算法求个最大公约数即可。

 #include <cstdio>

 long long abs(long long x)
 {
     return x <  ? -x : x;
 }

 long long gcd(long long a, long long b)
 {
     if (b == )
         return a;
     else if (a > b)
         return gcd(b, a % b);
     else
         return gcd(a, b % a);
 }

 struct FS
 {
     long long fz, fm;
     FS(long long _fz = , long long _fm = )
     {
         fz = _fz;
         fm = _fm;
         if (fz & fm)
         {
             long long g = gcd(abs(fz), abs(fm));
             fz /= g;
             fm /= g;
         }
     }
     friend FS operator+ (const FS& a, const FS& b)
     {
         FS ans;
         long long lcm = a.fm / gcd(abs(a.fm), abs(b.fm)) * b.fm;
         ans.fz = a.fz * (lcm / a.fm) + b.fz * (lcm / b.fm);
         ans.fm = lcm;
         if (ans.fz && ans.fm)
         {
             long long g = gcd(abs(ans.fz), abs(ans.fm));
             ans.fz /= g;
             ans.fm /= g;
         }
         return ans;
     }
 };

 int main()
 {
     int n;
     scanf("%d", &n);
     FS ans;
     char buf[];
     while (n--)
     {
         scanf("%s", buf);
         long long fz, fm;
         sscanf(buf, "%lld/%lld", &fz, &fm);
         ans = ans + FS(fz, fm);
     }
     if (ans.fz == )
         printf("");
     else if (abs(ans.fz) < abs(ans.fm))
         printf("%lld/%lld", ans.fz, ans.fm);
     else
     {
         if (ans.fz % ans.fm == )
             printf("%lld", ans.fz / ans.fm);
         else
             printf("%lld %lld/%lld", ans.fz / ans.fm, ans.fz % ans.fm, ans.fm);
     }
     return ;
 }

L1-2 比较大小

太水了，不解释，直接sort一下。

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

 int main()
 {
     int a[];
     scanf("%d%d%d", a, a + , a + );
     sort(a, a + );
     printf("%d->%d->%d", a[], a[], a[]);
     return ;
 }

L1-3 A-B

用一个bool数组记录第二个字符串中出现的字符，然后遍历第一个字符串，检测是否在第二个字符串中出现过。

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

 char s1[];
 char s2[];
 bool vis[];

 int main()
 {
     gets(s1);
     gets(s2);
     int idx = -;
     while (s2[++idx])
         vis[s2[idx]] = true;
     idx = -;
     while (s1[++idx])
         if (!vis[s1[idx]])
             putchar(s1[idx]);
     return ;
 }

L1-4 计算指数

太水了，直接左移位。

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

 int main()
 {
     int n;
     scanf("%d", &n);
     printf("%d^%d = %d", , n,  << n);
     return ;
 }

L1-5 计算阶乘和

太水了，求阶乘累加。

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

 int main()
 {
     int n;
     scanf("%d", &n);
     int sum = ;
     int fact = ;
     for (int i = ; i <= n; i++)
         sum += fact *= i;
     printf("%d", sum);
     return ;
 }

L1-6 简单题

hello world同级别的题。

 #include <cstdio>
 int main()
 {
     printf("This is a simple problem.");
     return ;
 }

L1-7 跟奥巴马一起画方块

双重循环。

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

 int main()
 {
     int n;
     char c[];
     scanf("%d%s", &n, c);
     for (int i = ; i < (n + ) / ; i++, puts(""))
         for (int j = ; j < n; j++)
             putchar(c[]);
     return ;
 }

L1-8 查验身份证

按规则模拟就好了，注意判断前17位有无非数字。

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

 int wei[] = {,,,,,,,,,,,,,,,,};
 int rlt[] = {,,-,,,,,,,,};

 bool check(char *s)
 {
     int sum = ;
     for (int i = ; i < ; i++)
     {
         if (!isdigit(s[i]))
             return false;
         sum += (s[i] - '') * wei[i];
     }
     sum %= ;
     if (rlt[sum] == -)
         return s[] == 'X';
     else
         return s[] - '' == rlt[sum];
 }

 int main()
 {
     int n;
     char s[];
     scanf("%d", &n);
     bool allpass = true;
     while (n--)
     {
         scanf("%s", s);
         if (!check(s))
         {
             puts(s);
             allpass = false;
         }
     }
     if (allpass)
         puts("All passed");
     return ;
 }

L2-1 集合相似度

排序后，对于每个询问二分好像会超时一组数据。那么我们可以把那些数字离散化&去重之后，用hash思想来做，O(M)复杂度处理每个查询。

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

 int sorted[];
 int sset[][];
 bool vis[];
 int rec[];

 int main()
 {
     int n;
     scanf("%d", &n);
     int tot = ;
     for (int i = ; i < n; i++)
     {
         scanf("%d", &sset[i][]);
         for (int j = ; j <= sset[i][]; j++)
             scanf("%d", &sset[i][j]), sorted[tot++] = sset[i][j];
         sort(sset[i] + , sset[i] +  + sset[i][]);
         sset[i][] = unique(sset[i] + , sset[i] +  + sset[i][]) - sset[i] - ;
     }
     sort(sorted, sorted + tot);
     tot = unique(sorted, sorted + tot) - sorted;
     for (int i = ; i < n; i++)
         for (int j = ; j <= sset[i][]; j++)
             sset[i][j] = lower_bound(sorted, sorted + tot, sset[i][j]) - sorted;
     int k;
     scanf("%d", &k);
     while (k--)
     {
         int a, b;
         scanf("%d%d", &a, &b);
         a--, b--;
         int nc = , nt = ;
         int reccnt = ;
         for (int i = ; i <= sset[a][]; i++)
             vis[sset[a][i]] = true, rec[reccnt++] = sset[a][i];
         nt = sset[a][];
         for (int i = ; i <= sset[b][]; i++)
         {
             rec[reccnt++] = sset[b][i];
             if (vis[sset[b][i]])
                 nc++;
             else
                 nt++;
         }
         for (int i = ; i < reccnt; i++)
             vis[rec[i]] = false;
         printf("%.2f%\n", 1.0 * nc / nt * );
     }
     return ;
 }

L2-2 树的遍历

后序序列最后一个是根节点，用那个根节点把中序序列分开，然后递归建树，最后再宽搜一下。

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

 vector<int> tree[];
 int n;
 int hx[];
 int zx[];

 int deal(int lz, int rz, int lh, int rh)
 {
     if (lz > rz || lh > rh)
         return -;
     int root = hx[rh];
     int pos = find(zx + lz, zx + rz + , root) - zx;
     int cnt = pos - lz;
     tree[root].push_back(deal(lz, pos - , lh, lh + cnt - ));
     tree[root].push_back(deal(pos + , rz, lh + cnt, rh - ));
     return root;
 }

 int main()
 {
     scanf("%d", &n);
     for (int i = ; i < n; i++)
         scanf("%d", hx + i);
     for (int i = ; i < n; i++)
         scanf("%d", zx + i);
     int root = deal(, n - , , n - );
     queue<int> q;
     q.push(root);
     bool flag = false;
     while (!q.empty())
     {
         int cur = q.front();
         q.pop();
         if (flag)
             printf(" %d", cur);
         else
             printf("%d", cur), flag = true;
         if (tree[cur][] != -)
             q.push(tree[cur][]);
         if (tree[cur][] != -)
             q.push(tree[cur][]);
     }
     return ;
 }

L2-3 家庭房产

思路很简单，就是普通的并查集，但是代码不太好写哦~

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

struct Node
{
    int parent;
    int ts, mj;
};
struct Result
{
    int minid;
    int siz;
    int ts, mj;
    friend bool operator< (const Result& a, const Result& b)
    {
        if (1LL * a.mj * b.siz == 1LL * b.mj * a.siz)
            return a.minid < b.minid;
        return 1LL * a.mj * b.siz > 1LL * b.mj * a.siz;
    }
};
Node node[];
Result rlt[];

int uf_find(int x)
{
    if (node[x].parent == x)
        return x;
    return node[x].parent = uf_find(node[x].parent);
}

void uf_union(int x, int y)
{
    x = uf_find(x);
    y = uf_find(y);
    if (x != y)
        node[x].parent = y;
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = ; i < ; i++)
        node[i].parent = i, rlt[i].minid = ;
    while (n--)
    {
        int id, f, m, k, hz;
        scanf("%d%d%d%d", &id, &f, &m, &k);
        if (f != -)
            uf_union(f, id);
        if (m != -)
            uf_union(m, id);
        for (int i = ; i < k; i++)
        {
            scanf("%d", &hz);
            uf_union(hz, id);
        }
        scanf("%d%d", &node[id].ts, &node[id].mj);
    }
    for (int i = ; i < ; i++)
    {
        int x = uf_find(i);
        rlt[x].minid = min(rlt[x].minid, i);
        rlt[x].ts += node[i].ts;
        rlt[x].mj += node[i].mj;
        rlt[x].siz++;
    }
    sort(rlt, rlt + );
    int cnt = ;
    for (int i = ; i < ; i++)
    {
        if (rlt[i].mj != )
            cnt++;
        else
            break;
    }
    printf("%d\n", cnt);
    for (int i = ; i < cnt; i++)
    {
        if (rlt[i].mj != )
            printf("%04d %d %.3f %.3f\n", rlt[i].minid, rlt[i].siz,
                   1.0 * rlt[i].ts / rlt[i].siz, 1.0 * rlt[i].mj / rlt[i].siz);
    }
    return ;
}

L2-4 最长对称子串

枚举回文中点，向两边扩展枚举。

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

 char s[];

 int main()
 {
     gets(s);
     int len = strlen(s);
     int ans = ;
     for (int i = ; i < len; i++)
     {
         int l = i, r = i;
         int curans = ;
         while (l >=  && r < len && s[l] == s[r])
             curans += , l--, r++;
         ans = max(ans, curans - );
         if (i < len -  && s[i] == s[i + ])
         {
             l = i;
             r = l + ;
             curans = ;
             while (l >=  && r < len && s[l] == s[r])
                 curans += , l--, r++;
             ans = max(ans, curans);
         }
     }
     printf("%d", ans);
     return ;
 }

L3-1 肿瘤诊断

三维的图找连通块，道理和二维一样，注意这里只能宽搜。

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

 bool pic[][][];
 bool vis[][][];
 int dx[] = {,-,,,,};
 int dy[] = {,,-,,,};
 int dz[] = {,,,,,-};
 int m, n, l, t;

 int bfs(int z, int x, int y)
 {
     queue<int> q;
     q.push(z * (m * n) + x * n + y);
     vis[z][x][y] = true;
     int cnt = ;
     while (!q.empty())
     {
         cnt++;
         int cur = q.front();
         q.pop();
         z = cur / (m * n);
         cur %= m * n;
         x = cur / n;
         y = cur % n;
         for (int i = ; i < ; i++)
         {
             int zz = z + dz[i];
             int xx = x + dx[i];
             int yy = y + dy[i];
             if (zz <  || zz >= l)
                 continue;
             if (xx <  || xx >= m)
                 continue;
             if (yy <  || yy >= n)
                 continue;
             if (pic[zz][xx][yy] && !vis[zz][xx][yy])
             {
                 vis[zz][xx][yy] = true;
                 q.push(zz * (m * n) + xx * n + yy);
             }
         }
     }
     return cnt;
 }

 int main()
 {
     scanf("%d%d%d%d", &m, &n, &l, &t);
     for (int i = ; i < l; i++)
         for (int j = ; j < m; j++)
             for (int k = ; k < n; k++)
             {
                 int v;
                 scanf("%d", &v);
                 pic[i][j][k] = v == ;
             }
     int ans = ;
     for (int i = ; i < l; i++)
         for (int j = ; j < m; j++)
             for (int k = ; k < n; k++)
             {
                 if (!vis[i][j][k] && pic[i][j][k])
                 {
                     int cnt = bfs(i, j, k);
                     if (cnt >= t)
                         ans += cnt;
                 }
             }
     printf("%d", ans);
     return ;
 }

L3-2 垃圾箱分布

跑m次spfa就好了，注意结果四舍五入~

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

 const long long inf = 1LL << ;
 vector<pair<int, int> > G[];
 long long dis[];
 bool inqueue[];
 int n, m, k;
 long long ds;
 long long ansdis = -;
 double avgdis = 1e30;
 int ansid = -;

 void spfa(int s)
 {
     fill(dis, dis + , inf);
     queue<int> q;
     q.push(s);
     dis[s] = ;
     while (!q.empty())
     {
         int cur = q.front();
         q.pop();
         inqueue[cur] = false;
         for (int i = ; i < G[cur].size(); i++)
         {
             if (dis[cur] + G[cur][i].second < dis[G[cur][i].first])
             {
                 dis[G[cur][i].first] = dis[cur] + G[cur][i].second;
                 if (!inqueue[G[cur][i].first])
                 {
                     inqueue[G[cur][i].first] = true;
                     q.push(G[cur][i].first);
                 }
             }
         }
     }
     long long mindis = *min_element(dis + , dis + n + );
     long long maxdis = *max_element(dis + , dis + n + );
     if (maxdis > ds)
         return;
     double sum = 0.0;
     for (int i = ; i <= n; i++)
         sum += dis[i];
     sum /= n;
     if (mindis > ansdis)
     {
         ansdis = mindis;
         avgdis = sum;
         ansid = s;
     }
     else if (mindis == ansdis)
     {
         if (avgdis - sum > 1e-)
         {
             ansdis = mindis;
             avgdis = sum;
             ansid = s;
         }
     }
 }

 int main()
 {
     scanf("%d%d%d%lld", &n, &m, &k ,&ds);
     for (int i = ; i < k; i++)
     {
         char s1[], s2[];
         int a, b, d;
         scanf("%s%s%d", s1, s2, &d);
         if (s1[] == 'G')
             sscanf(s1 + , "%d", &a), a += n;
         else
             sscanf(s1, "%d", &a);
         if (s2[] == 'G')
             sscanf(s2 + , "%d", &b), b += n;
         else
             sscanf(s2, "%d", &b);
         G[a].push_back(make_pair(b, d));
         G[b].push_back(make_pair(a, d));
     }
     for (int i = n + ; i <= n + m; i++)
         spfa(i);
     if (ansid == -)
         puts("No Solution");
     else
     {
         avgdis *= 10.0;
         avgdis += 0.5;
         avgdis = floor(avgdis);
         avgdis /= 10.0;
         printf("G%d\n%.1lf %.1lf", ansid - n, 1.0 * ansdis, avgdis);
     }
     return ;
 }

	L1-1	N个数求和
	L1-2	比较大小
	L1-3	A-B
	L1-4	计算指数
	L1-5	计算阶乘和
	L1-6	简单题
	L1-7	跟奥巴马一起画方块
	L1-8	查验身份证
	L2-1	集合相似度
	L2-2	树的遍历
	L2-3	家庭房产
	L2-4	最长对称子串
	L3-1	肿瘤诊断
	L3-2	垃圾箱分布