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

转载 2016年05月30日 16:02:45

通过这次天梯模拟赛,意识到了自己的编程程度竟是那么的不堪一击。在大神的博客中看到此文,特转载记录,供你我共勉。

如果你还是大一大二的学弟学妹,请不要吝啬自己的电脑和键盘,多多练习吧。加油!


L2-1. 集合相似度 (排序)

时间限制 400 ms
内存限制 65536 kB
代码长度限制 8000 B
判题程序 Standard 作者 陈越

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

输入格式:

输入第一行给出一个正整数N(<=50),是集合的个数。随后N行,每行对应一个集合。每个集合首先给出一个正整数M(<=104),是集合中元素的个数;然后跟M个[0, 109]区间内的整数。

之后一行给出一个正整数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%
第一次比较时也用的map,结果最后一组数据超时了

最后排序直接再两个集合扫一般即可

#include <cstdio>
#include <cstring>
#include <map>
#include <algorithm>

using namespace std;

int n,k,m,xx,a,b;
int cnt[51];
int num[51][10001];
map<int,bool> mp[51];

double getAns(int i,int j) {
    int nc=0,nt=cnt[i]+cnt[j],x=0,y=0;
    while(x<cnt[i]&&y<cnt[j]) {
        if(num[i][x]==num[j][y]) {
            ++nc;
            ++x;
            ++y;
        }
        else if(num[i][x]<num[j][y]) {
            ++x;
        }
        else {
            ++y;
        }
    }
    return 100.0*nc/(nt-nc);
}

int main() {
    while(1==scanf("%d",&n)) {
        for(int i=0;i<n;++i) {
            mp[i].clear();
            cnt[i]=0;
            scanf("%d",&m);
            for(int j=0;j<m;++j) {
                scanf("%d",&xx);
                if(!mp[i][xx]) {
                    num[i][cnt[i]++]=xx;
                    mp[i][xx]=true;
                }
            }
            sort(num[i],num[i]+cnt[i]);
        }
        scanf("%d",&k);
        while(k-->0) {
            scanf("%d%d",&a,&b);
            printf("%.2lf%%\n",getAns(a-1,b-1));
        }
    }
    return 0;
}


L2-2. 树的遍历 (分治)

时间限制 400 ms
内存限制 65536 kB
代码长度限制 8000 B
判题程序 Standard 作者 陈越

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

输入格式:

输入第一行给出一个正整数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
直接用的以前写的USACO 前序+中序 的代码改的 

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAXN=105;

int n,cnt=1,root;
int inod[35],bacod[35];
int q[35],head,tail;

struct Node {
    int lson,rson;
    int c;
}tr[35];


int dfs(int bl,int br,int il,int ir) {
    if(bl==br) {
        tr[cnt].lson=tr[cnt].rson=-1;
        tr[cnt].c=bacod[br];
        return cnt++;
    }
    for(int i=il;i<=ir;++i) {
        if(bacod[br]==inod[i]) {
            int cur=cnt++;
            tr[cur].lson=tr[cur].rson=-1;
            tr[cur].c=bacod[br];
            if(il<i) {
                tr[cur].lson=dfs(bl,bl+i-il-1,il,i-1);
            }
            if(i<ir) {
                tr[cur].rson=dfs(bl+i-il,br-1,i+1,ir);
            }
            return cur;
        }
    }
    return cnt;
}

void print(int root) {
    printf("%d",tr[root].c);
    int cur;
    head=tail=0;
    if(tr[root].lson!=-1) {
        q[tail++]=tr[root].lson;
    }
    if(tr[root].rson!=-1) {
        q[tail++]=tr[root].rson;
    }

    while(head!=tail) {
        cur=q[head++];
        printf(" %d",tr[cur].c);
        if(tr[cur].lson!=-1) {
            q[tail++]=tr[cur].lson;
        }
        if(tr[cur].rson!=-1) {
            q[tail++]=tr[cur].rson;
        }
    }
    printf("\n");
}

int main() {
    while(1==scanf("%d",&n)) {
        for(int i=0;i<n;++i) {
            scanf("%d",bacod+i);
        }
        for(int i=0;i<n;++i) {
            scanf("%d",inod+i);
        }
        cnt=0;
        print(dfs(0,n-1,0,n-1));
    }
    return 0;
}


L2-3. 家庭房产 (并查集)

时间限制 400 ms
内存限制 65536 kB
代码长度限制 8000 B
判题程序 Standard 作者 陈越

给定每个人的家庭成员和其自己名下的房产,请你统计出每个家庭的人口数、人均房产面积及房产套数。

输入格式:

输入第一行给出一个正整数N(<=1000),随后N行,每行按下列格式给出一个人的房产:

编号 父 母 k 孩子1 ... 孩子k 房产套数 总面积

其中 编号 是每个人独有的一个4位数的编号; 和  分别是该编号对应的这个人的父母的编号(如果已经过世,则显示-1);k(0<=k<=5)是该人的子女的个数;孩子i是其子女的编号。

输出格式:

首先在第一行输出家庭个数(所有有亲属关系的人都属于同一个家庭)。随后按下列格式输出每个家庭的信息:

家庭成员的最小编号 家庭人口数 人均房产套数 人均房产面积

其中人均值要求保留小数点后3位。家庭信息首先按人均面积降序输出,若有并列,则按成员编号的升序输出。

输入样例:
10
6666 5551 5552 1 7777 1 100
1234 5678 9012 1 0002 2 300
8888 -1 -1 0 1 1000
2468 0001 0004 1 2222 1 500
7777 6666 -1 0 2 300
3721 -1 -1 1 2333 2 150
9012 -1 -1 3 1236 1235 1234 1 100
1235 5678 9012 0 1 50
2222 1236 2468 2 6661 6662 1 300
2333 -1 3721 3 6661 6662 6663 1 100
输出样例:
3
8888 1 1.000 1000.000
0001 15 0.600 100.000
5551 4 0.750 100.000

并查集,要维护的东西比较多,有点繁琐


#include <cstdio>
#include <algorithm>

using namespace std;

const double EPS=0.0001;

struct Node {
    int index,peo;
    double buil,area;

    bool operator < (const Node& a) const {
        return area-EPS>a.area||(abs(area-a.area)<EPS&&index<a.index);
    }
}que[10005];

struct Fam {
    int i,f,m,k[5],n,b,a;
}p[1005];

int n,pa,pb,tail;
int par[10005],mn[100005],peo[10005],buil[10005],area[10005];
bool vis[10005];

int getPar(int a) {
    if(par[a]!=a) {
        par[a]=getPar(par[a]);
    }
    return par[a];
}

void merg(int a,int b) {
    pa=getPar(a);
    pb=getPar(b);
    if(pa!=pb) {
        par[pb]=pa;
        mn[pa]=min(mn[pa],mn[pb]);
        peo[pa]+=peo[pb];
        buil[pa]+=buil[pb];
        area[pa]+=area[pb];
    }
}

int main() {
    while(1==scanf("%d",&n)) {
        for(int i=0;i<10000;++i) {
            par[i]=mn[i]=i;
            peo[i]=1;
            buil[i]=0;
            area[i]=0;
            vis[i]=true;
        }
        for(int i=0;i<n;++i) {
            scanf("%d%d%d%d",&p[i].i,&p[i].f,&p[i].m,&p[i].n);
            for(int j=0;j<p[i].n;++j) {
                scanf("%d",&p[i].k[j]);
            }
            scanf("%d%d",&buil[p[i].i],&area[p[i].i]);
        }
        for(int i=0;i<n;++i) {
            vis[p[i].i]=false;
            if(p[i].f!=-1) {
                merg(p[i].i,p[i].f);
                vis[p[i].f]=false;
            }
            if(p[i].m!=-1) {
                merg(p[i].i,p[i].m);
                vis[p[i].m]=false;
            }
            for(int j=0;j<p[i].n;++j) {
                if(p[i].k[j]!=-1) {
                    merg(p[i].i,p[i].k[j]);
                    vis[p[i].k[j]]=false;
                }
            }
        }
        tail=0;
        for(int i=0;i<10000;++i) {
            if(!vis[i]&&par[i]==i) {
                que[tail].index=mn[i];
                que[tail].peo=peo[i];
                que[tail].area=1.0*area[i]/peo[i];
                que[tail++].buil=1.0*buil[i]/peo[i];
            }
        }
        sort(que,que+tail);
        printf("%d\n",tail);
        for(int i=0;i<tail;++i) {
            printf("%04d %d %.3lf %.3lf\n",que[i].index,que[i].peo,que[i].buil,que[i].area);
        }
    }
    return 0;
}


L2-4. 最长对称子串 (Manacher

时间限制 100 ms
内存限制 65536 kB
代码长度限制 8000 B
判题程序 Standard 作者 陈越

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

输入格式:

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

输出格式:

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

输入样例:
Is PAT&TAP symmetric?
输出样例:
11
直接粘最长回文字串的模版即可,用Manacher算法

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

int n,i,p[2000005];
char str[1000005],s[2000005];

int Manacher(char *ori) {
    s[0]=1;//第一个字符不同,防止越界
    s[1]=2;
    char *t=s+2;
    while(*ori) {
        *(t++)=*(ori++);
        *(t++)=2;
    }
    *(t++)='\0';

    int mxl=0,index=0;
    p[0]=0;
    for(int i=2;s[i];++i) {
        p[i]=(p[index]+index>i?min(p[(index<<1)-i],p[index]+index-i):1);
        while(s[i-p[i]]==s[i+p[i]])
            ++p[i];
        if(p[index]+index<p[i]+i)
            index=i;
        if(mxl<p[index])
            mxl=p[index];
    }
    return mxl-1;
}

int main() {
    while(gets(str)) {
        printf("%d\n",Manacher(str));
    }
    return 0;
}


L3-1. 肿瘤诊断 (BFS)

时间限制 400 ms
内存限制 65536 kB
代码长度限制 8000 B
判题程序 Standard 作者 陈越

在诊断肿瘤疾病时,计算肿瘤体积是很重要的一环。给定病灶扫描切片中标注出的疑似肿瘤区域,请你计算肿瘤的体积。

输入格式:

输入第一行给出4个正整数:M、N、L、T,其中M和N是每张切片的尺寸(即每张切片是一个M×N的像素矩阵。最大分辨率是1286×128);L(<=60)是切片的张数;T是一个整数阈值(若疑似肿瘤的连通体体积小于T,则该小块忽略不计)。

最后给出L张切片。每张用一个由0和1组成的M×N的矩阵表示,其中1表示疑似肿瘤的像素,0表示正常像素。由于切片厚度可以认为是一个常数,于是我们只要数连通体中1的个数就可以得到体积了。麻烦的是,可能存在多个肿瘤,这时我们只统计那些体积不小于T的。两个像素被认为是“连通的”,如果它们有一个共同的切面,如下图所示,所有6个红色的像素都与蓝色的像素连通。


Figure 1

输出格式:

在一行中输出肿瘤的总体积。

输入样例:
3 4 5 2
1 1 1 1
1 1 1 1
1 1 1 1
0 0 1 1
0 0 1 1
0 0 1 1
1 0 1 1
0 1 0 0
0 0 0 0
1 0 1 1
0 0 0 0
0 0 0 0
0 0 0 1
0 0 0 1
1 0 0 0
输出样例:
26

简单的连通块搜索,只是多了一维而已

#include <cstdio>

using namespace std;

const int di[]={-1,0,0,0,0,1};
const int dj[]={0,-1,0,1,0,0};
const int dk[]={0,0,1,0,-1,0};

struct Node {
    int i,j,k;
}que[61*1286*129],cur;

int m,n,l,t,ans,head,tail;
int num[61][1286][129];
bool vis[61][1287][129];

inline bool isInside(int i,int j,int k) {
    return 0<=i&&i<l&&0<=j&&j<n&&0<=k&&k<m;
}

int bfs(int stai,int staj,int stak) {
    head=tail=0;
    que[tail].i=stai;
    que[tail].j=staj;
    que[tail++].k=stak;
    vis[stai][staj][stak]=true;

    int res=1,ii,jj,kk;
    while(head!=tail) {
        cur=que[head++];
        for(int i=0;i<6;++i) {
            ii=cur.i+di[i];
            jj=cur.j+dj[i];
            kk=cur.k+dk[i];
            if(isInside(ii,jj,kk)&&!vis[ii][jj][kk]&&num[ii][jj][kk]==1) {
                ++res;
                vis[ii][jj][kk]=true;
                que[tail].i=ii;
                que[tail].j=jj;
                que[tail++].k=kk;
            }
        }
    }
    return res>=t?res:0;
}

int main() {
    while(4==scanf("%d%d%d%d",&n,&m,&l,&t)) {
        for(int i=0;i<l;++i) {
            for(int j=0;j<n;++j) {
                for(int k=0;k<m;++k) {
                    scanf("%d",&num[i][j][k]);
                    vis[i][j][k]=false;
                }
            }
        }
        ans=0;
        for(int i=0;i<l;++i) {
            for(int j=0;j<n;++j) {
                for(int k=0;k<m;++k) {
                    if(!vis[i][j][k]&&num[i][j][k]==1) {
                        ans+=bfs(i,j,k);
                    }
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
举报

相关文章推荐

团体程序设计天梯赛-模拟赛(2016年)

没有写完,不定时更新 L1-1  N个数求和  读入每个分数进行相加,每次相加都要化简。 输出要求假分数,若分母为1,则输出整数。 #include #include #include #includ...

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

L2-1. 集合相似度 (排序) L2-2. 树的遍历 (分治) L2-3. 家庭房产 (并查集) L2-4. 最长对称子串 (Manacher) L3-1. 肿瘤诊断 (BFS)

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

2016年 团体程序设计天梯赛 - 初赛

L1-1 到底有多二 模拟 L1-2 大笨钟 模拟 L1-3 谁先倒 L1-4 帅到没朋友 标记 L1-5 重要的话说三遍 模拟 L1-6 奇偶分家 模拟 L1-7 输出GPLT 标记 L1-8 后天...

2016年团体程序设计天梯赛-初赛 - 抢红包

没有人没抢过红包吧…… 这里给出N个人之间互相发红包、抢红包的记录,请你统计一下他们抢红包的收获。 输入格式: 输入第一行给出一个正整数N(4),即参与发红包和抢红包的总人数,则这些人从1到N编号...

团体程序设计天梯赛

L01-009   N个数求和 #include #include #include #include #include #include using namespace std; int a...

2017年团体程序设计天梯赛 - 大区赛

今天为了团体比赛,只得放弃个人的网易笔试... 3h内只AC了L1-1 ~ L1-8、L2-1 、 L2-3 ~ L2-4、L3-1(赛后已全部AC) L2-2(已AC) 和 L3-3(已AC)各...

2016年团体程序设计天梯赛-初赛 - 大笨钟 - Java

微博上有个自称“大笨钟V”的家伙,每天敲钟催促码农们爱惜身体早点睡觉。不过由于笨钟自己作息也不是很规律,所以敲钟并不定时。一般敲钟的点数是根据敲钟时间而定的,如果正好在某个整点敲,那么“当”数就等于那...

2016年团体程序设计天梯赛-初赛 - 谁先倒 - Java

划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为:每人口中喊出一个数字,同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和,谁就输了,输家罚一杯酒。两人同赢或两人同输...

2016年团体程序设计天梯赛-初赛 - 排座位(并查集)

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

2016年团体程序设计天梯赛-初赛 - 到底有多二 - Java

一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数,则程度增加0.5倍;如果还是个偶数,则再增加1倍。例如数字“-13142223336”是个11位数,其中有3个2,并且...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)