计蒜客NOIP2017提高组模拟赛（四）day1

T1:小X的质数

小 X 是一位热爱数学的男孩子，在茫茫的数字中，他对质数更有一种独特的情感。小 X 认为，质数是一切自然数起源的地方。

在小 X 的认知里，质数是除了本身和 1 以外，没有其他因数的数字。

但由于小 X 对质数的热爱超乎寻常，所以小 X 同样喜欢那些虽然不是质数，但却是由两个质数相乘得来的数。

于是，我们定义，一个数是小 X 喜欢的数，当且仅当其是一个质数，或是两个质数的乘积。

而现在，小 X 想要知道，在 L 到 R 之间，有多少数是他喜欢的数呢？

输入格式

第一行输入一个正整数 Q，表示询问的组数。

接下来 Q行。包含两个正整数 L 和 R。保证 L≤R。

输出格式

输出 Q 行，每行一个整数，表示小 X 喜欢的数的个数。

数据范围与约定

样例解释 1

666 以内的质数有 2,3,5，而 4=2∗2,6=2∗3。因此 2,3,4,5,6 都是小 X 喜欢的数，而 1 不是。

样例输入1

1

1 6

样例输出1

样例输入2

样例输出2

样例输入3

10

20513 96703

15236 86198

23185 78205

40687 48854

42390 95450

63915 76000

36793 92543

35347 53901

44188 76922

82177 90900

样例输出3

小 X 正困在一个密室里，他希望尽快逃出密室。

密室中有 N 个房间，初始时，小 X 在 1 号房间，而出口在 N 号房间。

密室的每一个房间中可能有着一些钥匙和一些传送门，一个传送门会单向地创造一条从房间 X 到房间 Y 的通道。另外，想要通过某个传送门，就必须具备一些种类的钥匙（每种钥匙都要有才能通过）。幸运的是，钥匙在打开传送门的封印后，并不会消失。

然而，通过密室的传送门需要耗费大量的时间，因此，小 X 希望通过尽可能少的传送门到达出口，你能告诉小 X 这个数值吗？

另外，小 X 有可能不能逃出这个密室，如果是这样，请输出 "No Solution"。

输入格式

第一行三个整数 N,M,K，分别表示房间的数量、传送门的数量以及钥匙的种类数。

接下来 N 行，每行 K 个 0 或 1，若第 iii 个数为 1，则表示该房间内有第 iii 种钥匙，若第 iii 个数为 0，则表示该房间内没有第 iii 种钥匙。

接下来 M 行，每行先读入两个整数 X,Y，表示该传送门是建立在 X 号房间，通向 Y 号房间的，再读入 K 个 0 或 1，若第 iii 个数为 1，则表示通过该传送门需要 iii 种钥匙，若第 iii 个数为0，则表示通过该传送门不需要第 iii 种钥匙。

输出格式

输出一行一个 "No Solution"，或一个整数，表示最少通过的传送门数。

数据规模与约定

输入格式

第一行三个整数 N,Q,num，分别表示 X 城地点的个数，小 X 蒸发学水的天数，以及测试点编号。注意，测试点编号是为了让选手们更方便的获得部分分，你可能不需要用到这则信息，在下发的样例中，测试点编号的含义是该样例满足某一测试点限制。

接下来 N – 1 行，每行两个整数 X,Y，表示 X 地与 Y 地之间有一条边。

接下来 Q 行，每行三个整数 A,B,C，表示一天中，有一名学水从 A 地走到 B 地，而小 X 会从 C 地走到 B 地。

输出格式

输出 Q 行，每行一个整数，表示小 X 能够蒸发的水塘数。

数据规模与约定

特殊性质 1：第 i 条边连接第 i 和第 i+1个地点。

特殊性质 2：A=C。

更多测试样例

样例输入

样例输出

T1:
将线性筛数变形即可
可见线性筛数既可以筛质数，也可以顺便判断质数的一些情况

 #include<cstdio>

 #include<cstdlib>

 #include<algorithm>

 #include<cstring>

 #define MAXN 10000001

 using namespace std;

 int prime[MAXN],cnt;

 bool b[MAXN];

 bool c[MAXN];

 int f[MAXN];

 int main()

 {

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

     b[]=;

     for(int i=;i<MAXN;i++){

         if(!b[i]){

             prime[++cnt]=i;

         }

         for(int j=;j<=cnt&&i*prime[j]<MAXN;j++){

             b[i*prime[j]]=;

             c[i*prime[j]]+=(!b[i]);

             if(i%prime[j]==){

                 break;

             }

         }

     }

     for(int i=;i<MAXN;i++){

         f[i]=f[i-];

         if(!b[i]||c[i]){

             f[i]++;

         }

     }

     int Q;

     scanf("%d",&Q);

     for(int i=;i<=Q;i++){

         int L,R;

         scanf("%d%d",&L,&R);

         printf("%d\n",f[R]-f[L-]);

     }

     return ;

 }

Code1

T2:

由于每条边的边权都是1，宽搜即可

钥匙用二进制存贮，然后可以预处理下子集即可高效判断

 #include<cstdio>

 #include<cstdlib>

 #include<algorithm>

 #include<cstring>

 #include<vector>

 #define MAXN 5005

 #define MAXM 6005

 #define INF 0x7f7f7f7f

 using namespace std;

 int qL[],qK[],L=,R;

 int d[MAXN][];

 int n,m,k;

 int key_room[MAXN];

 int first[MAXN],Next[MAXM],to[MAXM],w[MAXM],cnt;

 //single edge

 int bel[][];

 void Add(int x,int y,int key){

     Next[++cnt]=first[x];first[x]=cnt;to[cnt]=y;w[cnt]=key;

 }

 void bfs(){

     memset(d,0x7f,sizeof(d));

     qL[++R]=;

     qK[R]=key_room[];

     d[qL[R]][qK[R]]=;

     while(L<=R){

         int p=qL[L],key=qK[L];L++;

         int D=d[p][key];

         for(int i=first[p];i;i=Next[i]){

             int j=to[i];

             if(!bel[key][w[i]]) continue;

             int dk=(key|key_room[j]);

             if(d[j][dk]>D+){

                 d[j][dk]=D+;

                 qL[++R]=j;

                 qK[R]=dk;

                 if(n==j){

                     printf("%d\n",d[j][dk]);

                     return ;

                 }

               }

         }

     }

     printf("No Solution\n");

 }

 int main()

 {

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

     scanf("%d%d%d",&n,&m,&k);

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

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

             int c;

             scanf("%d",&c);

             key_room[i]+=(c<<j);

         }

     }

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

         int x=,y=,need=;

         scanf("%d%d",&x,&y);

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

             int c;

             scanf("%d",&c);

             need+=(c<<j);

         }

         Add(x,y,need);

     }

     bel[][]=;

     for(int i=;i<(<<k);i++){

         for(int j=i;;j=i&j){

             bel[i][j]=;

             j--;

             if(j<){

                 break;

             }

         }

     }

     bfs();

     return ;

 }

Code2

T3：

裸LCA

注意下分类讨论

 #include<cstdio>

 #include<cstdlib>

 #include<algorithm>

 #include<cstring>

 #define MAXN 200005

 #define LOG 21

 using namespace std;

 int n,num;

 int first[MAXN],Next[MAXN*],to[MAXN*],cnt;

 int dep[MAXN];

 int fa[LOG][MAXN];

 //double edge

 void Add(int x,int y){

     Next[++cnt]=first[x];first[x]=cnt;to[cnt]=y;

     Next[++cnt]=first[y];first[y]=cnt;to[cnt]=x;

 }

 void dfs(int x){

     for(int e=first[x];e;e=Next[e]){

         int y=to[e];

         if(y==fa[][x]){

             continue;

         }

         fa[][y]=x;

         dep[y]=dep[x]+;

         dfs(y);

     }

 }

 int lca(int x,int y){

     if(dep[x]<dep[y]){

         swap(x,y);

     }

     for(int i=dep[x]-dep[y],p=;i;i>>=,p++){

         if(i&){

             x=fa[p][x];

         }

     }

     if(x==y){

         return x;

     }

     for(int k=LOG-;k>=;k--){

         if(fa[k][x]!=fa[k][y]){

             x=fa[k][x];

             y=fa[k][y];

         }

     }

     return fa[][x];

 }

 int dist(int x,int y){

     int LCA=lca(x,y);

     return dep[x]-dep[LCA]+dep[y]-dep[LCA];

 }

 int main()

 {

     int T;

     scanf("%d%d%d",&n,&T,&num);

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

         int x,y;

         scanf("%d%d",&x,&y);

         Add(x,y);

     }

     dfs();

     for(int k=;k<LOG;k++){

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

             fa[k][i]=fa[k-][fa[k-][i]];

         }

     }

     for(int i=;i<=T;i++){

         int A,B,C;

         scanf("%d%d%d",&A,&B,&C);

         printf("%d\n",(dist(B,A)+dist(B,C)-dist(A,C))/+);

     }

     return ;

 }

Code3