Mice and Holes CodeForces

题意：有n只老鼠和m个洞，都在一个数轴上，老鼠坐标为x[1],...,x[n]，洞的坐标为p[1],...,p[m]，每个洞能容纳的老鼠为c[1],...,c[m]，问所有老鼠都躲到洞里后每只老鼠跑的距离之和的最小值。

分析：

如果不给出洞和老鼠的顺序的话，就需要集合操作，基本就是枚举，很慢不考虑。

因此，按坐标顺序排序洞和老鼠，然后定义状态：ans[i][j]表示前i个洞放前j个老鼠最小距离和。

这么做是由于如果有老鼠跑的路线交叠了，那么就一定不是最好的答案。而先排序后这么定义状态，就隐含了只能是前i-1个洞放前k个老鼠，然后第i个洞放第k+1到第j个老鼠，路线不交叠。

（以下部分自己想不到）

然而实际做的时候不一定能想到，这时一定要大胆尝试（比如试一试排序，很可能一排序就能定义出状态了）。

那么ans[i][j]=min(ans[i-1][j]+0,ans[i-1][j-1]+{ j ~ j 的点到i距离和},ans[i-1][j-2]+{ j-1 ~ j 的点到i距离和}...,ans[i-1][j-c[i]]+{ j-c[i]+1 ~ j 的点到i的距离和})

再看ans[i][j-1]=min(ans[i-1][j-1]+0,ans[i-1][j-2]+{ j-1 ~ j-1 的点到i距离和},...,ans[i-1][j-c[i]-1]+{ j-c[i] ~ j-1 的点到i距离和})

仔细看很像取一个"滑动窗口"中最小值，但形式不可以加速，还是太慢。

因此变形一下：

ans[i][j]=min(ans[i-1][j]+0,ans[i-1][j-1] + 1到j的点到i距离和 - 1到(j-1)的点到i距离和,ans[i-1][j-2] + 1到j的点到i距离和 - 1到(j-2)的点到i距离和,...,ans[i-1][j-c[i]] + 1到j的点到i距离和 - 1到(j-c[i])的点到i距离和)
ans[i][j-1]=min(ans[i-1][j-1]+0,ans[i-1][j-2] + 1到j-1的点到i距离和 - 1到j-2的点到i距离和,...,ans[i-1][j-c[i]-1] + 1到j-1的点到i距离和 - 1到j-c[i]-1的点到i距离和)

也就是，ans[i][j]=1到j的点到i距离和 + min{ans[i-1][j-k] - 1到j-k的点到点i距离和}(0<=k<=c[i])

ans[i][j-1]=1到j-1的点到i距离和 + min{ans[i-1][j-k-1]-1到j-k-1的点到点i距离和}(0<=k<=c[i]-1)

也就是，ans[i][j]=1到j的点到i距离和 + min(ans[i-1][j]-1到j的点到i距离和,...,ans[i-1][j-c[i]]-1到j-c[i]的点到i距离和)

ans[i][j-1]=1到j-1的点到i距离和 + min(ans[i-1][j-1]-1到j-1的地点到i距离和,...,ans[i-1][j-c[i]-1]-1到j-c[i]-1的点到i距离和)

这样就可以每次i变化时用单调队列维护min{ans[i-1][j-..]-..}。

还有，ans[i][..]只跟ans[i-1][..]有关，可以用滚动数组省空间。

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 using namespace std;

 typedef long long LL;//曾经忘开LL

 struct Hole

 {

     LL p,c;

     bool operator<(const Hole& b) const

     {

         return p<b.p;

     }

 }h[];

 LL n,m;

 LL x[];

 LL ans[][];

 //曾经写错成ans[5010][2]

 LL q[],l,r,i1;

 LL s1[];//表示前i个洞容纳的总老鼠数量

 LL s2[];//s2[j]表示预处理出的1~j的老鼠到i距离和

 int main()

 {

     LL i,j;

     scanf("%I64d%I64d",&n,&m);

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

         scanf("%I64d",&x[i]);

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

         scanf("%I64d%I64d",&h[i].p,&h[i].c);

     sort(x+,x+n+);

     sort(h+,h+m+);

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

         s1[i]=s1[i-]+h[i].c;

     memset(ans,0x3f,sizeof(ans));

     ans[][]=;//曾经误将ans[0][..]全部置0

     if(n>s1[m])

     {

         printf("-1");

         return ;

     }

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

     {

         i1^=;

         l=r=;

         for(j=;j<=min(s1[i],n);j++)

             s2[j]=s2[j-]+abs(x[j]-h[i].p);

         //q[r++]=0;

         for(j=;j<=min(s1[i],n);j++)//曾经误将初始当做1

         {

             if(r>l&&q[l]<j-h[i].c)    l++;//第j个要考虑的是j-c[i] ~ j，也就是去掉j-c[i]之前的，向单调队列中加入j

             while(r>l&&ans[i1^][q[r-]]-s2[q[r-]]>=ans[i1^][j]-s2[j])

                 r--;

             q[r++]=j;

             ans[i1][j]=ans[i1^][q[l]]-s2[q[l]]+s2[j];

         }

     }

     printf("%I64d",ans[m%][n]);

     return ;

 }

upd190422：

这题被超级加强了...加强后的题目：uoj455

稍微改一下可过此题

 #include<cstdio>

 #include<algorithm>

 #include<cstring>

 #include<vector>

 #include<queue>

 using namespace std;

 #define fi first

 #define se second

 #define mp make_pair

 #define pb push_back

 typedef long long ll;

 typedef unsigned long long ull;

 struct P

 {

     ll x,y;

 };

 bool operator<(const P &a,const P &b)

 {

     return a.x>b.x;

 }

 struct PP

 {

     int x,w,c;

 }p[];

 bool operator<(const PP &a,const PP &b)

 {

     return a.x<b.x;

 }

 int n,m;

 ll ans;

 priority_queue<P> q1,q2;

 int main()

 {

     int i;P t;ll v,ts=,t1,t2;

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

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

     {

         scanf("%d",&p[i].x);

         p[i].c=-;

     }

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

     {

         scanf("%d%d",&p[i+n].x,&p[i+n].c);

         ts+=p[i+n].c;

     }

     if(n>ts)    {puts("-1");return ;}

     sort(p+,p+n+m+);

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

     {

         if(p[i].c==-)

         {

             if(q2.empty())    v=1e11;

             else

             {

                 t=q2.top();q2.pop();

                 v=t.x;

                 if(t.y!=)    q2.push((P){t.x,t.y-});

             }

             ans+=p[i].x+v;

             q1.push((P){-*p[i].x-v,});

         }

         else

         {

             t1=;

             while(p[i].c && !q1.empty())

             {

                 t=q1.top();v=t.x;

                 if(p[i].x+p[i].w+v>=)    break;

                 q1.pop();

                 t2=min(ll(p[i].c),t.y);

                 t.y-=t2;p[i].c-=t2;

                 ans+=t2*(p[i].x+p[i].w+v);

                 t1+=t2;

                 q2.push((P){-*p[i].x-v,t2});

                 if(t.y)    q1.push(t);

             }

             if(t1)    q1.push((P){-p[i].x-p[i].w,t1});

             if(p[i].c)    q2.push((P){p[i].w-p[i].x,p[i].c});

         }

     }

     printf("%lld\n",ans);

     return ;

 }

巴特西

Mice and Holes CodeForces - 797F

最新文章

热门文章