【NOIP模拟赛】总结

题目描述

输入

第一行是5个正整数，n，m，k，S，T，分别代表无向图点数，边数，蝙蝠的数量，二小姐所在起点的编号，目标点的编号。

第二行是k个正整数，分别代表大小姐每个蝙蝠所在的起点的编号。接下来有m行，每行有4个正整数，u，v，q，p，分别是该边的起点、终点，蝙蝠通过该

路花费的代价，二小姐通过该路花费的代价。

输出

一行，一个整数，所有人物达到终点所需要的代价的和的最小值。

样例输入

5 5 2 3 4 1 5 1 2 3 5 3 2 3 5 2 4 4 9 3 4 9 6 5 4 1 1

样例输出

提示

1号蝙蝠从1到2，花费3

二小姐从3到2，花费5，遇见蝙蝠，之后不计算费用1号蝙蝠从2到4，花费4

2号蝙蝠从5到4，花费1

总计13

其中30%：n<=200。另有20%:保证S=T。

另有20%：保证k<=5，n<=1000,m<=10000。100%：n<=10000，m<=100000，k<=10000，1<=S、T、u、v<=n，1<=p、q<=1000，不保证

蝙蝠起点互不相等，数据中可能有重边和自环，保证所有点均能走到T点（即不存在无解情况）。

题解：

很容易想到枚举每一个个点作为蝙蝠和二小姐的交点

但是时间内存不允许，于是我们优化，我们可以虚拟一个S' S'到每一个蝙蝠的起点有一条，长度为 -dist ki-T

然后答案就是sum(F[ki][T])+min(F[s'][i]+F[S][i]+F[i][T])

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 using namespace std;

 const int N=,M=,INF=,MOD=;

 int head[N],num=;

 struct Lin{

     int next,to,dis[];

 }a[M<<];

 void init(int x,int y,int z1,int z2){

     a[++num].next=head[x];a[num].to=y;a[num].dis[]=z1;a[num].dis[]=z2;head[x]=num;

     if(!x)return ;a[++num].next=head[y];a[num].to=x;a[num].dis[]=z1;a[num].dis[]=z2;head[y]=num;

 }

 int gi(){

     int str=;char ch=getchar();

     while(ch>'' || ch<'')ch=getchar();

     while(ch>='' && ch<='')str=str*+ch-,ch=getchar();

     return str;

 }

 int n,m,k,S,T;int f[][N],q[N*],s[N];bool vis[N];

 void spfa(int sta,bool tt)

 {

     for(int i=;i<=n;i++)vis[i]=false,f[sta][i]=INF;

     int t=,sum=,x,u;

     int from=;

     if(sta==)from=S;if(sta==)from=T;if(sta==)from=;

     q[]=from;vis[from]=true;f[sta][from]=;

     while(t!=sum)

     {

         t++;t%=MOD;

         x=q[t];

         for(int i=head[x];i;i=a[i].next)

         {

             u=a[i].to;

             if(a[i].dis[tt]+f[sta][x]<f[sta][u])

             {

                 f[sta][u]=f[sta][x]+a[i].dis[tt];

                 if(!vis[u])vis[u]=true,sum++,sum%=MOD,q[sum]=u;

             }

         }

         vis[x]=false;

     }

 }

 int main()

 {

     n=gi();m=gi();k=gi();S=gi();T=gi();

     for(int i=;i<=k;i++)s[i]=gi();

     int x,y,z1,z2;

     for(int i=;i<=m;i++)

     {

         x=gi();y=gi();z1=gi();z2=gi();

         if(x==y)continue;

         init(x,y,z1,z2);

     }

     spfa(,);spfa(,);

     long long sum=;

     for(int i=;i<=k;i++)init(,s[i],-f[][s[i]],),sum+=f[][s[i]];

     spfa(,);

     long long ans=INF,tmp;

     long long pp=;

     for(int i=;i<=n;i++)

     {

         tmp=f[][i]+f[][i]+f[][i];

         if(tmp<ans)ans=tmp,pp=i;

     }

     printf("%lld",ans+sum);

     return ;

 }

题目描述

输入

第一行是一个正整数n,表示上式中的p的个数。

接下来有n行,每一行两个正整数pi 和ei 。

输出

样例输入

2 2 2 3 2

样例输出

2 2 3 1

提示

样例解释

N=2*2*3*3=36

phi(N）=36*(1-1/2)*(1-1/3)=12 12=2*2*3

样例输入二

37 1

3 4

37 1

333667 2

样例输出二

2 4

3 8

37 2

167 1 333667 1

题解：

水的数论，分解每一个pi-1即可

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 #include<cmath>

 using namespace std;

 typedef long long ll;

 const int N=,M=,T=;

 int gi(){

     int str=;char ch=getchar();

     while(ch>'' || ch<'')ch=getchar();

     while(ch>='' && ch<='')str=str*+ch-'',ch=getchar();

     return str;

 }

 bool d[M];int mark[T];bool cf[T];

 ll qm(ll x,int k)

 {

     if(x==)return ;

     if(k==)return ;

     ll sum=;

     while(k)

     {

         if(k&)sum*=x;

         k>>=;x*=x;

     }

     return sum;

 }

 int a[T],num=;int z[N],t=;

 void qd(int p)

 {

     int lim;int c;

     num=;

     for(int i=;i<=t;i++){if(p%z[i]==)a[++num]=z[i];}

     for(int i=;i<=num;i++)

     {

         int k=,tmp=p;

         while(tmp)

         {

             if(tmp%a[i])break;

             k++;tmp/=a[i];

         }

         mark[a[i]]+=k;

     }

 }

 int main()

 {

     //freopen("pp.in","r",stdin);

     int n,x,y;

     scanf("%d",&n);

     memset(mark,,sizeof(mark));

     for(int i=;i<=n;i++)

     {

         x=gi();y=gi();

         mark[x]+=y;

         cf[x]=true;

     }

     int m=1e6;

     d[]=false;

     for(int i=;i<=m;i++)

     {

         if(d[i])continue;

         z[++t]=i;

         for(int j=*i;j<=m;j+=i)d[j]=true;

     }

     int to=1e6;

     for(int i=;i<=to;i++)

     {

         if(cf[i])

         qd(i-),mark[i]--;

     }

     for(int i=;i<=to;i++)

     {

         if(mark[i])printf("%d %d\n",i,mark[i]);

     }

     return ;

 }

题目描述

输入

第一行一个正整数n，代表积木的个数。接下来有n行，每行两个数li，ri，分别代表第i块积木左端点和右端点。

输出

输出一行两个整数，用一个空格隔开，分别代表最底层最多有多少积木和积木最少有多少层。

样例输入

6 1 2 2 3 4 5 5 6 1 4 3 6

样例输出

4 2

提示

第 1、2、3、4 块放在最底层，第 5 块第二层，第 6块第三层。此时底层共 4块积木。

第 1、2、6块放在最底层，第 3、4、5块第二层。此时高度为 2。

30%：n<=10,0<=l,r<=20

另 20%: n<=100,0<=l<=50,r=l+2,即每块积木长均为 2

100%：n<=100000,-2*10^8<=l,r<=2*10^8

题解：

贪心，第一问线段覆盖，按右端点排序，然后以此判断 l>=last 满足就加入

第二问将每一条线段拆成两个点再将每个点排序，线性扫描一边，遇l h++遇r h-- 意为能塞入底层就塞入

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 using namespace std;

 const int N=;

 int gi(){

     int str=,f=;char ch=getchar();

     while(ch>'' || ch<''){if(ch=='-')f=-;ch=getchar();}

     while(ch>='' && ch<='')str=str*+ch-,ch=getchar();

     return str*f;

 }

 struct Point{

     int l,r;

 }a[N];

 bool comp(const Point &p,const Point &q){return p.r<q.r;}

 struct Pointed{

     int x;bool t;

 }p[N<<];

 bool cmp(const Pointed &p,const Pointed &q){if(p.x!=q.x)return p.x<q.x;return p.t>q.t;}

 int main()

 {

     int n=gi();

     for(int i=;i<=n;i++)

     {

         a[i].l=gi();a[i].r=gi();

         p[(i<<)-].x=a[i].l;p[(i<<)-].t=;

         p[i<<].x=a[i].r;p[i<<].t=;

     }

     sort(a+,a+n+,comp);

     int from=-2e9,ans1=;

     for(int i=;i<=n;i++)

     {

         if(a[i].l>=from)

         {

             ans1++;

             from=a[i].r;

         }

     }

     printf("%d ",ans1);

     sort(p+,p+(n<<)+,cmp);

     int top=,ans2=,ppap=(n<<);

     for(int i=;i<=ppap;i++)

     {

         if(!p[i].t)top++;

         else top--;

         if(top>ans2)ans2=top;

     }

     printf("%d",ans2);

     return ;

 }

题目描述

擦弹(graze)

输入

第一行是1个正整数n，代表道路长度。

接下来有4n-4行，每行n个整数，第i行第j个数代表在i时刻（开始为0时刻）在第j格内受到的伤害。

输出

两个整数，用空格隔开，分别代表最小的miss数，和在miss数最小的情况下最大的graze 数。

样例输入

2 1 2 2 2 3 2 4 2

样例输出

30 10

提示

只有一种走法。

第一回合：第一格3分身，第二格1分身，miss5，graze1。

第二回合：第一格2分身，第二格2分身，miss8，graze2。

第三回合：第一格1分身，第二格3分身，miss9，graze3。

第四回合：第一格0分身，第二格4分身，miss8，graze4。

其中30%数据:n<=3其中50%数据:n<=10其中70%数据:n<=30

100%数据:n<=100,每时刻每格中弹幕数均为正数且小于 1000

题解：

简单的高维dp 注意高维常数 F[i][j][k][g]表示i时刻，第一个分身走的步数为j，第二个为k，第三个为g，第四个为l-i-j-k的最小miss值

然后以miss为最高优先级，每一次miss更新 graze就更新，miss相等则取较大者

第一维明显可以滚动掉注意边界条件

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 #include<cmath>

 using namespace std;

 const int N=,M=;

 int F[][N][N][N],p[][N][N][N];int a[N];

 int gi(){

     int str=;char ch=getchar();

     while(ch>'' || ch<'')ch=getchar();

     while(ch>='' && ch<='')str=str*+ch-,ch=getchar();

     return str;

 }

 int main()

 {

     int n;

     scanf("%d",&n);

     int m=*n-;

     int tmp=,l=,pc=;

     memset(F,/,sizeof(F));

     F[][][][]=;

     int c=,cc=;

     for(int i=;i<=m;i++)

     {

         for(int j=;j<=n;j++)

         {

             a[j]=gi();

         }

         for(int j=;j<n;j++)

         {

             if(j>i)break;

             for(int k=j;k<n;k++)

             {

                 if(k+j>i)break;

                 pc=k>i-j-k-n?k:i-j-k-n;

                 for(int g=pc;g<n;g++)

                 {

                     if(g+j+k>i)break;

                     l=i-j-k-g;

                     if(l<g-)break;

                     int *pp=&F[cc][j][k][g];

                     int *qq=&p[cc][j][k][g];

                     *pp=2e8;

                     *qq=;

                     tmp=a[j+]+a[k+]+a[g+]+a[l+];

                     if(tmp+F[c][j-][k][g]<=*pp&& j)

                     {

                         int t=F[c][j-][k][g];

                         if(tmp+t<*pp)

                         *qq=p[c][j-][k][g]+a[j];

                         else if(p[c][j-][k][g]+a[j]>*qq)*qq=p[c][j-][k][g]+a[j];

                         *pp=tmp+t;

                     }

                     if(tmp+F[c][j][k-][g]<=*pp&& k)

                     {

                         int t=F[c][j][k-][g];

                         if(tmp+t<*pp)

                         *qq=p[c][j][k-][g]+a[k];

                         else if(p[c][j][k-][g]+a[k]>*qq)*qq=p[c][j][k-][g]+a[k];

                         *pp=tmp+t;

                     }

                     if(tmp+F[c][j][k][g-]<=*pp&& g)

                     {

                        int t=F[c][j][k][g-];

                         if(tmp+t<*pp)

                         *qq=p[c][j][k][g-]+a[g];

                         else if(p[c][j][k][g-]+a[j]>*qq)*qq=p[c][j][k][g-]+a[g];

                         *pp=tmp+t;

                     }

                     if(tmp+F[c][j][k][g]<=*pp)

                     {

                         int t=F[c][j][k][g];

                         if(tmp+t<*pp)

                         *qq=p[c][j][k][g]+a[l];

                         else if(p[c][j][k][g]+a[l]>*qq)*qq=p[c][j][k][g]+a[l];

                         *pp=tmp+t;

                     }

                 }

             }

         }

         c^=;cc^=;

     }

     cout<<F[c][n-][n-][n-]<<" "<<p[c][n-][n-][n-];

     return ;

 }