校内的hu测（10.5）

@liu_runda

这次的hu测，扒的是衡水中学lrd大神出的noip模拟题

简单来看一下吧：

T1.简(simple)

【题目描述】

大道至简.这就是出题人没有写题目背景的原因.

给出2n个数字,将它们划分成n组,每组的得分为这一组中两个数字的较小值.

求最大得分.

【输入格式】

第一行一个整数n表示正整数的数目.

接下来一行2n个空格隔开的整数a1,a2…a2n

【输出格式】

一行一个整数表示最大得分.

【样例输入】

2

1 3 1 2

【样例输出】

3

【数据范围】

对于10%的数据:n=2

对于另外20%的数据n<=7

对于另外20%的数据:n<=1000

对于另外20%的数据:ai<=100

对于100%的数据: n<=100000,1<=ai<=10^9

分析：

考虑2n个数字中最小的数字,

和它一组的数字产生的价值必然等于这个最小的数字

因此让第2小的数字和它一组是最优的

排序后从小到大依次分组即可

tip

开ll

这里写代码片
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long

using namespace std;

int n;
int a[];

int main()
{
    freopen("simple.in","r",stdin);  
    freopen("simple.out","w",stdout);
    scanf("%d",&n);
    for (int i=;i<=*n;i++)
        scanf("%d",&a[i]);
    sort(a+,a++n+n);
    ll ans=;
    for (int i=;i<=n*;i+=)
        ans+=(ll)a[i];
    printf("%lld",ans);
    return ;
}
           

T2.单(single)

【题目描述】

单车联通大街小巷.这就是出题人没有写题目背景的原因.

对于一棵树,认为每条边长度为1,每个点有一个权值a[i].dis(u,v)为点u到v的最短路径的边数.dis(u,u)=0.对每个点求出一个重要程度.点x的重要程度b[x]定义为其他点到这个点的距离乘上对应的点权再求和. 即:b[x]=a[1]*dis(1,x)+a[2]*dis(2,x)+….+a[n]*dis(n,x)

现在有很多树和对应的a数组，并求出了b数组.不幸的是，记录变得模糊不清了.幸运的是,树的形态完好地保存了下来,a数组和b数组至少有一个是完好无损的,但另一个数组完全看不清了.

希望你求出受损的数组.多组数据.

【输入格式】

第一行输入一个T，表示数据组数。接下来T组数据。

每组数据的第1行1个整数n表示树的点数.节点从1到n编号.

接下来n-1行每行两个整数u,v表示u和v之间有一条边.

接下来一行一个整数t，表示接下来数组的类型。

t=0则下一行是a数组，t=1则下一行是b数组。

接下来一行n个整数，表示保存完好的那个数组，第i个数表示a[i]或b[i]。

【输出格式】

T行，每组数据输出一行表示对应的a数组或b数组，数组的相邻元素用一个空格隔开。忽略行末空格和行尾回车.

【样例输入】

2

2

1 2

1

17 31

2

1 2

31 17

【样例输出】

31 17

17 31

【数据范围】

对于100%的数据，T=5,2<=n<=100000,1<=u,v<=n,保证给出的n-1条边形成一棵树

对于100%的数据，t=0或t=1,1<=a[i]<=100,1<=b[i]<=10^9，t=1时保证给出的b数组对应唯一的一个a数组。

对于100%的数据，单个输入文件不会包含超过2000000个整数，这段话可以理解为，你不必考虑输入输出对程序运行时间的影响。

对于100%的数据，保证答案不会超过int能表示的范围

接下来的表格中描述了每个测试点的具体特征。每个测试点的5组数据均符合表格中对应的特征。

测试点编号	n	特殊限制
1	<=1000	均有t=0
2	<=5	均有t=1,答案中a[i]<=20
3	<=100	均有t=1
4	<=100	均有t=1
5	<=30000	所有边满足v=u+1
6	<=10^5	均有t=0
7	<=10^5	均有t=0
8	<=10^5	无特殊限制
9	<=10^5	无特殊限制
10	<=10^5	无特殊限制

分析：

先说一下我自己yy的写法

受到1002T2的启发

我发现b可以两遍dfs算出(树形dp)：

sum：子树中Σai

zz：只在子树中计算的b

所以每个点的b可以从根向叶子推出

void dfs(int now,int f)
{
    deep[now]=deep[f]+;
    sum[now]=a[now];
    for (int i=st[now];i;i=way[i].nxt)
        if (way[i].y!=f)
        {
            dfs(way[i].y,now);
            zz[now]+=zz[way[i].y]+sum[way[i].y];   //子树中的b 
            sum[now]+=sum[way[i].y];
        }    
}

void js(int now,int fa)
{
    if (fa==)
    {
        b[now]=zz[now]; 
    }
    else
    {
        int ff=b[fa];
        ff-=zz[now]; ff-=sum[now];
        ff+=(sum[]-sum[now]);
        b[now]=ff+zz[now];
    } 
    for (int i=st[now];i;i=way[i].nxt)
        if (way[i].y!=fa)
            js(way[i].y,now);
}
           

所以稳妥30

现在的问题主要在t=1上：

我们遵从由浅入深的原则

先看链上的问题

对于测试点5,树退化为1条链。这个测试点的作用主要在于启发选手想到正解的思路。

考虑t=1的情况

我们知道suf(2)+suf(3)+…+suf(n)的值（即b[1])

知道pre(1) + suf(3) + suf(4) +…+suf(n)的值(即b[2])

知道pre(1)+pre(2)+suf(4)+…+suf(n)的值（即b[3]）

注意到这些式子有很多项是一样的

考虑作差，可以得到下面的式子:

b[2]-b[1]=pre(1)-suf(2)

b[3]-b[2]=pre(2)-suf(3)

…..

b[i+1]-b[i]=pre(i)-suf(i+1)

这些式子是有实际意义的,考虑从b[1]变到b[2]时答案的变化量

变化的就是1和2之间连边的贡献

同时,记SUM=a[1]+a[2]+…+a[n-1]+a[n]，

显然pre(i)+suf(i+1)=SUM

因此pre(i)=SUM-suf(i+1)

将上面式子中所有pre换成suf，

我们就知道了SUM-2*suf(2) ,SUM-2*suf(3)…SUM-2*suf(n)的取值

但是这些式子还不够

b[1]=suf(2)+suf(3)+suf(4)+… +suf(n)

我们发现suf(2)到suf(n)都恰好出现了一次

而之前得到了n-1个形如SUM-2*suf(i)的式子，

将这n-1个式子相加

suf(2),suf(3)…suf(n)前面的系数都是2，SUM的系数为(n-1)

那么把这个式子加上2*b[1]=2*（suf(2)+suf(3)+…+suf(n)），

就得到了(n-1)*SUM,

将求得的SUM代入之前的n-1个式子可以得到suf(2),suf(3),suf(4)……suf(n)

差分一下即可得到a数组.

时间复杂度O(n),可以通过第5个测试点

推出这个做法,树上的做法也就不难想了

t=1的时候，我们先随便找一个点为根建树，

将有边直接相连的两个点的b[i]作差

设x的父亲为fa[x],

以x为根的子树中所有a[i]之和为sum(x),

SUM=a[1]+a[2]+…+a[n-1]+a[n]，

那么b[x]-b[fa[x]]=(SUM-sum(x))-sum(x).

同链的情况一样,得到n-1个式子，

将树根的b[i]也列出式子,

b[root]=sum(2)+sum(2)+..+sum(n)

可以求出全部a[i]之和,

然后就可以根据之前的式子推出所有的a[i]

T3.题(problem)

【题目描述】

出个题就好了.这就是出题人没有写题目背景的原因.

你在平面直角坐标系上.

你一开始位于(0,0).

每次可以在上/下/左/右四个方向中选一个走一步.

即:从(x,y)走到(x,y+1),(x,y-1),(x-1,y),(x+1,y)四个位置中的其中一个.

允许你走的步数已经确定为n.现在你想走n步之后回到(0,0).但这太简单了.你希望知道有多少种不同的方案能够使你在n步之后回到(0,0).当且仅当两种方案至少有一步走的方向不同,这两种方案被认为是不同的.

答案可能很大所以只需要输出答案对10^9+7取模后的结果.(10^9+7=1000000007,1和7之间有8个0)

这还是太简单了,所以你给能够到达的格点加上了一些限制.一共有三种限制,加上没有限制的情况,一共有四种情况,用0,1,2,3标号:

0.没有任何限制,可以到达坐标系上所有的点,即能到达的点集为{(x,y)|x,y为整数}

1.只允许到达x轴非负半轴上的点.即能到达的点集为{(x,y)|x为非负数,y=0}

2.只允许到达坐标轴上的点.即能到达的点集为{(x,y)|x=0或y=0}

3.只允许到达x轴非负半轴上的点,y轴非负半轴上的点以及第1象限的点.即能到达的点集为{(x,y)|x>=0,y>=0}

【输入格式】

一行两个整数(空格隔开)n和typ,分别表示你必须恰好走的步数和限制的种类.typ的含义见【题目描述】.

【输出格式】

一行一个整数ans,表示不同的方案数对10^9+7取模后的结果.

【样例输入0】

100 0

【样例输出0】

383726909

【样例输入1】

100 1

【样例输出1】

265470434

【样例输入2】

100 2

【样例输出2】

376611634

【样例输入3】

100 3

【样例输出3】

627595255

【数据范围】

10%的数据,typ=0,n<=100

10%的数据,typ=0,n<=1000

5%的数据, typ=0,n<=100000

10%的数据,typ=1,n<=100

10%的数据,typ=1,n<=1000

5%的数据, typ=1,n<=100000

10%的数据,typ=2,n<=100

15%的数据,typ=2,n<=1000

10%的数据,typ=3,n<=100

10%的数据,typ=3,n<=1000

5%的数据, typ=3,n<=100000

以上11部分数据没有交集.

100%的数据,保证n为偶数,2<=n<=100000,0<=typ<=3.

分析：

考场上强行dp+滚动数组优化空间

卡过65

正解：卡特兰数

int doit1()
{
    int i,j,k;
    int now=;
    f[][n/+][n/+]=;
    for (i=;i<=n;i++)
    {
        now^=;
        memset(f[now],,sizeof(f[now]));
        for (j=;j<=n+;j++)
            for (k=;k<=n+;k++)
            {
                if (j) f[now][j][k]+=f[now^][j-][k],f[now][j][k]%=mod;
                if (k) f[now][j][k]+=f[now^][j][k-],f[now][j][k]%=mod;
                f[now][j][k]+=f[now^][j+][k],f[now][j][k]%=mod;
                f[now][j][k]+=f[now^][j][k+],f[now][j][k]%=mod;
            }
    }
    return f[now][n/+][n/+]%mod;
}

int doit2()
{
    int i,j,k;
    int now=;
    f[][n/+][n/+]=;
    for (i=;i<=n;i++)
    {
        now^=;
        memset(f[now],,sizeof(f[now]));
        for (j=;j<=n+;j++)
        {
            if (j) f[now][j][n/+]+=f[now^][j-][n/+],f[now][j][n/+]%=mod;
            f[now][j][n/+]+=f[now^][j+][n/+],f[now][j][n/+]%=mod;
        }
        for (k=;k<=n+;k++)
        {
            if (k) f[now][n/+][k]+=f[now^][n/+][k-],f[now][n/+][k]%=mod;
            f[now][n/+][k]+=f[now^][n/+][k+],f[now][n/+][k]%=mod;
        }
    }
    return f[now][n/+][n/+]%mod;
}

int doit3()
{
    int i,j,k;
    int now=;
    f[][][]=;
    for (i=;i<=n;i++)
    {
        now^=;
        memset(f[now],,sizeof(f[now]));
        for (j=;j<=n+;j++)
            for (k=;k<=n+;k++)
            {
                if (j) f[now][j][k]+=f[now^][j-][k],f[now][j][k]%=mod;
                if (k) f[now][j][k]+=f[now^][j][k-],f[now][j][k]%=mod;
                f[now][j][k]+=f[now^][j+][k],f[now][j][k]%=mod;
                f[now][j][k]+=f[now^][j][k+],f[now][j][k]%=mod;
            }
    }
    return f[now][][]%mod;
}

int solve()
{
    int i,j,k;
    int now=;
    ff[][]=;
    for (i=;i<=n;i++)
    {
        now^=;
        memset(ff[now],,sizeof(ff[now]));
        for (j=;j<=n+;j++)
        {
            if (j) ff[now][j]+=ff[now^][j-],ff[now][j]%=mod;
            ff[now][j]+=ff[now^][j+],ff[now][j]%=mod;
        }
    }
    return ff[now][]%mod;
}
           

T3详尽题解