2017蓝桥杯

整理这篇博客呢，是因为蓝桥杯临近，所以看了一下去年的赛题，去年大一没有参加蓝桥杯，所以这些题目是从别人的博客中看到的，搜集过来整理一篇自己的笔记，第一次要参加蓝桥杯，内心有点小惊喜，伴随而来的，还有些许小紧张~ 

因为没有找到可以提交题目的网站，所以代码中若出先错误，还望谅解与指出。

第一题 购物清单

小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。

这不，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折
--------------------

需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。

请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。


特别提醒：不许携带计算器入场，也不能打开手机。

分析：

去年参加过的人有的说这题恶心，有的说这题容易，感觉容易的人自然有方法，Excel表格计算是一种方法，但我看见有很多人用文件输入的方法，看起来更简单，但是，如果两种方法都不会的话，手算真的确实非常恶心。

5200

第二题 等差素数列

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

等差素数列，其公差最小值是多少？

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

分析：

本题虽然是填空题，但是手算的数据量太大，还需要借助于代码来实现。我们可以先将一定的范围内的不是素数的数标记出来，然后遍历将没有标记的素数从 1 到一个稍微大点的范围内判断一遍，看时候能找到 10 个符合条件的素数，因为题中并未明确给出数据的范围，很多地方需要我们假设。

210

#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

int s[100000000];

bool judge(int p,int q)///找从素数p开始，以q为公差，是否能找到符合条件的10个素数
{
    for(int i=1;i<10;i++)
    {
        p+=q;
        if(s[p])
            return false;
    }
    return true;
}

int main()
{
    for(int i=2;i<=10000;i++)///双重for循环将100000000内的虽有不是素数的数标记出来
        for(int j=i*i;j<=100000000;j+=i)
            s[j]=1;
            
    for(int i=2;i<=10000;i++)///随意整个范围遍历数组s
    {
        if(s[i])
            continue;
        for(int j=1;j<=1000;j++)///如果i是素数，就设定个范围找是否能以j作为公差，找出10个素数序列
        {
            if(judge(i,j))
                printf("%d\n",j);
        }
    }
    return 0;
}

第三题 承压计算

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 X X 


其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。


假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。


工作人员发现，其中读数最小的电子秤的示数为：2086458231


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

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

分析：

这题我一开始读题不仔细，总是搞不清，很迷糊，然后专心仔细的看了看题意，明白了，读题不仔细这个毛病不是第一次了，无数次的看不懂题意，就是因为读题不仔细造成的，小伙伴们不要学我呀，看题一定要仔细哇！

本题就是上一层的每个物品重量都是由下一层的两个物品平均分，然后一层一层到最后，将最后第30层的重量都求出来之后，再进行排序，2086458231除以对应最小的重量，得出电子秤的计数方式，然后乘以最大的重量即可，至输入，可以将题中的样例复制到文档，去掉前面多于的空格和最后一行的 X，整理好之后，将其复制到运行框里即可。

72665192664

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;

double s[35][35];

int main()
{
    for(int i=0;i<29;i++)///输入数据
    {
        for(int j=0;j<=i;j++)
        {
            scanf("%lf",&s[i][j]);
        }
    }
    for(int i=1;i<30;i++)///注意这里是小于30的，因为最后一行的数也要均分到最后一行的电子秤上
    {
        s[i][0]+=s[i-1][0]/2.0;///每行的第一个数和最后一个数单独处理
        s[i][i]+=s[i-1][i-1]/2.0;
        for(int j=1;j<i;j++)///每行中间的数就开始按套路均分了
        {
            s[i][j]+=s[i-1][j-1]/2.0;
            s[i][j]+=s[i-1][j]/2.0;
        }
    }
    sort(s[29],s[29]+30);///排序
    double ans=(2086458231/s[29][0])*s[29][29];
    printf("%f\n",ans);
    return 0;
}

第四题 方格分割

6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。

如图：p1.png, p2.png, p3.png 就是可行的分割法。

试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。


请提交该整数，不要填写任何多余的内容或说明文字。

分析：

看着是不是感觉是搜索，但是如何搜呢？因为剪开的两个图形完全一样，所以肯定是关于中心对称，那么我们可以以中心为元带你开始搜，只要搜到边界即可得到一种方法数目，但是原理明白，借鉴别人的思路，一开始的思路总是局限于格子，但是其实可以按边界来判断的，因为剪开肯定是从边界处剪，结果还要除以 4 ，因为旋转对称，恩恩，这题我悟了很久。。。

509

#include<iostream>
#include<stdio.h>
using namespace std;

int x[4]={0,-1,0,1};///四个方向
int y[4]={1,0,-1,0};
int s[10][10];
int ans=0;

void dfs(int a,int b)
{
    if(a==0||a==6||b==0||b==6)///边界判断条件
        ans++;
    else
    {
        for(int i=0;i<4;i++)
        {
            int aa=a+x[i];///这里一定要再定义一个变量来得到新位置，因为回溯的时候会消除该位置的标记
            int bb=b+y[i];
            if(s[aa][bb])///如果该点已经走过
                continue;
            s[aa][bb]=1;///可行的话将该点标记，中心对称的位置也要相应的标记
            s[6-aa][6-bb]=1;
            dfs(aa,bb);///继续搜下去
            s[aa][bb]=0;///回溯的时候将该点和对称点的标记撤走
            s[6-aa][6-bb]=0;
        }
    }
    return ;
}

int main()
{
    s[3][3]=1;
    dfs(3,3);
    printf("%d\n",ans/4);///结果别忘了除以4
    return 0;
}

第五题 取数位

求1个整数的第k位数字有很多种方法。
以下的方法就是一种。

// 求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 _____________________;  //填空
}

int main()
{
    int x = 23574;
    printf("%d\n", f(x,3));
    return 0;
}

对于题目中的测试数据，应该打印5。

请仔细分析源码，并补充划线部分所缺少的代码。

注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。

分析：

本题很简单，而且题中函数的作用都有已经给出。仔细看看便知道答案。

f( x/10, k)

第六题 最大公共子序列

最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。

比如："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] = __________________________;  //填空
                if(a[i][j] > max) max = a[i][j];
            }
        }
    }

    return max;
}

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


注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。

分析：

本题之前记得我整理过一篇详细的笔记，如果有不懂的可以戳以戳：点击打开链接

a[i-1][j-1]+1

第七题 日期问题

小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日
至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，
有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，
存在很多可能的日期与其对应。  

比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。  

给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？

输入
----
一个日期，格式是"AA/BB/CC"。  (0 <= A, B, C <= 9)  

输出
----
输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。  

样例输入
----
02/03/04  

样例输出
----
2002-03-04  
2004-02-03  
2004-03-02  

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

分析：

本题感觉自己写不出来，借鉴别人的代码，注意闰年，加排序。。

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

bool is_leap_year( int n ) {
	return (n%400==0 || (n%4==0&&n%100!=0));
} 

struct ST{
	int y, m, d;
	ST( int yy, int mm, int dd ) {
		y = yy;
		m = mm;
		d = dd;
	}
	bool operator < (const ST& o) const {
		if ( y != o.y ) return y<o.y;
		else if ( m != o.m ) return m<o.m;
		else return d<o.d;
	}
};

set<ST> s;

// 每月最多天数 
int mon[] = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

// 传入y年m月d日  判断是否合法 
bool is_valid_year( int y, int m, int d ) {
	if ( m<1 || m>12 ) return false;
	if ( d<1 || d>31 ) return false;
	if ( m == 2 && is_leap_year(y) ) {
		if ( d <= 29 ) {
			s.insert(ST(y,m,d));
			return true;
		}
	} else {
		if ( d <= mon[m] ) {
			s.insert(ST(y,m,d));
			return true;
		}
	}
	return false;
}

void print( const ST& s ) {
	printf( "%d/%02d/%02d\n", s.y, s.m, s.d );
}

int main()
{
	int a,b,c;
	scanf( "%d/%d/%d", &a,&b,&c );
	// 注意考虑 闰年 2-29号的问题 
	// 容易得出 年一定是合法的且只能在a或者c 对a|c分别当做年处理 
	
	// a为年份  则 a年b月c日
	if ( a >= 60 ) {
		is_valid_year(a+1900,b,c);
	} else {
		is_valid_year(a+2000,b,c);
	}
	
	// c为年份  
	if ( c >= 60 ) {
		// c年a月b日时
		is_valid_year(c+1900,a,b);
		// c年b月a日时 
		is_valid_year(c+1900,b,a);
	} else {
		// c年a月b日时
		is_valid_year(c+2000,a,b);
		// c年b月a日时 
		is_valid_year(c+2000,b,a);
	}
	
	for ( set<ST>::iterator it = s.begin() ; it != s.end() ; ++ it ) {
		print(*it);
	}
	
	return 0;
}

第八题 包子凑数

小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。
每种蒸笼都有非常多笼，可以认为是无限笼。

每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。
比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的
（也可能选出1笼3个的再加2笼4个的）。

当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。
而顾客想买7个包子时，大叔就凑不出来了。

小明想知道一共有多少种数目是包子大叔凑不出来的。

输入
----
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)  

输出
----
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。

例如，
输入：
2  
4  
5   

程序应该输出：
6  

再例如，
输入：
2  
4  
6    

程序应该输出：
INF

样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。  
对于样例2，所有奇数都凑不出来，所以有无限多个。  

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

分析：

本题一看肯定是动态规划问题，但是呢，题中并为明确给出数据，所以本题还有一个点（看大牛的博客知道的），就是如果任意两个数的最大公约数不为1，则有无穷个，否则就是有限个。还有就是如果有 1 的存在，结果肯定是 0 ，因为不管啥数，1 都能凑的出。

#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

const int INF = 100005;///自己设的范围
int s[INF];
int h[105];

int judge(int a,int b)///求a，b的最大公因数

{
    int r;
    while(a!=0&&b!=0)
    {
        while(b!=0)
        {
            r=a%b;
            a=b;
            b=r;
        }
    }
    return a;
}

int main()
{
    int n,bj=0;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&h[i]);
        s[h[i]]=1;///将自身先标记，印刻肯定可以
        if(bj==0)
        {
            for(int j=0;j<i;j++)
            {
                if(judge(h[i],h[j])==1)
                    bj=1;///判断是否有有限个数还是无限个数
            }
        }
    }
    if(s[1]==1)///有1的存在
        printf("0\n");
    else if(bj==0)
        printf("INF\n");
    else
    {
        for(int i=1;i<=INF;i++)
        {
            for(int j=0;j<h[j];j++)
            {
                if(i>h[j]&&s[i-h[j]]==1)///完全背包
                    s[i]=1;
            }
        }
        int ans=0;
        for(int i=1;i<=INF;i++)
        {
            if(s[i]==0)
                ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

第九题 分巧克力

儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。

为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：

    1. 形状是正方形，边长是整数  
    2. 大小相同  

例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。

当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？

输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)  
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000) 
输入保证每位小朋友至少能获得一块1x1的巧克力。   

输出
输出切出的正方形巧克力最大可能的边长。

样例输入：
2 10  
6 5  
5 6  

样例输出：
2

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

分析：

要是我的话，肯定是暴力，伦家都说是二分查找，感觉很有道理，我有是悟了半天，下边界肯定是一，至于上边界的话，可以让最大的一条边作。

#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

typedef long long int ll;

struct book
{
    ll a,b;
}s[100005];

int n,k;

bool judge(ll t)///统计当切的方块边长是t时，所有的桥可以可以切成的份数够不够人数
{
    int ans=0;
    for(int i=0;i<n;i++)
    {
        ans+=(s[i].a/t)*(s[i].b/t);
        if(ans>=k)
            return true;
    }
    return false;
}

int main()
{
    ll left=1,right=1;
    scanf("%d %d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%lld %lld",&s[i].a,&s[i].b);
        ll p=max(s[i].a,s[i].b);///选出最大的一条边作上边界
        if(p>right)
            right=p;
    }
    while(right>=left)///二分查找判断
    {
        ll mid=(right+left)/2;
        if(judge(mid))
        {
            left=mid+1;
        }
        else
        {
            right=mid-1;
        }
    }
    printf("%lld\n",right);
    return 0;
}

第十题 K倍区间

给定一个长度为N的数列，A1, A2, ... AN，如果其中一段连续的子序列Ai, Ai+1, ... Aj(i <= j)之和
是K的倍数，我们就称这个区间[i, j]是K倍区间。  

你能求出数列中总共有多少个K倍区间吗？  

输入
-----
第一行包含两个整数N和K。(1 <= N, K <= 100000)  
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)  

输出
-----
输出一个整数，代表K倍区间的数目。  

例如，
输入：
5 2
1  
2  
3  
4  
5  

程序应该输出：
6

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 2000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

分析：

这题看不懂大佬的博客。然后让学长给我讲的，着实费了一番功夫，感觉差距就是这么明显，别人三言两语就分析了，笔尖透露着非常简单的感觉，但是我悟了一遍又一遍，再加上学长讲的 n 遍，我才彻底明白，但是本题运用到了一个公式，同余定理，之前学长讲过，但是我没遇见过这方面的题，所以了解的并不是很深刻，时间一长就忘完了，以至于本题理解起来非常费力，感觉自己又待进步，平时接触的东西，应该好好整明白才是，后悔莫及，也算是个教训吧。

我们想，如果 sum[i] 表示的是前 i 个数的和 ，如果符合题意的区间肯定是 (sum[j] - sum[i])%k ==0 (j>i),是不是这个式子我们可以移项得到 sum[j]%k==sum[i]%k,那也就是说我们对于第 i 个数，都记录着从第一个数开始到这个数的所有加和再除以 k 得到的余数，然后统计在这个序列中的每一个数对应的余数，对于相同的余数，我们可以用排列组合公式来求得结果，但是对于余数为 0 的数，我们要额外加上所有余数为 0 的个数，因为如果余数为 0 的，因为如果 余数为 0 的话，相当于对应的加和自身可以被除尽，ok，就是这样，他们管这个叫做同余定理。

拿本题的样例举个例子：

                         1       2       3       4       5

对应的加和        1        3        6        10        15

对应的余数        1        1        0        0        1

那么计算方法就是 C（3,2）+C（2,2）+2；从三个 1 中选择两个组合区间，从两个 0 中选两个 ，再加上单独的两个 0 。

#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

int s[100005];

long long int judge(long long int a)///计算C（a，2）的值
{
    return a*(a-1)/2;
}

int main()
{
    int n,k;
    int p;
    long long int num=0;
    scanf("%d %d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&p);
        num=(num+p)%k;///一边求和一边取余
        s[num]++;///统计相同余数的个数
    }
    long long int ans=s[0];///首先加上余数为0的个数
    for(int i=0;i<100000;i++)
    {
        if(s[i]>1)
            ans+=judge(s[i]);///求相同余数组成的区间个数
    }
    printf("%lld\n",ans);
    return 0;
}