sgu364dp

题意：在一个二维坐标平面内， （以下所有坐标都是整数）有一个生产机器人的地方，这个坐标平面内有100个平行x轴的平板， 机器人可以在平板上走。现在马上生产n个机器人， 生产两个机器人中间间隔s秒。 当机器人脚下没有板子的时候就垂直往下掉， 机器人开始的方向是向右的。 现在有一个home， 想让尽量多的机器人最后都回到home。而现在唯一能做的操作就是让一个机器人停下， 以后其他机器人碰到他的时候就会改变方向。

现在想要求出最多有多少个机器人会回到home， 这么多机器人回到home最少需要多少时间。

 

思路：如果说机器人是从一个板子的左端掉下的， 那么他的方向一定是向左的。 同理， 如果是从右端掉下的，那么他的方向一定是向右的。 那么我们就可以求出到达一个板子的左端和右端最少需要几个机器人， 同时在这样的情况下最少需要多少时间。 但是在这个更新的同时要注意如果该板子上有home的话要先更新home的值。 记住先要对板子的高低顺序排一下序。

AC代码：

View Code 
  1 #include <iostream>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <string>
  5 #include <queue>
  6 #include <map>
  7 #include <algorithm>
  8 using namespace std;
  9 const int N = 300, INF = 1<<29;
 10 
 11 struct hh
 12 {
 13     int l, r, h;
 14 } p[N];
 15 
 16 struct
 17 {
 18     int p, t;
 19 } dp[N][2];
 20 
 21 int n, s, m, x0, y0, a, b, k;
 22 int x[N];
 23 
 24 bool cmp(hh A, hh B)
 25 {
 26     return A.h > B.h;
 27 }
 28 
 29 void init()
 30 {
 31     int cnt = 0;
 32     scanf("%d%d%d%d", &x0, &y0, &a, &b);
 33     scanf("%d", &m);
 34     for(int i=1; i<=m; i++)
 35     {
 36         scanf("%d%d%d", &p[i].l, &p[i].r, &p[i].h);
 37     }
 38     sort(p+1, p+m+1, cmp);
 39 }
 40 
 41 int myabs(int u)
 42 {
 43     return u>0 ? u:-u;
 44 }
 45 
 46 void solve()
 47 {
 48     for(int i=0; i<=m; i++)
 49         for(int j=0; j<2; j++)
 50             dp[i][j].t = dp[i][j].p = INF;
 51 
 52     int ansp = INF, anst = INF;
 53     for (int i=1; i<=m; i++)
 54     {
 55         if (p[i].h<=y0 && p[i].l<=x0 && p[i].r >= x0)
 56         {
 57             if(b == p[i].h && p[i].l<=a && p[i].r >= a)
 58             {
 59                 if(a < x0)
 60                 {
 61                     ansp = 1;
 62                 }
 63                 else ansp = 0;
 64                 anst = y0 - p[i].h + myabs(x0-a);
 65             }
 66             else
 67             {
 68                 if(p[i].l <= x0)
 69                 dp[i][0].p = 1;
 70                 dp[i][0].t = y0-p[i].h + myabs(x0-p[i].l);
 71 
 72                 dp[i][1].p = 0;
 73                 dp[i][1].t = y0-p[i].h + myabs(x0-p[i].r);
 74             }
 75             break;
 76         }
 77     }
 78     for(int i=1; i<=m; i++)
 79     {
 80         for(int j=0; j<2; j++)
 81         {
 82             if(dp[i][j].p == INF) continue;
 83             if(j == 0) x0 = p[i].l;
 84             else  x0 = p[i].r;
 85             y0 = p[i].h;
 86 
 87             for(int k=i+1; k<=m; k++)
 88             {
 89                 if(p[k].h<y0 && p[k].l<=x0 && p[k].r >= x0)
 90                 {
 91                     if(b == p[k].h && p[k].l<=a && p[k].r >= a)
 92                     {
 93                         int w;
 94                         if( (a<x0&&j) || (a>x0&&!j) )
 95                             w = 1;
 96                         else  w = 0;
 97                         if(ansp > dp[i][j].p+w)
 98                         {
 99                             ansp = dp[i][j].p+w;
100                             anst = dp[i][j].t + y0-p[k].h + myabs(x0-a) ;
101                         }
102                         else if(ansp == dp[i][j].p+w)
103                         {
104                             anst = min(anst, dp[i][j].t + y0-p[k].h + myabs(x0-a));
105                         }
106                     }
107                     else
108                     {
109                         int w = 0;
110                         if( p[k].l<=x0&&j ) w = 1;
111                         else w = 0;
112                         if(dp[k][0].p > dp[i][j].p + w)
113                          {
114                              dp[k][0].p = dp[i][j].p+w;
115                              dp[k][0].t = dp[i][j].t+y0-p[k].h + myabs(x0-p[k].l);
116                          }
117                         else if(dp[k][0].p == dp[i][j].p+w)
118                         dp[k][0].t = min(dp[k][0].t,dp[i][j].t+y0-p[k].h + myabs(x0-p[k].l));
119 
120                         if(p[k].r>=x0 && !j) w = 1;
121                         else w = 0;
122 
123                         if(dp[k][1].p > dp[i][j].p + w)
124                          {
125                              dp[k][1].p = dp[i][j].p+w;
126                              dp[k][1].t = dp[i][j].t+y0-p[k].h + myabs(x0-p[k].r);
127                          }
128                         else if(dp[k][1].p == dp[i][j].p+w)
129                         dp[k][1].t = min(dp[k][1].t,dp[i][j].t+y0-p[k].h + myabs(x0-p[k].r));
130                     }
131                     break;
132                 }
133             }
134         }
135     }
136    ansp = n-ansp;
137 
138    anst = (n-1)*s+anst;
139    if(ansp <= 0)
140     printf("0 0\n");
141    else printf("%d %d\n", ansp, anst);
142 }
143 
144 int main()
145 {
146     while(scanf("%d%d", &n, &s) != EOF)
147     {
148         init();
149         solve();
150     }
151     return 0;
152 }

 

 

posted @ 2012-10-04 13:20  Gu Feiyang  阅读(230)  评论(0)    收藏  举报