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

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

A.Wasserstein Distance

题目描述

最近对抗生成网络(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

最小体力，可能题目数据不怎么好，暴力可以直接过，我是先相减的，然后从头遍历到后面。
直到找完。

#include <iostream>
#include <cstring>
#define mem(a) memset(a,0,sizeof(a))
#define ll long long int
#define N 100020
using namespace std;
int a[N],b[N];
int t;
int main(){
    cin>>t;
    while(t--){
        mem(a);
        mem(b);
        int n;
        cin>>n;
        for(int i=0;i<n;i++)
            cin>>a[i];
        for(int i=0;i<n;i++){
            cin>>b[i];
            a[i]=a[i]-b[i];
        }
        ll sum = 0;
        for(int i=0;i<n;i++){
            if(a[i]<0){
                for(int j=i+1;j<n;j++){
                    if(a[j]>0){
                        if(a[j]>=abs(a[i])){
                            sum+=abs(a[i])*(j-i);
                            a[j]+=a[i];
                            a[i]=0;
                        }else{
                            sum+=a[j]*(j-i);
                            a[i]+=a[j];
                            a[j]=0;
                        }
                    }
                    if(a[i]==0)
                        break;
                }
            }else if(a[i]>0){
                for(int j=i+1;j<n;j++){
                    if(a[j]<0){
                        if(abs(a[j])>=a[i]){
                            sum+=a[i]*(j-i);
                            a[j]+=a[i];
                            a[i]=0;
                        }else{
                            sum+=abs(a[j])*(j-i);
                            a[i]+=a[j];
                            a[j]=0;
                        }
                    }
                    if(a[i]==0)
                        break;
                }
            }
        }
        cout<<sum<<endl;
    }
    return 0;
}

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

E.小Y吃苹果

题目描述

小Y买了很多苹果，但他很贪吃，过了几天一下就吃剩一只了。每一天小Y会数出自己的苹果个数X，如果X是偶数，他就会吃掉只苹果；如果X是奇数，他就会吃掉只苹果。

你知道现在苹果只剩下一只，并且小Y是在N天前买的苹果，现在小Y想知道在那天买了多少苹果。当然，可能性不止一种，你只需要求出他买的苹果数量有多少种可能。

输入描述:

输入数据只有一个整数N，表示小Y在N天前买了苹果。

输出描述:

输出一个整数，表示可能的数量种数。

示例1

输入

1

输出

2

说明

样例中小Y在一天前买了苹果，因此他只可能买了2个或者3个苹果，共2种情况。

这个就是最简单的一道，就不说了。

#include <iostream>
#define ll long long int
using namespace std;
 
int main(){
    int n;
    cin>>n;
    ll sum =1;
    while(n--){
        sum*=2;
    }
    cout<<sum<<endl;
    return 0;
}

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

1 + 2 = 3?

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

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

(表示按位异或运算)

输入描述:

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

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

输出描述:

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

示例1

输入

4
1
2
3
10

输出

1
2
4
18

这题确实不错，开始准备暴力，没看清题意，
只后发现那是不存在的！！！tan 90.
这里理清思路，仔细找会发现就是只要没有1和1紧靠就可以了。
然后就可以dp了，再加上前缀和就行了。
想起来有点复杂，但是想通了就很简单了。

#include <iostream>
#include <cmath>
#include <queue>
#include <algorithm>
#define ll long long int
using namespace std;
 
ll dp[65];
int n;
 
int main(){
    cin>>n;
    dp[1]=1;
    dp[0]=0;
    for(int i=2;i<=60;i++){
        dp[i] = dp[i-1]+dp[i-2];
    }
    for(int i=1;i<=60;i++){
        dp[i]+=dp[i-1];
    }
    for(int i=0;i<=60;i++){
        dp[i]++;
        // cout<<dp[i]<<" ** ";
    }
    // cout<<endl;
    while(n--){
        ll m;
        cin>>m;
        ll cnt = 0;
        while(m){
            for(int i=1;i<=60;i++){
                if(dp[i]>m&&dp[i-1]<=m){
                    cnt+=(1ll<<(i-1));
                    m-=dp[i-1];
                    break;
                }
            }
        }
        cout<<cnt<<endl;
    }
    return 0;
}

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

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

这道题ennnnnnnnnn。。怎么说呢，想到了思路，但是比赛的时候没写出来,之后补上来的，
不想写大数，就直接搬了一份大数的源代码过来了。
首先思路是字符串输入，
找到第一个奇数，没有就直接输出。
有的话就看当前位置是否是第一位，然后分别做两种选择，一个是向上取，一个是向下取。
注意特殊情况，比如：第一位为1，和第一位为9，还有就是只有一位数为1.
剩下的就仔细点就可以了。

#include <bits/stdc++.h>
#define mem(a) memset(a,0,sizeof(a))
using namespace std;

int Subtraction(char num1[], char num2[], int sum[])
{
    int i, j, len, blag;
    char *temp;
    int n2[1000000] = {0};
    int len1 = strlen(num1); // 计算数组num1的长度，即大数的位数
    int len2 = strlen(num2); // 计算数组num2的长度，即大数的位数
    blag = 0;
    if(len1 < len2)
    {
        blag = 1; // 标记结果为负数
        temp = num1;
        num1 = num2;
        num2 = temp;
        len = len1;
        len1 = len2;
        len2 = len;
    }
    else if(len1 ==len2) // 如果被减数的位数等于减数的位数
    {
        for(i = 0; i < len1; i++)
        {
            if(num1[i] == num2[i])
                continue;
            if(num1[i] > num2[i])
            {
                blag = 0; // 标记结果为正数
                break;
            }
            else
            {
                blag = 1; // 标记结果为负数
                temp = num1;
                num1 = num2;
                num2 = temp;
                break;
            }
        }
    }
    len = len1>len2 ? len1 : len2;
    for (i = len1-1, j = 0; i >= 0; i--, j++)
        sum[j] = num1[i] - '0';
    for (i = len2-1, j = 0; i >= 0; i--, j++)
        n2[j] = num2[i] - '0';
    for (i = 0; i <= len; i++)
    {
        sum[i] = sum[i] - n2[i]; // 两个数从低位开始相减
        if (sum[i] < 0)   // 判断是否有借位
        {    // 借位
            sum[i] += 10;
            sum[i+1]--;
        }
    }
    for (i = len1-1; i>=0 && sum[i] == 0; i--)
        ;
    len = i+1;
    if(blag==1)
    {
        sum[len] = -1;  // 在高位添加一个-1表示负数
        len++;
    }
    return len;   // 返回结果的位数
}
char s[100000]={0};
int sum[100000]={0},sum1[100000]={0};
char s1[100000]={0},s2[100000]={0};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t;
    cin>>t;
    while(t--){
        mem(s);
        mem(sum);
        mem(sum1);
        mem(s1);
        mem(s2);
        cin>>s;
        bool prime = true;
        int p=0,q=0;
        for(int i=0;i<strlen(s);i++){
            if(!prime){
                s1[p++]='8';
                s2[q++]='0';
                continue;
            }
            if((s[i]-'0')%2==1&&prime){
                if(i==0){
                    if(s[i]!='1'){
                        s1[p++]=s[i]-1;
                    }
                    if(s[i]=='9'){
                        s2[q++]='2';
                        s2[q++]='0';
                    }else{
                        s2[q++]=s[i]+1;
                    }
                }else{
                    s1[p++]=s[i]-1;

                    if(s[i]=='9'){
                        s2[q-1]+=1;
                        q++;
                        s2[q++]='0';
                    }else{
                        s2[q++]=s[i]+1;
                    }
                }
                prime = false;
            }else{
                s1[p++]=s[i];
                s2[q++]=s[i];
            }
        }
        if(strlen(s1)==0){
            s1[p++]='0';
        }
        int slen = Subtraction(s2, s, sum);
        int slen1 = Subtraction(s, s1, sum1);
        if(slen>slen1){
            cout<<s1<<endl;
        }else if(slen<slen1){
            cout<<s2<<endl;
        }else{
            bool flag = true;
            for(int i=slen-1;i>=0;i--){
                  if(sum[i]>sum1[i]){
                      cout<<s1<<endl;
                      flag = false;
                      break;
                  }else if(sum[i]<sum1[i]){
                      cout<<s2<<endl;
                      flag = false;
                      break;
                  }
            }
            if(flag){
                cout<<s1<<endl;
            }
        }
    }
    return 0;
}

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

L.K序列

题目描述

给一个数组 a，长度为 n，若某个子序列中的和为 K 的倍数，那么这个序列被称为“K 序列”。现在要你 对数组 a 求出最长的子序列的长度，满足这个序列是 K 序列。 

输入描述:

第一行为两个整数 n, K, 以空格分隔，第二行为 n 个整数，表示 a[1] ∼ a[n]，1 ≤ n ≤ 10

⁵

 , 1 ≤ a[i] ≤ 10

⁹

 , 1 ≤ nK ≤ 10

⁷

输出描述:

输出一个整数表示最长子序列的长度 m

示例1

输入

7 5
10 3 4 2 2 9 8

输出

6

这题也是可以用前缀和来算的，然后遍历，尽量优化一下，避免超时。

#include <iostream>
#include <cstring>
#define ll long long int
#define N 1000000
using namespace std;
 
int a[N];
int n,m;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        a[i]%=m;
    }
    for(int i=2;i<=n;i++){
        a[i] = a[i]+a[i-1];
    }
    int sum = 0;
    for(int i=0;i<=n;i++){
        for(int j=i+1;j<=n;j++){
            if(j-i<sum){
                j=i+sum-1;
            }
            int aa = a[j]-a[i];
            if(aa%m==0){
                sum = max(sum,j-i);
            }
        }
    }
    cout<<sum<<endl;
 
    return 0;
}

 赛完之后看到题解说，其实是后台数据没出好，当它为字串也可以过。

所以又重新学了一下，滚动数组加压缩dp：

代码如下：

题解：

为求最大子序列，就是找到最长。

开始先将输入的初始化，就是先对K求模，然后我们来看一下滚动数组就是将空间简化，

当我当前的状态只与我前一次的数据有关时，我只需要保留前一状态的数据就可以了，就

这样减少空间复杂度，然后就是下面的状态压缩了。

dp[last][n] 指的时余数为n时的子序列的最长长度。

所以下面两个状态压缩方程就是根据它的上一次的状态来取决的，dp[1-last][n].

只有当我前一个状态为为非零的状态时，才好进行累加操作，否则就会是错的。

dp[last][(j+a[i])%m] = max(dp[1-last][(j+a[i])%m],dp[1-last][j]+1);

否则，我们就将前一个状态传给当前状态。

dp[last][(j+a[i])%m] = dp[1-last][(j+a[i])%m];

#include <iostream>
#include <cstring>
using namespace std;

int dp[2][10000005];
int a[110000];
int n,m;

int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>a[i];
        a[i]%=m;
    }
    memset(dp,0,sizeof(0));
    dp[0][a[0]] = 1;
    int last = 0;//滚动标记
    for(int i=1;i<n;i++){
        last = 1-last;
        for(int j=0;j<m;j++){
            if(dp[1-last][j]){
                dp[last][(j+a[i])%m] = max(dp[1-last][(j+a[i])%m],dp[1-last][j]+1);
            }else{
                dp[last][(j+a[i])%m] = dp[1-last][(j+a[i])%m];
            }
        }
    }
    cout<<dp[last][0]<<endl;
    return 0;
}