题目1：购物单

标题： 购物单
小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
**** 180.90 88折
**** 10.25 65折
**** 56.14 9折
**** 104.65 9折
**** 100.30 88折
**** 297.15 半价
**** 26.75 65折
**** 130.62 半价
**** 240.28 58折
**** 270.62 8折
**** 115.87 88折
**** 247.34 95折
**** 73.21 9折
**** 101.00 半价
**** 79.54 半价
**** 278.44 7折
**** 199.26 半价
**** 12.97 9折
**** 166.30 78折
**** 125.50 58折
**** 84.98 9折
**** 113.35 68折
**** 166.57 半价
**** 42.56 9折
**** 81.90 95折
**** 131.78 8折
**** 255.89 78折
**** 109.17 9折
**** 146.69 68折
**** 139.33 65折
**** 141.16 78折
**** 154.74 8折
**** 59.42 8折
**** 85.44 68折
**** 293.70 88折
**** 261.79 65折
**** 11.30 88折
**** 268.27 58折
**** 128.29 88折
**** 251.03 8折
**** 208.39 75折
**** 128.88 75折
**** 62.06 9折
**** 225.87 75折
**** 12.89 75折
**** 34.28 75折
**** 62.16 58折
**** 129.12 半价
**** 218.37 半价
**** 289.69 8折
解法：Excel； 结果：5200

题目2：等差素数列

2,3,5,7,11,13,....是素数序列。
类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。
2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。
这是数论领域一项惊人的成果！
有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：
长度为10的等差素数列，其公差最小值是多少？

注意：需要提交的是一个整数，不要填写任何多余的内容和说明文字。
答案：210

//暴力枚举
#include <bits/stdc++.h>
using namespace std;

bool isPrime(long k)
{
    int n=sqrt(k);

    if(k<2){
        return false;
    }
    else{
        for(int i=2;i<=n;i++){
            if(k%i==0){
                return false;
            }
        }
    }
    return true;
}
int main()
{
    //生成一个等差数列，判断其中的每一个数是不是素数
    for(long i=1;i<=10000;i++){//枚举素数
        for(int j=1;j<=10000;j++){//枚举公差
            if(isPrime(i)&&isPrime(i+j)&&isPrime(i+2*j)&&isPrime(i+3*j)&&isPrime(i+4*j)
               &&isPrime(i+5*j)&&isPrime(i+6*j)&&isPrime(i+7*j)&&isPrime(i+8*j)&&isPrime(i+9*j)){
                cout<<j<<endl;
                break;
            }
        }
    }
    return 0;
}

题目3：承压计算

标题：承压计算

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X
其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：2086458231

请你推算出：读数最大的电子秤的示数为多少？

注意：需要提交的是一个整数，不要填写任何多余的内容。
答案：72665192664

//想要直接用高精度除法-可以去使用java
//为了防止丢失精度，先对数据进行扩大倍数-扩大2的n次方倍
#include <bits/stdc++.h>
using namespace std;
long long arr[30][30];
int main()
{
    long long factor=1;
    for(int m=0;m<30;m++){
        factor<<=1;//左移一位相当于乘以2
    }
    cout<<factor<<endl;
    for(int i=0;i<29;i++){
        for(int j=0;j<=i;j++){
            int a=0;
            scanf("%d",&a);
            arr[i][j]=a*factor;
        }
    }
    //数据准备好了
    for(int i=1;i<30;i++)
    {
        for(int j=0;j<=i;j++)
        {
            if(j==0)
                arr[i][j]+=arr[i-1][j]/2;
            else if(i==j)
                arr[i][j]+=arr[i-1][j-1]/2;
            else
                arr[i][j]+=arr[i-1][j]/2+arr[i-1][j-1]/2;
        }
    }
    sort(arr[29],arr[29]+30);//最后一行30个数
    cout<<arr[29][0]<<endl;
    cout<<arr[29][29]<<endl;
    //观察输出的最小值和2086458231的倍数关系
    cout<<arr[29][0]/2<<endl;
    cout<<arr[29][29]/2<<endl;
    return 0;
}

附：Java解法：

public class Test3 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        //为什么要用double类型这里要注意
        double max=0;
        double min=100000;
        double[][] array=new double[30][30];
        for(int i=0;i<29;i++){
            for(int j=0;j<=i;j++){
                array[i][j]=sc.nextInt();
            }
        }
        for(int i=1;i<30;i++){
            for(int j=0;j<=i;j++){
                if(j==0){
                    array[i][j]+=array[i-1][j]/2;//要用double类型
                }else{
                    array[i][j]+=array[i-1][j-1]/2+array[i-1][j]/2;
                }
            }
        }
        for(int i=0;i<30;i++){//最后一行有30个数
            System.out.println(array[29][i]);
            max=Math.max(max, array[29][i]);
            min=Math.min(min, array[29][i]);        
        }
        System.out.println(max);
        System.out.println(min);
        System.out.println((long)((2086458231l/min)*max));

    }

}

题目4：方格分割

6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
请提交该整数，不要填写任何多余的内容或说明文字。

#include <bits/stdc++.h>
using namespace std;
int ans=0;
int dire[4][2]={-1,0,1,0,0,-1,0,1};
/*
定义二维数组的时候，行可以是空值，但是列不可以为空值
这样代表有n列，当存入了n个数据后会自动换行。
*/
int vis[7][7];//标志哪些点已经被访问

void dfs(int x,int y){
    if(x==0 || y==0 || x==6 || y==6){
        ans++;
        return;
    }
    for(int k=0;k<4;k++){//四个方向
        int nx=x+dire[k][0];
        int ny=y+dire[k][1];
        //新坐标准备好了
        if(nx<0 || nx>6 || ny<0 || ny>6)
            continue;
        if(!vis[nx][ny]){//0表示假，1表示真，!0-表示新的坐标点没有被访问
            vis[nx][ny]=1;//当前的点标注为已访问
            vis[6-nx][6-ny]=1;//对称点也标注为已访问
            dfs(nx,ny);
            //进行回溯
            vis[nx][ny]=0;
            vis[6-nx][6-ny]=0;
        }
    }
}

int main(){
     vis[3][3]=1;//中心点（初始访问点）标志为1
     dfs(3,3);
     cout<<(ans/4)<<endl;
    return 0;
}

题目5：取数位

求1个整数的第k位数字有很多种方法。
以下的方法就是一种。
注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。

#include <bits/stdc++.h>
using namespace std;
// 求x用10进制表示时的数位长度
int len(int x){
    if(x<10) return 1;
    return len(x/10)+1;
}
// 取x的第k位数字
int f(int x, int k){
    if(len(x)-k==0) return x%10;
    //return _____________________;  //填空
    return f(x/10,k);
}
int main()
{
    int x = 124567;
    printf("%d\n", f(x,3));
    return 0;
}

题目6：最大公共子串

最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如："abcdkkk" 和 "baabcdadabc"，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码

#include <stdio.h>
#include <string.h>
#define N 256
int f(const char* s1, const char* s2)
{
    int a[N][N];
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int i,j;
    memset(a,0,sizeof(int)*N*N);
    int max = 0;
    for(i=1; i<=len1; i++){
        for(j=1; j<=len2; j++){
            if(s1[i-1]==s2[j-1]) {
                //a[i][j] = __________________________;  //填空
                a[i][j]=a[i-1][j-1]+1;
                if(a[i][j] > max) max = a[i][j];
            }
        }
    }

    return max;
}
int main()
{
    printf("%d\n", f("abckkk", "baabcdadabc"));
    return 0;
}