NJUST校赛部分题解

周末两场校赛中，这一场的数论让我很方啊，在这里提供部分A掉的题的题解，官方也有题解，链接是https://icpc.njust.edu.cn/gist/comzyh/a36db955-1113-4fa2-9000-2beb0bdc7201/

---

A-偷吃糖果
签到题之一，分别将两个字符串连续的字母删掉，比较处理完的字符串是否一致就行了。

//
//  main.cpp
//  17-1
//
//  Created by 袁子涵 on 16/4/17.
//  Copyright © 2016年 袁子涵. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;
int t;
string str1,str2;
char final1[1005],final2[1005];
int now1,now2,l1,l2;
char last;
string out1,out2;
int main(int argc, const char * argv[]) {
    cin >> t;
    while (t--) {
        cin >> str1 >> str2;
        memset(final1, 0, sizeof(final1));
        memset(final2, 0, sizeof(final2));
        l1=str1.size();
        l2=str2.size();
        now1=now2=0;
        last=0;
        for (int i=0; i<l1; i++) {
            if (str1[i]!=last) {
                last=str1[i];
                final1[now1++]=last;
            }
        }
        final1[now1]='\0';
        last=0;
        for (int i=0; i<l2; i++) {
            if (str2[i]!=last) {
                last=str2[i];
                final2[now2++]=last;
            }
        }
        final2[now2]='\0';
        out1=final1;
        out2=final2;
        if (out1==out2) {
            cout << "Yes" << endl;
        }
        else
            cout << "No" << endl;
    }
    return 0;
}

---

B-banana
不会！听说有人脚本卡yes no，还是%一发。

---

C-count_prime
队友做的- -也是签到题，http://chilumanxi.org/2016/04/18/%E5%8D%97%E4%BA%AC%E7%90%86%E5%B7%A5%E5%A4%A7%E5%AD%A6%E7%AC%AC%E5%85%AB%E5%B1%8A%E6%A0%A1%E8%B5%9B-c-count_prim/。

---

D-Triple
还是队友做的，http://chilumanxi.org/2016/04/17/%E6%B5%85%E8%B0%88%E8%8E%AB%E6%AF%94%E4%B9%8C%E6%96%AF%E5%8F%8D%E6%BC%94/。

---

E-sad
全场过俩。。真的不会啊。

---

F-sequence
坑题啊，出题人要么故意不好好说话，要么语文学的不好，总之这题卡掉很多时间，原因是那句“每个数出现且只出现一次”，&^&#*$!，好吧，说白了还是导弹拦截问题，一个正向求最长单调递减序列长度就可以的，当然也可以贪心，如果用DP注意要用二分去做，N^2绝对死，不要问我为什么知道。

//
//  main.cpp
//  17-3
//
//  Created by 袁子涵 on 16/4/17.
//  Copyright © 2016年 袁子涵. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#define INF 0x3f3f3f3f
using namespace std;
int t;
long long int n;
long long int num[50005],out=0;
long long int S[50005],d[50005];
/*最长不上升子序列 POJ 1887*/
void init()
{
    for(long long int i = 1; i <= n; i++) S[i] = -INF; //注意初始值
    memset(d, 0, sizeof(d));
}

long long int BSearch(long long int x, long long int y,long long int v)
{
    while(x <= y)
    {
        long long int mid = x+(y-x)/2;
        if(S[mid] > v) x = mid+1; //注意看二分的变化
        else y = mid-1;
    }
    return x;
}

long long int  dp()
{
    init();
    long long int ans = 0;
    for(long long int i = 1; i <= n; i++)
    {
        long long int x = 1, y = i;
        long long int pos = BSearch(x, y, num[i]);
        d[i] = pos;
        S[d[i]] = max(S[d[i]], num[i]); //max
        ans = max(ans, d[i]);
    }
    return ans;
}




int main(int argc, const char * argv[]) {
    cin >> t;
    while (t--) {
        scanf("%lld",&n);
        memset(num, 0, sizeof(num));
        for (long long int i=1; i<=n; i++) {
            scanf("%lld",&num[i]);
        }
        out=dp();
        cout << out << endl;
    }
    return 0;
}

---

G-琪露诺的算术教室
这个题，一开始确实不知道怎么下手，模拟了一发求样例的过程就懂了，只需要先把-1的情况判一下，然后剩下都是绝对有解的情况，模拟乘法，A的一位乘以k得出B新的一位，而B新的一位又一定是A新的一位，这样一直模拟乘法，直到进位为0且得出的新的位等于初始n为止。

//
//  main.cpp
//  17-4
//
//  Created by 袁子涵 on 16/4/17.
//  Copyright © 2016年 袁子涵. All rights reserved.
//

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#include <cmath>
using namespace std;
int t;
int a,k;
long long int num,tmp,tl;
vector<long long int>re;
void GetNum(int a,int k)
{
    re.clear();
    tl=0;
    long long int shi=1,jin=0,now=0,last=a;
    while (now!=a || jin!=0) {
        tmp=last*k+jin;
        now=tmp%10;
        jin=tmp/10;
        re.push_back(now);
        shi*=10;
        last=now;
    }
}
int main(int argc, const char * argv[]) {
    cin >> t;
    while (t--) {
        cin >> a >> k;
        if (a==0) {
            cout << 0 << endl;
            continue;
        }
        if (!k) {
            cout << -1 << endl;
            continue;
        }
        if (k>a) {
            cout << -1 << endl;
            continue;
        }
        GetNum(a, k);
        for (long long int i=re.size()-1; i>=0; i--) {
            printf("%lld",re[i]);
        }
        cout << endl;
    }
    return 0;
}

---

H-谁才是最强战舰
队友做的，博弈论题，http://blog.youkuaiyun.com/sinluan/article/details/51181021。

---

I-puzzle
姿势不够，应该是2-SAT能做的，现场学并没有来得及A。

---

J-water1
一道坑到家的签到题。
真的是坑，其实就是总面积减去各个区域的面积就行了，但是如果不一个区域一个区域去减了然后加起来的话，直接相乘得总面积会爆long long，为此贡献-3，最后直接套了个大数模板，懒得一个区域一个区域的去弄，复制粘贴快得多。

//
//  main.cpp
//  17-2
//
//  Created by 袁子涵 on 16/4/17.
//  Copyright © 2016年 袁子涵. All rights reserved.
//

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

using namespace std;
#define MAXN 9999
#define MAXSIZE 1010
#define DLEN 4
class BigNum
{
private:
    int a[500]; //可以控制大数的位数
    int len;
public:
    BigNum()
    {
        len=1;    //构造函数
        memset(a,0,sizeof(a));
    }
    BigNum(const int); //将一个int类型的变量转化成大数
    BigNum(const char*); //将一个字符串类型的变量转化为大数
    BigNum(const BigNum &); //拷贝构造函数
    BigNum &operator=(const BigNum &); //重载赋值运算符，大数之间进行赋值运算
    friend istream& operator>>(istream&,BigNum&); //重载输入运算符
    friend ostream& operator<<(ostream&,BigNum&); //重载输出运算符
    BigNum operator+(const BigNum &)const; //重载加法运算符，两个大数之间的相加运算
    BigNum operator-(const BigNum &)const; //重载减法运算符，两个大数之间的相减运算
    BigNum operator*(const BigNum &)const; //重载乘法运算符，两个大数之间的相乘运算
    BigNum operator/(const int &)const; //重载除法运算符，大数对一个整数进行相除运算
    BigNum operator^(const int &)const; //大数的n次方运算
    int operator%(const int &)const; //大数对一个int类型的变量进行取模运算
    bool operator>(const BigNum &T)const; //大数和另一个大数的大小比较
    bool operator>(const int &t)const; //大数和一个int类型的变量的大小比较
    void print(); //输出大数
};
BigNum::BigNum(const int b) //将一个int类型的变量转化为大数
{
    int c,d=b;
    len=0;
    memset(a,0,sizeof(a));
    while(d>MAXN)
    {
        c=d-(d/(MAXN+1))*(MAXN+1);
        d=d/(MAXN+1);
        a[len++]=c;
    }
    a[len++]=d;
}
BigNum::BigNum(const char *s) //将一个字符串类型的变量转化为大数
{
    int t,k,index,L,i;
    memset(a,0,sizeof(a));
    L=strlen(s);
    len=L/DLEN;
    if(L%DLEN)len++;
    index=0;
    for(i=L-1; i>=0; i-=DLEN)
    {
        t=0;
        k=i-DLEN+1;
        if(k<0)k=0;
        for(int j=k; j<=i; j++)
            t=t*10+s[j]-'0';
        a[index++]=t;
    }
}
BigNum::BigNum(const BigNum &T):len(T.len) //拷贝构造函数
{
    int i;
    memset(a,0,sizeof(a));
    for(i=0; i<len; i++)
        a[i]=T.a[i];
}
BigNum & BigNum::operator=(const BigNum &n) //重载赋值运算符，大数之间赋值运算
{
    int i;
    len=n.len;
    memset(a,0,sizeof(a));
    for(i=0; i<len; i++)
        a[i]=n.a[i];
    return *this;
}
istream& operator>>(istream &in,BigNum &b)
{
    char ch[MAXSIZE*4];
    int i=-1;
    in>>ch;
    int L=strlen(ch);
    int count=0,sum=0;
    for(i=L-1; i>=0;)
    {
        sum=0;
        int t=1;
        for(int j=0; j<4&&i>=0; j++,i--,t*=10)
        {
            sum+=(ch[i]-'0')*t;
        }
        b.a[count]=sum;
        count++;
    }
    b.len=count++;
    return in;
}
ostream& operator<<(ostream& out,BigNum& b) //重载输出运算符
{
    int i;
    cout<<b.a[b.len-1];
    for(i=b.len-2; i>=0; i--)
    {
        printf("%04d",b.a[i]);
    }
    return out;
}
BigNum BigNum::operator+(const BigNum &T)const //两个大数之间的相加运算
{
    BigNum t(*this);
    int i,big;
    big=T.len>len?T.len:len;
    for(i=0; i<big; i++)
    {
        t.a[i]+=T.a[i];
        if(t.a[i]>MAXN)
        {
            t.a[i+1]++;
            t.a[i]-=MAXN+1;
        }
    }
    if(t.a[big]!=0)
        t.len=big+1;
    else t.len=big;
    return t;
}
BigNum BigNum::operator-(const BigNum &T)const //两个大数之间的相减运算
{
    int i,j,big;
    bool flag;
    BigNum t1,t2;
    if(*this>T)
    {
        t1=*this;
        t2=T;
        flag=0;
    }
    else
    {
        t1=T;
        t2=*this;
        flag=1;
    }
    big=t1.len;
    for(i=0; i<big; i++)
    {
        if(t1.a[i]<t2.a[i])
        {
            j=i+1;
            while(t1.a[j]==0)
                j++;
            t1.a[j--]--;
            while(j>i)
                t1.a[j--]+=MAXN;
            t1.a[i]+=MAXN+1-t2.a[i];
        }
        else t1.a[i]-=t2.a[i];
    }
    t1.len=big;
    while(t1.a[len-1]==0 && t1.len>1)
    {
        t1.len--;
        big--;
    }
    if(flag)
        t1.a[big-1]=0-t1.a[big-1];
    return t1;
}
BigNum BigNum::operator*(const BigNum &T)const //两个大数之间的相乘
{
    BigNum ret;
    int i,j,up;
    int temp,temp1;
    for(i=0; i<len; i++)
    {
        up=0;
        for(j=0; j<T.len; j++)
        {
            temp=a[i]*T.a[j]+ret.a[i+j]+up;
            if(temp>MAXN)
            {
                temp1=temp-temp/(MAXN+1)*(MAXN+1);
                up=temp/(MAXN+1);
                ret.a[i+j]=temp1;
            }
            else
            {
                up=0;
                ret.a[i+j]=temp;
            }
        }
        if(up!=0)
            ret.a[i+j]=up;
    }
    ret.len=i+j;
    while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
    return ret;
}
BigNum BigNum::operator/(const int &b)const //大数对一个整数进行相除运算
{
    BigNum ret;
    int i,down=0;
    for(i=len-1; i>=0; i--)
    {
        ret.a[i]=(a[i]+down*(MAXN+1))/b;
        down=a[i]+down*(MAXN+1)-ret.a[i]*b;
    }
    ret.len=len;
    while(ret.a[ret.len-1]==0 && ret.len>1)
        ret.len--;
    return ret;
}
int BigNum::operator%(const int &b)const //大数对一个 int类型的变量进行取模
{
    int i,d=0;
    for(i=len-1; i>=0; i--)
        d=((d*(MAXN+1))%b+a[i])%b;
    return d;
}
BigNum BigNum::operator^(const int &n)const //大数的n次方运算
{
    BigNum t,ret(1);
    int i;
    if(n<0)exit(-1);
    if(n==0)return 1;
    if(n==1)return *this;
    int m=n;
    while(m>1)
    {
        t=*this;
        for(i=1; (i<<1)<=m; i<<=1)
            t=t*t;
        m-=i;
        ret=ret*t;
        if(m==1)ret=ret*(*this);
    }
    return ret;
}
bool BigNum::operator>(const BigNum &T)const //大数和另一个大数的大小比较
{
    int ln;
    if(len>T.len)return true;
    else if(len==T.len)
    {
        ln=len-1;
        while(a[ln]==T.a[ln]&&ln>=0)
            ln--;
        if(ln>=0 && a[ln]>T.a[ln])
            return true;
        else
            return false;
    }
    else
        return false;
}
bool BigNum::operator>(const int &t)const //大数和一个int类型的变量的大小比较
{
    BigNum b(t);
    return *this>b;
}
void BigNum::print() //输出大数
{
    int i;
    printf("%d",a[len-1]);
    for(i=len-2; i>=0; i--)
        printf("%04d",a[i]);
    printf("\n");
}
long long int n;
BigNum now,total;
long long int tmp1,tmp2,maxs;
BigNum length;
int main(int argc, const char * argv[]) {
    while (cin >> n) {
        maxs=0;
        if (n==0) {
            cout << 1 << endl;
            continue;
        }
        now=BigNum(0);
        total=BigNum(0);
        length=BigNum(0);
        for (long long int i=0; i<n; i++) {
            scanf("%lld %lld",&tmp1,&tmp2);
            maxs=max(maxs,tmp1+1);
            length=length+tmp2;
            now=now+tmp1*tmp2;
        }
        length=length*maxs;
        total=length-now;
        total.print();
    }
    return 0;
}