记2018/4/29 qbxt 测试

　　　　记 2018/4/29  qbxt 测试（提高基础班）

　　　　　　简单的 NOIP 模拟赛
　　竞赛时间： 2018 年 4 月 29 日 13:30-17:00

题目名称	乘法	求和	计数
输入文件名	mul.in	sum.in	count.in
输出文件名	mul.out	sum.out	count.in
每个测试点时限	1 sec	4 sec	1 sec
内存限制	128MB	128MB	128MB
测试点数目	10	10	10
每个测试点分值	10	10	10
是否有部分分	无	无	无
题目类型	传统	传统	传统

T1 期望得分：100；实际得分：100

　　　　　　　　　　乘法

【问题描述】

　　给定正整数n，m，p，你需要输出 n * m 对 p 取模后的值
【输入文件】

　　输入文件为 mul.in

　　输入为一行 n, m, p

【输出文件】

　　输出文件为 mul.out

　　输出一行为一个整数，为所求的答案

【输入输出样例】

mul.in	mul.out
11  22  10	2

【数据规模和约定】

　　对于30%的数据，n, m, p <=10000;

　　对于60%的数据，n, m, p <= 10⁹

　　对于100%的数据， n, m, p <= 10¹⁸

【一些提示】

　　　　以下是一些对取模操作的介绍：
　　一个整数a对一个整数p取模的值，是一个不超过p的非负整数b，并且a-b是p的倍数。可以证明，满足条件的b有且只有一个；

　　一些运算在取模前后仍然成立，例如：

　　　　两个数的和对p取模的值等于两个数先对p取模，再求和，在取模；

　　　　两个数的乘积对p取模的值等于两个数先对p取模，再求乘积，再取模

　　　　但两个数的除法没有类似的性质

思路：快速乘（类似于快速幂） or 高精

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
long long n, m, p;
long long Mul(long long x, long long y){
    long long res = ;
    x %= p; y %= p;
    while(y) {
        if(y & ) res = (res+x) % p;
        x = (x+x) % p;
        y >>= ;
    }
    return res;
}
int main() {
    //freopen("mul.in","r",stdin);
    //freopen("mul.out","w",stdout);
    cin >> n >> m >> p;
    cout<< Mul(n, m);
    //fclose(stdin); fclose(stdout);
    return ;
}

快速乘

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
namespace BigInteger
{
    #define maxn 10005
    using std::sprintf;
    using std::string;
    using std::max;
    using std::istream;
    using std::ostream;

    struct Big_integer
    {
        int d[maxn],len;
        void clean()
        {
            while(len>&&!d[len-])
                len--;
        }
        Big_integer()
        {
            memset(d,,sizeof(d));
            len=;
        }
        Big_integer(int num)
        {
            *this=num;
        }
        Big_integer(char* num)
        {
            *this=num;
        }
        Big_integer operator = (const char* num)
        {
            memset(d,,sizeof(d));
            len=strlen(num);
            for(int i=;i<len;i++)
              d[i]=num[len--i]-'';
            clean();
            return *this;
        }
        Big_integer operator = (int num)
        {
            char s[];
            sprintf(s,"%d",num);
            *this=s;
            return *this;
        }
        Big_integer operator + (const Big_integer& b)
        {
            Big_integer c=*this;
            int i;
            for(i=;i<b.len;i++)
            {
                c.d[i]+=b.d[i];
                if(c.d[i]>)
                {
                    c.d[i]%=;
                    c.d[i+]++;
                }
            }
            while(c.d[i]>)
            {
                c.d[i++]%=;
                c.d[i]++;
            }
            c.len=max(len,b.len);
            if(c.d[i]&&c.len<=i)
              c.len=i+;
            return c;
        }
        Big_integer operator - (const Big_integer& b)
        {
            Big_integer c=*this;
            int i;
            for(i=;i<b.len;i++)
            {
                c.d[i]-=b.d[i];
                if(c.d[i]<)
                {
                    c.d[i]+=;
                    c.d[i+]--;
                }
            }
            while(c.d[i]<)
            {
                c.d[i++]+=;
                c.d[i]--;
            }
            c.clean();
            return c;
        }
        Big_integer operator * (const Big_integer& b) const
        {
            int i,j;
            Big_integer c;
            c.len=len+b.len;
            for(j=;j<b.len;j++)
              for(i=;i<len;i++)
                c.d[i+j]+=d[i]*b.d[j];
            for(i=;i<c.len-;i++)
            {
                c.d[i+]+=c.d[i]/;
                c.d[i]%=;
            }
            c.clean();
            return c;
        }
        Big_integer operator % (const Big_integer& b)
        {
            int i,j;
            Big_integer a=;
            for(i=len-;i>=;i--)
            {
                a=a*+d[i];
                for(j=;j<;j++)
                  if(a<b*(j+))
                    break;
                  a=a-b*j;
            }
            return a;
        }
        bool operator < (const Big_integer& b) const
        {
            if(len != b.len) return len<b.len;
            for(int i=len-;i>=;i--)
              if(d[i]!=b.d[i])
                return d[i]<b.d[i];
            return false;
        }
        string str()const
        {
            char s[maxn]={};
            for(int i=;i<len;i++)
              s[len--i]=d[i]+'';
            return s;
        }
    };
    istream& operator >> (istream& in,Big_integer& x)
    {
        string s;
        in>>s;
        x=s.c_str();
        return in;
    }

    ostream& operator << (ostream& out,const Big_integer& x)
    {
        out<<x.str();
        return out;
    }
}
using namespace BigInteger;
using namespace std;
Big_integer a,b,k;
int main()
{
    //freopen("mul.in","r",stdin);
    //freopen("mul.out","w",stdout);
    cin>>a>>b>>k;
    cout<<a*b%k;
    //fclose(stdin);
    //fclose(stdout);
    return ;
}

高精

T2  期望得分：30；实际得分：0  qwq

　　　　　　求和

【题目描述】

　　给定n个正整数d₁ , d₂ , d₃ ..... d_n。如果取出其中的任意两个数（可以相同） ，则可以得到这两个数的和。对于n个数，则至多可以产生n*(n + 1) / 2 种不同的和。
　　给出正整数 m，你需要判断： 是否存在两个整数 u, v , 满足 d_u + d_v = m.
【输入文件】
　　输入文件为 sum. in。
　　本题一个输入中包含多组数据。 输入第一行为一个整数 T ,  表示数据组数。对于每组数据， 输入的第一行为两个正整数 n, m，输入的第二行为 n 个正整数 d1, d2, d3 ..... dn
【输出文件】
　　输入文件为 sum.out。
　　输出 T 行， 每行一个整数。 如果正整数 u, v 存在， 则输出 1； 否则输出 0。
【输入输出样例】

sum.in	sum.out
2 3 3 2 3 4 3 4 1 2 4	0 1

　　

【数据规模和约定】
　　对于30%的数据，满足 n <= 1000, m <= 10000;

　　对于60%的数据，满足 n <= 10⁵；

　　对于另30%的数据，满足 m <= 10⁷;

　　对于100%的数据，满足 1 <= n <= 10⁶, 1 <= d_i <= 10⁹, 1 <= T <= 20.

【一些提示】
在下发文件中附有文件 sample.cpp， 包含了自定义函数 read()及其使用示例。 对于本题，请务必使用 read()函数进行读入， 否则可能会有时间的问题。
 思路：   30 分： 暴力
　　　　60 分： 排序后， 两根指针进行扫᧿。
　　　　另 30 分： 用计数数组记录数的分布
　　　　100 分： 在使用计数数组的基础上进行拓展。考虑设置一个数 b ，把每个d_i 写成 d_i = a_i * b + r_i ;并且把每个 d_i 按 a_i 的值分成若干组，a_i 相同的数放在一组里。
　　　　考虑一次性处理某一组的数。 如果假设 d_u + d_v = m 的一个数在某一组中，那么另一个数的分布范围一定不超过两组。 所以， 如果要检测某一组的数是否可以作为一个加数， 只需要把另外的两组放入计数数组即可。 这样就解决了计数数组开不下的问题。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
typedef long long ll;
typedef vector<int>::iterator iter;
const int N = , M = ;
int d[N];
int a[M];
vector<int> block[M];
int cnt[M * ];
int read()
{
    int x=;char ch=getchar();
    while(ch<''||ch>'') ch=getchar();
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x;
}
int main()
{
    freopen("sum.in","r",stdin);
    freopen("sum.out","w",stdout);
    setvbuf(stdin, new char[ << ], _IOFBF,  << );
    setvbuf(stdout, new char[ << ], _IOFBF,  << );
    int T = read();
    while (T--)
    {

        int n = read(), m = read();
        int maxblock = m / M;
        int ans = ;
        for (int i = ; i <= maxblock; i++)
            block[i].clear();
        int tmptme = clock();
        while (n--)
        {
            int x = read();
            int y = x % M;
            x /= M;
            block[x].push_back(y);
        }
        for (int i = ; i <= maxblock; i++)
        {
            int lblock = (m - (i + ) * M + ) / M;
            int rblock = (m - i * M) / M;
            int base = lblock * M;
            for (int j = lblock; j <= rblock; j++)
            {
                for (iter it = block[j].begin(); it != block[j].end(); it++)
                {
                    cnt[*it + j * M - base] = ;
                }
            }
            for (iter it = block[i].begin(); it != block[i].end(); it++)
            {
                if (cnt[m - i * M - *it - base])
                {
                    ans = ;
                    break;
                }
            }
            for (int j = lblock; j <= rblock; j++)
            {
                for (iter it = block[j].begin(); it != block[j].end(); it++)
                {
                    cnt[*it + j * M - base] = ;
                }
            }
            if (ans) break;
        }
        cout << ans << endl;
    }
    return ;
}

标程

T3 期望得分：40；实际得分：40；

 　　　　　　计数
【问题描述】
　　杨辉三角是一个满足如下条件的三角形矩阵：
　　边界条件：f [ i ] [ 0 ] = f [ i ] [ i ] = 1 , i >= 0 .
　　其余部分：f [ i ] [ j ] = f [ i - 1 ] [ j - 1 ] + f [ i - 1 ] [ j ] , 如果( i, j )不在边界上
　　由此可以得出杨辉三角的前5行大致如下：
　　　　1
　　　　1 1
　　　　1 2 1
　　　　1 3 3 1
　　　　1 4 6 4 1
　　现在，给定正整数n你需要计算杨辉三角前n行有多少个偶数
【输入文件】
　　输入文件为 count.in。
　　输入文件为一行一个正整数n。
【输出文件】
　　输入文件为 cs.out。
　　输出一行一个整数， 为杨辉三角前n行的偶数个数。
【输入输出样例】
　　5    4
【数据规模和约定】
　　对于40%的数据，满足n<=1000。
　　对于70%的数据，满足n<=10⁶。
　　对于90%的数据，满足n<=10⁹。
　　对于100%的数据，满足n<=10¹⁰⁰。

思路：杨辉三角的奇偶分布是一个经典的分形图形。 由此可以观察出的规律有：杨辉三角的前 2ⁿ 行的奇数个数是 3ⁿ 个，如果找到一个 k，使 2^k <= n < 2^k-1, 那么前 2^k 行的奇数个数可以单独计算； 而余下部分两边对称， 所以可以递归算其中的一边， 再乘以 2 加入答案。
上述算法计算出的是杨辉三角前 n 行有多少个奇数， 作差即可得到偶数的个数。
对于最后一个测试点， 需要使用高精度来支持上述做法。

#include<algorithm>
#include<cstdio>
using namespace std;
int n, sum;
int a[][];

int main() {
    //freopen("count.in","r",stdin);
    //freopen("count.out","w",stdout);
    scanf("%d", &n);
    a[][] = ;
    for(int i = ; i < n; i++)
        for(int j = ; j < i+; j++) {
            if(i == ) a[i][j] = ;
            else a[i][j] = a[i-][j-]+a[i-][j];
            if(a[i][j]% == ) sum++;
        }
    printf("%d", sum);
    //fclose(stdin); fclose(stdout);
    return ;
}

40分暴力

#include<iostream>
using namespace std;
long long n;
long long work(long long n)
{
    if(n== || n== )return ;
    if(n&)return *work(n/)+work(n/+)+(n/)*(n/+)/;
    else return *work(n/)+(n/)*(n/-)/;
}
int main()
{
    //freopen("count.in","r",stdin);
    //freopen("count.out","w",stdout);
    cin>>n;
    cout<<work(n);
    //fclose(stdin);fclose(stdout);
    return ;
}

90分递归 没有高精

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<string>
using namespace std;
const int N = ;

struct bignum
{
    int a[N];
    int n;
    bignum()
        {
            n = ;
            memset(a, , sizeof(a));
        }
    bignum(string s)
        {
            memset(a, , sizeof(a));
            n = s.size();
            for (int i = ; i < n; i++)
                a[i] = s[n -  - i] -'';
        }
    bignum(int x)
        {
            memset(a, , sizeof(a));
            n = ;
            while (x)
            {
                a[n] = x % ;
                x /= ;
                n++;
            }
        }
    void deal()
        {
            for (int i = ; i < n; i++)
            {
                if (a[i] < )
                {
                    int tmp = (-a[i] - ) /  + ;
                    a[i] +=  * tmp;
                    a[i + ] -= tmp;
                }
                if (a[i] >= )
                {
                    int tmp = a[i] / ;
                    a[i] -=  * tmp;
                    a[i + ] += tmp;
                    if (i == n -  && a[i + ] > ) n++;
                }
            }
            while (n >  && a[n - ] == ) n--;
        }
    void div2()
        {
            int tmp = ;
            for (int i = n - ; i >= ; i--)
            {
                int tmp_ = a[i] & ;
                a[i] = (a[i] + tmp * ) >> ;
                tmp = tmp_;
            }
            deal();
        }
    void print()
        {
            for (int i = n - ; i >= ; i--)
                cout << a[i];
            cout << endl;
        }
};

bignum operator + (const bignum &a, const bignum &b)
{
    bignum c;
    c.n = max(a.n, b.n);
    for (int i = ; i < c.n; i++)
        c.a[i] = a.a[i] + b.a[i];
    c.deal();
    return c;
}

bignum operator - (const bignum &a, const bignum &b)
{
    bignum c;
    c.n = max(a.n, b.n);
    for (int i = ; i < c.n; i++)
        c.a[i] = a.a[i] - b.a[i];
    c.deal();
    return c;
}

bignum operator * (const bignum &a, const bignum &b)
{
    bignum c;
    c.n = a.n + b.n - ;
    for (int i = ; i < a.n; i++)
        for (int j = ; j < b.n; j++)
            c.a[i + j] += a.a[i] * b.a[j];
    c.deal();
    return c;
}
bool no_bigger_than(const bignum &a, const bignum &b)
{
    if (a.n < b.n) return ;
    if (b.n < a.n) return ;

    for (int i = a.n - ; i >= ; i--)
    {
        if (a.a[i] > b.a[i]) return ;
        if (a.a[i] < b.a[i]) return ;
    }
    return ;
}

bignum calc(bignum n)
{
    if (n.n == ) return ;
    bignum ret();
    bignum now();
    bignum big2();
    bignum big3();
    while (no_bigger_than(now * big2, n))
    {
        now = now * big2;
        ret = ret * big3;

    }
    /*
    cout << "*****" << endl;
    n.print();
    now.print();
    ret.print();
    cout << "*****" << endl;
    */
    return ret + big2 * calc(n - now);
}

int main()
{
    freopen("count.in","r",stdin);
    freopen("count.out","w",stdout);
    string s;
    cin >> s;
    bignum a(s);
    bignum n(s);
    bignum b();
    //b.print();
    bignum c = a + b;
    //a.print();
    //c.print();
    //return 0;
    a = a * c;
    //a.print();
    a.div2();
    //a.print();
    (a - calc(n)).print();
    return ;
}

标程

附加题：HDU  矩形面积并