【2013杭州区域赛】部分题解 hdu4770—4780

1008：

题意：

有20W个数，每个数都在20W以内，现在有20W个询问，每次询问L，R区间内不会打架的数有多少个

定义两个数不互质 就会打架

解法：

脑洞很大的一道题，先要进行预处理，对每一个数预处理出 最大的，没有跟他不互质数（即这个数不会打架）的区间

显然可以通过找到这个数左边和右边的第一个跟他互质的数来求得此区间，那么这个怎么求呢，发现可以通过枚举当前数的质因数找到

我们先处理，每一个数左边的最后一次出现的坐标，这样每扫到一个数，都只需要对这个数及其质因数进行更新

找到了每个数的上述区间后，我们发现设某个数的上述区间为 [L,R]，这个数自己的位置为pos，现在对于一个询问[a,b]

这个数是询问中的一个答案的条件就是   L<=a,b<=R 且 a<=pos<=b。现在可以离线进行更新和查询

我们可以在L 处将区间[pos,R]位置的值+1，并在pos处对该区间的值 -1，那么对于某个查询[a,b] 只需要在扫到a的时候，单点查询b的值即可

代码：

 #include <bits/stdc++.h>
 using namespace std;
 int a[];
 int l[];
 int r[];
 int pre[];
 vector<int>d[];
 bool np[];
 void setprime(int maxn)
 {
     memset(np,,sizeof(np));
     for(int i=; i<=maxn; i++)
     {
         if(np[i]==)
             d[i].push_back(i);
         for(int j=i+i; j<=maxn; j+=i)
         {
             np[j]=;
             if(np[i]==)
                 d[j].push_back(i);
         }
     }
 }
 int n,m;
 struct node
 {
     int type; //-1:+1 -2:-1,else &sup2;é&Ntilde;&macr;;
     int pos;
     int num;
     bool operator <(const node a)const
     {
         if(pos!=a.pos)
             return pos<a.pos;
         else
         {
             return type<a.type;
         }
     }
 };
 int ans[];
 vector<node>q;
 int t[];
 int lowbit(int x)
 {
     return x&(-x);
 }
 
 int getSum(int x)
 {
     int sum = ;
     while(x)
     {
         sum += t[x];
         x -= lowbit(x);
     }
     return sum;
 }
 
 void add(int x , int val)
 {
     while(x <=)
     {
         t[x] += val;
         x += lowbit(x);
     }
 }
 void init()
 {
     memset(t,,sizeof(t));
     q.clear();
     memset(l,,sizeof(l));
     for(int i=; i<=n; i++)
     {
         r[i]=n+;
     }
 }
 int main()
 {
     //freopen("in.txt","r",stdin);
     setprime();
     while(scanf("%d%d",&n,&m),n+m)
     {
         init();
         for(int i=; i<=n; i++)
         {
             scanf("%d",a+i);
         }
         memset(pre,,sizeof(pre));
         for(int i=; i<=n; i++)
         {
             for(int j=; j<(int)d[a[i]].size(); j++)
             {
                 int now=d[a[i]][j];
                 l[i]=max(pre[now],l[i]);
                 pre[now]=i;
             }
             l[i]++;
         }
         memset(pre,0x3f,sizeof(pre));
         for(int i=n; i>; i--)
         {
             for(int j=; j<(int)d[a[i]].size(); j++)
             {
                 int now=d[a[i]][j];
                 r[i]=min(pre[now],r[i]);
                 pre[now]=i;
             }
             r[i]--;
             q.push_back(node {-,l[i],i});
             q.push_back(node {m,i,i});
         }
         for(int i=; i<m; i++)
         {
             int u,v;
             scanf("%d%d",&u,&v);
             q.push_back(node {i,u,v});
         }
         //printf("%d\n",q.size());
         sort(q.begin(),q.end());
         for(int i=; i<(int)q.size(); i++)
         {
             node now=q[i];
             if(now.type==-)
             {
                 add(now.num,);
                 add(r[now.num]+,-);
             }
             if(now.type==m)
             {
                 add(now.num,-);
                 add(r[now.num]+,);
             }
             if(now.type>=&&now.type<m)
             {
                 ans[now.type]=getSum(now.num);
             }
         }
         for(int i=; i<m; i++)
         {
             printf("%d\n",ans[i]);
         }
     }
     return ;
 }

1009：

题意：

有g种不同颜色的小球，b个袋子，每个袋子里面有若干个每种小球

两人轮流取袋子，当袋子里面的同色小球有s个时，会合并成一个魔法球，并被此次取袋子的人获得

成功获得魔法球的人可以再次取

求二者都进行最优策略之后两人所得魔法球个数差

解法：

数据不大，考虑搜索，发现不行，于是可以记忆化搜索，转移不难想到

代码：

 #include <iostream>
 #include <stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<string>
 #include<ctype.h>
 using namespace std;
 #define MAXN 10000
 typedef struct Node
 {
     int a,b;
 }node;
 node dp[];
 bool vi[];
 int num[][];
 int p[];
 int g,b,s,k,m,x;
 void dfs(int state,int turn)
 {
     if(state==(<<b)-)
     {
         dp[state].a=;
         dp[state].b=;
         return ;
     }
     if(vi[state])
     {
         return ;
     }
     int ok;
     node t;
     node ans;
     ans.a=-;
     ans.b=;
     int pp[];
     memcpy(pp,p,sizeof(pp));
     for(int i=;i<b;i++)
     {
         t.a=;
         t.b=;
         ok=;
         if(state&(<<i))
           continue;
         int st=state|(<<i); //状态
         for(int j=;j<g;j++)
         {
             p[j]+=num[i][j];
             ok+=p[j]/s;
             p[j]%=s;
         }
         int tur=ok?turn:!turn;//是否交换选手
         dfs(st,tur);
         memcpy(p,pp,sizeof(pp));
         t.a+=ok;
         if(tur==turn)   //子状态的先手所要转移到的状态相同
         {
             t.a+=dp[st].a;
             t.b+=dp[st].b;
         }
         else            //选手交换了
         {
             t.b+=dp[st].a;
             t.a+=dp[st].b;
         }
         if(t.a-t.b>ans.a-ans.b)
         {
             ans=t;
         }
     }
     vi[state]=;
     dp[state]=ans;
     return ;
 }
 int main()
 {
     while(scanf("%d%d%d",&g,&b,&s),g+b+s)
     {
         memset(num,,sizeof(num));
         for(int i=;i<b;i++)
         {
             scanf("%d",&k);
             while(k--)
             {
                 scanf("%d",&x);
                 num[i][x-]++;
             }
         }
         memset(p,,sizeof(p));
         memset(vi,,sizeof(vi));
         dfs(,);
         printf("%d\n",dp[].a-dp[].b);
     }
     return ;
 }