pat甲级题解

127道甲级题 好像数据结构搭边的 有四十道左右吧

 

1003. Emergency (25)（最短路）

题意：给一个无向图，每个顶点有一个价值，求解从s到t有几条最短路，然后求出这几条最短路中，价值最高的一条。
思路：直接建图，最短路

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn_v = 500 +5;
typedef pair<int, int>pii;

int vis[maxn_v], dis[maxn_v], nodePeople[maxn_v], ansPeople[maxn_v], ansNum[maxn_v];

struct edge
{
    int to, co;
    bool operator < (const edge &other)const//比较函数反着写，因为优先队列默认权值大的
    {
        if(co != other.co)  return co > other.co;
        return to < other.to;
    }
};
vector<edge>G[maxn_v];

void dijkstra(int s, int vs)
{
    //初始化
    for(int i = 0; i <= vs; i++)
    {
        vis[i] = 0;
        dis[i] = INF;
        ansPeople[i] = 0;
        ansNum[i] = 0;
    }

    //给起点s更新数据
    dis[s] = 0;
    ansPeople[s] = nodePeople[s];
    ansNum[s] = 1;//有用的最短路条数

    //入队
    priority_queue<edge>que;//因为默认的时候是取最大的，所以重载运算符的时候反过来写
    que.push({s, dis[s]});

    while(que.size())
    {
        edge cur = que.top();que.pop();
        int u = cur.to;

        if(vis[u])  continue;
        vis[u] = 1;

        for(auto e : G[u])
        {
            int v = e.to, edgeCost = e.co;
            //计算有几条最短路
            if(dis[v] > dis[u] + edgeCost)//能更新，说明v的最短路条数和u相同
            {
                ansNum[v] = ansNum[u];
            }
            else if(dis[v] == dis[u] + edgeCost)//发现从u走到v的最短路径长度和 起点s从别的路去v的最短路径长度 相同，说明ansNum[v] = ansNum[v] + ansNum[u]
            {
                ansNum[v] += ansNum[u];
            }

            if(dis[v] > dis[u] + edgeCost
               ||   (dis[v] == dis[u] + edgeCost && ansPeople[v] < ansPeople[u] + nodePeople[v]))
            {
                dis[v] = dis[u] + edgeCost;
                ansPeople[v] = ansPeople[u] + nodePeople[v];//v的总人员 = 到u时的总人员 + v的人员
                que.push({v, dis[v]});
            }
        }
    }
}

int main()
{
   int vs, es, sg, eg;//vs顶点数 es边数 sg起点 eg终点
    scanf("%d%d%d%d", &vs, &es, &sg, &eg);
    for(int i = 0; i < vs; i++)    scanf("%d", &nodePeople[i]);
    //初始化地图
    for(int i = 0; i < es; i++)
    {
        int u, v, co;
        scanf("%d%d%d", &u, &v, &co);
        G[u].push_back({v, co});//无向图建图
        G[v].push_back({u, co});
    }

    dijkstra(sg, vs);
    printf("%d %d\n", ansNum[eg], ansPeople[eg]);
    return 0;
}

 

 

1004. Counting Leaves (30)（dfs）

题意：好像是求一下每层结点中，没有孩子的结点数分别是多少。

思路：n才一百，随便搜一下就好了吧。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 100 +5;
typedef pair<int, int>pii;

int maxlv;
int level[maxn];
int cnt[maxn];
vector<int>G[maxn];

void dfs(int cur, int lv)
{
    level[cur] = lv;
    maxlv = max(maxlv, lv);
    if(G[cur].size() == 0)  cnt[lv]++;//如果它没有孩子，说明它这一层没有孩子的结点数++
    for(auto o : G[cur])   dfs(o, lv + 1);
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    while(m--)
    {
        int pa, num;
        scanf("%d%d", &pa, &num);
        while(num--)
        {
            int ch;
            scanf("%d", &ch);
            G[pa].push_back(ch);
        }
    }
    maxlv = 0;
    dfs(1, 0);
    for(int i = 0; i <= maxlv; i++)
    {
        printf("%d%c", cnt[i], i == maxlv ? '\n' : ' ');
    }
    return 0;
}

 

 

1013. Battle Over Cities (25)（并查集 or dfs）

题意：从一个无向图里头，取出一个顶点，至少要补几条边能够使得它联通。

思路：就相当于求它的连通分量x，需要连x-1条边。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1000 +5;
typedef pair<int, int>pii;

int attack;
int vis[maxn];
vector<int>G[maxn];

void dfs(int cur)
{
    vis[cur] = 1;
    for(auto o : G[cur])    if(vis[o] == 0 && o != attack) dfs(o);
}

int main()
{
    int vs, es, query;
    scanf("%d%d%d", &vs, &es, &query);

    while(es--)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].push_back(v);//无向图建图
        G[v].push_back(u);
    }

    while(query--)
    {
        int x;
        scanf("%d", &x);
        attack = x;
        //计算联通分量
        memset(vis, 0, sizeof(vis));
        int scc = 0;
        for(int i = 1; i <= vs; i++)
        {
            if(i == attack || vis[i]) continue;//如果已经被攻占，或者已经被dfs过了，跳过
            dfs(i);
            scc++;
        }
        printf("%d\n", scc - 1);
    }
    return 0;
}

 

 

1020. Tree Traversals (25)（树的遍历序列转换）

题意：树的遍历序列转换。

思路：递归建树。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 500 +5;

typedef pair<int, int>pii;
int post[35], in[35], lch[35], rch[35];
int build(int L1, int R1, int L2, int R2)//in中序遍历 [L1，R1], post后序遍历[L2,R2]
{
    if(L1 > R1) return -1;
    int root = post[R2];
    int p = L1;
    while(in[p] != root)    p++;//推算出根节点在中序遍历中的位置。
    int cnt = p - L1;

    lch[root] = build(L1, p - 1, L2, L2 + cnt - 1);//建立左子树
    rch[root] = build(p + 1, R1, L2 + cnt, R2 - 1);//建立右子树
    return root;
}

void level_order(int root)//层序遍历
{
    queue<int>que;
    que.push(root);
    while(que.size())
    {
        int cur = que.front();que.pop();
        int lson = lch[cur], rson = rch[cur];
        if(lson != -1)  que.push(lson);
        if(rson != -1)  que.push(rson);
        printf("%d%c", cur, que.size() ? ' ' : '\n');
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d", &post[i]);
    for (int i = 0; i < n; i++) scanf("%d", &in[i]);
    int root = build(0, n - 1, 0, n - 1);
    level_order(root);
    return 0;
}

 

 

1021. Deepest Root (25)（树的直径）

题意：问你这是不是一棵树，然后求出那些顶点：满足条件，以它为根，这颗树最深。

思路：树的直径，两次dfs能计算出树的直径。其实这道题可以再快一点，把三次dfs缩到两次。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 10000 +5;

int maxLevel;
int vis[maxn];
int level[maxn];
vector<int>G[maxn];
vector<int>temp;

void dfs_scc(int cur)
{
    vis[cur] = 1;
    for(auto o : G[cur])    if(vis[o] == 0) dfs_scc(o);
}

void dfs_level(int cur, int pa, int lv)
{//深搜层数
    level[cur] = lv;
    if(lv > maxLevel)
    {
        maxLevel = lv;
        temp.clear();
        temp.push_back(cur);
    }
    else if(lv == maxLevel)
    {
        temp.push_back(cur);
    }

    for(auto o : G[cur])
    {
        if(o != pa)
        {
            dfs_level(o, cur, lv + 1);
        }
    }
}

int main()
{
    int vs;
    scanf("%d", &vs);
    for(int i = 1; i < vs; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].push_back(v);//无向图建图10
        G[v].push_back(u);
    }

    int scc = 0;
    for(int i = 1; i <= vs; i++)
    {
        if(vis[i] == 0) dfs_scc(i), scc++;
    }

    if(scc != 1)
    {
        printf("Error: %d components\n", scc);
    }
    else
    {
        set<int>ans;
        //第一次dfs
        maxLevel = 0;
        temp.clear();
        memset(level, 0, sizeof(level));
        dfs_level(1, -1, 0);
        int root = temp[0];

        for(auto o : temp)  ans.insert(o);

        //第二次dfs
        maxLevel = 0;
        temp.clear();
        memset(level, 0, sizeof(level));
        dfs_level(root, -1, 0);
        root = temp[0];

        for(auto o : temp)  ans.insert(o);

        for(auto o : ans)
        {
            printf("%d\n", o);
        }
    }
    return 0;
}

 

1030. Travel Plan (30)（最短路）

题意：

思路：...最短路呗，两个条件的那种。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn_v = 500 +5;
typedef pair<int, int>pii;

int vis[maxn_v], dis[maxn_v], cost[maxn_v], pre[maxn_v];

struct edge
{
    int to, dis, co;
    bool operator < (const edge &other)const//比较函数反着写，因为优先队列默认权值大的
    {
        if(dis != other.dis)    return dis > other.dis;
        if(co != other.co)  return co > other.co;
        return to < other.to;
    }
};
vector<edge>G[maxn_v];

void dijkstra(int s, int vs)
{
    //初始化
    for(int i = 0; i <= vs; i++)
    {
        pre[i] = -1;
        vis[i] = 0;
        dis[i] = INF;
        cost[i] = INF;
    }

    //给起点s更新数据
    dis[s] = 0;
    cost[s] = 0;
    //入队
    priority_queue<edge>que;//因为默认的时候是取最大的，所以重载运算符的时候反过来写
    que.push({s, dis[s], cost[s]});

    while(que.size())
    {
        edge cur = que.top();que.pop();
        int u = cur.to;

        if(vis[u])  continue;
        vis[u] = 1;

        for(auto e : G[u])
        {
            if(dis[e.to] > dis[u] + e.dis ||
                dis[e.to] == dis[u] + e.dis && cost[e.to] > cost[u] + e.co)
            {
                pre[e.to] = u;
                dis[e.to] = dis[u] + e.dis;
                cost[e.to] = cost[u] + e.co;
                que.push({e.to, dis[e.to], cost[e.to]});
            }
        }
    }
}

int main()
{
    int vs, es, sg, eg;//vs顶点数 es边数 sg起点 eg终点
    scanf("%d%d%d%d", &vs, &es, &sg, &eg);

    for(int i = 0; i < es; i++)
    {
        int u, v, dis, co;
        scanf("%d%d%d%d", &u, &v, &dis, &co);
        G[u].push_back({v, dis, co});//无向图建图
        G[v].push_back({u, dis, co});
    }

    dijkstra(sg, vs);

    stack<int>sta;
    int now = eg;
    while(now != -1)
    {
        sta.push(now);
        now = pre[now];
    }
    while(sta.size())
    {
        printf("%d ", sta.top());sta.pop();
    }
    printf("%d %d\n", dis[eg], cost[eg]);
    return 0;
}

 

1032. Sharing (25)（模拟）

思路：找到两个链表相同的地方就好了。。然后输出就完事了，pat的链表都是数组+map模拟。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 +5;
typedef pair<int, int>pii;

struct node
{
    char ch;
    int nxt;
}nodes[maxn];


int main()
{
    int add1, add2, n;
    scanf("%d%d%d", &add1, &add2, &n);
    map<int, int>ma;
    for(int i = 0; i < n; i++)
    {
        char ch;
        int add, nxt;
        scanf("%d %c %d", &add, &ch, &nxt);
        nodes[add] = {ch, nxt};
    }

    map<int, int>vis;//遍历第一个链表存储所有出现过的结点编号
    int now = add1;
    while(now != -1)
    {
        vis[now] ++;
        now = nodes[now].nxt;
    }

    now = add2;
    while(now != -1)
    {
        if(vis[now] == 0)//这个结点在第一个链表中未出现
        {
            now = nodes[now].nxt;
        }
        else break;//和第一个链表中的某个结点重合。跳出即可。
    }
    if(now != -1)   printf("%05d\n", now);
    else puts("-1");
    return 0;
}

 

1043. Is It a Binary Search Tree (25)（二叉搜索树）

题意：让你判断一下这棵树是否是BST。

思路：递归judge。先根据左子树小于根节点，把左右子树切分出来，然后检测一下右子树是否均大于根。然后如果是BST，那么递归建树就行了。

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1000 +5;
typedef pair<int, int>pii;

struct node
{
    int val;
    node *left, *right;
    node():left(NULL), right(NULL){}
};
int pre[maxn];//二叉搜索树的先序序列

bool judge(int L, int R, int k)
{
    if(L >= R)  return true;
    int p = L + 1;
    if(k == 0)
    {
        while(p <= R && pre[p] < pre[L])  p++;//左子树小于根节点

        for(int i = p; i <= R; i++)
        {
            if(pre[i] < pre[L]) return false;
        }
    }
    else if(k == 1)//BST的镜像
    {
        while(p <= R && pre[p] >= pre[L]) p++;
        for(int i = p; i <= R; i++)
        {
            if(pre[i] >= pre[L])    return false;
        }
    }

    return judge(L + 1, p - 1, k) && judge(p, R, k);
}

node *build(int L, int R, int k)
{
    if(L > R)  return NULL;

    node *root = new node();
    root->val = pre[L];

    int p = L + 1;
    if(k == 0)
    {
        while(p <= R && pre[p] < pre[L])  p++;//左子树小于根节点
    }
    else if(k == 1)//BST的镜像
    {
        while(p <= R && pre[p] >= pre[L]) p++;
    }
    root->left = build(L + 1, p - 1, k);
    root->right = build(p, R, k);
    return root;
}
void post_order(node *x, node *root)
{
    if(x->left != NULL) post_order(x->left, root);
    if(x->right != NULL)    post_order(x->right, root);

    printf("%d", x->val);

    if(x != root)   printf(" ");
    else printf("\n");
}

void solve(int n)
{
    if (judge(0, n - 1, 0))
    {
        puts("YES");
        node *root = build(0, n - 1, 0);
        post_order(root, root);
        return ;
    }
    if (judge(0, n - 1, 1))
    {
        puts("YES");
        node *root = build(0, n - 1, 1);
        post_order(root, root);
        return ;
    }

    puts("NO");
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &pre[i]);
    }
    solve(n);

    return 0;
}

 

1051. Pop Sequence (25)（栈）

题意：

思路：...栈的基础题

#include <bits/stdc++.h>
using namespace std;


int maxStore, len, k;
int a[1005];

bool solve()
{
    int cnt = 1, B = 1;
    stack<int>sta;
    while(sta.size() || B <= len)
    {
        if(a[cnt] == B)//如果和123456那个序列匹配，就去配对
        {
            B++;
            cnt++;
        }//如果不匹配那个序列
        else if(sta.size() && a[cnt] == sta.top())//在看看栈顶是否匹配
        {
            sta.pop();
            cnt++;
        }//如果栈顶不匹配 只能压入栈
        else if(B <= len)//检测此时压入栈的数字是否合法
        {
            sta.push(B);
            B++;
            if(sta.size() > maxStore - 1)   return false;//如果爆了容量了false
        }
        else return false;
    }
    return cnt == (len + 1);
}
int main()
{
    scanf("%d%d%d", &maxStore, &len, &k);
    while(k--)
    {
        for(int i = 1; i <= len; i++)
        {
            scanf("%d", &a[i]);
        }
        if(solve()) puts("YES");
        else puts("NO");
    }
    return 0;
}

 

1053. Path of Equal Weight (30)（dfs+打印路径）

题意：给了一棵每个节点都有相应权值的树，规定根节点是0，从根节点向叶子节点计算，若一直走到某个叶子节点的所有权值和为给定的数s，就要保留这条路径。最后路径们按字典序输出吧好像？

思路：

　　因为考虑到最后输出好像比较麻烦，然后dfs又是那样的顺序，所以我用set读入了数据以后，每一层都从大到小来建树，保证到时候搜出来的路径，直接可以按顺序打印。

　　通过一次dfs，求出了所有满足条件的路径的终点（叶子节点），保存在ansLeftNode中，然后一条一条的回溯回去，保存在ans数组里，然后输出。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
typedef long long LL;
typedef pair<int, int>pii;

int cnt, targetSum;
int val[maxn];
vector<int>tree[maxn];
stack<int>ans[maxn];
set<pii>temp[maxn];
vector<int>ansLeftNode;
bool dfs(int cur, int pa, LL sum)
{
    int ret = 0;
    if(tree[cur].size() == 0 && sum == targetSum)//leaf node
    {
        ansLeftNode.push_back(cur);
        return true;
    }
    for(auto o : tree[cur])
    {
        if(o != pa)
        {
            int ok = dfs(o, cur, sum + val[o]);
            ret |= ok;
        }
    }
    return ret;
}
bool dfs_path(int cur, int pa, int eg, LL sum)
{
    int ret = 0;
    if(cur == eg && sum + val[cur] == targetSum)//leaf node
    {
        ans[cnt].push(val[cur]);
        return true;
    }
    for(auto o : tree[cur])
    {
        if(o != pa)
        {

            int ok = dfs_path(o, cur, eg, sum + val[cur]);
            ret |= ok;
            if(ok)
            {
                ans[cnt].push(val[cur]);
            }
        }
    }
    return ret;
}
int main()
{
    int n, m;
    scanf("%d%d%d", &n, &m, &targetSum);
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &val[i]);
    }
    for (int i = 0; i < m; i++)
    {
        int u, num;
        scanf("%d%d", &u, &num);
        while(num--)
        {
            int v;
            scanf("%d", &v);
            temp[u].insert({val[v], v});
        }
    }
    for(int i = 0; i < n; i++)
    {
        set<pii>::reverse_iterator it = temp[i].rbegin();
        for(; it != temp[i].rend(); it++)
        {
            tree[i].push_back(it->second);
        }
    }
    cnt = 0;
    dfs(0, -1, val[0]);
    for(auto o : ansLeftNode)
    {
        dfs_path(0, -1, o, 0);
        cnt++;
    }

    for(int i = 0; i < cnt; i++)
    {
        printf("%d", ans[i].top());ans[i].pop();
        while(ans[i].size())
        {
            printf(" %d", ans[i].top());ans[i].pop();
        }
        puts("");
    }
    return 0;
}

 

 

1057. Stack (30)（线段树）

题意：有一个东西在不停的模拟栈的进退，然后在制定的操作时，要查询栈中的median value。

思路：是一个线段树的单点更新，单点查询的题。线段树查询第k大的数。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int INF = 0x3f3f3f3f;
typedef long long LL;
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

int sum[maxn << 2];//开四倍大小空间。线段树

void pushup(int rt){sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];};

void build(int l, int r, int rt)
{
    if(l == r)
    {
        sum[rt] = 0;
        return ;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    pushup(rt);
}

void modify(int l, int r, int rt, int p, int add)//在[l,r]区间内，当前结点编号为rt，查找一个结点编号为p的结点，更新add
{
    if(l == r)
    {
        sum[rt] += add;//对当前结点进行更新
        return ;
    }
    int m = (l + r) >> 1;
    if(p <= m)  modify(lson, p, add);
    else modify(rson, p, add);
    pushup(rt);//更新完所需叶子结点以后，需要pushup向上传递更新后的信息
}

int query(int l, int r, int rt, int k)
{
    if(l == r)  return l;// 查询第k大的数
    int m = (l + r) >> 1;
    if(sum[rt << 1] >= k)   return query(lson, k);//如果左子树的数的数量大于等于k，显然可以左子树里
    else return query(rson, k - sum[rt << 1]);
}



int main()
{
    int n;
    scanf("%d", &n);
    stack<int>sta;

    while(n--)
    {
        char s[20];
        scanf("%s", s);
        if(s[1] == 'o')//pop
        {
            if(sta.size())
            {
                int temp = sta.top();
                printf("%d\n", temp);
                sta.pop();
                modify(1, maxn, 1, temp, -1);//从线段树中清除
            }
            else puts("Invalid");
        }
        else if(s[1] == 'u')//push
        {
            int x;
            scanf("%d", &x);
            sta.push(x);
            modify(1, maxn, 1, x, 1);//线段树更新
        }
        else if(s[1] == 'e')//PeekMedian
        {
            //线段树里查
            if(sta.size())
            {
                int x = (sta.size() + 1) / 2;
                printf("%d\n", query(1, maxn, 1, x));
            }
            else puts("Invalid");
        }
    }
    return 0;
}

 

1064. Complete Binary Search Tree (30)（完全二叉搜索树）

题意：把一个序列填充成一个完全二叉搜索树。输出层序遍历的结果

思路：query函数是计算左右子树的结点个数。因为完全二叉树的性质，可以算出来。

　　写完以后，发现。傻逼了啊！！！你们记不记得有个东西叫做堆，手写堆都会的对吧。它就是完全BST，有一个特性啊！！！它的左右儿子结点编号为2*i，2*i+1。所以这题其实。。可以很简单对吧。

/*
    把一个序列填充成一个完全二叉搜索树。输出层序遍历的结果
*/
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;

int a[maxn], lch[2000 + 5], rch[2000 +5];//注意 lch和rch数组的大小 和 给出的数字的范围息息相关。写指针就无关了

void query(int n, int &lsonSize, int &rsonSize)
{//n是整棵树的总结点数
    if(n == 1)
    {
        lsonSize = rsonSize = 0;
        return ;
    }
    //求出整棵树的最深层数
    //显然此时层数必定大于等于2
    int level = 2;
    while(n >= ((1 << level) - 1))
    {
        level++;
    }
    lsonSize = rsonSize = (1 << (level - 2)) - 1;
    lsonSize += min(n - ((1 << (level - 1)) - 1), 1 << (level - 2));// 左子树的最后一层最多只有(2^(level - 1) / 2) 个，这里是用总的结点数，减掉前level-1层的满二叉搜索树的结点个数
    rsonSize += n - 1 - lsonSize;
}

int build(int L, int R)
{
    if(L > R)   return -1;
    int totNodes = R - L + 1;
    int lsonSize = 0, rsonSize = 0;
    query(totNodes, lsonSize, rsonSize);
    int root = a[L + lsonSize];

    lch[root] = build(L, L + lsonSize - 1);
    rch[root] = build(L + lsonSize + 1, R);
    return root;
}

void level_order(int root)
{
    queue<int>que;
    que.push(root);
    while(que.size())
    {
        int cur = que.front();que.pop();
        if(lch[cur] != -1)  que.push(lch[cur]);
        if(rch[cur] != -1)  que.push(rch[cur]);
        if(cur != root) printf(" ");
        printf("%d", cur);
    }
    puts("");
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    sort(a, a + n);
    int root = build(0, n - 1);
    level_order(root);
    return 0;
}

 

1066. Root of AVL Tree (25)（avl树的旋转）

题意：问你最后avl树的根是谁。

思路：avl树的旋转的模拟。课本基础知识。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 30 + 5;

int a[maxn];

struct node
{
    int val, height;
    node *left, *right;
    node(int x):left(NULL), right(NULL), val(x), height(0){}
};

int Height(node *p)
{
    if (p == NULL)   return -1;
    else return p->height;
}

node *avl_RightRotate(node *k2);//LL旋转
node *avl_LeftRightRotate(node *k3);//LR旋转
node *avl_LeftRotate(node *k2);//RR旋转
node *avl_RightLeftRotate(node *k3);//RL旋转


node *avl_RightRotate(node *k2)//LL旋转
{
    node *k1;
    k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;

    k2->height = max(Height(k2->left), Height(k2->right)) + 1;
    k1->height = max(Height(k1->left), Height(k1->right)) + 1;
    return k1;//新的根结点
}

node *avl_LeftRightRotate(node *k3)//LR旋转
{
    k3->left = avl_LeftRotate(k3->left);
    return avl_RightRotate(k3);
}

node *avl_LeftRotate(node *k2)//RR旋转
{
    node *k1;
    k1 = k2->right;
    k2->right = k1->left;
    k1->left = k2;

    k2->height = max(Height(k2->left), Height(k2->right)) + 1;
    k1->height = max(Height(k1->left), Height(k1->right)) + 1;
    return k1;//新的根结点
}

node *avl_RightLeftRotate(node *k3)//RL旋转
{
    k3->right = avl_RightRotate(k3->right);
    return avl_LeftRotate(k3);
}


node *avl_insert(int x, node *T)
{
    if (T == NULL)
    {
        T = new node(x);
    }
    else if (x < T->val)//要插入的元素x比当前结点的值小
    {//插入T的左子树中
        T->left = avl_insert(x, T->left);
        if(Height(T->left) - Height(T->right) == 2)
        {
            if (x < T->left->val)//插入到T的左子树的左边，是LL旋转
                T = avl_RightRotate(T);//left单旋
            else if (x > T->left->val)//插入到左子树的右边，是LR旋转
                T = avl_LeftRightRotate(T);//left双旋
        }
    }
    else if (x > T->val)//要插入的元素x比当前结点的值大
    {//插入T的右子树中
        T->right = avl_insert(x, T->right);
        if (Height(T->right) - Height(T->left) == 2)
        {
            if (x > T->right->val)//插入到右子树的右边是，RR旋转
                T = avl_LeftRotate(T);//right单选
            else if (x < T->right->val)//插入到右子树的左边是，RL旋转
                T = avl_RightLeftRotate(T);//right双旋
        }
    }

    T->height = max(Height(T->left), Height(T->right)) + 1;
    return T;
}

int main()
{
    int n;
    scanf("%d", &n);
    node *root = NULL;

    for (int i = 0; i < n; i++)
    {
        int x;
        scanf("%d", &x);
        root = avl_insert(x, root);
    }
    printf("%d\n", root->val);

    return 0;
}

 

1074. Reversing Linked List (25)（模拟）

题意：链表每k个，一翻转。

思路：这题很恶心啊，题意没说清楚，它给的数据可能是好几条链，沃日。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
typedef pair<int, int>pii;

struct node
{
    int val, nxt;
}nodes[maxn];
int temp[maxn];

int main()
{
    int head, n, reverseLen;
    scanf("%d%d%d", &head, &n, &reverseLen);
    for(int i = 0; i < n; i++)
    {
        int address, val, nxt;
        scanf("%d%d%d", &address, &val, &nxt);
        nodes[address] = {val, nxt};
    }

    int now = head;
    int cnt = 0;
    while(now != -1)
    {
        temp[cnt++] = now;
        now = nodes[now].nxt;
    }

    //找出每一个翻转区间的起始位置
    for(int i = 0; i + reverseLen <= cnt; i += reverseLen)
    {
        reverse(temp + i, temp + i + reverseLen);
    }


    for(int i = 0; i < cnt; i++)
    {
        printf("%05d %d ", temp[i], nodes[temp[i]].val);
        if(i == cnt - 1)    printf("-1\n");
        else printf("%05d\n", temp[i + 1]);
    }
    return 0;
}

 

1076. Forwards on Weibo (30)（bfs）

思路：看清楚谁follow谁就行了，bfs。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
typedef pair<int, int>pii;

int level[maxn];
vector<int>follower[maxn];

int bfs(int s, int L)
{
    memset(level, -1, sizeof(level));

    level[s] = 0;

    queue<pii>que;
    que.push({s, level[s]});

    int ret = 0;
    while(que.size())
    {
        pii cur = que.front();que.pop();
        if(cur.second > L)  continue;//只能传L层

        ret++;
        for(auto o : follower[cur.first])
        {
            if(level[o] == -1)
            {
                level[o] = level[cur.first] + 1;
                que.push({o, level[o]});
            }
        }
    }
    return ret - 1;//去除自身
}

int main()
{
    int n, L;
    scanf("%d%d", &n, &L);
    for(int i = 1; i <= n; i++)
    {
        int k;
        scanf("%d", &k);
        while(k--)
        {
            int x;
            scanf("%d", &x);
            follower[x].push_back(i);//谁跟随谁看清楚
        }
    }
    int query;
    scanf("%d", &query);
    while(query--)
    {
        int x;
        scanf("%d", &x);
        cout << bfs(x, L) << endl;
    }
    return 0;
}

 

1078. Hashing (25)（哈希表的二次探测）

思路：

　　不是筛出10000以内的素数，要多筛一点，确保筛到了比10000大的最小的素数，同时，要小心那几个数组开的大小。其实也可以用最普通的isPrime去判。pat数据水的...

　　还考了一个.....哈希的二次探测。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 5;

int tot;
int vis[maxn], check[maxn], prime[maxn];

void sieve(int n)
{
    tot = 0;
    check[0] = check[1] = 1;//check为0时是素数
    for (int i = 2; i <= n; i++)
    {
        if (!check[i])
        {
            prime[tot++] = i;
            for (int j = i * i; j <= n; j += i)
            {
                check[j] = 1;
            }
        }
    }

}
void modify(int &x)
{
    x = *lower_bound(prime, prime + tot, x);
}

int main()
{
    sieve(12000);
    int Msize, n;
    scanf("%d%d", &Msize, &n);

    modify(Msize);

    for (int i = 0; i < n; i++)
    {
        int x;
        scanf("%d", &x);
        int pos = x % Msize;
        if(vis[pos] == 0)
        {
            vis[pos] = 1;
            printf("%d", pos);

        }
        else
        {
            int ok = 0;
            for (int j = 0; j < Msize; j++)//哈希表的二次探测
            {
                int nxtPos = (j * j + pos) % Msize;
                if(vis[nxtPos] == 0)
                {
                    vis[nxtPos] = 1;
                    printf("%d", nxtPos);
                    ok = 1;
                    break;
                }
            }
            if(ok == 0) printf("-");
        }
        printf(i == n - 1 ? "\n" : " ");
    }


    return 0;
}

 

1079. Total Sales of Supply Chain (25)

思路：

　　很简单的深搜。但是注意一点。处理零售商的加和的时候 一定要放在for(auto)遍历子节点之前，至于为什么？  想想看
 　 1 1.8 1
  　0 5
     这组样例

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;

double ans;
vector<int>tree[maxn];
int amount[maxn];

void dfs(int cur, double curPrice, double rate)
{
    double netPrice = curPrice * (1.0 + rate / 100);

    if(amount[cur])//是零售商
    {
        ans += amount[cur] * curPrice;
        return;
    }

    for(auto o : tree[cur])
    {
        dfs(o, netPrice, rate);
    }
}

int main()
{
    int n;
    double rootPrice, rate;
    scanf("%d%lf%lf", &n, &rootPrice, &rate);
    for(int i = 0; i < n; i++)
    {
        int k;
        scanf("%d", &k);
        if(k == 0)
        {
            scanf("%d", &amount[i]);//是零售商
            continue;
        }
        //供应商
        while(k--)
        {
            int x;
            scanf("%d", &x);
            tree[i].push_back(x);
        }
    }
    ans = 0.0;
    dfs(0, rootPrice, rate);
    printf("%.1f\n", ans);
    return 0;
}

 

1086. Tree Traversals Again (25)（树的遍历序列转换）

思路：思考一下，可以发现入栈的顺序，是根左右，是前序序列。出栈的顺序是，左根右，是中序序列。那么就很简单了啊，求一个后序序列会的吧。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;

vector<int>pre, in;
int lch[35], rch[35];

int build(int L1, int R1, int L2, int R2)// pre   in
{
    if(L1 > R1) return -1;
    cout << "L1 = " << L1 << "  R1 = " << R1 <<endl;
    int root = pre[L1];
    int p = L2;
    while(in[p] != root)    p++;
    int cnt = p - L2;
    lch[root] = build(L1 + 1, L1 + cnt, L2, p - 1);
    rch[root] = build(L1 + cnt + 1, R1, p + 1, R2);
    if(L1 == R1)cout << "p = " << p << " lch[root] = " <<lch[root] << " rch[root] = " << rch[root] <<endl;
    return root;
}
void post_order(int x, int root)
{
    if(lch[x] != -1)   post_order(lch[x], root);
    if(rch[x] != -1)   post_order(rch[x], root);
    printf("%d%c", x, x == root ? '\n' : ' ');
}
int main()
{
    int n;
    scanf("%d", &n);
    stack<int>sta;
    int cnt = 0;
    for (int i = 0; i < 2 * n; i++)
    {
        char s[10];
        scanf("%s", s);

        if (s[1] == 'u')//push
        {
            int x;
            scanf("%d", &x);
            sta.push(x);
            pre.push_back(x);
        }
        else
        {
            in.push_back(sta.top());
            sta.pop();
        }
    }
    int root = build(0, n - 1, 0, n - 1);
    post_order(root, root);
    return 0;
}

 

 

1091. Acute Stroke (30)（bfs）

思路：bfs，三维的宽搜，不能用深搜，会爆栈的。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 30 + 5;

int m, n, L, T;
int ma[65][1300][130];
#define isInside(x, y, z) (0 <= x && x < L && 0 <= y && y < m && 0 <= z && z < n)

int dx[] = {-1, 0, 0, 0, 0, 1};
int dy[] = {0, -1, 0, 0, 1, 0};
int dz[] = {0, 0, -1, 1, 0, 0};
struct node
{
    int x, y, z;
};
int bfs(int x, int y, int z)
{
    int ret = 1;
    queue<node>que;
    que.push({x, y, z});
    ma[x][y][z] = 0;
    while(que.size())
    {
        node cur = que.front();que.pop();

        for(int kind = 0; kind < 6; kind++)
        {
            int fx = cur.x + dx[kind], fy = cur.y + dy[kind], fz = cur.z + dz[kind];
            if(isInside(fx, fy, fz) && ma[fx][fy][fz] == 1)
            {
                ma[fx][fy][fz] = 0;
                ret++;
                que.push({fx, fy, fz});
            }
        }

    }
    return ret;
}

int main()
{
    scanf("%d%d%d%d", &m, &n, &L, &T);
    for(int i = 0; i < L; i++)
    {
        for(int j = 0; j < m; j++)
        {
            for(int k = 0; k < n; k++)
            {
                scanf("%d", &ma[i][j][k]);
            }
        }
    }
    int ans = 0;
    for(int i = 0; i < L; i++)
    {
        for(int j = 0; j < m; j++)
        {
            for(int k = 0; k < n; k++)
            {
                if(ma[i][j][k] == 1)
                {
                    int temp = bfs(i, j, k);
                    if(temp >= T)   ans += temp;
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}

 

 

1097. Deduplication on a Linked List (25)

思路：map+数组一通模拟就好了。先分类，哪些是第一次出现绝对值的，留下来left，不然要删掉delete，然后把两个容器里的东西重新串起来即可。

#include <stdio.h>
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
const int INF = 0x3f3f3f3f;
typedef long long LL;
typedef pair<int, int>pii;
typedef pair<LL, LL>pLL;
typedef unsigned long long ull;


struct node
{
    int key, nex;
}nodes[maxn];

int main()
{
    int head, n;
    scanf("%d%d", &head, &n);

    vector<int>del;
    vector<int>left;
    map<int, int>ma;

    for(int i = 0; i < n; i++)
    {
        int add, key, nex;
        scanf("%d%d%d", &add, &key, &nex);
        nodes[add] = {key, nex};
    }

    //判断其键值的绝对值是否出现过
    int now = head;
    while(now != -1)
    {
        int key = abs(nodes[now].key);
        if(ma[key] == 0)    ma[key]++, left.push_back(now);//尚未出现过 说明这个结点可以留下来，更新map
        else    del.push_back(now);//已经出现过 说明要delete掉
        now = nodes[now].nex;
    }


    for(int i = 0; i < left.size(); i++)
    {
        int cur = left[i];
        nodes[cur].nex = -1;//当前结点cur 的 nex指针指空
        if(i == 0)  continue;//i==0时没有前继结点

        int last = left[i - 1];//把前一个结点left的nex指针 指到 当前结点cur身上
        nodes[last].nex = cur;
    }

    for(int i = 0; i < del.size(); i++)
    {
        int cur = del[i];
        nodes[cur].nex = -1;//当前结点cur 的 nex指针指空
        if(i == 0)  continue;//i==0时没有前继结点

        int last = del[i - 1];//把前一个结点left的nex指针 指到 当前结点cur身上
        nodes[last].nex = cur;
    }
    //输出结果
    for(auto o : left)
    {
        printf("%05d %d ", o, nodes[o].key);//因为所有编号是五位整数，用int存，%05d输出比较方便。
        if(nodes[o].nex == -1)    puts("-1");//但是%05d输出的时候，遇到-1，会变成-00001，所以要特判
        else printf("%05d\n", nodes[o].nex);
    }

    for(auto o : del)
    {
        printf("%05d %d ", o, nodes[o].key);
        if(nodes[o].nex == -1)    puts("-1");
        else printf("%05d\n", nodes[o].nex);
    }
    return 0;
}

 

 

1099. Build A Binary Search Tree (30)（给定结构的BST的填充）

题意：建立一棵给定结构的二叉搜索树，并且进行层序遍历。

思路：利用BST的性质，左小右大，那么它的中序遍历就是一个从小到大的有序数组对吧。

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;

int cnt;
int lch[maxn], rch[maxn], a[maxn], val[maxn];

void dfs(int x)
{
    int lson = lch[x], rson = rch[x];

    if(lson != -1)//左子树不为空，就进去
    {
        dfs(lson);
    }
    val[x] = a[cnt];
    cnt++;
    if(rson != -1)  dfs(rson);
}

void level_order(int root)
{
    queue<int>que;
    que.push(root);
    while(que.size())
    {
        int cur = que.front();que.pop();
        int lson = lch[cur], rson = rch[cur];
        if(lson != -1)  que.push(lson);
        if(rson != -1)  que.push(rson);

        if(cur != root) printf(" ");
        printf("%d", val[cur]);
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        int l, r;
        scanf("%d%d", &l, &r);
        lch[i] = l;
        rch[i] = r;
    }
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    sort(a, a + n);
    cnt = 0;
    dfs(0);
    level_order(0);

    return 0;
}

 

 

 

 

1102. Invert a Binary Tree (25)

题意：给你一个树的输入，让你把数左右互换（invert）然后对其进行层序遍历和中序遍历。

思路：...输出的时候左右儿子调换一下就行了呗。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;

int cnt, n;
int lch[15], rch[15], vis[15];

void in_order(int x)
{
    if(rch[x] != -1)   in_order(rch[x]);
    printf("%d%c", x, cnt++ == n ? '\n' : ' ');
    if(lch[x] != -1)   in_order(lch[x]);
}

void level_order(int root)//层序遍历
{
    queue<int>que;
    que.push(root);
    while(que.size())
    {
        int cur = que.front();que.pop();
        int lson = lch[cur], rson = rch[cur];

        if(rson != -1)  que.push(rson);
        if(lson != -1)  que.push(lson);

        printf("%d%c", cur, que.size() ? ' ' : '\n');
    }
}

int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        getchar();
        char left, right;
        scanf("%c %c", &left, &right);
        if(left != '-')
        {
            int lson = left - '0';
            vis[lson] = 1;
            lch[i] = lson;
        }
        else lch[i] = -1;

        if(right != '-')
        {
            int rson = right - '0';
            vis[rson] = 1;
            rch[i] = rson;
        }
        else rch[i] = -1;
    }
    //如果不在各个结点的子树中出现，则这个编号为根节点
    int root;
    for(int i = 0; i < n; i++)
    {
        if(vis[i] == 0) root = i;
    }

    //翻转树以后的序列，所以在这两个函数中左右倒转
    level_order(root);
    cnt = 1;
    in_order(root);
    return 0;
}

 

 

1110. Complete Binary Tree (25)（判断是否为完全二叉树）

题意：这是否是一个完全二叉树。

思路：基础题吧。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;

int cnt, n;
int lch[25], rch[25], vis[25];

void in_order(int x)
{
    if(rch[x] != -1)   in_order(rch[x]);
    printf("%d%c", x, cnt++ == n ? '\n' : ' ');
    if(lch[x] != -1)   in_order(lch[x]);
}
int isCompleteBinaryTree;

int level_order(int root)//层序遍历
{//整棵树压进队列中，由完全二叉树的性质可知，第一个层序遍历的空结点就是整棵树的终点，检查此时是否n个结点都已经被遍历完全
//    int flag = 0;
    queue<int>que;
    que.push(root);
    while(que.size())
    {
        int cur = que.front();que.pop();
        if(cur == -1)
        {
            if(cnt != n)    isCompleteBinaryTree = 0;
            continue;
        }
        cnt++;
        int lson = lch[cur], rson = rch[cur];
        que.push(lson);
        que.push(rson);
        if(cnt == n) return cur;
    }
}

int main()
{
    scanf("%d", &n);
    getchar();
    for(int i = 0; i < n; i++)
    {
        char left[10], right[10];
        scanf("%s %s", left, right);

        int lson, rson;
        if(left[0] != '-')
        {
            lson = 0;
            for(int i = 0; i < strlen(left); i++)
            {
                lson = lson * 10 + left[i] - '0';
            }
            vis[lson] = 1;
            lch[i] = lson;
        }
        else lch[i] = -1;

        if(right[0] != '-')
        {
            rson = 0;
            for(int i = 0; i < strlen(right); i++)
            {
                rson = rson * 10 + right[i] - '0';
            }

            vis[rson] = 1;
            rch[i] = rson;
        }
        else rch[i] = -1;

    }
    //如果不在各个结点的子树中出现，则这个编号为根节点
    int root;
    for(int i = 0; i < n; i++)
    {
        if(vis[i] == 0) root = i;
    }
    isCompleteBinaryTree = 1;
    int ret = level_order(root);
    if(isCompleteBinaryTree)
    {
        printf("YES %d\n", ret);
    }
    else
    {
        printf("NO %d\n", root);
    }

    return 0;
}

 

 

1114. Family Property (25)(并查集)

题意：给出每个人的家庭成员信息和自己的房产个数与房产总面积，让你统计出每个家庭的人口数、人均房产个数和人均房产面积。第一行输出家庭个数，随后每行输出家庭成员的最小编号、家庭人口数、人均房产个数、人均房产面积。

思路：...并查集模拟题。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 1e4 + 5;

int pa[maxn], vis[maxn];
int sum[maxn], peo[maxn], num[maxn], small[maxn];//房产总面积，人数，房产套数，最小编号

void init(int n)
{
    for (int i = 0; i <= n; i++)
    {
        pa[i] = small[i] = i;
        peo[i] = 1;
    }
}
int uf_find(int x){return pa[x] == x ? x : uf_find(pa[x]);}

void join(int x, int y)
{
    int fx = uf_find(x), fy = uf_find(y);
    if (fx != fy)//把fy 并到fx上
        pa[fy] = fx;
}
struct family
{//按人均面积降序输出，若有并列，则按成员编号的升序输出。
    int id, small, peo, num, sum;
    bool operator < (const family& other)
    {
        if (sum * other.peo != other.sum * peo)//防止浮点误差  人均面积 sum / peo    other.sum / other.peo
            return  sum * other.peo > other.sum * peo;
        return small < other.small;//试了一下 题意指的好像是最小成员编号的升序
    }
};

int main()
{
    init(10000);//四位编号因此，最多10000个
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        int cur, fa, mo, k;
        scanf("%d%d%d%d", &cur, &fa, &mo, &k);//输入自身编号 父母编号，孩子数量
        vis[cur] = 1;//标记i结点，可能作为某个并查集的根节点
        int a[10];
        for (int j = 0; j < k; j++)  scanf("%d", &a[j]);//输入他的孩子们
        scanf("%d%d", &num[cur], &sum[cur]);//输入他拥有的房产套数，住房面积

        //更新完当前用户的房产情况后。join父母，孩子
        //合并并查集的过程中pa[fy] = fx,也就是把后者合并到前者上，
        //让每一个并查集的根节点出现在vis[i] = 1的i结点上
        if (fa != -1)    join(cur, fa);
        if (mo != -1)    join(cur, mo);
        for (int j = 0; j < k; j++)
            if (a[j] != -1)
                join(cur, a[j]);

    }
    for (int i = 0; i <= 10000; i++)
    {
        int fi = uf_find(i);
        if (i != fi)
        {//如果这个编号的根结点，不是自己，把它的最小编号，人口数量，房产套数，住房面积更新到根结点去
            sum[fi] += sum[i];
            peo[fi] += peo[i];
            num[fi] += num[i];
            small[fi] = min(small[fi], small[i]);
        }
    }

    vector<family>vec;//记录所有family的根节点

    for (int i = 0; i <= 10000; i++)
    {
        if (vis[i] && uf_find(i) == i)//如果这个结点vis[i]==1并且它的根节点是他自身，那么压进vec
            vec.push_back({i, small[i], peo[i], num[i], sum[i]});
    }
    sort(vec.begin(), vec.end());//按需求排序

    printf("%d\n", vec.size());//输出并查集的数量
    for (auto o : vec)
    {//输出每个并查集的最小编号 家庭人口数 人均房产套数 人均房产面积
        printf("%04d %d %.3f %.3f\n", o.small, o.peo, 1.0 * o.num / o.peo, 1.0 * o.sum / o.peo);
    }
    return 0;
}

 

 

1115. Counting Nodes in a BST (30)（BST插入操作+dfs）

题意：给你一棵BST的插入序列，问你插完后，这颗BST的最下面两层，各有几个顶点。

思路：完成BST的插入操作，然后搜一遍就完了呗。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;

struct node
{
    int val;
    node *left, *right;
    node():left(NULL), right(NULL){}
};

node *BST_insert(node *T, int val)
{
    if(T == NULL)
    {
        T = new node();
        T->val = val;
    }
    else if(val <= T->val)//题目此时对左子树的定义是<=
    {
        T->left = BST_insert(T->left, val);
    }
    else
    {
        T->right = BST_insert(T->right, val);
    }
    return T;
}


int level[1005];
int maxLevel = -1;
void dfs_level(node *root, int lv)
{
    if(root == NULL)    return;
    maxLevel = max(maxLevel, lv);
    level[lv]++;
    dfs_level(root->left, lv + 1);
    dfs_level(root->right, lv + 1);
}

int main()
{
    int n;
    scanf("%d", &n);
    node *root = NULL;
    for (int i = 0; i < n; i++)
    {
        int x;
        scanf("%d", &x);
        root = BST_insert(root, x);
    }

    dfs_level(root,1);
    int n2 = level[maxLevel], n1 = level[maxLevel - 1];
//不知道为什么下面这个...最后一个测试点过不去
//    int n2 = level[1], n1 = level[2];
//    for(int i = 3; i <= maxLevel; i++)
//    {
//        n2 = n1;
//        n1 = level[i];
//    }
    printf("%d + %d = %d\n", n1, n2, n1 + n2);

    return 0;
}

 

 

 

1118. Birds in Forest (25)

题意：有一些鸟在一棵树上，然后问你有几棵树，几只鸟，那几只鸟在一棵树上。

思路：基础并查集。。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 5;

int vis[maxn], pa[maxn];
void init(int n){for(int i = 1; i <= n; i++) vis[i] = 0, pa[i] = i;}
int uf_find(int x){return x == pa[x] ? x : uf_find(pa[x]);}
bool same(int x, int y){return uf_find(x) == uf_find(y);}
void uf_join(int x, int y)
{
    int fx = uf_find(x), fy = uf_find(y);
    if(fx != fy)
       pa[fx] = fy;
}

int main()
{
    init(maxn);
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        int k, x, y;
        scanf("%d", &k);

        if(k >= 2)
        {
            scanf("%d", &x);
            vis[x] = 1;
            for(int j = 0; j < k - 1; j++)
            {
                scanf("%d", &y);
                vis[y] = 1;
                uf_join(x, y);
            }
        }
        else if(k == 1)
        {
            scanf("%d", &x);
            vis[x] = 1;
        }
    }
    int cntTree = 0, cntBird = 0;
    for(int i = 1; i <= 10000; i++)
    {
        if(vis[i])
        {
            cntBird++;
            cntTree += (i == pa[i]);
        }
    }

    printf("%d %d\n", cntTree, cntBird);
    int query;
    scanf("%d", &query);
    while(query --)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        if(same(x, y))  puts("Yes");
        else puts("No");
    }

    return 0;
}

 

 

1119. Pre- and Post-order Traversals (30)

题意：给出前序，后序序列，问你这棵树是否唯一。

思路：这题真的挺好的啊，考你对递归的理解。我们知道如果已知，中序序列加前/后序序列，那么树唯一。现在已知前后序序列，那么我们想，递归到某个结点，它如果只有一个child的时候，是不是这颗树就不唯一了，因为这个child可能是左边或者右边。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 30 + 5;

struct node
{
    int val;
    node *left, *right;
    node():left(NULL), right(NULL){}
};
int n;
bool isOnlyOne;
int pre[maxn], post[maxn];

node *build(int L1, int R1, int L2, int R2)//pre  [L1,R1]   post   [L2,R2]
{
    if(L1 > R1)     return NULL;

    node *root = new node();
    root->val = pre[L1];
    if(L1 == R1)    return root;
    int p = L1 + 1;
    while(pre[p] != post[R2 - 1]) p++;//post[R2-1]是root右子树的根
    int lsonSize = p - L1 - 1;
    //此时如果没有左子树，显然不唯一。需要中序序列来维护
    if(p == L1 + 1)
    {
        isOnlyOne = false;
        root->left = NULL;
        root->right = build(L1 + 1, R1, L2, R2 - 1);
    }
    else
    {
        root->left = build(L1 + 1, L1 + lsonSize, L2, L2 + lsonSize - 1);
        root->right = build(p, R1, L2 + lsonSize, R2 - 1);
    }

    return root;
}

int cntSize;//看看已经输出几个点了
void in_order(node *root)
{
    if(root->left != NULL)  in_order(root->left);
    cntSize++;
    printf("%d%c", root->val, cntSize == n ? '\n' : ' ');
    if(root->right != NULL) in_order(root->right);
}

int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i++)  scanf("%d", &pre[i]);
    for(int i = 0; i < n; i++)  scanf("%d", &post[i]);

    isOnlyOne = true;
    node *root = build(0, n - 1, 0, n - 1);

    if(isOnlyOne)   puts("Yes");
    else puts("No");

    cntSize = 0;
    in_order(root);
    return 0;
}

 

1122. Hamiltonian Cycle (25)

题意：让你判断一下这一条路径是不是哈密顿回路。

思路：判一下路上的不同的结点数，然后检测相邻两点是否图上相连就好了。模拟题。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 + 5;

set<int>G[maxn];
int n, m;
int path[2000];

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].insert(v);
        G[v].insert(u);
    }

    int query;
    scanf("%d", &query);
    while (query --)
    {
        int k ;
        scanf("%d", &k);

        set<int>s;
        for (int i = 1; i <= k; i++)
        {
            scanf("%d", &path[i]);
            s.insert(path[i]);
        }
        int isHamiltonPath = 1;
        if(s.size() == n && k == n + 1 && path[1] == path[k])
        {
            for(int i = 2; i <= k; i++)
            {
                int u = path[i - 1], v = path[i];
                if(G[u].find(v) == G[u].end())
                {
                    isHamiltonPath = 0;
                    break;
                }
            }
            if(isHamiltonPath)  puts("YES");
            else puts("NO");
        }
        else puts("NO");
    }
    return 0;
}

 

1123. Is It a Complete AVL Tree (30)

题意：模拟avl树的插入。

思路：....课本知识

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;

int n, isComplete;

struct node
{
    int val, height;
    node *left, *right;
    node():left(NULL), right(NULL){}
};

int Height(node *T)
{
    if(T == NULL)   return -1;
    return T->height;
}

node *avl_RightRotate(node *k2);//左子树的左边插入，LL旋转 需要一次右单旋
node *avl_LeftRightRotate(node *k3);//左子树的右边插入，LR旋转 需要一次左单旋，再一次右单旋

node *avl_LeftRotate(node *k2);//右子树的右边插入RR旋转 需要一次左单旋
node *avl_RightLeftRotate(node *k3);//右子树的左边插入，RL旋转 需要一次右单旋，再一次左单旋

node *avl_RightRotate(node *k2)//左子树的左边插入，LL旋转 需要一次右单旋
{
    node *k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;

    k1->height = max(Height(k1->left), Height(k1->right)) + 1;
    k2->height = max(Height(k2->left), Height(k2->right)) + 1;
    return k1;
}


node *avl_LeftRightRotate(node *k3)//左子树的右边插入，LR旋转 需要一次左单旋，再一次右单旋
{
    k3->left = avl_LeftRotate(k3->left);
    k3 = avl_RightRotate(k3);
    return k3;
}

node *avl_LeftRotate(node *k2)//右子树的右边插入RR旋转 需要一次左单旋
{
    node *k1 = k2->right;
    k2->right = k1->left;
    k1->left = k2;

    k1->height = max(Height(k1->left), Height(k1->right)) + 1;
    k2->height = max(Height(k2->left), Height(k2->right)) + 1;
    return k1;
}

node *avl_RightLeftRotate(node *k3)//右子树的左边插入，RL旋转 需要一次右单旋，再一次左单旋
{
    k3->right = avl_RightRotate(k3->right);
    k3 = avl_LeftRotate(k3);
    return k3;
}

node *avl_insert(node *T, int x)
{
    if(T == NULL)
    {
        T = new node();
        T->val = x;
        T->height = 0;
    }
    else if(x < T->val)
    {
        T->left = avl_insert(T->left, x);
        if(Height(T->left) - Height(T->right) == 2)
        {
            if(x < T->left->val)//LL
                T = avl_RightRotate(T);
            else
                T = avl_LeftRightRotate(T);
        }
    }
    else
    {
        T->right = avl_insert(T->right, x);
        if(Height(T->right) - Height(T->left) == 2)
        {
            if(x > T->right->val)//RR
                T = avl_LeftRotate(T);
            else
                T = avl_RightLeftRotate(T);
        }
    }
    T->height = max(Height(T->left), Height(T->right)) + 1;
    return T;
}

void level_order(node *root)
{
    queue<node*>que;
    que.push(root);
    int cnt = 0;
    while(que.size())
    {
        node *cur = que.front();que.pop();

        if(cur == NULL)
        {
            if(cnt != n) isComplete = 0;
            continue;
        }
        cnt++;//非空结点计数
        que.push(cur->left);
        que.push(cur->right);
        if(cur != root) printf(" ");
        printf("%d", cur->val);
    }
    puts("");
}

int main()
{
    scanf("%d", &n);
    node *root = NULL;
    for (int i = 0; i < n; i++)
    {
        int x;
        scanf("%d", &x);
        root = avl_insert(root, x);
    }
    isComplete = 1;
    level_order(root);


    printf("%s\n", isComplete ? "YES" : "NO");
    return 0;
}

 

1127. ZigZagging on a Tree (30)

题意：序列转换

思路：....套路题。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 30 + 5;

int lch[maxn], rch[maxn], post[maxn], in[maxn], level[maxn];

int build(int L1, int R1, int L2, int R2)//前面的是中序遍历的， 后面的是后序遍历的
{
    if (L1 > R1)  return -1;//你的子树已经不存在了 返回-1
    int root = post[R2];

    int p = L1;
    while (in[p] != root)  p++;
    int cnt = p - L1;//他的左子树有几个点

    lch[root] = build(L1, p - 1, L2, L2 + cnt - 1);
    rch[root] = build(p + 1, R1, L2 + cnt, R2 - 1);
    return root;
}

void dfs(int cur, int depth)
{
    level[cur] = depth;
    int lson = lch[cur], rson = rch[cur];
    if (lson != -1)  dfs(lson, depth + 1);
    if (rson != -1)  dfs(rson, depth + 1);
}

void show_post(int root)
{
    int lson = lch[root], rson = rch[root];
    if(lson != -1)  show_post(lson);
    if(rson != -1)  show_post(rson);
    printf("%d ", root);
}

void show(int root, vector<int> &ans)
{
    vector<int>vec;
    queue<int>que;
    que.push(root);
    int d = 0;
    while(que.size())
    {
        int cur = que.front();que.pop();
        if(level[cur] != d)
        {
            if(d & 1)
            {
                for (int i = 0; i < vec.size(); i++)    ans.push_back(vec[i]);
            }
            else
            {
                for (int i = vec.size() - 1; i >= 0; i--)   ans.push_back(vec[i]);
            }
            d = level[cur];
            vec.clear();
        }

        vec.push_back(cur);
        int lson = lch[cur], rson = rch[cur];
        if (lson != -1)  que.push(lson);
        if (rson != -1)  que.push(rson);
    }

    if(d & 1)
    {
        for (int i = 0; i < vec.size(); i++)    ans.push_back(vec[i]);
    }
    else
    {
        for (int i = vec.size() - 1; i >= 0; i--)   ans.push_back(vec[i]);
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)  scanf("%d", &in[i]);//中序遍历 左根右
    for (int i = 0; i < n; i++)  scanf("%d", &post[i]);//后序遍历 左右根
    int root = build(0, n - 1, 0, n - 1);
    dfs(root, 0);

    vector<int>ans;
    show(root, ans);
    for(int i = 0; i < ans.size(); i++) printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
    return 0;
}