陕西金融大学第七交程序设计大赛通告,ACM 国际大学生程序设计比赛 (International Collegiate Programming

“波导杯”陕西医科高校第七顶程序设计大赛

Contest – 2016 “Bird
Cup” ICPC7th@ahstu

Start time:  2016-04-23
08:00:00.0  End time:  2016-04-23
12:00:00.0
Current System Time:  2016-04-23
19:02:17.554  Contest Status:   Ended

有关设置“波导杯”浙江外国语高校第七到程序设计大赛布告

ACM 国际研究生程序设计比赛 (International
Collegiate Programming Contest)是出于美利坚合众国总括机协会(ACM)主办的等同焦点在体现大学生改进能力、团队精神和当压力下编写程序、分析以及缓解问题能力的有名竞技。二零一零年吧,我校出席了趟广东省 ACM 程序设计比赛,并收获了精的成。为遴选校 ACM 参赛队员,将设“波导杯” 山东传媒大学第七到总括机程序设计大赛,热忱欢迎广大程序设计爱好者踊跃参与。

主办方:黑龙江师范学院教务处、消息与网络工程高校

承办方:信息及网络工程大学

赞助方:宁波波导软件有限集团(独家赞助)

相同、 比赛日:2016 年 4 月23(周六)上午 8:00~12:00

仲、比赛地方:总计机与网试验中央(力行楼六楼)

老三、比赛设奖:苟一等奖8%、二等奖12%、三等奖15%。

六、比赛相关:

赛语言:C/C++/JAVA 环境:DevCpp /CodeBlock /Eclipse

比赛试题:选拔 ICPC 样式——赛题 8~10道

注意事项:

·  1. 操练赛网站(安科 OJ):http://183.167.205.82:8081/JudgeOnline/

·  2. 处理器系 ACM/ICPC 学生活动室位于力行楼六楼,欢迎互换。

比赛 QQ 群:173592864(波导杯第七到校ACM赛)

Problem Id Title
1366 Problem A Dotaer vs Loler
1367 Problem B so so so easy
1368 Problem C 反转链表
1369 Problem D 贪吃蛇
1370 Problem E 均分硬币
1371 Problem F 丢啊丢啊丢手绢
1372 Problem G 分糖果
1373 Problem H 埋炸弹啦~
1374 Problem I 化学老师的惩罚
1375 Problem J 水题!

[Standings]  [Status]  [Statistics]

“波导杯”湖北政法高校第七及程序设计大赛

原小说网页

Contest – 2016 “Bird Cup” ICPC7th@ahstu

Start time:  2016-04-23 08:00:00.0  End time:  2016-04-23 12:00:00.0
Current System Time:  2016-04-23 19:02:17.554  Contest Status:   Ended

关于设立“波导杯”甘肃交通高校第七届程序设计大赛通知

ACM 国际研究生程序设计比赛 (International Collegiate Programming
Contest)是由米国统计机协会(ACM)主办的如出一辙起意在展示硕士立异能力、团队精神和于压力下编写程序、分析及化解问题能力的显赫比赛。二〇一〇年以来,我校参预了和浙江省 ACM 程序设计比赛,并获了理想的战表。为挑选校 ACM 参赛队员,将开办“波导杯” 黑龙江中医药高校第七届总计机程序设计大赛,热忱欢迎广大程序设计爱好者踊跃插手。

主办方:广东农业大学教务处、音讯和网络工程高校

承办方:音信与网络工程高校

赞助方:塞维伯明翰波导软件有限公司(独家赞助)

平等、 比赛时间:2016 年 4 月23(周六)上午 8:00~12:00

次、比赛地方:处理器和网络试验中央(力行楼六楼)

其三、竞赛设奖:若一等奖8%、二等奖12%、三等奖15%。

六、比赛相关:

比语言:C/C++/JAVA 环境:DevCpp /CodeBlock /Eclipse

竞试题:采取 ICPC 样式——赛题 8~10道

注意事项:

·  1. 演习赛网站(安科 OJ):http://183.167.205.82:8081/JudgeOnline/

·  2. 电脑系 ACM/ICPC 学生活动室位于力行楼六楼,欢迎交换。

竞赛 QQ 群:173592864(波导杯第七届校ACM赛)

Problem Id Title
1366 Problem A Dotaer vs Loler
1367 Problem B so so so easy
1368 Problem C 反转链表
1369 Problem D 贪吃蛇
1370 Problem E 均分硬币
1371 Problem F 丢啊丢啊丢手绢
1372 Problem G 分糖果
1373 Problem H 埋炸弹啦~
1374 Problem I 化学老师的惩罚
1375 Problem J 水题!

[Standings]  [Status]  [Statistics]

# Dotaer vs Loler

Time Limit:1000MS Memory Limit:65536K
Total Submit:170 Accepted:31

Dotaer vs Loler


Time Limit:1000MS Memory Limit:65536K
Total Submit:170 Accepted:31

Description

小杨是平等称Dota资深玩家,和众多Dota玩家一样,他以及四周四广大LOL玩家在同步爆发一致种植自然之优越感,然则身边的刀友确一个个投入了撸狗的队列,直到现在周围又无了
一个同行。。。他不行气恼,于是发生了底就道题目:
个别独分别仅含Dotaer和Loler中之假名之字符串,长度(<10^6),请你分别总计两单字符串中所蕴涵字母可以做Dotaer和Loler的极可怜数额(不区分轻重缓急写),然后根
本两者的多少判断输赢,若Loler数量大于Dotaer数量的3倍增,则Loler
win,反之Dotaer win。

Description

小杨是一样叫Dota资深玩家,和广大Dota玩家一样,他以及四周天众多LOL玩家在联合暴发同样种植自然之优越感,然则身边的刀友确一个个投入了撸狗的队列,直到现在周围又无了
一个同行。。。他挺气恼,于是暴发了底就道题目:
少只分别仅含Dotaer和Loler中之假名之字符串,长度(<10^6),请你分别总结两单字符串中所富含字母可以做Dotaer和Loler的可是酷数额(不区分轻重缓急写),然后根
比如两者的多寡判断输赢,若Loler数量大于Dotaer数量的3加倍,则Loler
win,反之Dotaer win。

Input

每个输入包含多独测试用例,每个测试用包个别行,第一行成Dotaer的字符串,第二行为结合Loler的字符串。

Input

每个输入包含多少个测试用例,每个测试用包个别实施,第一行构成Dotaer的字符串,第二行为成Loler的字符串。

Output

对此每个测试用例输出三行,第一表现Dotaer数量,第二表现Loler数量,第三行哪方win。

Output

对此每个测试用例输出三行,第一作为Dotaer数量,第二行事Loler数量,第三行事哪方win。

Sample Input

otdarrreoddtooaaoooee
rolereoreolrereoreol

Sample Input

otdarrreoddtooaaoooee
rolereoreolrereoreol

Sample Output

Dotaer: 2
Loler: 1
Dotaer win

Sample Output

Dotaer: 2
Loler: 1
Dotaer win

Source

icpc7th@ahstu

#include<iostream>
#include<string>
#include<map>
#include<fstream>
using namespace std;
map<char,int>Dota;
map<char,int>LOL;
map<char,int>::iterator d_it;
map<char,int>::iterator l_it;
char change(char a)
{
   return (a<97)?(a+32):a;
}
void print()
{
    for(d_it=LOL.begin();d_it!=LOL.end();d_it++)
    {
        cout<<d_it->second<<" "<<d_it->first<<endl;
    }
}
int dota(string D)
{
    for(int i=0;i<D.size();i++)
    {
        Dota[change(D[i])]++;
    }
    Dota['d'];Dota['o'];
    Dota['t'];Dota['a'];
    Dota['e'];Dota['r'];
    int m=1000001;
   for(d_it=Dota.begin();d_it!=Dota.end();d_it++)
   {
       if(m>(d_it->second))
        m=(d_it->second);
   }
   return m;
}
int lol(string L)
{
     for(int i=0;i<L.size();i++)
    {
        LOL[change(L[i])]++;
    }
    LOL['l']; LOL['o'];
    LOL['e']; LOL['r'];
    int m=1000001;
    for(l_it=LOL.begin();l_it!=LOL.end();l_it++)
    {
        if((l_it->first)!='l')
        {
            if(m>(l_it->second))
                m=l_it->second;
        }
        else
        {
            if(m>(l_it->second)/2)
                m=(l_it->second)/2;
        }
    }
    return m;
}
int main()
{
    //freopen("Dotaer vs Loler.in","r",stdin);
    //freopen("Dotaer vs Loler.out","w",stdout);
    string D,L;
    int D_num,L_num;
    while(cin>>D>>L)
    {
       D_num=dota(D);
       L_num=lol(L);
       cout<<"Dotaer: "<<D_num<<endl;
       cout<<"Loler: "<<L_num<<endl;
       if(L_num>3*D_num)
        cout<<"Loler win"<<endl;
       else
       cout<<"Dotaer win"<<endl;
       Dota.clear();
       LOL.clear();
    }
    return 0;
}

Source

icpc7th@ahstu

#include<iostream>
#include<string>
#include<map>
#include<fstream>
using namespace std;
map<char,int>Dota;
map<char,int>LOL;
map<char,int>::iterator d_it;
map<char,int>::iterator l_it;
char change(char a)
{
   return (a<97)?(a+32):a;
}
void print()
{
    for(d_it=LOL.begin();d_it!=LOL.end();d_it++)
    {
        cout<<d_it->second<<" "<<d_it->first<<endl;
    }
}
int dota(string D)
{
    for(int i=0;i<D.size();i++)
    {
        Dota[change(D[i])]++;
    }
    Dota['d'];Dota['o'];
    Dota['t'];Dota['a'];
    Dota['e'];Dota['r'];
    int m=1000001;
   for(d_it=Dota.begin();d_it!=Dota.end();d_it++)
   {
       if(m>(d_it->second))
        m=(d_it->second);
   }
   return m;
}
int lol(string L)
{
     for(int i=0;i<L.size();i++)
    {
        LOL[change(L[i])]++;
    }
    LOL['l']; LOL['o'];
    LOL['e']; LOL['r'];
    int m=1000001;
    for(l_it=LOL.begin();l_it!=LOL.end();l_it++)
    {
        if((l_it->first)!='l')
        {
            if(m>(l_it->second))
                m=l_it->second;
        }
        else
        {
            if(m>(l_it->second)/2)
                m=(l_it->second)/2;
        }
    }
    return m;
}
int main()
{
    //freopen("Dotaer vs Loler.in","r",stdin);
    //freopen("Dotaer vs Loler.out","w",stdout);
    string D,L;
    int D_num,L_num;
    while(cin>>D>>L)
    {
       D_num=dota(D);
       L_num=lol(L);
       cout<<"Dotaer: "<<D_num<<endl;
       cout<<"Loler: "<<L_num<<endl;
       if(L_num>3*D_num)
        cout<<"Loler win"<<endl;
       else
       cout<<"Dotaer win"<<endl;
       Dota.clear();
       LOL.clear();
    }
    return 0;
}

# so so so easy

Time Limit:1000MS Memory Limit:65536K
Total Submit:46 Accepted:14

so so so easy


Time Limit:1000MS Memory Limit:65536K
Total Submit:46 Accepted:14

Description

为防止起光头的情况出现,仁慈的老赵于每一次比被终究会千方百计的加水题上,一个点儿独三独…..。
幸存一个全然由让空格所分开的英文单词构成的字符串(单词数量<=100),请你频繁起每个单词是接连第几差面世。(例如
so so so easy 结果吧 1 2 3 1)

Description

为避免起光头的景观出现,仁慈的老赵在每一回比被到底会想尽的加水题上,一个个别单三单…..。
幸存一个净是因为被空格所分开的英文单词构成的字符串(单词数量<=100),请您往往出每个单词是连连第几蹩脚面世。(例如
so so so easy 结果也 1 2 3 1)

Input

每个输入包含多独测试用例,每个测试用例为一个通通出于为空格所分开的英文单词构成的字符串。

Input

每个输入包含六个测试用例,每个测试用例为一个了是因为为空格所分开的英文单词构成的字符串。

Output

于每个测试用例,输出其每个单词是连续第几潮出现。

Output

对每个测试用例,输出其每个单词是接连第几不行面世。

Sample Input

so so so easy so so

Sample Input

so so so easy so so

Sample Output

1 2 3 1 1 2

Sample Output

1 2 3 1 1 2

Source

icpc7th@ahstu

#include<iostream>
#include<string>
#include<fstream>
#include<sstream>
using namespace std;
void easy(string A)
{
    int i;
    int num=0;
    string flag;
    string B[100];
    istringstream sin(A);
    for(i=0;sin>>B[i];i++);
    flag="";
    for(int j=0;j<i;j++)
    {
        if(B[j]!=flag)
        {
            num=1;
            flag=B[j];
            cout<<num<<" ";
        }
        else
        {
            num++;
            cout<<num<<" ";
        }
    }
    cout<<endl;
}
int main()
{
   // freopen("so so so easy.in","r",stdin);
   // freopen("so so so easy.out","w",stdout);
    string A;
    while(getline(cin,A))
    {
        easy(A);
    }
    return 0;
}

Source

icpc7th@ahstu

#include<iostream>
#include<string>
#include<fstream>
#include<sstream>
using namespace std;
void easy(string A)
{
    int i;
    int num=0;
    string flag;
    string B[100];
    istringstream sin(A);
    for(i=0;sin>>B[i];i++);
    flag="";
    for(int j=0;j<i;j++)
    {
        if(B[j]!=flag)
        {
            num=1;
            flag=B[j];
            cout<<num<<" ";
        }
        else
        {
            num++;
            cout<<num<<" ";
        }
    }
    cout<<endl;
}
int main()
{
   // freopen("so so so easy.in","r",stdin);
   // freopen("so so so easy.out","w",stdout);
    string A;
    while(getline(cin,A))
    {
        easy(A);
    }
    return 0;
}

# 反转链表

Time Limit:1000MS Memory Limit:65536K
Total Submit:5 Accepted:0

反转链表


Time Limit:1000MS Memory Limit:65536K
Total Submit:5 Accepted:0

Description

给一定一个平日反复K以及一个单链表L,请编写程序将L中各K个结点反转。例如:给定L为1→2→3→4→5→6,K为3,则输出应该吗3→2→1→6→5→4;要是K为4,则输出应该也4→3→2→1→5→6,即最终不至K个元素不反转。

Description

深受得一个时时反复K以及一个单链表L,请编写程序将L中各类K个结点反转。例如:给定L为1→2→3→4→5→6,K为3,则输出应该也3→2→1→6→5→4;假如K为4,则输出应该为4→3→2→1→5→6,即最后不交K个元素不反转。

Input

每个输入包含多独测试用例。每个测试用例第1履行吃有第1个结点的地点、结点总个数正整数N(<=
105)、以及正整数K(<=N),即要求反转之子链结点的个数。结点的地方是5号非负整数,NULL地址用-1象征。

连接下有N行,每行格式为:

Address Data Next

中间Address是结点地址,Data是拖欠结点保存的整数数据,Next是下一结点的地方。

Input

每个输入包含四只测试用例。每个测试用例第1尽于来第1独结点的地方、结点总个数正整数N(<=
105)、以及正整数K(<=N),即要求反转之子链结点的个数。结点的地方是5各项非负整数,NULL地址用-1象征。

通下去有N行,每行格式为:

Address Data Next

里Address是结点地址,Data是拖欠结点保存的整数数据,Next是下一结点之地址。

Output

针对每个测试用例,顺序输出反转后的链表(每个节点的 Address Data
Next),其达成每个结点占一执行,格式和输入相同。

Output

本着每个测试用例,顺序输出反转后底链表(每个节点的 Address Data
Next),其上每个结点占一行,格式和输入相同。

Sample Input

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

Sample Input

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

Sample Output

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

Sample Output

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

Source

icpc7th@ahstu

#include<iostream>
#include<vector>
#include<algorithm>
#include<stdio.h>
#include<cstdlib>
#include<fstream>
using namespace std;

typedef struct
{
    int add;
    int data;
    int next;
}Node;
Node L[100001];
vector<Node>N;
vector<Node>::iterator it;
int scan(int &Add,int &num,int &n)
{
    Node N;
    for(int i=0;i<num;i++)
    {
        cin>>N.add>>N.data>>N.next;
        L[N.add]=N;
    }
    return 1;
}
void L_sort(int start,int n)
{
     int flag=start;
     while(flag!=-1)
     {
         N.push_back(L[flag]);
         flag=L[flag].next;
     }
}
void F_sort(int n)
{
    int G=N.size()/n;
    for(int i=0;i<G;i++)
    {
        reverse((N.begin()+i*n),(N.begin()+(i+1)*n));
    }
}
void print()
{
    for(it=N.begin();it<N.end()-1;it++)
    {
        printf("%05d %d %05d\n",(*it).add,(*it).data,(*(it+1)).add);
    }
            printf("%05d %d -1\n",(*(N.end()-1)).add,(*(N.end()-1)).data);
}
int main()
{
   int Add,num,n;
    //freopen("反转链表.in","r",stdin);
    //freopen("反转链表.out","w",stdout);
    while(cin>>Add>>num>>n)
    {
        scan(Add,num,n);
       L_sort(Add,n);
       F_sort(n);
       print();
       N.clear();
    }
    return 0;
}

Source

icpc7th@ahstu

    #include<iostream>
    #include<vector>
    #include<algorithm>
    #include<stdio.h>
    #include<cstdlib>
    #include<fstream>
    using namespace std;

    typedef struct
    {
        int add;
        int data;
        int next;
    }Node;
    Node L[100001];
    vector<Node>N;
    vector<Node>::iterator it;
    int scan(int &Add,int &num,int &n)
    {
        Node N;
        for(int i=0;i<num;i++)
        {
            cin>>N.add>>N.data>>N.next;
            L[N.add]=N;
        }
        return 1;
    }
    void L_sort(int start,int n)
    {
         int flag=start;
         while(flag!=-1)
         {
             N.push_back(L[flag]);
             flag=L[flag].next;
         }
    }
    void F_sort(int n)
    {
        int G=N.size()/n;
        for(int i=0;i<G;i++)
        {
            reverse((N.begin()+i*n),(N.begin()+(i+1)*n));
        }
    }
    void print()
    {
        for(it=N.begin();it<N.end()-1;it++)
        {
            printf("%05d %d %05d\n",(*it).add,(*it).data,(*(it+1)).add);
        }
                printf("%05d %d -1\n",(*(N.end()-1)).add,(*(N.end()-1)).data);
    }
    int main()
    {
       int Add,num,n;
        //freopen("反转链表.in","r",stdin);
        //freopen("反转链表.out","w",stdout);
        while(cin>>Add>>num>>n)
        {
            scan(Add,num,n);
           L_sort(Add,n);
           F_sort(n);
           print();
           N.clear();
        }
        return 0;
    }

# 贪吃蛇

Time Limit:1000MS Memory Limit:65536K
Total Submit:9 Accepted:2

贪吃蛇


Time Limit:1000MS Memory Limit:65536K
Total Submit:9 Accepted:2

Description

起小儿底孩子还打过此经典游戏,但是此的规则而小不同,现在起一个N*M(N,M<=100)的方形矩形,在斯矩形的诸一个方格上且加大有几五只樱桃,一修可爱的小蛇从矩形的
左上角起头起身,每一遍运动还不得不移动一格,向左边或向下,而各类抵达一格饕餮的小蛇都会合吧该地方及之樱桃吃个一样关乎二净,直到到右下角时截至。而贪吃的略蛇不畏惧撑大,它独自想吃到绝多
的樱桃,请您告知她他绝多会吃到多少樱桃和实际途径吧。(数据保证最好突出路线只有出同一条)

Description

来小儿之男女都玩了此经典游戏,然则这里的规则以粗不同,现在生一个N*M(N,M<=100)的方形矩形,在此矩形的各一个方格上且放起好多独樱桃,一长达可爱之小蛇从矩形的
左上角开始出发,每便活动还不得不移动一格,向左边或朝向下,而各达一格饕餮的小蛇都汇合吧该岗位上的樱桃吃个一律干二全都,直到抵达右下角时截止。而贪吃的粗蛇不惧怕撑坏,它只是想吃到绝多
的樱桃,请你告诉它他但是多会吃到稍微樱桃和具体路线吧。(数据保证最好地道路线才来同等长长的)

Input

每个输入包含两只测试用例,每个测试用例第一履行吃出N,M,接下去N行M列数据意味着每个岗位及之樱桃个数。(矩阵坐标从(1,1)最先)。

Input

每个输入包含多单测试用例,每个测试用例第一尽于出N,M,接下N行M列数据意味着每个地方上的樱桃个数。(矩阵坐标从(1,1)起先)。

Output

于每个测试用例输出第一行会吃到之极端充裕樱桃个数,接下去吗小蛇所待活动之不二法门的坐标,每个坐标占一行。

Output

对于每个测试用例输出第一行为能够吃到之最好特别樱桃个数,接下去为小蛇所急需走之门道的坐标,每个坐标占一行。

Sample Input

4 4
1 2 3 7
3 4 2 1
1 5 4 8
10 3 0 3

Sample Input

4 4
1 2 3 7
3 4 2 1
1 5 4 8
10 3 0 3

Sample Output

28
(1,1)
(2,1)
(2,2)
(3,2)
(3,3)
(3,4)
(4,4)

Sample Output

28
(1,1)
(2,1)
(2,2)
(3,2)
(3,3)
(3,4)
(4,4)

Source

icpc7th@ahstu

#include<iostream>
#include<string>
#include<fstream>
#include<vector>
#include<algorithm>
using namespace std;
typedef struct
{
    int m_sum;
    vector<string> way;
}MP;
int mp[102][102];
MP Mp[102][102];
int N,M;
string change(int a)
{
    string A;
    while(a!=0)
    {
        A+=((a%10)+'0');
        a/=10;
    }
    reverse(A.begin(),A.end());
    return A;
}
void scan()
{
    for(int i=0;i<=M;i++)
        mp[0][i]=0;
    for(int i=0;i<=N;i++)
        mp[i][0]=0;
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=M;j++)
        cin>>mp[i][j];
    }
}
void hand_mp()
{
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=M;j++)
        {
            Mp[i][j].m_sum=mp[i][j]+((mp[i][j-1]>=mp[i-1][j])?mp[i][j-1]:mp[i-1][j]);
            mp[i][j]= Mp[i][j].m_sum;
            Mp[i][j].way=(mp[i][j-1]>=mp[i-1][j])?(Mp[i][j-1]).way:(Mp[i-1][j]).way;
            Mp[i][j].way.push_back(change(i));
            Mp[i][j].way.push_back(change(j));
        }
    }
}
void print()
{
    cout<<Mp[N][M].m_sum<<endl;
    for(int i=0;i<Mp[N][M].way.size();i+=2)
    {
        cout<<"("<<Mp[N][M].way[i]<<","<<Mp[N][M].way[i+1]<<")"<<endl;
    }
}
int  main()
{
   // freopen("贪吃蛇.in","r",stdin);
   // freopen("贪吃蛇.out","w",stdout);
    while(cin>>N>>M)
    {
        scan();
        hand_mp();
        print();
    }
    return 0;
}

Source

icpc7th@ahstu

    #include<iostream>
    #include<string>
    #include<fstream>
    #include<vector>
    #include<algorithm>
    using namespace std;
    typedef struct
    {
        int m_sum;
        vector<string> way;
    }MP;
    int mp[102][102];
    MP Mp[102][102];
    int N,M;
    string change(int a)
    {
        string A;
        while(a!=0)
        {
            A+=((a%10)+'0');
            a/=10;
        }
        reverse(A.begin(),A.end());
        return A;
    }
    void scan()
    {
        for(int i=0;i<=M;i++)
            mp[0][i]=0;
        for(int i=0;i<=N;i++)
            mp[i][0]=0;
        for(int i=1;i<=N;i++)
        {
            for(int j=1;j<=M;j++)
            cin>>mp[i][j];
        }
    }
    void hand_mp()
    {
        for(int i=1;i<=N;i++)
        {
            for(int j=1;j<=M;j++)
            {
                Mp[i][j].m_sum=mp[i][j]+((mp[i][j-1]>=mp[i-1][j])?mp[i][j-1]:mp[i-1][j]);
                mp[i][j]= Mp[i][j].m_sum;
                Mp[i][j].way=(mp[i][j-1]>=mp[i-1][j])?(Mp[i][j-1]).way:(Mp[i-1][j]).way;
                Mp[i][j].way.push_back(change(i));
                Mp[i][j].way.push_back(change(j));
            }
        }
    }
    void print()
    {
        cout<<Mp[N][M].m_sum<<endl;
        for(int i=0;i<Mp[N][M].way.size();i+=2)
        {
            cout<<"("<<Mp[N][M].way[i]<<","<<Mp[N][M].way[i+1]<<")"<<endl;
        }
    }
    int  main()
    {
       // freopen("贪吃蛇.in","r",stdin);
       // freopen("贪吃蛇.out","w",stdout);
        while(cin>>N>>M)
        {
            scan();
            hand_mp();
            print();
        }
        return 0;
    }

# 均分硬币

Time Limit:1000MS Memory Limit:65536K
Total Submit:14 Accepted:4

皆分硬币


Time Limit:1000MS Memory Limit:65536K
Total Submit:14 Accepted:4

Description

发出N堆硬币,编号分别吗 1,2,…, N(N<=100)
每堆上起好多单硬币,可以在无一积聚上取多少只硬币,然后倒。移动规则为:在数码也
1 堆上取的硬币,只可以换到号吧 2 的堆积上;
在数码为 N 的堆上得到之硬币,只可以换来号吧 N-1
的积上;其他堆上获取之硬币,可以转移到隔壁左边或右侧的堆上。现在求寻找来同种运动方法,用极少之移位次数要每堆上硬币
往往还一律多。例如 N=4,4 硬币数分别吗: ① 9 ② 8 ③ 17 ④ 6
移动3次于而直达目标。

Description

发出N堆硬币,编号分别吗 1,2,…, N(N<=100)
每堆上起六个硬币,可以以管一堆积上获多少单硬币,然后倒。移动规则为:在数码也
1 堆上取的硬币,只好换来数码吧 2 的积聚上;
当数码为 N 的堆积上赢得的硬币,只可以换来数码吧 N-1
的堆上;其他堆上收获的硬币,可以转换来附近左边或右手边的堆上。现在要求寻找有同种运动方法,用最好少的活动次数要每堆上硬币
几度都无异多。例如 N=4,4 硬币数分别吗: ① 9 ② 8 ③ 17 ④ 6
移动3潮可上目标。

Input

每个输入包含六个测试用例,每个测试用例第一表现整数N硬币堆数,接下去一行N个数为相应堆上硬币的多少。

Input

每个输入包含多单测试用例,每个测试用例第一表现整数N硬币堆数,接下一行N个数为对应堆上硬币的数目。

Output

对于每个测试用例,输出其最少要走次数,若无法均分则输出“Oh no!”

Output

对于每个测试用例,输出其最少需要走次数,若无法均分则输出“Oh no!”

Sample Input

4
9 8 17 6

Sample Input

4
9 8 17 6

Sample Output

3

Sample Output

3

Source

icpc7th@ahstu

#include<iostream>
#include<fstream>
using namespace std;
int avg(int *A,int n)
{
    int sum=0;
    int avge;
    int flag=0;
    for(int i=0;i<n;i++)
        sum+=A[i];
    avge=sum/n;
    if(avge*n==sum)
    {
        for(int i=0;i<n-1;i++)
        {
            if(A[i]!=avge)
            {
                A[i+1]+=A[i]-avge;
                flag++;
            }

        }
        cout<<flag<<endl;
    }
    else
        cout<<"Oh no!"<<endl;
}
int main()
{
    int N;
    int A[101];
    while(cin>>N)
    {
        for(int i=0;i<N;i++)
            cin>>A[i];
        avg(A,N);
    }
    return 0;
}

Source

icpc7th@ahstu

    #include<iostream>
    #include<fstream>
    using namespace std;
    int avg(int *A,int n)
    {
        int sum=0;
        int avge;
        int flag=0;
        for(int i=0;i<n;i++)
            sum+=A[i];
        avge=sum/n;
        if(avge*n==sum)
        {
            for(int i=0;i<n-1;i++)
            {
                if(A[i]!=avge)
                {
                    A[i+1]+=A[i]-avge;
                    flag++;
                }

            }
            cout<<flag<<endl;
        }
        else
            cout<<"Oh no!"<<endl;
    }
    int main()
    {
        int N;
        int A[101];
        while(cin>>N)
        {
            for(int i=0;i<N;i++)
                cin>>A[i];
            avg(A,N);
        }
        return 0;
    }

# 丢啊丢啊丢手绢

Time Limit:1000MS Memory Limit:65536K
Total Submit:17 Accepted:4

委啊丢啊丢手绢


Time Limit:1000MS Memory Limit:65536K
Total Submit:17 Accepted:4

Description

每当安科教室面前的草坪上围绕以在N个同学1,2,3,…..N.(按顺序围成一个绕),然后打里边一个同室先导,拿在一手绢比照号从小至大之方向一致步一步绕在世界走,
平步经过一个同学,若干步后将手绢交给面前的校友,接到手绢的同桌不改变方向用同的艺术把手绢交给其他一个同校后淘汰出游戏,凡是一个同校去圈子,剩下同学
将空缺消除再做一个周(相对地点不换)。现在晓您起首同学的编号和手帕n次行进之步数,你通晓竟剩下什么同学为?

Description

每当安科教室前之绿地上围为正N个同学1,2,3,…..N.(按梯次围成一个环),然后打里面一个同学先导,拿在一手绢按编号从小到好的自由化同样步一步绕在世界走,
平等步经过一个同班,若干步后拿手绢交给面前的同窗,接到手绢的同窗不改变方向用同样的方将手绢交给其他一个同室后淘汰出游戏,凡是一个同学去圈子,剩下同学
拿空缺消除重做一个到(相对地点不移)。现在晓您起来同学的编号与手帕n次行进的步数,你了解到底剩下什么同学也?

Input

每个输入包含两只测试用例,每个测试用例包括个别有的:
首先局部叔单数字num(到场打学生总数),i(初阶学生编号),n(手绢移动的次数)。
其次部分n个整数为n次手绢分别倒的步数。

Input

每个输入包含多少个测试用例,每个测试用例包括个别有:
率先片叔独数字num(参与游戏学生总数),i(初叶学生编号),n(手绢移动的次数)。
次有的n个整数为n次手绢分别运动的步数。

Output

输出游戏停止后所留学生的数码(按升序输出)。

Output

出口游戏了晚所遗留学生的号子(按升序输出)。

Sample Input

6 2 3
2 3 4

Sample Input

6 2 3
2 3 4

Sample Output

5 6

Sample Output

5 6

Source

icpc7th@ahstu

#include<iostream>
#include<algorithm>
#include<vector>
#include<fstream>
using namespace std;
void init(vector<int> &A,int num)
{
    for(int i=0;i<=num;i++){
        A.push_back(i);
    }
}
void game(vector<int> A,int *way,int n,int first)
{
    int index;
     A.erase(A.begin()+first);
     index=first-1;
    for(int i=0;i<n;i++)
    {
        A.erase(A.begin()+(index+way[i])%A.size());
        index=(index+way[i])%A.size()-1;
    }
    for(int i=1;i<A.size();i++)
    cout<<A[i]<<" ";
    cout<<endl;
}
int main()
{
    //freopen("¶ª°¡¶ª°¡¶ªÊÖ¾î.in","r",stdin);
    //freopen("¶ª°¡¶ª°¡¶ªÊÖ¾î.out","w",stdout);
    int num,first,n;
    vector<int> A;
    int way[100];
    while(cin>>num>>first>>n)
    {
        for(int i=0;i<n;i++)
            cin>>way[i];

        init(A,num);
         game(A,way,n,first);
         A.clear();
    }
    return 0;
}

Source

icpc7th@ahstu

    #include<iostream>
    #include<algorithm>
    #include<vector>
    #include<fstream>
    using namespace std;
    void init(vector<int> &A,int num)
    {
        for(int i=0;i<=num;i++){
            A.push_back(i);
        }
    }
    void game(vector<int> A,int *way,int n,int first)
    {
        int index;
         A.erase(A.begin()+first);
         index=first-1;
        for(int i=0;i<n;i++)
        {
            A.erase(A.begin()+(index+way[i])%A.size());
            index=(index+way[i])%A.size()-1;
        }
        for(int i=1;i<A.size();i++)
        cout<<A[i]<<" ";
        cout<<endl;
    }
    int main()
    {
        //freopen("¶ª°¡¶ª°¡¶ªÊÖ¾î.in","r",stdin);
        //freopen("¶ª°¡¶ª°¡¶ªÊÖ¾î.out","w",stdout);
        int num,first,n;
        vector<int> A;
        int way[100];
        while(cin>>num>>first>>n)
        {
            for(int i=0;i<n;i++)
                cin>>way[i];

            init(A,num);
             game(A,way,n,first);
             A.clear();
        }
        return 0;
    }

# 分糖果

Time Limit:1000MS Memory Limit:65536K
Total Submit:0 Accepted:0

分糖果


Time Limit:1000MS Memory Limit:65536K
Total Submit:0 Accepted:0

Description

小洛,小欢,小涛是三单稍屁孩,他们出一个协办之珍爱—吃糖!小杨每一天都会合给他俩购进糖吃,但他生个要求,每回小杨会把市来的糖随机分成三堆积,
(<=10^4)
五只小屁孩想要吃到糖,就务须遵照小杨的求每趟将自由一积糖的一半放权任何糖堆里,最后使三积聚糖的数目及小杨所要求的完全一致,才为允许吃.
(若一积聚糖啊惊异数独,它的一半乎于少的那么部分)。那么他们至少要走多少次才会吃到糖果。

Description

小洛,小欢,小涛是五只稍屁孩,他们有一个联机的爱—吃糖!小杨每一天都会合被她们买糖吃,但他发出个要求,每一趟小杨会把买来的糖随机分成三堆,
(<=10^4)
两个小屁孩想假诺吃到糖,就亟须依据小杨的渴求每便将自由一积聚糖的一半放权任何糖堆里,最后要三堆放糖的数额和小杨所要求的完全一致,才于允许吃.
(若一堆放糖也惊诧数单,它的一半呢相比较少的那么有)。那么他们至少要走多少次才会吃到糖果。

Input

每个输入包含三个测试用例,每个测试用例第一履行吃有3单数字为始发的糖堆数量,第二执行3只数字呢小杨要求糖堆最后数额。

Input

每个输入包含两只测试用例,每个测试用例第一尽于来3独数字也始发的糖堆数量,第二行3单数字呢小杨要求糖堆最后数额。

Output

对此每个测试用例输出一行也该最少移动次数,若无容许高达要求输出“Unfind”。

Output

对此每个测试用例输出一行也其最少移动次数,若未容许上要求输出“Unfind”。

Sample Input

6 10 3
6 5 8

1 2 5
3 0 5

Sample Input

6 10 3
6 5 8

1 2 5
3 0 5

Sample Output

1
Unfind

Sample Output

1
Unfind

Source

icpc7th@ahstu

#include<iostream>
#include<queue>
#include<string>
#include<map>
#include<cstdio>
#include<sstream>
using namespace std;

typedef struct
{
    int step;
    int candy[3];
} ST;
map<string,int>mp;
int init[3];
int target[3];
void state(ST &S,int i)
{
    int f,s,t;
    f=S.candy[0];
    s=S.candy[1];
    t=S.candy[2];
    S.step++;
    switch(i)
    {
    case 1:
        S.candy[0]=f-f/2;
        S.candy[1]=s+f/2;
        break;
    case 2:
        S.candy[0]=f+s/2;
        S.candy[1]=s-s/2;
        break;
    case 3:
        S.candy[0]=f-f/2;
        S.candy[2]=t+f/2;
        break;
    case 4:
        S.candy[0]=f+t/2;
        S.candy[2]=t-t/2;
        break;
    case 5:
        S.candy[1]=s-s/2;
        S.candy[2]=t+s/2;
        break;
    case 6:
        S.candy[1]=s+t/2;
        S.candy[2]=t-t/2;
        break;
    }
}
int Search(int *init,int *target,queue<ST> &Q,int &STEP)
{
    ST flag;
    string fl,l;
    flag.step=0;
    flag.candy[0]=init[0];
    flag.candy[1]=init[1];
    flag.candy[2]=init[2];
    Q.push(flag);
    for(int i=0; i<3; i++)
    {
        char b[15];
        sprintf(b,"%d",flag.candy[i]);
        fl+=b;
    }
    mp[fl]=1;
    if(flag.candy[0]==target[0]&&flag.candy[1]==target[1]&&flag.candy[2]==target[2])
    {
        STEP=flag.step;
        return 1;
    }
    while(!Q.empty())
    {
        flag=Q.front();
        for(int i=1; i<=6; i++)
        {
            state(flag,i);
            if(flag.candy[0]==target[0]&&flag.candy[1]==target[1]&&flag.candy[2]==target[2])
            {
                STEP=flag.step;
                return 1;
            }
            fl="";
            for(int i=0; i<3; i++)
            {
                char b[15];
                sprintf(b,"%d",flag.candy[i]);
                fl+=b;
            }
            if(mp[fl]!=1)
            {
                Q.push(flag);
                mp[fl]=1;
            }
            flag=Q.front();
        }
        Q.pop();
    }
    return 0;
}
int main()
{
    int f,s,t;
    int F,S,T;
    int STEP;
   // freopen("分糖果.in","r",stdin);
    //freopen("分糖果.out","w",stdout);
    while(cin>>f>>s>>t>>F>>S>>T)
    {
        if((f+s+t)!=(F+S+T))
        {
            cout<<"Unfind"<<endl;
            continue;
        }
        queue<ST> Q;
        init[0]=f;
        init[1]=s;
        init[2]=t;
        target[0]=F;
        target[1]=S;
        target[2]=T;
        if(Search(init,target,Q,STEP))
            cout<<STEP<<endl;
        else
            cout<<"Unfind"<<endl;
        mp.clear();
    }
    return 0;
}

Source

icpc7th@ahstu

    #include<iostream>
    #include<queue>
    #include<string>
    #include<map>
    #include<cstdio>
    #include<sstream>
    using namespace std;

    typedef struct
    {
        int step;
        int candy[3];
    } ST;
    map<string,int>mp;
    int init[3];
    int target[3];
    void state(ST &S,int i)
    {
        int f,s,t;
        f=S.candy[0];
        s=S.candy[1];
        t=S.candy[2];
        S.step++;
        switch(i)
        {
        case 1:
            S.candy[0]=f-f/2;
            S.candy[1]=s+f/2;
            break;
        case 2:
            S.candy[0]=f+s/2;
            S.candy[1]=s-s/2;
            break;
        case 3:
            S.candy[0]=f-f/2;
            S.candy[2]=t+f/2;
            break;
        case 4:
            S.candy[0]=f+t/2;
            S.candy[2]=t-t/2;
            break;
        case 5:
            S.candy[1]=s-s/2;
            S.candy[2]=t+s/2;
            break;
        case 6:
            S.candy[1]=s+t/2;
            S.candy[2]=t-t/2;
            break;
        }
    }
    int Search(int *init,int *target,queue<ST> &Q,int &STEP)
    {
        ST flag;
        string fl,l;
        flag.step=0;
        flag.candy[0]=init[0];
        flag.candy[1]=init[1];
        flag.candy[2]=init[2];
        Q.push(flag);
        for(int i=0; i<3; i++)
        {
            char b[15];
            sprintf(b,"%d",flag.candy[i]);
            fl+=b;
        }
        mp[fl]=1;
        if(flag.candy[0]==target[0]&&flag.candy[1]==target[1]&&flag.candy[2]==target[2])
        {
            STEP=flag.step;
            return 1;
        }
        while(!Q.empty())
        {
            flag=Q.front();
            for(int i=1; i<=6; i++)
            {
                state(flag,i);
                if(flag.candy[0]==target[0]&&flag.candy[1]==target[1]&&flag.candy[2]==target[2])
                {
                    STEP=flag.step;
                    return 1;
                }
                fl="";
                for(int i=0; i<3; i++)
                {
                    char b[15];
                    sprintf(b,"%d",flag.candy[i]);
                    fl+=b;
                }
                if(mp[fl]!=1)
                {
                    Q.push(flag);
                    mp[fl]=1;
                }
                flag=Q.front();
            }
            Q.pop();
        }
        return 0;
    }
    int main()
    {
        int f,s,t;
        int F,S,T;
        int STEP;
       // freopen("分糖果.in","r",stdin);
        //freopen("分糖果.out","w",stdout);
        while(cin>>f>>s>>t>>F>>S>>T)
        {
            if((f+s+t)!=(F+S+T))
            {
                cout<<"Unfind"<<endl;
                continue;
            }
            queue<ST> Q;
            init[0]=f;
            init[1]=s;
            init[2]=t;
            target[0]=F;
            target[1]=S;
            target[2]=T;
            if(Search(init,target,Q,STEP))
                cout<<STEP<<endl;
            else
                cout<<"Unfind"<<endl;
            mp.clear();
        }
        return 0;
    }

# 埋炸弹啦~

Time Limit:1000MS Memory Limit:65536K
Total Submit:47 Accepted:18

埋炸弹啦~


Time Limit:1000MS Memory Limit:65536K
Total Submit:47 Accepted:18

Description

小明是独埋弹专家同时为是个数学爱好者,他老是举办埋弹任务时都喜欢数字操纵埋于哪,他会晤选出两只数字然后分别把其转化成八各二前进制数,第一单当横向坐标(从左往右),
其次独当纵向(从上通往生)坐标构成一个8*8底矩阵,而他埋弹的职当然就是横坐标中1之交叉点。请将他挂的职务表示出,炸弹地方用‘+’表示,其他地点用‘-’表示。

Description

小明是个埋弹专家以也是单数学爱好者,他每一回举行埋弹任务时都好数字操纵埋于何,他会选出两独数字然后分别将它们转化成八各二前进制数,第一单当横向坐标(从左往右),
次个当纵向(从高达往下)坐标构成一个8*8底矩阵,而异埋弹的岗位当然就是是反正坐标中1之交叉点。请将他挂的职位表示出,炸弹地方用‘+’表示,其他地点用‘-’表示。

Input

每个输入包含两个测试用例,每个测试用例一行也寡单整数
a,b(0<=a,b<256)为小明所选定的星星点点独数。

Input

每个输入包含两只测试用例,每个测试用例一行也寡独整数
a,b(0<=a,b<256)为小明所选定的鲜单数。

Output

对每个测试用例,输出一个8*8之矩阵,按要求声明炸弹地点。

Output

对每个测试用例,输出一个8*8底矩阵,按要求表明炸弹地点。

Sample Input

9 18

Sample Input

9 18

Sample Output

--------
--------
--------
----+--+
--------
--------
----+--+
--------

Sample Output

--------
--------
--------
----+--+
--------
--------
----+--+
--------

Source

icpc7th@ahstu

#include<iostream>
#include<string>
#include<fstream>
#include<algorithm>
using namespace std;
string X,Y;
int x,y;
void init()
{
    while(x!=0)
    {
        X+=((x%2)+'0');
        x/=2;
    }
    while(y!=0)
    {
        Y+=((y%2)+'0');
        y/=2;
    }
    reverse(X.begin(),X.end());
    reverse(Y.begin(),Y.end());
    int l1=X.size();
    int l2=Y.size();
    for(int i=0;i<8-l1;i++)
        X.insert(X.begin(),'0');
    for(int i=0;i<8-l2;i++)
        Y.insert(Y.begin(),'0');
}
void bomb()
{
    for(int i=0;i<Y.size();i++)
    {
        for(int j=0;j<X.size();j++)
    {
        if(Y[i]=='1'&&X[j]=='1')
            cout<<'+';
        else
            cout<<'-';
    }
    cout<<endl;
    }
}
int main()
{
    //freopen("ÂñÕ¨µ¯À²~.in","r",stdin);
   // freopen("ÂñÕ¨µ¯À²~.out","w",stdout);
    while(cin>>x>>y)
    {
        init();
        bomb();
        X="";
        Y="";
    }
    return 0;
}

Source

icpc7th@ahstu

    #include<iostream>
    #include<string>
    #include<fstream>
    #include<algorithm>
    using namespace std;
    string X,Y;
    int x,y;
    void init()
    {
        while(x!=0)
        {
            X+=((x%2)+'0');
            x/=2;
        }
        while(y!=0)
        {
            Y+=((y%2)+'0');
            y/=2;
        }
        reverse(X.begin(),X.end());
        reverse(Y.begin(),Y.end());
        int l1=X.size();
        int l2=Y.size();
        for(int i=0;i<8-l1;i++)
            X.insert(X.begin(),'0');
        for(int i=0;i<8-l2;i++)
            Y.insert(Y.begin(),'0');
    }
    void bomb()
    {
        for(int i=0;i<Y.size();i++)
        {
            for(int j=0;j<X.size();j++)
        {
            if(Y[i]=='1'&&X[j]=='1')
                cout<<'+';
            else
                cout<<'-';
        }
        cout<<endl;
        }
    }
    int main()
    {
        //freopen("ÂñÕ¨µ¯À²~.in","r",stdin);
       // freopen("ÂñÕ¨µ¯À²~.out","w",stdout);
        while(cin>>x>>y)
        {
            init();
            bomb();
            X="";
            Y="";
        }
        return 0;
    }

# 化学老师的惩罚

Time Limit:1000MS Memory Limit:65536K
Total Submit:0 Accepted:0

化学老师的发落


Time Limit:1000MS Memory Limit:65536K
Total Submit:0 Accepted:0

Description

小明的赛璐珞战表很不同,他的园丁对客恨铁不成钢啊,于是想了一个计——把他拉扯在了一个密室里,出无来无让吃饭。这些把小明急很了。。
小明发现密室的墙上写了多化学方程式中。化学方程式,也号称化学反应方程式,是故化学式表示物质化学反应的姿势。化学方程式反映的凡客观事实。因而书化学方程式要服从五个原则:一是要为客观事实为底蕴;二凡是假如按照质地守恒定律。
化学方程式不仅标志了反应物、生成物和反馈条件。同时,化学计量数代表了各级反应物、生成物物质的量关系,通过相对分子质地或相对原子质地还足以代表各物质中的色关系,即每物质中的成色相比较。对于气体反应物、生成物,还好直接通过化学计量数得出体积比。例如:2NaOH+H2SO4=Na2SO4+2H2O
透过一再试探、推理,小明发现密码是4各项数字,就藏在化学方程式等号晚底首先个分子中,其分子量就可能是密码(若分子量不足4位,前边加0)。

吓当小明还记得墙上各化学方程式用到的化学元素的原子量如下:

N | C | O | Cl | S | H | Al | Ca | Zn | Na | B | Ni

14 | 12 | 16 | 35 | 32 | 2 | 27 | 40 | 65 | 23 | 11 | 59

君会协理小明尽快找到密码也?

Description

小明的赛璐珞战表万分不同,他的导师对客恨铁不成钢啊,于是想了一个术——把他关在了一个密室里,出无来无受吃饭。这个把小明急很了。。
小明发现密室的墙上写了过多化学方程式中。化学方程式,也叫化学反应方程式,是故化学式表示物质化学反应的相。化学方程式反映的是客观事实。由此书化学方程式要听从两单标准:一凡须以客观事实为底蕴;二是倘使严守质地守恒定律。
化学方程式不仅标志了反应物、生成物和反馈条件。同时,化学计量数代表了各级反应物、生成物物质的量关系,通过相对分子质地或相对原子质地仍可以象征各物质中的质地关系,即每物质中的质比。对于气体反应物、生成物,还好直接通过化学计量数得出体积比。例如:2NaOH+H2SO4=Na2SO4+2H2O
透过反复试探、推理,小明发现密码是4员数字,就藏于化学方程式等号晚底第一单成员被,其分子量就可能是密码(若分子量不足4各种,前边加0)。

哼当小明还记得墙上各化学方程式用到之化学元素的原子量如下:

N | C | O | Cl | S | H | Al | Ca | Zn | Na | B | Ni

14 | 12 | 16 | 35 | 32 | 2 | 27 | 40 | 65 | 23 | 11 | 59

卿可知支援小明尽快找到密码为?

Input

输入包含多组测试用例。
每个测试用例 第一执: K,表示出K个化学方程式;
属下有K行,每行为一个化学方程式

Input

输入包含多组测试用例。
每个测试用例 第一履行: K,表示出K个化学方程式;
联网下去有K行,每行为一个化学方程式

Output

对于每个化学方程式输出一行:即密码。

Output

于每个化学方程式输出一行:即密码。

Sample Input

2
2C+O2=2CO
Ca2CO3+H2O=Ca2(OH)2+CO2

Sample Input

2
2C+O2=2CO
Ca2CO3+H2O=Ca2(OH)2+CO2

Sample Output

0056
0116

Sample Output

0056
0116

Source

icpc7th@ahstu

#include<iostream>
#include<string>
#include<algorithm>
#include<iterator>
#include<vector>
#include<map>
#include<cstdlib>
#include<cstdio>
#include<fstream>
using namespace std;
map<string,int>mp;
vector<string>sp;
vector<string>sp_num;
string total;
void init()
{
    mp["Na"]=23;mp["Zn"]=65;
    mp["Ca"]=40;mp["Al"]=27;
    mp["H"]=2;  mp["S"]=32;
    mp["Cl"]=35;mp["O"]=16;
    mp["C"]=12; mp["N"]=14;
     mp["B"]=11; mp["Ni"]=59;
}
int calculate(string B)
{
    int sum=0;
    for(int i=0; i<B.size(); i++)
    {
        string flag;
        flag+=B[i];
        flag+=B[i+1];
        if(mp[flag]!=0)
        {
            int f=i+2;
            string n;
            while(isdigit(B[f]))
            {
                n+=B[f];
                f++;
            }
            if(n=="")
                n="1";
            i=(--f);
            sum+=mp[flag]*atoi(n.c_str());
        }
        else
        {
            int l=i+1;
            string n;
            while(isdigit(B[l]))
            {
                n+=B[l];
                l++;
            }
            if(n=="")
                n="1";
            string K;
            K+=B[i];
            sum+=mp[K]*atoi(n.c_str());
            i=(--l);
        }
    }
    return sum;
}
int T_calculate()
{
    int S=0;
    for(int i=0; i<sp.size(); i++)
    {
        S+=calculate(sp[i])*(atoi(sp_num[i].c_str()));
    }
    return S*atoi(total.c_str());
}
void Find(string A)
{
    string B;
    string::iterator it;
    for(it=(find(A.begin(),A.end(),'=')+1); it!=A.end(); it++)
    {
        if(*it=='+')
            break;
        B+=(*it);
    }
    while(isdigit(B[0]))
    {
        total+=B[0];
        B.erase(B.begin());
    }
    if(total=="")
        total="1";
    string flag;
    int o=3;
    while(!B.empty())
    {
        if(o==0)
            while(1);
        o--;
        if(B[0]=='(')
        {
            string::iterator it,it1;
            string F;
            it=find(B.begin(),B.end(),')');
            F.assign(B.begin()+1,it);
            sp.push_back(F);
            F="";
            it1=(++it);
            while(isdigit((*it))&&it!=B.end())
            {
                F+=*it;
                it++;
            }
            if(F=="")
                sp_num.push_back("1");
            else
                sp_num.push_back(F);
            B.erase(B.begin(),(it));
        }
        else
        {
            string flag;
            string::iterator it=(find(B.begin(),B.end(),'('));
            flag.assign(B.begin(),(it));
            sp.push_back(flag);
            B.erase(B.begin(),(it));
            sp_num.push_back("1");
        }
    }
}
int main()
{
    //freopen("化学老师的惩罚.in","r",stdin);
    //freopen("化学老师的惩罚.out","w",stdout);
    int N;
    init();
    while(cin>>N)
    {
    while(N--)
    {
        string A;
        cin>>A;
        Find(A);
        printf("%04d\n",T_calculate());
        sp.clear();
        sp_num.clear();
        total="";
    }
    }
    return 0;
}

Source

icpc7th@ahstu

    #include<iostream>
    #include<string>
    #include<algorithm>
    #include<iterator>
    #include<vector>
    #include<map>
    #include<cstdlib>
    #include<cstdio>
    #include<fstream>
    using namespace std;
    map<string,int>mp;
    vector<string>sp;
    vector<string>sp_num;
    string total;
    void init()
    {
        mp["Na"]=23;mp["Zn"]=65;
        mp["Ca"]=40;mp["Al"]=27;
        mp["H"]=2;  mp["S"]=32;
        mp["Cl"]=35;mp["O"]=16;
        mp["C"]=12; mp["N"]=14;
         mp["B"]=11; mp["Ni"]=59;
    }
    int calculate(string B)
    {
        int sum=0;
        for(int i=0; i<B.size(); i++)
        {
            string flag;
            flag+=B[i];
            flag+=B[i+1];
            if(mp[flag]!=0)
            {
                int f=i+2;
                string n;
                while(isdigit(B[f]))
                {
                    n+=B[f];
                    f++;
                }
                if(n=="")
                    n="1";
                i=(--f);
                sum+=mp[flag]*atoi(n.c_str());
            }
            else
            {
                int l=i+1;
                string n;
                while(isdigit(B[l]))
                {
                    n+=B[l];
                    l++;
                }
                if(n=="")
                    n="1";
                string K;
                K+=B[i];
                sum+=mp[K]*atoi(n.c_str());
                i=(--l);
            }
        }
        return sum;
    }
    int T_calculate()
    {
        int S=0;
        for(int i=0; i<sp.size(); i++)
        {
            S+=calculate(sp[i])*(atoi(sp_num[i].c_str()));
        }
        return S*atoi(total.c_str());
    }
    void Find(string A)
    {
        string B;
        string::iterator it;
        for(it=(find(A.begin(),A.end(),'=')+1); it!=A.end(); it++)
        {
            if(*it=='+')
                break;
            B+=(*it);
        }
        while(isdigit(B[0]))
        {
            total+=B[0];
            B.erase(B.begin());
        }
        if(total=="")
            total="1";
        string flag;
        int o=3;
        while(!B.empty())
        {
            if(o==0)
                while(1);
            o--;
            if(B[0]=='(')
            {
                string::iterator it,it1;
                string F;
                it=find(B.begin(),B.end(),')');
                F.assign(B.begin()+1,it);
                sp.push_back(F);
                F="";
                it1=(++it);
                while(isdigit((*it))&&it!=B.end())
                {
                    F+=*it;
                    it++;
                }
                if(F=="")
                    sp_num.push_back("1");
                else
                    sp_num.push_back(F);
                B.erase(B.begin(),(it));
            }
            else
            {
                string flag;
                string::iterator it=(find(B.begin(),B.end(),'('));
                flag.assign(B.begin(),(it));
                sp.push_back(flag);
                B.erase(B.begin(),(it));
                sp_num.push_back("1");
            }
        }
    }
    int main()
    {
        //freopen("化学老师的惩罚.in","r",stdin);
        //freopen("化学老师的惩罚.out","w",stdout);
        int N;
        init();
        while(cin>>N)
        {
        while(N--)
        {
            string A;
            cin>>A;
            Find(A);
            printf("%04d\n",T_calculate());
            sp.clear();
            sp_num.clear();
            total="";
        }
        }
        return 0;
    }

# 水题!

Time Limit:1000MS Memory Limit:65536K
Total Submit:116 Accepted:44

水题!


Time Limit:1000MS Memory Limit:65536K
Total Submit:116 Accepted:44

Description

海高H,水高h,杯顶半径R,杯底半径r,求水的体积。(Pi=3.1415926)

Description

海高H,水高h,杯顶半径R,杯底半径r,求水的体积。(Pi=3.1415926)

Input

H R r h

Input

H R r h

Output

番的体积

Output

趟的体积

Sample Input

10 8 7 4

Sample Input

10 8 7 4

Sample Output

855.56

Sample Output

855.56

Hint

圆台计算公式V=1/3*Pi*h*(R^2+r^2+R*r)

Hint

圆台计算公式V=1/3*Pi*h*(R^2+r^2+R*r)

Source

icpcth7@ahstu

得奖名单

图片 1

Source

icpcth7@ahstu

相关文章