2017-10-02清北模拟赛

P98
zhx
竞赛时间： ????年??月??日??:??-??:??
题目名称
a
b
c
名称
a
b
c
输入
a.in
b.in
c.in
输出
a.out
b.out
c.out
每个测试点时限
1s
1s
1s
内存限制
256MB
256MB
256MB
测试点数目
10
10
10
每个测试点分值
10
10
10
是否有部分
无
无
无
题目类型
传统
传统
传统
注意 事项 （请务必仔细阅读） （请务必仔细阅读） ：
P98 zhxa
第 2 页 共 6 页

T1 a

【问题描述】
你是能看到第一题的 friends呢。
—— hja
世界上没有什么比卖的这 贵弹丸三还令人绝望事了，所以便么一道题。定义 𝑓(𝑥)为满足 (𝑎×𝑏)|𝑥的有序正整数对 (𝑎,𝑏)的个数。现在给定 𝑁，求 Σ𝑓(𝑖)𝑁𝑖=1
【输入格式】
一行个整数 𝑁。
【输出格式】
一行个整数代表答案 。
【样例输入】
6
【样例输出】
25
【数据范围与规定】
对于 30%的数据， 1≤𝑛≤100。
对于 60%的数据， 1≤𝑛≤1000。
对于 100%的数据， 1≤𝑛≤1011.
P98 zhxb
第 3 页 共6 页

 

/*
60 n^2做法，找规律发现，
对于每一个f[i]= i的每个约数的因子总个数、
处理处f[i]累加ans便可
但是数组开大爆零了 
*/
#include <cstdio>

#define LL long long
inline void read(LL &x)
{
    x=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}
const int N(1e8+5);
LL n,ans,tmp,cnt[N],num[N];

int Presist()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    read(n);
    for(int i=1; i<=n; ++i)
    {
        for(int j=1; j<=i; ++j)
            if(i%j==0) cnt[i]++,num[++tmp]=j;
        for(int j=1; j<=tmp; ++j)
            ans+=cnt[num[j]]; tmp=0;
    }
    printf("%lld\n",ans);
    return 0;
}

int Aptal=Presist();
int main(int argc,char*argv[]){;}

/*
将条件 满足(a,b)\x 的a，b数对个数 看作为
            存在 a*b*c<=n 的c 的取值
则原问题转化为 找出a*b*c<=n 的a，b，c的组成发难书
可以考虑 假设 a<=b<=c，通过枚举a,b累加ans 
可以发现a*a*a<=n,b*b<=n/a,所以复杂度 根号5/6 
*/
#include <cstdio>

#define LL long long
#ifdef WIN32
#define L_ "%I64d"
#else
#define L_ "%lld"
#endif

inline void read(LL &x)
{
    x=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}
LL n,ans,cnt;

int Presist()
{
    read(n);
    for(LL i=1,t; i*i<=(t=n/i); ++i)
      for(LL j=i+1; j*j<=t; ++j)
        cnt+=n/(i*j)-j;    //此时假定a<b<c，cnt累加三个数的不同种类数 
    ans+=cnt*6; cnt=0; // C(3,3) 累加ans 
    for(LL i=1,t; (t=i*i)<=n; ++i)
    {
        cnt+=n/t;    //此时假定a=b ，cnt累加a的种类数 
        if(t<=n/i) ans++,cnt--;//此时a==b==c单独累加ans 
    }
    ans+=cnt*3; //三个数中仅存在两个数相同的组合数 
    printf(L_ "\n",ans);
    return 0;
}

int Aptal=Presist();
int main(int argc,char*argv[]){;}

 

 

T2 b

【问题描述】
你是能看到第二题的 friends呢。
—— laekov
Hja和 Yjq为了 抢男主 角打了 起来 ，现在 他们 正在 一棵树 上决斗 。Hja在 A点，Yjq在 B点，Hja先发制人 开始 移动 。每次 他们 可以 沿着 一条边 移动 ，但 一旦 一条边 被对方 走过了 自己 就不能 再走这条边 了。每条 边上 都有 权值 ，他们 都希望 自己 的权值 尽量多 。现在 给你 这棵树 以及 他们 俩开始 的位置 ，问 Hja能 够获得 的最大权值 。
【输入格式】
第一行 两个 整数 𝑁,𝑀，代表 树的点数 和询问 的个数 。
接下来 𝑁−1行每行 三个 整数 𝑎,𝑏,𝑐，代表 从𝑎到𝑏有一条 权值 为𝑐的边 。
接下来 𝑀行，每行 两个整数 𝐴,𝐵代表 一次 询问 。
【输出格式】
对于 每次 询问 ，输出 一个 整数 代表 答案 。
【样例输入1】
2 1
1 2 3
1 2
【样例输出1】 3
【样例输入2】
3 2
1 2 3
1
3 2 3
1 3
【样例输出2】 3 4
P98 zhxb
第 4 页 共 6 页
【数据范围与规定】
对于 30%的数据 ，1≤𝑁,𝑀≤1000。
对于另外 30%的数据 ，𝑀=1。
对于 100%的数据， 1≤𝑁,𝑀≤105,0≤𝑐≤103,1≤𝑎,𝑏,𝐴,𝐵≤𝑁。

/*
分情况讨论增加ans 
倍增LCA 维护一条链上的点权和 
*/
#include<algorithm>
#include<cstdlib>
#include<cstring>
#include<cstdio>

using namespace std;

const int maxn=100010;

int n,m,en;
int z[maxn*3],f[maxn][20],q[maxn],depth[maxn];
sum[maxn*3][2],fd[maxn],start[maxn],end[maxn],value[maxn];

struct edge
{
    int e,d;
    edge *next;
}*v[maxn],ed[maxn<<1];

void add_edge(int s,int e,int d)
{
    en++;
    v[s].e=e;v[s].d=d;
    ed[en].next=v[s];v[s]=ed+en;
}

int get(int p,int d)
{
    if (d==-1) return p;
    int x=0;
    while (d)
    {
        if (d&1) p=f[p][x];
        d>>=1;
        x++;
    }
    return p;
}

int get_lca(int p1,int p2)
{
    if (depth[p1]<depth[p2]) swap(p1,p2);
    p1=get(p1,depth[p1]-depth[p2]);
    int x=0;
    while (p1!=p2)
    {
        if (!x || f[p1][x]!=f[p2][x])
        {
            p1=f[p1][x];
            p2=f[p2][x];
            x++;
        }
        else x--;
    }
    return p1;
}

int calc(int p1,int p2)
{
    if (p1==f[p2][0]) return value[1]-value[p2];
    else return value[p1]+fd[p1];
}

int calcp(int p,int v)
{
    int l=start[p]-1,r=end[p];
    while (l+1!=r)
    {
        int m=(l+r)>>1;
        if (v>z[m]) l=m;
        else r=m;
    }
    return r;
}

int main()
{
    freopen("b.in","r",stdin);
    freopen("b.out","w",stdout);

    scanf("%d%d",&n,&m);
    int tot=0;
    for (int a=1;a<n;a++)
    {
        int s,e,d;
        scanf("%d%d%d",&s,&e,&d);
        tot+=d;
        add_edge(s,e,d);
        add_edge(e,s,d);
    }
    depth[1]=1;
    int front=1,tail=1;
    q[1]=1;
    for (;front<=tail;)
    {
        int now=q[front++];
        for (edge *e=v[now];e;e=e->next)
            if (!depth[e.e])
            {
                depth[e.e]=depth[now]+1;
                fd[e.e]=e->d;
                f[e.e][0]=now;
                int p=now,x=0;
                while (f[p][x])
                {
                    f[e.e][x+1]=f[p][x];
                    p=f[p][x];
                    x++;
                }
                q[++tail]=e.e;
            }
    }
    int cnt=0;
    for (int a=n;a>=1;a--)
    {
        int now=q[a];
        start[now]=cnt+1;
        for (edge *e=v[now];e;e=e.next)
            if (depth[e.e]==depth[now]+1)
            {
                z[++cnt]=value[e.e]+e.d;
                value[now]+=value[e.e]+e.d;
            }
        z[++cnt]=tot-value[now];
        end[now]=cnt;
        sort(z+start[now],z+end[now]+1);
        sum[end[now]][0]=z[end[now]];
        sum[end[now]][1]=0;
        for (int a=end[now]-1;a>=start[now];a--)
        {
            sum[a][0]=sum[a+1][0];
            sum[a][1]=sum[a+1][1];
            if ((a&1)==(end[now]&1)) sum[a][0]+=z[a];
            else sum[a][1]+=z[a];
        }
        cnt++;
    }
    for (int a=1;a<=m;a++)
    {
        int p1,p2;
        scanf("%d%d",&p1,&p2);
        int lca=get_lca(p1,p2);
        int dist=depth[p1]+depth[p2]-2*depth[lca];
        int delta=dist/2+(dist&1);
        int px,px1,px2;
        if (depth[p1]-depth[lca]<delta) px=get(p2,dist-delta);
        else px=get(p1,delta);
        if (depth[p1]-depth[lca]<delta-1) px1=get(p2,dist-delta+1);
        else px1=get(p1,delta-1);
        if (depth[p2]-depth[lca]<dist-delta-1) px2=get(p1,delta+1);
        else px2=get(p2,dist-delta-1);
        int ans=0;
        if (p1==px)
        {
            if (p2==px) ans=sum[start[px]][0];
            else
            {
                int v2=calc(px2,px);
                int p=calcp(px,v2);
                ans=sum[p+1][0]+sum[start[px]][1]-sum[p][1];
            }
        }
        else
        {
            if (p2==px)
            {
                int v1=calc(px1,px);
                int p=calcp(px,v1);
                ans=v1+sum[p+1][1]+sum[start[px]][0]-sum[p][0];
            }
            else
            {
                int v1=calc(px1,px);
                int pp1=calcp(px,v1);
                int v2=calc(px2,px);
                int pp2=calcp(px,v2);
                if (pp2==pp1) pp2++;
                if (pp1>pp2) swap(pp1,pp2);
                ans=v1+sum[pp2+1][dist&1]+sum[pp1+1][1-(dist&1)]-
                       sum[pp2][1-(dist&1)]+sum[start[px]][dist&1]-sum[pp1][dist&1];
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

 

 

P98 zhxc
第 5 页 共 6 页

T3 c

【问题描述】
你是能看到第三题的 friends呢。
—— aoao
Yjq买了 36个卡包，并且把他们排列成 6×6的阵型准备开包 。左上角是(0,0)，右下角为 ，右下角为 (5,5)。为了能够开到更多的金色普通卡， 。为了能够开到更多的金色普通卡， Yjq会为每个包添加 1−5个玄学值，每可以是 个玄学值，每可以是 1−30中的一个整数。但是不同玄学值会造 中的一个整数。但是不同玄学值会造 成不同的欧气加，具体如下：
1、同一个卡包如果有两相的玄学值会无限大欧气加成。
2、同一个卡包如果 有 两个相邻的玄学值会𝐴点欧气加成。
3、相邻的两个卡包如果有 同玄学值会𝐵点欧气加成。
4、相邻的两个卡包如果有 玄学值会𝐶点欧气加成。
5、距离为 2的卡包如果有 相同玄学值会𝐷点欧气加成。
6、距离为 2的卡包如果有 相邻玄学值会𝐸点欧气加成。
以上的所有 加成是每存在一个符合条件就会次，如包卡以上的所有 加成是每存在一个符合条件就会次，如包卡1,2,3的玄 学值就会加两次。
但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使但是 ，玄学值个不可控的东西即使Yjq也只能自己决定 也只能自己决定 也只能自己决定 也只能自己决定 也只能自己决定 也只能自己决定 也只能自己决定 (2,2),(2,3),(3,2),(3,3)这几包卡的玄学值。为了能够抽到更多金色普通， 这几包卡的玄学值。为了能够抽到更多金色普通， Yjq想知道自己能够获得的最 少的欧气加成是多。 注意 你只能 修改 玄学值 ，不能 修 改玄学值 的个数 。
【输入格式】
输入的第一行有 5个整数 𝐴,𝐵,𝐶,𝐷,𝐸。
接下去有 6×6的代表初始玄学值。
每个玄学值为 [𝑛:𝑎1,𝑎2,⋯,𝑎𝑛]的描述形式。
【输出格式】
一行个整数代表答案。
【样例输入】
5 4 3 2 1
[1:1][2][3][4][5][6]
[1:1][2][3][4][5][6]
[1:1][2][5:1,2,3,4,5][5][6]
[1:1][ 1:2][5:1,2,3,4,5][5][6]
[1:1][2][3][4][5][6]
[1:1][2][3][4][5][6]
P98 zhxc
第 6 页 共 6 页
【样例输出】
250
【数据规模与约定】
对于 100%的数据， 1≤𝐴,𝐵,𝐶,𝐷,𝐸≤100,1≤𝑛≤5,1≤𝑎𝑖≤30。有部分 。有部分 。

 

 

/*
九维DP
维护点之间的最小价值 
*/
#include<algorithm>
#include<cstdlib>
#include<cstring>
#include<cstdio>

using namespace std;

#define now pre[a][b][c][d][e][s1][s2][s3][s4]
#define dis(a,b,c,d) (abs(a-c)+abs(b-d))

const int INF=0x3f3f3f3f;

int A,B,C,D,E,num[10][10],value[10][10][10],delta[10][10][40],dp[31][6][6][6][6][2][2][2][2];

char s[500];

bool map[6][6][6][6];

int main()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);

    scanf("%d%d%d%d%d",&A,&B,&C,&D,&E);
    for (int a=0;a<6;a++)
    {
        scanf("%s",s);
        int p=0;
        for (int b=0;b<6;b++)
        {
            int px=p;
            while (s[px]!=']')
                px++;
            p++;
            num[a][b]=s[p]-'0';
            p++;
            p++;
            for (int c=1;c<=num[a][b];c++)
            {
                int v=0;
                while (s[p]>='0' && s[p]<='9')
                {
                    v=v*10+s[p]-'0';
                    p++;
                }
                value[a][b][c]=v;
                p++;
            }
            p=px+1;
        }
    }
    int base=0;
    for (int a=0;a<6;a++)
        for (int b=0;b<6;b++)
            if (a>=2 && a<=3 && b>=2 && b<=3) ;
            else
            {
                sort(value[a][b]+1,value[a][b]+num[a][b]+1);
                for (int c=2;c<=num[a][b];c++)
                    if (value[a][b][c]-value[a][b][c-1]==1) base+=A;
                for (int c=2;c<=3;c++)
                    for (int d=2;d<=3;d++)
                    {
                        if (dis(a,b,c,d)==1)
                        {
                            for (int e=1;e<=num[a][b];e++)
                            {
                                delta[c][d][value[a][b][e]]+=B;
                                delta[c][d][value[a][b][e]-1]+=C;
                                delta[c][d][value[a][b][e]+1]+=C;
                            }
                        }
                        if (dis(a,b,c,d)==2)
                        {
                            for (int e=1;e<=num[a][b];e++)
                            {
                                delta[c][d][value[a][b][e]]+=D;
                                delta[c][d][value[a][b][e]-1]+=E;
                                delta[c][d][value[a][b][e]+1]+=E;
                            }
                        }
                    }
                for (int c=0;c<6;c++)
                    for (int d=0;d<6;d++)
                        if (dis(a,b,c,d)<=2 && (c!=a || d!=b) && !map[a][b][c][d])
                        {
                            map[a][b][c][d]=map[c][d][a][b]=true;
                            if (c>=2 && c<=3 && d>=2 && d<=3) ;
                            else
                            {
                                int dist=dis(a,b,c,d);
                                for (int e=1;e<=num[a][b];e++)
                                    for (int f=1;f<=num[c][d];f++)
                                    {
                                        if (abs(value[a][b][e]-value[c][d][f])==0)
                                        {
                                            if (dist==1) base+=B;
                                            else base+=D;
                                        }
                                        if (abs(value[a][b][e]-value[c][d][f])==1)
                                        {
                                            if (dist==1) base+=C;
                                            else base+=E;
                                        }
                                    }
                            }
                        }
            }
    memset(dp,0x3f,sizeof(dp));
    dp[0][0][0][0][0][0][0][0][0]=base;
    for (int a=0;a<30;a++)
        for (int b=0;b<=num[2][2];b++)
            for (int c=0;c<=num[2][3];c++)
                for (int d=0;d<=num[3][2];d++)
                    for (int e=0;e<=num[3][3];e++)
                        for (int s1=0;s1<=1;s1++)
                            for (int s2=0;s2<=1;s2++)
                                for (int s3=0;s3<=1;s3++)
                                    for (int s4=0;s4<=1;s4++)
                                        if (dp[a][b][c][d][e][s1][s2][s3][s4]!=INF)
                                        {
                                            int v=dp[a][b][c][d][e][s1][s2][s3][s4];
                                            for (int sx1=0;sx1<=(b!=num[2][2]);sx1++)
                                                for (int sx2=0;sx2<=(c!=num[2][3]);sx2++)
                                                    for (int sx3=0;sx3<=(d!=num[3][2]);sx3++)
                                                        for (int sx4=0;sx4<=(e!=num[3][3]);sx4++)
                                                        {
                                                            int wmt=0;
                                                            if (sx1) 
                                                            {
                                                                wmt+=delta[2][2][a+1];
                                                                if (s1) wmt+=A;
                                                                if (s2) wmt+=C;
                                                                if (s3) wmt+=C;
                                                                if (s4) wmt+=E;
                                                            }
                                                            if (sx2) 
                                                            {
                                                                wmt+=delta[2][3][a+1];
                                                                if (s1) wmt+=C;
                                                                if (s2) wmt+=A;
                                                                if (s3) wmt+=E;
                                                                if (s4) wmt+=C;
                                                            }
                                                            if (sx3) 
                                                            {
                                                                wmt+=delta[3][2][a+1];
                                                                if (s1) wmt+=C;
                                                                if (s2) wmt+=E;
                                                                if (s3) wmt+=A;
                                                                if (s4) wmt+=C;
                                                            }
                                                            if (sx4) 
                                                            {
                                                                wmt+=delta[3][3][a+1];
                                                                if (s1) wmt+=E;
                                                                if (s2) wmt+=C;
                                                                if (s3) wmt+=C;
                                                                if (s4) wmt+=A;
                                                            }
                                                            if (sx1 && sx2) wmt+=B;
                                                            if (sx1 && sx3) wmt+=B;
                                                            if (sx1 && sx4) wmt+=D;
                                                            if (sx2 && sx3) wmt+=D;
                                                            if (sx2 && sx4) wmt+=B;
                                                            if (sx3 && sx4) wmt+=B;
                                                            int &t=dp[a+1][b+sx1][c+sx2][d+sx3][e+sx4][sx1][sx2][sx3][sx4];
                                                            if (t>v+wmt) t=v+wmt;
                                                        }
                                        }
    int ans=INF;
    for (int a=0;a<=1;a++)
        for (int b=0;b<=1;b++)
            for (int c=0;c<=1;c++)
                for (int d=0;d<=1;d++)
                    ans=min(ans,dp[30][num[2][2]][num[2][3]][num[3][2]][num[3][3]][a][b][c][d]);
    printf("%d\n",ans);

    return 0;
}