第四届“图灵杯”NEUQ-ACM 程序设计竞赛(团队赛)

问题 A: 谷神的赌博游戏

题目描述
NEUQ的谷神要和我赌一个游戏：谷神要求我随机在纸上写出整数集合{1,2,3，…,3n+1}（n是整数）的一个排列（即不重复的随机写出从1到3n+1的所有整数）。并且要求在我写的过程中，从我写的第一个数开始一直加到我正在写的数的总和不被3整除。如果我能写出来符合要求的一个排列，那么我就赢得游戏。那么问题来了，我赢得游戏的概率是多少？

输入
一组测试数据，第一行输入测试样例的数目k，接下来k行每行一个正整数n代表一个样例（1<=n<=15）。

输出
对于每个样例数据依次输出我赢得比赛的概率（结果保留小数点后9位有效数字）。

样例输入
1
1
样例输出
0.250000000
提示
例如n=1，则谷神要求我随机写1到4的排列，如果我按顺序写1 3 4 2则是合法的，因为1，1+3、1+3+4、1+3+4+2都不被3整除。如果我按顺序写1 2 3 4则是不合法的，因为当我写到2的时候1+2=3可以被3整除，不符合游戏规定。

这道题刚上来思路是对的，式子推半天没推出来，后来发现是0的位置的问题
因为要问加起来的这个数能不能被3整除，所以我们可以直接把所有数想成0，1，2，0一共有i个，1一共有i+1个，2一共有i个，所以问题放在了如何排列这道题上
我们先排1：一共有i！种
然后排2：因为最后的0不会影响最后的加法，所以你可以试一试2可以放在那些位置，最后发现只能摆成 1 1 2 1 2 1 2这种的形式，所以2一共有（i+1）！种
最后排0：刚开始0可以放到（2i+1）个地方（第一个位置不可以放！），然后第二个0可以放到（2i+2）个地方，一共有i个，所以一共可以放到3i个地方
所以最后的式子就变成了i！＊（i+1）！＊（2i+1）＊（2i+2）…＊3i/（3i+1）！
附上AC代码：

#include<bits/stdc++.h>
using namespace std;
using LL=int64_t;
const int INF=0x3f3f3f3f;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int T;
    cin>>T;
    for(int i=0;i<T;i++) {
        int temp;
        double sum=1;
        cin>>temp;
        for(int i=1;i<=temp;i++) sum*=(double)i;
        for(int i=temp+2;i<=temp*2;i++) sum/=(double)i;
        sum/=(double)(3*temp+1);
        cout<<fixed << setprecision(9) << sum<<endl;
    }
    return 0;
}

问题 B: 一个简单的问题

题目描述
实验班最近在准备购置新的书籍。现在统计出了一份有十本书的书单，但是由于预算有限，必须删掉一本书。大家讨论决定把价格第三高的书删掉，请你找出这本书。

输入
第一行是一个整数T（1<=T<=1000），表示有T组数据。接下来的T行，每行有十一个整数，第一个整数表示这是第几组输入数据，接下来的十个整数表示你要处理的十本书的价格。每组数据用空格分隔，书的价格不超过1000。

输出
对每组输入数据，输出它的组号和第三高的价格，用空格分隔。

样例输入
3
1 1 2 3 4 5 6 7 8 9 10
2 931 240 986 894 826 640 965 833 136 138
3 940 955 364 188 133 254 501 122 768 408
样例输出
1 8
2 931
3 768

AC代码：

#include<bits/stdc++.h>
using namespace std;
using LL=int64_t;
const int INF=0x3f3f3f3f;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n,x;
    cin>>n;
    for(int i=1;i<=n;i++) {
        int ans[10];
        cin>>x;
        for(int j=0;j<10;j++)
            cin>>ans[j];
        sort(ans,ans+10);
        cout<<i<<" "<<ans[7]<<endl;
    }
    return 0;
}

问题 C: 来简单地数个数

题目描述
这是一个斐波那契数列：
f1 = 1
f2 = 2
fn = fn-1 + fn-2 (n>=3)
蔡老板想知道，给你两个数a、b，你能否求出在区间[a,b]里有多少个斐波那契数。

输入
多组数据输入。一行为一组输入数据，包括两个非负整数a、b（a <= b <= 10^100），当a=b=0时输入终止。

输出
对每组输入，输出单独一行，包含一个整数表示区间[a,b]里的斐波那契数个数。

样例输入
10 100
1234567890 9876543210
0 0
样例输出
5
4

这道题调试了好久，最后终于调出来了，就是判断a,b的时候a和b有一个可能为0，我想的方法是先把前1000个斐波那契写出来然后判断，写斐波那契确实费了一些时间，还有关于范围的确定也确实好费事
附上AC代码：

#include<bits/stdc++.h>
using namespace std;
using LL=int64_t;
const int INF=0x3f3f3f3f;
const int num=1005;

int fib[num][105];
int temp[num][105];
int length[num];
void init()
{
    memset(temp,0,sizeof(temp));
    memset(fib,0,sizeof(fib));
    temp[0][0]=fib[0][0]=1,temp[1][0]=fib[1][0]=1;
    length[0]=0;length[1]=0,length[2]=0;
    for(int i=2;i<num;i++) {
        for(int j=0;j<105;j++) {
            temp[i][j]+=temp[i-1][j]+temp[i-2][j];
            if(temp[i][j]>=10) {
                temp[i][j]-=10;
                temp[i][j+1]++;
            }
        }
        for(int j=104;j>=0;j--)
            if(temp[i][j]>0) {
                length[i]=j;
                break;
            }
        for(int j=length[i];j>=0;j--)
            fib[i][length[i]-j]=temp[i][j];
    }
}

bool compear1(string x,int n) {
    if(x.length()<length[n]+1) return true;
    if(x.length()>length[n]+1) return false;
    for(int i=0;i<x.length();i++) {
        if(fib[n][i]>x[i]-'0') return true;
        if(fib[n][i]<x[i]-'0') return false;
    }
    return true;
}

bool compear2(string x,int n) {
    if(x.length()>length[n]+1) return true;
    if(x.length()<length[n]+1) return false;
    for(int i=0;i<x.length();i++) {
        if(fib[n][i]<x[i]-'0') return true;
        if(fib[n][i]>x[i]-'0') return false;
    }
    return true;
}

int main()
{
    init();
    ios::sync_with_stdio(0);
    cin.tie(0);
    string a,b;
    while(cin>>a>>b) {
        if(a=="0"&&b=="0") break;
        int temp1=0,temp2=0;
        for(int i=1;i<num;i++) {
            if(compear1(a,i)) {
                temp1=i;break;
            }
        }
        for(int i=num-1;i>=1;i--) {
            if(compear2(b,i)) {
                temp2=i;break;
            }
        }
        cout<<temp2-temp1+1<<endl;
    }
    return 0;
}

下面是标程：

/*
先算前480个fibs，然后二分确定a和b数列fibs里的位置，ab两位置求个差值，就可以得到他们中间包含的fibs个数。
a和b也是fibs的情况特判一下。
*/

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

#define MAXN    500
#define MAXLEN  110
#define LAST MAXLEN-2

char store[MAXN][MAXLEN];
char *Fibs[MAXN];

char* IntAddition(char *a,char *b,char *sum){
    int i,j,k,first;
    for(i=strlen(a)-1,j=LAST;i>=0;i--,j--){
        sum[j]=a[i]-'0';
        }
    for(i=strlen(b)-1,k=LAST;i>=0;i--,k--){
        sum[k]+=b[i]-'0';
        }
    first=j<k?j:k;
    for(i=LAST;i>=first;i--){
        sum[i-1]+=sum[i]/10;
        sum[i]=sum[i]%10+'0';
        }
    while(sum[first]=='0'&&first<LAST){
        first++;
        }
    return &sum[first];
    }

void Fibonacci(void){
    memset(store,0,sizeof(store));
    memset(Fibs,NULL,sizeof(Fibs));

    strcpy(store[1],"1");
    strcpy(store[2],"2");
    Fibs[1]=store[1];
    Fibs[2]=store[2];

    int i;
    for(i=3;i<485;i++){
        Fibs[i]=IntAddition(Fibs[i-2],Fibs[i-1],store[i]);
        }
    }

int Compare(char *a,char *b){
    int lenA=strlen(a);
    int lenB=strlen(b);
    if(lenA==lenB)
        return strcmp(a,b);
    return lenA>lenB?1:-1;
    }

int BinarySearch(char *num,bool &flag){
    int low=1;
    int high=480;   
    while(low<=high){
        int mid=(low+high)/2;
        int res=Compare(num,Fibs[mid]);
        if(res==0){
            flag=true;
            return mid;
            }
        else if(res<0)
            high=mid-1;
        else
            low=mid+1;
        }
    return low;
    }

int main(){
    Fibonacci();
    char a[MAXLEN],b[MAXLEN];
    while(scanf("%s %s",a,b)!=EOF){
        if(strcmp(a,"0")==0&&strcmp(b,"0")==0){
            break;
            }
        bool flagLeft=false;
        bool flagRight=false;
        int left=BinarySearch(a,flagLeft);
        int right=BinarySearch(b,flagRight);
        if (flagRight)
            printf("%d\n",right-left+1);
        else
            printf("%d\n",right-left);
        }
    return 0;
    }

问题 D: 简单的图形输出

题目描述
谢尔宾斯基三角形是一种分形，它的构造过程是这样的：
1.取一个实心的三角形。（多数使用等边三角形）
2.沿三边中点的连线，将它分成四个小三角形。
3.去掉中间的那一个小三角形。
4.对其余三个小三角形重复1。
我们想尝试用斜线、反斜线和下划线画出谢尔宾斯基三角，假设最小的三角是长这样的：
/\
/__\
具体规律详见样例。
输入
多组数据输入输出。每行有一个整数n（1<=n<=10），表示执行了一次操作1，n=0时结束输入。

输出
画出执行n次操作1后的图形，调整你的输出到最左端（底边的第一个斜杠在第一列）。输出不能包含任何尾随空格。在每个测试用例后打印空行。

样例输入
3
2
1
0
样例输出
/\
/__\
/\ /\
/\/\
/\ /\
/\ /\
/\ /\ /\ /\
/\/\/\/\

/\
/__\
/\ /\
/\/\

/\
/__\

递归题，标程代码：

//递归
#include <cstdio>
#include <cstring>
#define N 2050
using namespace std;
int n;
char s[N/2][N];

void print(int x,int y,int d){
    int offset=1<<(d-1);
    if(d==1){
        s[x][y]=s[x+1][y-1]='/';
        s[x][y+1]=s[x+1][y+2]='\\';
        s[x+1][y]=s[x+1][y+1]='_';
        return ;
        }
    print(x,y,d-1);
    print(x+offset, y-offset, d-1);
    print(x+offset, y+offset, d-1);
    }

int main(){
    while(scanf("%d",&n) && n){
        int i,j,k;
        for(i=1;i<=(1<<n);i++)
            for(j=1;j<=(1<<(n+1));j++)
                s[i][j]=' ';
        print(1,(1<<n),n);
        k=(1<<n)+1;
        for(i=1;i<=(1<<n);i++,k++){
            for(j=1;j<=k;j++)
                putchar(s[i][j]);
            printf("\n");
            }
        printf("\n");
        }
    return 0;
    }

问题 G: 那么大奶牛之神

题目描述
那么大奶牛之神把一个神秘数字通过信使传递给了奶牛们，但由于信件上出现了偏差，一个数字变成了两个数字,现在你需要通过这两个数字还原出大么大奶牛之神给的神秘数字。需要用第二个数字通过加(+)，减(-)，乘(*)，除(/)，次幂(^)，阶乘(!)，开平方(√)这几个符号凑出第一个数字。使用第二个数字的次数最少的时候，那么使用次数就是神秘数字。

例如第一个数字是300，第二个数字是7，那么7用得最少是6次，所以神秘数字是6。具体方法如图用了6个7。虽然最优解的算式不是唯一的，但是并不妨碍得到最少的使用次数。

现在得知第一个数字是51，第二个数字是整数n(0< n< 10)，求神秘数字。

输入
输入n(0< n<10)

输出
输出神秘数字

样例输入
1
样例输出
8
传说中的真正防AK题，出奇的脑洞，官方题解是找规律…..

51#1最优解1+（111-11）／（1+1）
51#2最优解2+2/2+2*（2*2）！
51#3最优解3!*3+33
51#4最优解4!*(√4+√√√(√4^(-4!)))
51#5最优解5/5+55-5
51#6最优解(6!-6*6)/(6+6)-6
51#7最优解7*7+(7+7)/7
51#8最优解√√(8+8)+√(√(8-8/8)^8)
51#9最优解(√9)!*9-√9
51的9个最优解是864456563

标程：

#include<iostream>
using namespace std;
int main()
{
    int n,a[10]={0,8,6,4,4,5,6,5,6,3};
    while (cin >> n){
        cout << a[n] << endl;
    }
    return 0;
}

问题 I: 一道不简单的题目

题目描述
这是一道拼手速的题！

你在跟acmclub机器人对话。对它说：“Is this NEUQ？”，它会回答你：“Yes, welcome to NEUQ.”。对它说：“I have some question!”，它会回复：“What can I do for you?”。

输入
输入为一句话。

输出
输出也为一句话。

样例输入
Is this NEUQ？
样例输出
Yes, welcome to NEUQ.

注意第一句Is this NEUQ？的问号是中文问号
AC代码：

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

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    string q;
    getline(cin,q);
    if(q=="Is this NEUQ£¿") cout<<"Yes, welcome to NEUQ."<<endl;
    if(q=="I have some question!") cout<<"What can I do for you?"<<endl;
    return 0;
}

问题 J: 简单的变位词

题目描述
变位词是指改变某个词的字母顺序后构成的新词。蔡老板最近沉迷研究变位词并给你扔了一道题：

给你一些单词，让你把里面的变位词分组找出来。互为变位词的归为一组，最后输出含有变位词最多的前五组。如果有组数相同的按照字典序输出。

输入
输入包含由小写字母组成的单词，用换行分割，被EOF终止。 输入数据不超过30000个单词。

输出
输出五组包含单词数量最多的变位词，如果少于五组，输出全部。对每组输出，写出它的大小和成员词，成员词按字典序排序用空格分隔，每组输出之间用换行分隔，相同词只输出一次，但算个数。

样例输入
neuq
tea
bate
beat
caret
trace
nueq
carte
cater
crate
abet
ate
eat
beta
eta
signal
样例输出
Group of size 5: caret carte cater crate trace .
Group of size 4: abet bate beat beta .
Group of size 4: ate eat eta tea .
Group of size 2: neuq nueq .
Group of size 1: signal .

这道题写了一中午+半下午，其实最主要的就是要灵活运用STL中的各种容器，这道题我的思路就是首先一个map< key,value>第一个key是按字典序排好的，第二个是一个set用来储存字典序相同的string，然后再用一个map< key,value>用来保存按字典序排好的string对应的数量，然后找到数量最多的，如果数量相同，就在比较字典序最后输出

附上AC代码：

#include<bits/stdc++.h>
using namespace std;
map<string,set<string> >ans;
map<string,int>cnt;
map<string,int>::iterator is;
set<string>::iterator its;
int main()
{
    string x;
    while(cin>>x) {
        string temps=x;
        sort(x.begin(),x.end());
        ans[x].insert(temps);
        cnt[x]++;
    }
       string max_temp;
        int time=0;
        while(time<5&&ans.size()) {
        int maxn=0;
        for(is=cnt.begin();is!=cnt.end();is++) {
            if(is->second > maxn) {maxn=is->second;max_temp=is->first;}
            else if(is->second==maxn) {
            if(*ans[is->first].begin()<*ans[max_temp].begin())
                    max_temp=is->first;
            }
          }
        cout<<"Group of size "<<maxn<<": ";
        for(its=ans[max_temp].begin();its!=ans[max_temp].end();its++) {
            cout<<*its<<" ";
        }
        cout<<"."<<endl;
        time++;
        ans.erase(max_temp);
        cnt.erase(max_temp);
      }
    return 0;
}

下面附上标程：

/*
所有字符串统计字符后hash，排完序就确定每组的个数、确定一组中字典序最小的字符串。
再根据个数以和字符串对组进行排序。
*/

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

const int maxn=30005;
const int maxm=30;
const int X=30;
typedef unsigned long long ll;
typedef pair<ll,int> pii;

int N,M,E;
vector<pii> vec,grop;
vector<int> g[maxn];
char word[maxn][maxm],st[maxn][maxm];

inline ll Hash(char* s){
    int len=strlen(s),c[maxm];
    memset(c,0,sizeof(c));
    for(int i=0;i<len;i++)
        c[s[i]-'a']++;
    ll ret=0;
    for(int i=0;i<26;i++)
        ret=ret*X+c[i];
    return ret;
    }

inline bool cmp (const pii& a,const pii& b){
    if(a.second==b.second)
        return strcmp(st[a.first],st[b.first])<0;
    return a.second>b.second;
    }

inline bool sort_by(const int& a,const int& b){
    return strcmp(word[a],word[b])<0;
    }

int main(){
    N=M=E=0;
    vec.clear();
    grop.clear();
    while(scanf("%s",word[N])==1){
        ll key=Hash(word[N]);
        vec.push_back(make_pair(key,N));
        N++;
        }
    sort(vec.begin(),vec.end());
    int cnt=0;
    ll pre=-1;
    for(int i=0;i<vec.size();i++){
        int idx=vec[i].second;
        if(vec[i].first!=pre){
            if(cnt)
                grop.push_back(make_pair(M++,cnt));
            cnt=0;
            g[M].clear();
            pre=vec[i].first;
            strcpy(st[M],word[idx]);
            }
        cnt++;
        g[M].push_back(idx);
        if (strcmp(word[idx],st[M])<0)
            strcpy(st[M],word[idx]);
        }
    if (cnt)
        grop.push_back(make_pair(M++,cnt));
    sort(grop.begin(),grop.end(),cmp);

    for(int i=0;i<min(5,(int)grop.size());i++){
        printf("Group of size %d: ",grop[i].second);
        int x=grop[i].first;
        sort(g[x].begin(),g[x].end(),sort_by);
        for (int j=0;j<g[x].size();j++){
            if (j==0||strcmp(word[g[x][j-1]],word[g[x][j]]))
                printf("%s ",word[g[x][j]]);
            }
        printf(".\n");
        }
    return 0;
    }