埃森哲杯第十六届上海大学程序设计联赛春季赛暨上海高校金马五校赛部分题解

Wasserstein Distance

链接：https://www.nowcoder.com/acm/contest/91/A
来源：牛客网

题目描述

最近对抗生成网络(GAN)很火，其中有一种变体WGAN，引入了一种新的距离来提高生成图片的质量。这个距离就是Wasserstein距离，又名铲土距离。

这个问题可以描述如下:

有两堆泥土，每一堆有n个位置，标号从1~n。第一堆泥土的第i个位置有a_i克泥土，第二堆泥土的第i个位置有b_i克泥土。小埃可以在第一堆泥土中任意移挪动泥土，具体地从第i个位置移动k克泥土到第j个位置，但是会消耗的体力。小埃的最终目的是通过在第一堆中挪动泥土，使得第一堆泥土最终的形态和第二堆相同，也就是a_i=b_i (1<=i<=n), 但是要求所花费的体力最小

左图为第一堆泥土的初始形态，右图为第二堆泥土的初始形态，颜色代表了一种可行的移动方案，使得第一堆泥土的形态变成第二堆泥土的形态

输入描述:

输入测试组数T，每组测试数据,第一行输入n，1<=n<=100000,紧接着输入两行，每行n个整数，前一行为a

₁

, a

₂

,…,a

_n

,后一行为b

₁

,b

₂

,…,b

_n

.其中0<=a

_i

,b

_i

<=100000,1<=i<=n,数据保证 

输出描述:

对于每组数据，输出一行，将a土堆的形态变成b土堆的形态所需要花费的最小体力

示例1

输入

2
3
0 0 9
0 2 7
3
1 7 6
6 6 2

输出

2
9

备注:

输入数据量较大，建议使用scanf/printf

做法：
只移动相邻的两个即可

#include<iostream>
using namespace std;
#include<cmath>
#include<cstring>
#include<cstdio>
typedef long long ll;
const ll maxn = 1e5+10;
ll a[maxn];
ll b[maxn];
int main(){
    ll n;
    ll t;
    scanf("%lld",&t);
    while(t--){
    scanf("%lld",&n);
    long long ans = 0;
    for(ll i=1;i<=n;i++)
        scanf("%lld",&a[i]);
    for(ll i=1;i<=n;i++)
        scanf("%lld",&b[i]);
    for(ll i=1;i<=n;i++){
        ll c = b[i]-a[i];
        a[i+1] -= c;
        ans+=abs(c);
    }
    printf("%lld\n",ans);
    }
    return 0;
}

1 + 2 = 3?

链接：https://www.nowcoder.com/acm/contest/91/F
来源：牛客网

题目描述

小Y在研究数字的时候，发现了一个神奇的等式方程，他屈指算了一下有很多正整数x满足这个等式，比如1和2，现在问题来了，他想知道从小到大第N个满足这个等式的正整数，请你用程序帮他计算一下。

(表示按位异或运算)

输入描述:

第一行是一个正整数，表示查询次数。

接着有T行，每行有一个正整数，表示小Y的查询。

输出描述:

对于每一个查询N，输出第N个满足题中等式的正整数，并换行。

示例1

输入

4
1
2
3
10

输出

1
2
4
18
做法：
找规律or数位DP
易知x的二进制数肯定满足不存在两个1相邻的情况。
所以，我们用数位DP可以快速得到小于等于p的符合条件数的个数
那么我们要找第n大，那么二分即可。需要注意的是，要找到的是
大于等于n的最左边的值，注意二分的写法

#include<iostream>
using namespace std;
#include<cmath>
#include<cstring>
#include<cstdio>
typedef long long ll;
ll a,b;
ll f[100][3];
int number[100];
int trans(ll p){
    memset(number,0,sizeof(number));
    if(p==0){
      number[0]=0;
      return 1;
    }
    int ws = 0;
    while(p>0){
        number[ws++] = p%2;
        p/=2;
    }
    return ws;
}
ll dfs(int bit,int pre,int limit){
  // cout<<bit<<" "<<pre<<" "<<limit<<"*\n";
    if(bit==-1){
        return 1;}
    if(limit==0&&f[bit][pre]!=-1LL)
        return f[bit][pre];
    int up = limit?number[bit]:1;
    ll ans = 0;
  //  cout<<"UP:"<<up<<endl;
    for(int i=0;i<=up;i++){
         if(pre==1&&i==1)
             continue;
         ans = ans + dfs(bit-1,i,limit&&i==number[bit]);
    } 
    if(!limit)
        f[bit][pre] = ans;
    return ans;
}
ll get(ll n){
    ll l = 1,r = 1e18;
    while(l<=r){
        ll mid = (l+r)/2;
        int ws = trans(mid);
        ll p = dfs(ws-1,0,1)-1;
    //    cout<<mid<<" "<<p<<endl;
        if(p<n)
            l = mid+1;
        else
            r = mid-1;
    }
    return r+1;
}
int main(){
    ll p;
    memset(f,-1,sizeof(f));
    int t;
    cin>>t;
    while(t--){
    cin>>p;
    ll ans = get(p);
    cout<<ans<<endl;
    }
    return 0;
}

小Y吃苹果

题目略

输出2的n次方即可

#include<iostream>
using namespace std;
#include<cmath>
#include<cstring>
#include<cstdio>
typedef long long ll;
const ll maxn = 1e5+10;
ll a[maxn];
ll b[maxn];
int main(){
    ll n;
    ll p = 1;
    cin>>n;
    cout<<(p<<n);
    return 0;
}

K序列

n^2暴力水过

#include<bits/stdc++.h>
using namespace std;
#define read(x) scanf("%lld",&x)
#define out(x) printf("%lld",&x)
#define cfread(x) scanf("%I64d",&x)
#define cfout(x) printf("%I64d",&x)
#define mian main
#define min(x,y) (x<y?x:y)
#define max(x,y) (x<y?y:x)
#define f(i,p,q,t) for(i=p;i<q;i+=t)
#define MAXN 110000
#define inf 0x3f3f3f3f
#define mem(x,t) memset(x,t,sizeof(x));
#define T true
#define F false
#define def -1*inf
typedef long long ll;
typedef long long LL;
typedef double dd;
int a[110000];
ll ssum[1100000];
ll sum = 0;
int main(){
    ll n,p;
    scanf("%lld%lld",&n,&p);
    sum = 0;
    ssum[0] = 0;
    long long ans = 0;
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
        a[i]%=p;
        if(a[i]==0)
            a[i] = p;
        sum +=a[i];
        ssum[i] = sum;
    }
    for(int i=n;i>=1;i--){
        int pp = 0;
        for(int j=1;j<=i;j++){
            if((ssum[i]-ssum[j-1])%p==0){
                ans = max(ans,i-j+1);
                pp =1;
            //    cout<<j<<"->"<<i<<endl;
                break;
            }
        }
    }
    printf("%lld",ans);
    return 0;
}

二数
链接：https://www.nowcoder.com/acm/contest/91/I
来源：牛客网

题目描述

我们把十进制下每一位都是偶数的数字叫做“二数”。

小埃表示自己很聪明，最近他不仅能够从小数到大：2,3,4,5....，也学会了从大数到小：100,99,98...，他想知道从一个数开始数最少的数就得到一个二数。但是聪明的小森已经偷偷在心里算好了小埃会数到哪个二数，请你求出他要数到哪个数吧。
换句话说，给定一个十进制下最多10⁵位的数字，请你求出和这个数字的差的绝对值最小的二数，若答案不唯一，输出最小的那个。

也就是说，给定数字n，求出m，使得abs(n-m)最小且m[i] mod 2 = 0

输入描述:

1 ≤ T ≤ 100, 1 ≤ n ≤ 10

¹⁰⁰⁰⁰⁰

 − 1, T组数据的数字的十进制表示长度总和不超过1000000

输出描述:

每行一个整数 m 第 i 行表示第 i 个数所对应的“最邻近二数”

示例1

输入

5
42
11
1
2018
13751

输出

42
8
0
2020
8888
做法:（大数+贪心构造）
对于n,我们需要构造一个大于等于n的符合条件数字和小于等于n的符合条件的数字

构造大于等于n的符合条件的数方法:
从高位向地位扫
使最高位的非偶数位+1，并且处理好进位的情况。如果进位，亦需更新使前面高位的数依旧是偶数
更新完最高位非偶数位之后，后面的数，全部使之为0

构造小于等于n的符合条件的数方法:
从高位向地位扫
使最高位的非偶数位-1
更新完最高位非偶数位之后，后面的数，全部使之为8

然后大数减法，算出来两个数与原来数的差值，取差最小的答案输出即可。

#include<iostream>
using namespace std;
#include<cstdio>
#include<cstdlib>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include<algorithm> 
using namespace std; 

#define MAXN 9
#define MAXSIZE 10
#define DLEN 1

class BigNum
{ 
private: 
    int a[110000];    //可以控制大数的位数 
    int len;       //大数长度
public: 
    BigNum(){ len = 1;memset(a,0,sizeof(a)); }   //构造函数
    BigNum(const int);       //将一个int类型的变量转化为大数
    BigNum(const char*,int);     //将一个字符串类型的变量转化为大数
    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 l)     //将一个字符串类型的变量转化为大数
{
    int t,k,index,i;
    memset(a,0,sizeof(a));
    len=l/DLEN;
    if(l%DLEN)
        len++;
    index=0;
    for(i=len-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--)
    { 
        cout.width(DLEN); 
        cout.fill('0'); 
        cout << 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[t1.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;   
    cout << a[len - 1]; 
    for(i = len - 2 ; i >= 0 ; i--)
    { 
        cout.width(DLEN); 
        cout.fill('0'); 
        cout << a[i]; 
    } 
    cout << endl;
}

BigNum c1,c2;
BigNum *l,*r,*m;
struct Number{
    char s[110000];
    int len;
    void creat(char ss[],int n){
        len  = n;
        for(int i=1;i<=n;i++)
            s[i] = ss[i-1] - '0';
    }
    char bs[110000];
    int bslen;
    char ms[110000];
    int mslen;
    void cbs(){;
        int pre = 0;
        memset(bs,0,sizeof(bs));
        bslen = len;
        for(int i=1;i<=len;i++){
            bs[i] = s[i];
            if(pre==1){
                bs[i] = 0;
                continue;
            }
            if(bs[i]%2==0)
                continue;
            bs[i] = bs[i]+1;
            pre = 1;
            int j = i;
            while(bs[j]>=10&&j>=0){
                bs[j-1] += bs[j]/10;
                bs[j]%=10;
                if(bs[j-1]%2!=0)
                    bs[j-1]+=1;
                j-=1;
            }
        }
        if(bs[0]>0){
            bslen+=1;
            for(int i=bslen;i>=1;i--)
                bs[i] = bs[i-1];
        }
        bs[0] = 0;
        int qd = 0;
        int ppre = 0;
        for(int i=0;i<=len;i++){
            if(bs[i]==0)
                qd+=1;
            else{
                ppre = 1;
                break;
            }
        }
        if(ppre==0){
            bs[1]=0;
            bslen=1;
            return;
        }
        if(qd>1)
        for(int i=1;i<=len;i++){
            bs[i] = bs[i+qd-1];
        }
        bslen -= (qd-1);
    }
    void mbs(){
        int pre = 0;
        memset(ms,0,sizeof(ms));
        mslen = len;
        for(int i=1;i<=len;i++){
            ms[i] = s[i];
            if(pre==0){
                if(ms[i]%2==0)
                    continue;
                ms[i] -= 1;
                pre = 1;    
            }
            else{
                ms[i] = 8;
            }
        }
        int qd = 0;
        int ppre = 0;
        for(int i=0;i<=len;i++){
            if(ms[i]==0)
                qd+=1;
            else{
                ppre = 1;
                break;
            }
        }
        if(ppre==0){
            ms[1] = 0;
            mslen = 1;
            return;
        }
        if(qd>1)
        for(int i=1;i<=len;i++){
            ms[i] = ms[i+qd-1];
        }
        mslen -= (qd-1);
    }
    bool check(){
            for(int i=1;i<=bslen;i++)
                bs[i]+='0';
            for(int i=1;i<=mslen;i++)
                ms[i]+='0';
            for(int i=1;i<=len;i++)
                s[i]+='0';
        l=new BigNum(bs+1,bslen),r=new BigNum(ms+1,mslen),m=new BigNum(s+1,len);
    //    cout<<(*l)<<" "<<(*m)<<" "<<(*r)<<endl;
        c1 = (*l)-(*m);
        c2 = (*m)-(*r);
    //    cout<<c1<<" "<<c2<<endl;
        if(c2>c1)
            for(int i=1;i<=bslen;i++)
                printf("%c",bs[i]);
        else
            for(int i=1;i<=mslen;i++)
                printf("%c",ms[i]);
        putchar('\n');        
        delete l;
        delete r;
        delete m; 
        return 0;
    }
};
char s[300000];
Number a;
void deal(){
    scanf("%s",s);
    a.creat(s,strlen(s));
    a.cbs();
    a.mbs();
    a.check();    
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        deal();
    }
    return 0;
}

写于 2018/4/15 17:02