天梯赛2016-L2

L2-001. 紧急救援

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式：

输入第一行给出4个正整数N、M、S、D，其中N（2<=N<=500）是城市的个数，顺便假设城市的编号为0~(N-1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式：

第一行输出不同的最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出首尾不能有多余空格。

输入样例：

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2

输出样例：

2 60
0 1 3

//2017-03-17
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>

using namespace std;

const int N = 510;
const int inf = 0x3f3f3f3f;
int n, m, G[N][N], dis[N], vis[N], pre[N], way[N], maxpeo[N];

int dijkstra(int s, int d)
{
    for(int i = 0; i < n; i++)
    {
        dis[i] = G[s][i];
        if(G[s][i] != inf){
            pre[i] = s;
            way[i]++;
        }
    }
    pre[s] = -1;
    dis[s] = 0;
    vis[s] = 1;
    way[s] = 1;
    int mindis,  u;
    maxpeo[s] = G[s][s];
    for(int i = 0; i < n; i++)
    {
        mindis = inf;
        for(int j = 0; j < n; j++)
            if(!vis[j] && dis[j] < mindis)
            {
                mindis = dis[j];
                u = j;
            }
        vis[u] = 1;
        for(int v = 0; v < n; v++)
        {
            if(vis[v] || G[u][v]==inf)continue;
            if(dis[v] > dis[u]+G[u][v]){
                dis[v] = dis[u]+G[u][v];
                pre[v] = u;
                maxpeo[v] = maxpeo[u] + G[v][v];
                way[v] = way[u];
            }else if(dis[v] == dis[u]+G[u][v]){
                way[v] += way[u];
                if(maxpeo[v] < maxpeo[u]+G[v][v]){
                    maxpeo[v] = maxpeo[u] + G[v][v];
                    pre[v] = u;
                }
            }
        }
    }
    return maxpeo[d]+maxpeo[s];
}

int main()
{
    int s, d, u, v, w;
    while(cin>>n>>m>>s>>d)
    {
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
                  G[i][j] = inf;
            vis[i] = 0;
            dis[i] = inf;
            pre[i] = -1;
            way[i] = 0;
            maxpeo[i] = 0;
            cin>>G[i][i];
            maxpeo[i] = G[i][i];
        }
        for(int i = 0; i < m; i++)
        {
            cin>>u>>v>>w;
            G[u][v] = G[v][u] = w;
        }
        int peo = dijkstra(s, d);
        int pr = d;
        stack<int> sk;
        while(pr != s)
        {
            sk.push(pr);
            pr = pre[pr];
        }
        cout<<way[d]<<" "<<peo<<endl;
        cout<<s;
        int o;
        while(!sk.empty())
        {
            o = sk.top();
            cout<<" "<<o;
            sk.pop();
        }
        cout<<endl;
    }

    return 0;
}

 

L2-002. 链表去重

给定一个带整数键值的单链表L，本题要求你编写程序，删除那些键值的绝对值有重复的结点。即对任意键值K，只有键值或其绝对值等于K的第一个结点可以被保留。同时，所有被删除的结点必须被保存在另外一个链表中。例如：另L为21→-15→-15→-7→15，则你必须输出去重后的链表21→-15→-7、以及被删除的链表-15→15。

输入格式：

输入第一行包含链表第一个结点的地址、以及结点个数N（<= 10⁵ 的正整数）。结点地址是一个非负的5位整数，NULL指针用-1表示。

随后N行，每行按下列格式给出一个结点的信息：

Address Key Next

其中Address是结点的地址，Key是绝对值不超过10⁴的整数，Next是下一个结点的地址。

输出格式：

首先输出去重后的链表，然后输出被删除结点组成的链表。每个结点占一行，按输入的格式输出。

输入样例：

00100 5
99999 -7 87654
23854 -15 00000
87654 15 -1
00000 -15 99999
00100 21 23854

输出样例：

00100 21 23854
23854 -15 99999
99999 -7 -1
00000 -15 87654
87654 15 -1

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <list>

using namespace std;

const int N = 1e6+10;
int ne[N], ke[N], book[10005];
struct node
{
    int add, key, next;
    void setNode(int a, int k, int n){
        this->add = a;
        this->key = k;
        this->next = n;
    }
};

int main()
{
    int s, n, pos;
    while(cin>>s>>n)
    {
        int ad;
        for(int i = 0; i < n; i++)
        {
            cin>>ad;
            cin>>ke[ad]>>ne[ad];
        }
        list<node> l1, l2;
        list<node>::iterator it;
        node tmp;
        memset(book, 0, sizeof(book));
        pos = s;
        book[abs(s)] = 1;
        tmp.setNode(pos, ke[pos], ne[pos]);
        l1.push_back(tmp);
        pos = ne[pos];
        while(pos != -1)
        {
            if(book[abs(ke[pos])]){
                if(!l2.empty()){
                    tmp = l2.back();
                    tmp.next = pos;
                    l2.pop_back();
                    l2.push_back(tmp);
                }
                tmp.setNode(pos, ke[pos], ne[pos]);
                l2.push_back(tmp);
            }else{
                book[abs(ke[pos])] = 1;
                if(!l1.empty()){
                    tmp = l1.back();
                    tmp.next = pos;    
                    l1.pop_back();
                    l1.push_back(tmp);
                }
                tmp.setNode(pos, ke[pos], ne[pos]);
                l1.push_back(tmp);
            }
            pos = ne[pos];
        }
        tmp = l1.back(); tmp.next = -1;
        l1.pop_back();l1.push_back(tmp);
        for(it = l1.begin(); it != l1.end(); it++){
            if(it->next == -1)printf("%05d %d %d\n", it->add, it->key, it->next);
            else printf("%05d %d %05d\n", it->add, it->key, it->next);
        }
        if(!l2.empty()){
            tmp = l2.back(); tmp.next = -1;
            l2.pop_back();l2.push_back(tmp);
        }
        for(it = l2.begin(); it != l2.end(); it++){
            if(it->next == -1)printf("%05d %d %d\n", it->add, it->key, it->next);
            else printf("%05d %d %05d\n", it->add, it->key, it->next);
        }
    }

    return 0;
}

L2-003. 月饼

 

月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。

注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有3种月饼，其库存量分别为18、15、10万吨，总售价分别为75、72、45亿元。如果市场的最大需求量只有20万吨，那么我们最大收益策略应该是卖出全部15万吨第2种月饼、以及5万吨第3种月饼，获得 72 + 45/2 = 94.5（亿元）。

输入格式：

每个输入包含1个测试用例。每个测试用例先给出一个不超过1000的正整数N表示月饼的种类数、以及不超过500（以万吨为单位）的正整数D表示市场最大需求量。随后一行给出N个正数表示每种月饼的库存量（以万吨为单位）；最后一行给出N个正数表示每种月饼的总售价（以亿元为单位）。数字间以空格分隔。

输出格式：

对每组测试用例，在一行中输出最大收益，以亿元为单位并精确到小数点后2位。

输入样例：

3 20
18 15 10
75 72 45

输出样例：

94.50

//2017-03-18
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1005;
struct node{
    double a, b;
    double c;
    bool operator < (const node& x){
        return c > x.c;
    }
}moom[N];

int main()
{
    int n, need;
    while(cin>>n>>need)
    {
        for(int i = 0; i < n; i++)
            cin>>moom[i].a;
        for(int i = 0; i < n; i++)
              cin>>moom[i].b;
        for(int i = 0; i < n; i++)
            moom[i].c = moom[i].b*1.0/moom[i].a;
        sort(moom, moom+n);
        double ans = 0;
        for(int i = 0; i < n; i++)
        {
            if(need < moom[i].a){
                ans += moom[i].c*need;
                break;
            }else{
                ans += moom[i].b;
                need -= moom[i].a;
            }
        }
        printf("%.2lf\n", ans);
    }

    return 0;
}

L2-004. 这是二叉搜索树吗？

一棵二叉搜索树可被递归地定义为具有下列性质的二叉树：对于任一结点，

• 其左子树中所有结点的键值小于该结点的键值；
• 其右子树中所有结点的键值大于等于该结点的键值；
• 其左右子树都是二叉搜索树。

所谓二叉搜索树的“镜像”，即将所有结点的左右子树对换位置后所得到的树。

给定一个整数键值序列，现请你编写程序，判断这是否是对一棵二叉搜索树或其镜像进行前序遍历的结果。

输入格式：

输入的第一行给出正整数N（<=1000）。随后一行给出N个整数键值，其间以空格分隔。

输出格式：

如果输入序列是对一棵二叉搜索树或其镜像进行前序遍历的结果，则首先在一行中输出“YES”，然后在下一行输出该树后序遍历的结果。数字间有1个空格，一行的首尾不得有多余空格。若答案是否，则输出“NO”。

输入样例1：

7
8 6 5 7 10 8 11

输出样例1：

YES
5 7 6 8 11 10 8

输入样例2：

7
8 10 11 8 6 7 5

输出样例2：

YES
11 8 10 7 5 6 8

输入样例3：

7
8 6 8 5 10 9 11

输出样例3：

NO

//2017-03-19
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int N = 1005;
int bt[N], bst1[N], bst2[N], ANS[N], n, cnt;
struct node{
    int data;
    node *lson, *rson;
    node(int d):data(d), lson(NULL), rson(NULL){}
};

class BST
{
public:
    node *rt;
    BST():rt(NULL){}
    void insert(int a)
    {
        node* nd = new node(a);
        if(rt == NULL){
            rt = nd;
        }else{
            node *p = rt, *q = NULL;
            while(p != NULL){
                q = p;
                if(a < p->data){
                    p = p->lson;
                }else{
                    p = p->rson;
                }
            }
            if(a < q->data)q->lson = nd;
            else q->rson = nd;
        }
    }
};

void preOrder1(node* id)
{
    if(id != NULL)
    {
        bst1[cnt] = id->data;
        cnt++;
        preOrder1(id->lson);
        preOrder1(id->rson);
    }
}

void preOrder2(node* id)
{
    if(id != NULL)
    {
        bst2[cnt] = id->data;
        cnt++;
        preOrder2(id->rson);
        preOrder2(id->lson);
    }
}

void postOrder1(node* id)
{
    if(id != NULL){
        postOrder1(id->lson);
        postOrder1(id->rson);
        ANS[cnt] = id->data;
        cnt++;
    }
}

void postOrder2(node* id)
{
    if(id != NULL){
        postOrder2(id->rson);
        postOrder2(id->lson);
        ANS[cnt] = id->data;
        cnt++;
    }
}

int main()
{
    while(cin>>n)
    {
        BST bst;
        for(int i = 0; i < n; i++)
        {
            cin>>bt[i];
            bst.insert(bt[i]);
        }
        cnt = 0;
        preOrder1(bst.rt);
        cnt = 0;
        preOrder2(bst.rt);
        bool fg1 = true, fg2 = true;
        for(int i = 0; i < n; i++){
            if(bt[i] != bst1[i])fg1 = false;
            if(bt[i] != bst2[i])fg2 = false;
        }
        if(fg1){
            cout<<"YES"<<endl;
            cnt = 0;
            postOrder1(bst.rt);
            for(int i = 0; i < n; i++)
                  if(i == n-1)cout<<ANS[i]<<endl;
                else cout<<ANS[i]<<" ";
        }else if(fg2){
            cout<<"YES"<<endl;
            cnt = 0;
            postOrder2(bst.rt);
            for(int i = 0; i < n; i++)
                  if(i == n-1)cout<<ANS[i]<<endl;
                else cout<<ANS[i]<<" ";
        }else cout<<"NO"<<endl;
    }

    return 0;
}

L2-005. 集合相似度

给定两个整数集合，它们的相似度定义为：N_c/N_t*100%。其中N_c是两个集合都有的不相等整数的个数，N_t是两个集合一共有的不相等整数的个数。你的任务就是计算任意一对给定集合的相似度。

输入格式：

输入第一行给出一个正整数N（<=50），是集合的个数。随后N行，每行对应一个集合。每个集合首先给出一个正整数M（<=10⁴），是集合中元素的个数；然后跟M个[0, 10⁹]区间内的整数。

之后一行给出一个正整数K（<=2000），随后K行，每行对应一对需要计算相似度的集合的编号（集合从1到N编号）。数字间以空格分隔。

输出格式：

对每一对需要计算的集合，在一行中输出它们的相似度，为保留小数点后2位的百分比数字。

输入样例：

3
3 99 87 101
4 87 101 5 87
7 99 101 18 5 135 18 99
2
1 2
1 3

输出样例：

50.00%
33.33%

//2017-03-19
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>

using namespace std;

int se[55][1005], cnt[55];

double merge(int a, int b)
{
    int nt = 0, nc = 0;
    int cnt1 = 0, cnt2 = 0;
    while(cnt1 < cnt[a] && cnt2 < cnt[b])
    {
        if(se[a][cnt1] < se[b][cnt2]){
            nt++;
            cnt1++;
        }else if(se[a][cnt1] > se[b][cnt2]){
            nt++;
            cnt2++;
        }else{
            nt++;
            nc++;
            cnt1++;
            cnt2++;
        }
    }
    if(cnt1<cnt[a])nt += cnt[a]-cnt1;
    if(cnt2<cnt[b])nt += cnt[b]-cnt2;
    return nc*1.0/nt;
}

int main()
{
    int n, m, a;
    while(cin>>n)
    {
        memset(cnt, 0, sizeof(cnt));
        for(int i = 1; i <= n; i++)
        {
            cin>>m;
            set<int> S;
            set<int>::iterator it;
            for(int j = 0; j < m; j++)
            {
                cin>>a;
                it = S.find(a);
                if(it == S.end()){
                    S.insert(a);
                    se[i][cnt[i]] = a;
                    cnt[i]++;
                }
            }
            sort(se[i], se[i]+cnt[i]);
        }
        cin>>m;
        int s1, s2;
        while(m--)
        {
            cin>>s1>>s2;
            double ans = merge(s1, s2)*100;
            printf("%.2lf%\n", ans);
        }
    }

    return 0;
}

L2-006. 树的遍历

给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（<=30），是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

输出样例：

4 1 6 3 5 7 2

//2017-03-20
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

int post[35], in[35], ANS[35];
struct node{
    int data;
    node *lson, *rson;
    node(int d):data(d), lson(NULL), rson(NULL){}
};

struct BT{
    node *root;
    void rebuild(int n)
    {
        root = buildTree(post, in, n);
    }
    node* buildTree(int *post, int *in, int n)
    {
        if(n < 1)return NULL;
        node *rt = new node(post[n-1]);
        if(n == 1)return rt;
        int R;
        for(int i = 0; i < n; i++)
        {
            if(in[i] == post[n-1]){
                R = i;
                break;
            }
        }
        rt->lson = buildTree(post, in, R);
        rt->rson = buildTree(post+R, in+R+1, n-R-1);
        return rt;
    }
    void levelOrder()
    {
        queue<node*> q;
        q.push(root);
        node *h;
        int cnt = 0;
        while(!q.empty()){
            h = q.front();
            q.pop();
            ANS[cnt++] = h->data;
            if(h->lson)q.push(h->lson);
            if(h->rson)q.push(h->rson);
        }
        for(int i = 0; i < cnt; i++)
              if(i == cnt-1)cout<<ANS[i]<<endl;
            else cout<<ANS[i]<<" ";
    }
};

int main()
{
    int n;
    while(cin>>n)
    {
        for(int i = 0; i < n; i++)
              cin>>post[i];
        for(int i = 0; i < n; i++)
              cin>>in[i];
        BT bt;
        bt.rebuild(n);
        bt.levelOrder();
    }

    return 0;
}

L2-008. 最长对称子串

对给定的字符串，本题要求你输出最长对称子串的长度。例如，给定"Is PAT&TAP symmetric?"，最长对称子串为"s PAT&TAP s"，于是你应该输出11。

输入格式：

输入在一行中给出长度不超过1000的非空字符串。

输出格式：

在一行中输出最长对称子串的长度。

输入样例：

Is PAT&TAP symmetric?

输出样例：

11

//2017-03-19
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

string str;
int len;

int search(int pos)
{
    int l, r, ans = 1;
    l = pos-1;
    r = pos+1;
    while(l >= 0 && r < len)
    {
        if(str[l] == str[r])
        {
            ans+=2;
            l--;
            r++;
        }else break;
    }
    return ans;
}

int search2(int pos)
{
    int l, r, ans = 0;
    l = pos;
    r = pos+1;
    while(l >= 0 && r < len)
    {
        if(str[l] == str[r])
        {
            ans+=2;
            l--;
            r++;
        }else break;
    }
    return ans;
}

int main()
{
    while(getline(cin, str))
    {
        len = str.length();
        int ans = 0, tmp;
        for(int i = 0; i < len; i++)
        {
            tmp = search(i);
            if(tmp>ans)ans = tmp;
            tmp = search2(i);
            if(tmp>ans)ans = tmp;
        }
        cout<<ans<<endl;
    }

    return 0;
}

L2-009. 抢红包

没有人没抢过红包吧…… 这里给出N个人之间互相发红包、抢红包的记录，请你统计一下他们抢红包的收获。

输入格式：

输入第一行给出一个正整数N（<= 10⁴），即参与发红包和抢红包的总人数，则这些人从1到N编号。随后N行，第i行给出编号为i的人发红包的记录，格式如下：

K N₁ P₁ ... N_K P_K

其中K（0 <= K <= 20）是发出去的红包个数，N_i是抢到红包的人的编号，P_i（> 0）是其抢到的红包金额（以分为单位）。注意：对于同一个人发出的红包，每人最多只能抢1次，不能重复抢。

输出格式：

按照收入金额从高到低的递减顺序输出每个人的编号和收入金额（以元为单位，输出小数点后2位）。每个人的信息占一行，两数字间有1个空格。如果收入金额有并列，则按抢到红包的个数递减输出；如果还有并列，则按个人编号递增输出。

输入样例：

10
3 2 22 10 58 8 125
5 1 345 3 211 5 233 7 13 8 101
1 7 8800
2 1 1000 2 1000
2 4 250 10 320
6 5 11 9 22 8 33 7 44 10 55 4 2
1 3 8800
2 1 23 2 123
1 8 250
4 2 121 4 516 7 112 9 10

输出样例：

1 11.63
2 3.63
8 3.63
3 2.11
7 1.69
6 -1.67
9 -2.18
10 -3.26
5 -3.26
4 -12.32

 

//2017-03-19
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 10010;
struct node{
    int id, cnt;
    double out, in;
    double fin;
    bool operator <(node x)
    {
        if(fin == x.fin)return cnt > x.cnt;
        return fin > x.fin;
    }
}man[N];

int main()
{
    int n, k;
    while(cin>>n)
    {
        for(int i = 1; i <= n; i++)
        {
            man[i].in = 0;
            man[i].out = 0;
            man[i].cnt = 0;
        }
        for(int i = 1; i <= n; i++)
        {
            man[i].id = i;
            cin>>k;
            int id, monky;
            while(k--)
            {
                cin>>id>>monky;
                man[id].in += monky;
                man[i].out += monky;
                man[id].cnt++;
            }
        }
        for(int i = 1; i <= n; i++)
              man[i].fin = (man[i].in-man[i].out)/100;
        sort(man+1, man+n+1);
        for(int i = 1; i <= n; i++)
              printf("%d %.2lf\n", man[i].id, man[i].fin);
    }

    return 0;
}

L2-010. 排座位

布置宴席最微妙的事情，就是给前来参宴的各位宾客安排座位。无论如何，总不能把两个死对头排到同一张宴会桌旁！这个艰巨任务现在就交给你，对任何一对客人，请编写程序告诉主人他们是否能被安排同席。

输入格式：

输入第一行给出3个正整数：N（<= 100），即前来参宴的宾客总人数，则这些人从1到N编号；M为已知两两宾客之间的关系数；K为查询的条数。随后M行，每行给出一对宾客之间的关系，格式为：“宾客1 宾客2 关系”，其中“关系”为1表示是朋友，-1表示是死对头。注意两个人不可能既是朋友又是敌人。最后K行，每行给出一对需要查询的宾客编号。

这里假设朋友的朋友也是朋友。但敌人的敌人并不一定就是朋友，朋友的敌人也不一定是敌人。只有单纯直接的敌对关系才是绝对不能同席的。

输出格式：

对每个查询输出一行结果：如果两位宾客之间是朋友，且没有敌对关系，则输出“No problem”；如果他们之间并不是朋友，但也不敌对，则输出“OK”；如果他们之间有敌对，然而也有共同的朋友，则输出“OK but...”；如果他们之间只有敌对关系，则输出“No way”。

输入样例：

7 8 4
5 6 1
2 7 -1
1 3 1
3 4 1
6 7 -1
1 2 1
1 4 1
2 3 -1
3 4
5 7
2 3
7 2

输出样例：

No problem
OK
OK but...
No way

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int G[105][105];
int n;

void query(int a, int b)
{
    if(G[a][b] == 0){
        for(int i = 1; i <= n; i++)
              if(G[a][i] == 1 && G[b][i] == 1){
                  cout<<"No problem"<<endl;
                  return;
        }
        cout<<"OK"<<endl;
    }else if(G[a][b] == 1){
        for(int i = 1; i <= n; i++)
              if(G[a][i] == -1 && G[b][i] == -1)
                  return;
        cout<<"No problem"<<endl;
    }else if(G[a][b] == -1){
        for(int i = 1; i <= n; i++)
          if(G[a][i] == 1 && G[b][i] == 1){
              cout<<"OK but..."<<endl;
              return;
          }
        cout<<"No way"<<endl;
    }
}

int main()
{
    int m, q, u, v, re;
    while(cin>>n>>m>>q)
    {
        memset(G, 0, sizeof(G));
        for(int i = 0; i < m; i++)
        {
            cin>>u>>v>>re;
            G[u][v] = G[v][u] = re;
        }
        while(q--)
        {
            cin>>u>>v;
            query(u, v);
        }
    }

    return 0;
}

L2-011. 玩转二叉树

给定一棵二叉树的中序遍历和前序遍历，请你先将树做个镜面反转，再输出反转后的层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（<=30），是二叉树中结点的个数。第二行给出其中序遍历序列。第三行给出其前序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树反转后的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

7
1 2 3 4 5 6 7
4 1 3 2 6 5 7

输出样例：

4 6 1 7 5 3 2

//2017-03-20
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

int pre[35], in[35], ANS[35];
struct node{
    int data;
    node *lson, *rson;
    node(int d):data(d), lson(NULL), rson(NULL){}
};

struct BT{
    node *root;
    void rebuild(int n)
    {
        root = buildTree(pre, in, n);
    }
    node* buildTree(int *pre, int *in, int n)
    {
        if(n < 1)return NULL;
        node *rt = new node(pre[0]);
        if(n == 1)return rt;
        int R;
        for(int i = 0; i < n; i++)
        {
            if(in[i] == pre[0]){
                R = i;
                break;
            }
        }
        rt->lson = buildTree(pre+1, in, R);
        rt->rson = buildTree(pre+1+R, in+R+1, n-R-1);
        return rt;
    }
    void levelOrder()
    {
        queue<node*> q;
        q.push(root);
        node *h;
        int cnt = 0;
        while(!q.empty()){
            h = q.front();
            q.pop();
            ANS[cnt++] = h->data;
            if(h->rson)q.push(h->rson);
            if(h->lson)q.push(h->lson);
        }
        for(int i = 0; i < cnt; i++)
              if(i == cnt-1)cout<<ANS[i]<<endl;
            else cout<<ANS[i]<<" ";
    }
};

int main()
{
    int n;
    while(cin>>n)
    {
        for(int i = 0; i < n; i++)
              cin>>in[i];
        for(int i = 0; i < n; i++)
              cin>>pre[i];
        BT bt;
        bt.rebuild(n);
        bt.levelOrder();
    }

    return 0;
}

L2-012. 关于堆的判断

将一系列给定数字顺序插入一个初始为空的小顶堆H[]。随后判断一系列相关命题是否为真。命题分下列几种：

• “x is the root”：x是根结点；
• “x and y are siblings”：x和y是兄弟结点；
• “x is the parent of y”：x是y的父结点；
• “x is a child of y”：x是y的一个子结点。

输入格式：

每组测试第1行包含2个正整数N（<= 1000）和M（<= 20），分别是插入元素的个数、以及需要判断的命题数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。之后M行，每行给出一个命题。题目保证命题中的结点键值都是存在的。

输出格式：

对输入的每个命题，如果其为真，则在一行中输出“T”，否则输出“F”。

输入样例：

5 4
46 23 26 24 10
24 is the root
26 and 23 are siblings
46 is the parent of 23
23 is a child of 10

输出样例：

F
T
F
T

//2017-03-20
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct Heap{
    int h[1010];
    int n;
    void init()
    {
        n = 0;
    }
    void shiftup(int pos)
    {
        int fa, tmp;
        while(pos >= 0){
            fa = (pos-1)/2;
            if(h[fa]>h[pos]){
                tmp = h[pos];
                h[pos] = h[fa];
                h[fa] = tmp;
                pos = fa;
            }else break;
        }
    }
    void addNode(int x)
    {
        h[n++] = x;
        shiftup(n-1);
    }
    void show(){
        for(int i = 0; i < n; i++)
              cout<<h[i]<<" ";
        cout<<endl;
    }
};

int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        Heap heap;
        heap.init();
        int a;
        for(int i = 0; i < n; i++)
        {
            cin>>a;
            heap.addNode(a);
        }
        int x, y;
        string s1, s2, s3, s4;
        while(m--)
        {
            cin>>x;
            cin>>s1;
            if(s1[0] == 'a'){
                cin>>y>>s2>>s3;
                int p1, p2;
                for(int i = 0; i < heap.n; i++)
                {
                    if(heap.h[i] == x)p1 = i;
                    if(heap.h[i] == y)p2 = i;
                }
                if((p1-1)/2 == (p2-1)/2)cout<<"T"<<endl;
                else cout<<"F"<<endl;
            }else{
                cin>>s2;
                if(s2[0] == 'a'){
                    cin>>s3>>s4>>y;
                    int p1, p2;
                    for(int i = 0; i < heap.n; i++)
                    {
                        if(heap.h[i] == x)p1 = i;
                        if(heap.h[i] == y)p2 = i;
                    }
                    if((p1-1)/2 == p2)cout<<"T"<<endl;
                    else cout<<"F"<<endl;    
                }else{
                    cin>>s3;
                    if(s3[0] == 'r'){
                        if(heap.h[0] == x)cout<<"T"<<endl;
                        else cout<<"F"<<endl;
                    }else{
                        cin>>s4>>y;
                        int p1, p2;
                        for(int i = 0; i < heap.n; i++){
                            if(heap.h[i] == x)p1 = i;
                            if(heap.h[i] == y)p2 = i;
                        }
                        if((p2-1)/2 == p1)cout<<"T"<<endl;
                        else cout<<"F"<<endl;
                    }
                }
            }
        }
    }

    return 0;
}

 

L2-017. 人以群分

社交网络中我们给每个人定义了一个“活跃度”，现希望根据这个指标把人群分为两大类，即外向型（outgoing，即活跃度高的）和内向型（introverted，即活跃度低的）。要求两类人群的规模尽可能接近，而他们的总活跃度差距尽可能拉开。

输入格式：

输入第一行给出一个正整数N（2 <= N <= 10⁵）。随后一行给出N个正整数，分别是每个人的活跃度，其间以空格分隔。题目保证这些数字以及它们的和都不会超过2³¹。

输出格式：

按下列格式输出：

Outgoing #: N1
Introverted #: N2
Diff = N3

其中 N1 是外向型人的个数；N2 是内向型人的个数；N3 是两群人总活跃度之差的绝对值。

输入样例1：

10
23 8 10 99 46 2333 46 1 666 555

输出样例1：

Outgoing #: 5
Introverted #: 5
Diff = 3611

输入样例2：

13
110 79 218 69 3721 100 29 135 2 6 13 5188 85

输出样例2：

Outgoing #: 7
Introverted #: 6
Diff = 9359

//2018-03-14
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100005;
int arr[N];

int main()
{
    int n;
    while(~scanf("%d", &n)){
        for(int i = 0; i < n; i++)
              scanf("%d", &arr[i]);
        sort(arr, arr+n);
        int in = n/2;
        int sumIn = 0, sumOut = 0;
        for(int i= 0; i < n; i++){
            if(i < in) sumIn += arr[i];
            else sumOut += arr[i];
        }
        printf("Outgoing #: %d\nIntroverted #: %d\nDiff = %d\n", n-in, in, sumOut-sumIn);
    }

    return 0;
}

 

L2-019. 悄悄关注

新浪微博上有个“悄悄关注”，一个用户悄悄关注的人，不出现在这个用户的关注列表上，但系统会推送其悄悄关注的人发表的微博给该用户。现在我们来做一回网络侦探，根据某人的关注列表和其对其他用户的点赞情况，扒出有可能被其悄悄关注的人。

输入格式：

输入首先在第一行给出某用户的关注列表，格式如下：

人数N 用户1 用户2 …… 用户N

其中N是不超过5000的正整数，每个“用户i”（i=1, ..., N）是被其关注的用户的ID，是长度为4位的由数字和英文字母组成的字符串，各项间以空格分隔。

之后给出该用户点赞的信息：首先给出一个不超过10000的正整数M，随后M行，每行给出一个被其点赞的用户ID和对该用户的点赞次数（不超过1000），以空格分隔。注意：用户ID是一个用户的唯一身份标识。题目保证在关注列表中没有重复用户，在点赞信息中也没有重复用户。

输出格式：

我们认为被该用户点赞次数大于其点赞平均数、且不在其关注列表上的人，很可能是其悄悄关注的人。根据这个假设，请你按用户ID字母序的升序输出可能是其悄悄关注的人，每行1个ID。如果其实并没有这样的人，则输出“Bing Mei You”。

输入样例1：

10 GAO3 Magi Zha1 Sen1 Quan FaMK LSum Eins FatM LLao
8
Magi 50
Pota 30
LLao 3
Ammy 48
Dave 15
GAO3 31
Zoro 1
Cath 60

输出样例1：

Ammy
Cath
Pota

输入样例2：

11 GAO3 Magi Zha1 Sen1 Quan FaMK LSum Eins FatM LLao Pota
7
Magi 50
Pota 30
LLao 48
Ammy 3
Dave 15
GAO3 31
Zoro 29

输出样例2：

Bing Mei You

//2018-03-14
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <set>

using namespace std;

const int N = 5005;

string strs[2*N];
int arr[2*N];
set<string> st, ans_st;

int main()
{
    int n, m;
    while(cin>>n){
        string str;
        st.clear();
        for(int i = 0; i < n; i++){
            cin>>str;
            st.insert(str);
        }
        cin>>m;
        int sum = 0;
        for(int i = 0; i < m; i++){
            cin>>strs[i]>>arr[i];
            sum += arr[i];
        }
        double avg = 1.0*sum/m;
        set<string>::iterator iter;
        ans_st.clear();
        for(int i = 0; i < m; i++){
            if((iter = st.find(strs[i])) == st.end() && arr[i] > avg){
                ans_st.insert(strs[i]);
            }
        }
        if(ans_st.empty()){
            cout<<"Bing Mei You"<<endl;
        }else{
            for(auto x: ans_st){
                cout<<x<<endl;
            }
        }
    }

    return 0;
}

 

L2-020. 功夫传人

一门武功能否传承久远并被发扬光大，是要看缘分的。一般来说，师傅传授给徒弟的武功总要打个折扣，于是越往后传，弟子们的功夫就越弱…… 直到某一支的某一代突然出现一个天分特别高的弟子（或者是吃到了灵丹、挖到了特别的秘笈），会将功夫的威力一下子放大N倍 —— 我们称这种弟子为“得道者”。

这里我们来考察某一位祖师爷门下的徒子徒孙家谱：假设家谱中的每个人只有1位师傅（除了祖师爷没有师傅）；每位师傅可以带很多徒弟；并且假设辈分严格有序，即祖师爷这门武功的每个第i代传人只能在第i-1代传人中拜1个师傅。我们假设已知祖师爷的功力值为Z，每向下传承一代，就会减弱r%，除非某一代弟子得道。现给出师门谱系关系，要求你算出所有得道者的功力总值。

输入格式：

输入在第一行给出3个正整数，分别是：N（<=10⁵）——整个师门的总人数（于是每个人从0到N-1编号，祖师爷的编号为0）；Z——祖师爷的功力值（不一定是整数，但起码是正数）；r ——每传一代功夫所打的折扣百分比值（不超过100的正数）。接下来有N行，第i行（i=0, ..., N-1）描述编号为i的人所传的徒弟，格式为：

K_i ID[1] ID[2] ... ID[K_i]

其中K_i是徒弟的个数，后面跟的是各位徒弟的编号，数字间以空格间隔。K_i为零表示这是一位得道者，这时后面跟的一个数字表示其武功被放大的倍数。

输出格式：

在一行中输出所有得道者的功力总值，只保留其整数部分。题目保证输入和正确的输出都不超过10¹⁰。

输入样例：

10 18.0 1.00
3 2 3 5
1 9
1 4
1 7
0 7
2 6 1
1 8
0 9
0 4
0 3

输出样例：

404

//2018-03-15
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

const int N = 100005;
int fa[N], dd_id[N], dd_bs[N], depth[N];

int getDepth(int x){
    if(fa[x] == x)return 0;
    if(depth[x])return depth[x];
    return depth[x] = getDepth(fa[x])+1;
}

int main()
{
    int n, k;
    double Z, r;
    while(cin>>n>>Z>>r){
        r = (100-r)/100;
        int cnt = 0, tmp;
        memset(depth, 0, sizeof(depth));
        for(int i = 0; i < n; i++)
              fa[i] = i;
        for(int i = 0; i < n; i++){
            cin >> k;
            if(!k){
                cin>>tmp;
                dd_id[cnt] = i;
                dd_bs[cnt++] = tmp;
            }else{
                while(k--){
                    cin>>tmp;
                    fa[tmp] = i;
                }
            }
        }
        double sum = 0;
        for(int i = 0; i < cnt; i++){
            double dsum = Z*dd_bs[i];
            int dp = getDepth(dd_id[i]);
            dsum *= pow(r, dp);
            sum += dsum;
        }
        cout<<(int)sum<<endl;
    }

    return 0;
}

 

L2-021. 点赞狂魔

微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。然而有这么一种人，他们会通过给自己看到的一切内容点赞来狂刷存在感，这种人就被称为“点赞狂魔”。他们点赞的标签非常分散，无法体现出明显的特性。本题就要求你写个程序，通过统计每个人点赞的不同标签的数量，找出前3名点赞狂魔。

输入格式：

输入在第一行给出一个正整数N（<=100），是待统计的用户数。随后N行，每行列出一位用户的点赞标签。格式为“Name K F₁ ... F_K”，其中 Name 是不超过8个英文小写字母的非空用户名，1<=K<=1000，F_i（i=1, ..., K）是特性标签的编号，我们将所有特性标签从1到10⁷编号。数字间以空格分隔。

输出格式：

统计每个人点赞的不同标签的数量，找出数量最大的前3名，在一行中顺序输出他们的用户名,其间以1个空格分隔,且行末不得有多余空格。如果有并列，则输出标签出现次数平均值最小的那个，题目保证这样的用户没有并列。若不足3人，则用“-”补齐缺失，例如“mike jenny -”就表示只有2人。

输入样例：

5
bob 11 101 102 103 104 105 106 107 108 108 107 107
peter 8 1 2 3 4 3 2 5 1
chris 12 1 2 3 4 5 6 7 8 9 1 2 3
john 10 8 7 6 5 4 3 2 1 7 5
jack 9 6 7 8 9 10 11 12 13 14

输出样例：

jack chris john

 

//2018-03-15
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

struct Node{
    string name;
    int len, uniLen;

    bool operator<(Node node){
        if(uniLen == node.uniLen)
              return len < node.len;
        return uniLen > node.uniLen;
    }
}person[N];

int arr[1010];

int main()
{
    int n;
    while(cin >> n){
        string str;
        for(int i = 0; i < n; i++){
            cin>>person[i].name>>person[i].len;
            for(int j = 0; j < person[i].len; j++)
                  scanf("%d", &arr[j]);
            sort(arr, arr+person[i].len);
            int cnt = unique(arr, arr+person[i].len) - arr;
            person[i].uniLen = cnt;
        }
        sort(person, person+n);
        if(n == 0)cout<<"- - -"<<endl;
        else if(n == 1)cout<<person[0].name<<" - -"<<endl;
        else if(n == 2)cout<<person[0].name<<" "<<person[1].name<<" -"<<endl;
        else cout<<person[0].name<<" "<<person[1].name<<" "<<person[2].name<<endl;
    }

    return 0;
}

 

L3-001. 凑零钱

韩梅梅喜欢满宇宙到处逛街。现在她逛到了一家火星店里，发现这家店有个特别的规矩：你可以用任何星球的硬币付钱，但是绝不找零，当然也不能欠债。韩梅梅手边有10⁴枚来自各个星球的硬币，需要请你帮她盘算一下，是否可能精确凑出要付的款额。

输入格式：

输入第一行给出两个正整数：N（<=10⁴）是硬币的总个数，M（<=10²）是韩梅梅要付的款额。第二行给出N枚硬币的正整数面值。数字间以空格分隔。

输出格式：

在一行中输出硬币的面值 V₁ <= V₂ <= ... <= V_k，满足条件 V₁ + V₂ + ... + V_k = M。数字间以1个空格分隔，行首尾不得有多余空格。若解不唯一，则输出最小序列。若无解，则输出“No Solution”。

注：我们说序列{A[1], A[2], ...}比{B[1], B[2], ...}“小”，是指存在 k >= 1 使得 A[i]=B[i] 对所有 i < k 成立，并且 A[k] < B[k]。

输入样例1：

8 9
5 9 8 7 2 3 4 1

输出样例1：

1 3 5

输入样例2：

4 8
7 2 4 3

输出样例2：

No Solution

//2018-03-15
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 10010;
int arr[N], book[N], suffix_sum[N];//后缀和
int n, m;
bool ok;

void dfs(int step, int money){
    //剪枝
    if(step > n || ok || money > m || money+suffix_sum[step] < m)return;
    if(money == m){
        ok = true;
        bool first = true;
        for(int i = 0; i < n; i++){
            if(book[i]){
                if(first){
                    printf("%d", arr[i]);
                    first = false;
                }else{
                    printf(" %d", arr[i]);
                }
            }
        }
        printf("\n");
    }
    book[step] = 1;
    dfs(step+1, money+arr[step]);
    book[step] = 0;
    dfs(step+1, money);
}

int main()
{
    while(~scanf("%d%d", &n, &m))
    {
        for(int i = 0; i < n; i++)
              scanf("%d", &arr[i]);
        sort(arr, arr+n);
        suffix_sum[n] = 0;
        for(int i = n-1; i >= 0; i--)
              suffix_sum[i] = suffix_sum[i+1]+arr[i];
        ok = false;
        memset(book, 0, sizeof(book));
        dfs(0, 0);
        if(!ok)printf("No Solution\n");
    }

    return 0;
}