POJ3034+DP

题意：给定一个N*N的矩阵, 然后在这个矩阵的每个格子在任意时间会出现一个鼹鼠,这个出现
     出现鼹鼠的时间是输出信息所确定的. 现在你手里有一把锤子能够去锤这些鼹鼠. 你能
     够移动锤子,移动的两点之间的距离不能超过d,且中心在这条路径上的鼹鼠到都要受到
     打击. 每个鼹鼠出现的时间值维持一秒钟. 现在问在一次游戏中最多打到多少鼹鼠 

  1 /*
  2 dp
  3 题意：给定一个N*N的矩阵, 然后在这个矩阵的每个格子在任意时间会出现一个鼹鼠,这个出现
  4      出现鼹鼠的时间是输出信息所确定的. 现在你手里有一把锤子能够去锤这些鼹鼠. 你能
  5      够移动锤子,移动的两点之间的距离不能超过d,且中心在这条路径上的鼹鼠到都要受到
  6      打击. 每个鼹鼠出现的时间值维持一秒钟. 现在问在一次游戏中最多打到多少鼹鼠 
  7 思路：一开始状态定义正确，但是思路有问题，不能处理 k-1时刻 到 k时刻 的鼹鼠（也就是没法判断这“两种”鼹鼠的距离是否小于<=d）
  8     
  9 */
 10 #include<algorithm>
 11 #include<iostream>
 12 #include<string.h>
 13 #include<stdlib.h>
 14 #include<stdio.h>
 15 #include<math.h>
 16 #include<queue>
 17 #include<stack>
 18 #include<map>
 19 #include<set>
 20 using namespace std;
 21 typedef long long int64;
 22 //typedef __int64 int64;
 23 typedef pair<int64,int64> PII;
 24 #define MP(a,b) make_pair((a),(b)) 
 25 const int inf = 0x3f3f3f3f;
 26 const double pi=acos(-1.0);
 27 const int dx[]={1,-1,0,0};
 28 const int dy[]={0,0,1,-1};
 29 const double eps = 1e-8;
 30 const int maxm = 1005;
 31 const int maxn = 35;
 32 
 33 int mat[ 12 ][ maxn ][ maxn ];
 34 int dp[ 12 ][ maxn ][ maxn ];
 35 //dp[t][x][y]:当t时刻，锤子打了xy的鼹鼠的MaxVal
 36 int d;
 37 
 38 int dis2( int x1,int y1,int x2,int y2 ){
 39     return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
 40 }
 41 
 42 int Count( int cur_ti,int x1,int y1,int x2,int y2 ){
 43     int cnt = 0;
 44     if( x1==x2 ){
 45         if( y1>y2 ) swap( y1,y2 );
 46         for( int i=y1;i<=y2;i++ ){
 47             cnt += mat[ cur_ti ][ x1 ][ i ];
 48         }
 49         return cnt;
 50     }
 51     if( y1==y2 ){
 52         if( x1>x2 ) swap( x1,x2 );
 53         for( int i=x1;i<=x2;i++ ){
 54             cnt += mat[ cur_ti ][ i ][ y1 ];
 55         }
 56         return cnt;
 57     }
 58     if( x1>x2 ){
 59         swap( x1,x2 );
 60         swap( y1,y2 );
 61     }
 62     for( int i=x1;i<=x2;i++ ){
 63         if( ((i-x1)*y2+(x2-i)*y1)%(x2-x1)==0 ){
 64             cnt += mat[ cur_ti ][ i ][ ((i-x1)*y2+(x2-i)*y1)/(x2-x1) ];
 65         }
 66     }
 67     return cnt;
 68 }
 69 
 70 int DP( int n,int MaxTi ){
 71     n+=10;
 72     int ans = 0;
 73     for( int i=2;i<=MaxTi+1;i++ ){
 74         for( int x=0;x<n;x++ ){
 75             for( int y=0;y<n;y++ ){
 76                 dp[ i ][ x ][ y ] = 0;
 77                 int Ymax = min( y+d,n-1 );
 78                 int Ymin = max( 0,y-d );
 79                 int Xmax = min( x+d,n-1 );
 80                 int Xmin = max( 0,x-d );
 81                 for( int x2=Xmin;x2<=Xmax;x2++ ){
 82                     for( int y2=Ymin;y2<=Ymax;y2++ ){
 83                         if( dis2( x,y,x2,y2 )<=d*d ){
 84                             dp[i][x][y] = max( dp[i][x][y],dp[i-1][x2][y2]+Count( i-1,x,y,x2,y2 ) );
 85                         }
 86                     }
 87                 }
 88                 ans = max( ans,dp[ i ][ x ][ y ] );
 89             }
 90         }
 91     }
 92     return ans;
 93 }        
 94 
 95 int main(){
 96     int n,m;
 97     while( scanf("%d%d%d",&n,&d,&m)==3 ){
 98         if( n==0&&d==0&&m==0 )
 99             break;
100         memset( mat,0,sizeof( mat ) );
101         int MaxTi = 0;
102         for( int i=0;i<m;i++ ){
103             int x,y,t;
104             scanf("%d%d%d",&x,&y,&t);
105             x += 5;
106             y += 5;
107             MaxTi = max( MaxTi,t );
108             mat[ t ][ x ][ y ] = 1;
109         }
110         int ans = DP( n,MaxTi );
111         printf("%d\n",ans);
112     }
113     return 0;
114 }
View Code

下面把自己wa的也贴出来。。。

  1 /*
  2  
  3 */
  4 #include<algorithm>
  5 #include<iostream>
  6 #include<string.h>
  7 #include<stdlib.h>
  8 #include<stdio.h>
  9 #include<math.h>
 10 #include<queue>
 11 #include<stack>
 12 #include<map>
 13 #include<set>
 14 using namespace std;
 15 typedef long long int64;
 16 //typedef __int64 int64;
 17 typedef pair<int64,int64> PII;
 18 #define MP(a,b) make_pair((a),(b)) 
 19 const int inf = 0x3f3f3f3f;
 20 const double pi=acos(-1.0);
 21 const int dx[]={1,-1,0,0};
 22 const int dy[]={0,0,1,-1};
 23 const double eps = 1e-8;
 24 const int maxm = 1005;
 25 const int maxn = 1005;
 26  
 27 struct Node{
 28     double x,y;
 29     int t;
 30 }node[ maxn ];
 31 double d;
 32  
 33 double dis( int i,int j ){
 34     return sqrt( (node[i].x-node[j].x)*(node[i].x-node[j].x)+(node[i].y-node[j].y)*(node[i].y-node[j].y) );
 35 }
 36  
 37 struct Node2{
 38     int val;
 39     int pre_mole;
 40     int cur_mole;
 41 }dp[ 12 ][ maxn ];
 42 //dp[i][j]:时刻i打了第j只地鼠
 43 int cmp( Node a,Node b ){
 44     if( a.t!=b.t ) return a.t<b.t;
 45     else if( a.x!=b.x ) return a.x<b.x;
 46     else if( a.y<b.y ) return a.y<b.y;
 47 }
 48  
 49 bool OnLine3( int x,int y,int z ){
 50     double sum = (node[x].x-node[y].x)*(node[y].y-node[z].y)-(node[y].x-node[z].x)*(node[x].y-node[y].y);
 51     if( sum==0 ) return true;
 52     return false;
 53 }
 54  
 55 bool JudgeDis( int x,int y,int z ){
 56     double d1 = dis( x,y );
 57     double d2 = dis( x,z );
 58     double d3 = dis( y,z );
 59     if( d1>d||d2>d||d3>d ) return false;
 60     return true;
 61 }
 62  
 63 int main(){
 64     int n,m;
 65     //double d;
 66     freopen("in.txt","r",stdin);
 67     while( scanf("%d%lf%d",&n,&d,&m)==3 ){
 68         if( n==0&&d==0&&m==0 )
 69             break;
 70         int M = -1;
 71         for( int i=1;i<=m;i++ ){
 72             scanf("%lf%lf%d",&node[i].x,&node[i].y,&node[i].t);
 73             M = max( M,node[i].t );
 74         }
 75         sort( node+1,node+1+m,cmp );
 76         //for( int i=1;i<=m;i++ )
 77         //    printf("%lf %lf\n",node[i].x,node[i].y);
 78         for( int i=0;i<12;i++ ){
 79             for( int j=0;j<maxn;j++ ){
 80                 dp[i][j].pre_mole = -1;
 81                 dp[i][j].cur_mole = -1;
 82                 dp[i][j].val = 0;
 83             }
 84         }//init
 85         for( int i=1;i<=m;i++ ){
 86             dp[ node[i].t ][ i ].val = 1;
 87             dp[ node[i].t ][ i ].cur_mole = i;
 88         }
 89         for( int i=1;i<=m;i++ ){
 90             //printf("\nNow = %d\n",i);
 91             for( int j=i+1;j<=m;j++ ){
 92                 //if( i==j ) continue;
 93                 //printf("j = %d\n",j);
 94                 if( node[j].t>node[i].t && dis( i,j )<=d ){
 95                     if( dp[ node[j].t ][ j ].val<dp[ node[i].t ][ i ].val+1 ) {
 96                         dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+1;
 97                         dp[ node[j].t ][ j ].cur_mole = j;
 98                         dp[ node[j].t ][ j ].pre_mole = i;
 99                     }
100                 }
101                 else if( node[j].t==node[i].t ){
102                     if( dp[ node[i].t ][ i ].pre_mole==-1 ){
103                         if( dis(i,j)<=d && dp[ node[i].t ][ i ].val+1>dp[ node[j].t ][ j ].val ){
104                             dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+1;
105                             dp[ node[j].t ][ j ].cur_mole = j;
106                             dp[ node[j].t ][ j ].pre_mole = i;
107                         }
108                     }//2
109                     else {
110                         if( OnLine3( dp[ node[i].t ][ i ].pre_mole,i,j )==true ){
111                             if( JudgeDis( dp[ node[i].t ][ i ].pre_mole,i,j )==true && dp[ node[i].t ][ i ].val+1>dp[ node[j].t ][ j ].val ){
112                                 dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+1;
113                                 dp[ node[j].t ][ j ].cur_mole = j;
114                                 dp[ node[j].t ][ j ].pre_mole = dp[ node[i].t ][ i ].pre_mole;
115                             }
116                         }
117                         else if( node[j].t>node[dp[ node[i].t ][ i ].pre_mole].t ){
118                             if( dis( i,j )<=d &&dp[ node[i].t ][ i ].val+1>dp[ node[j].t ][ j ].val ){
119                                 dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+1;
120                                 dp[ node[j].t ][ j ].cur_mole = j;
121                                 dp[ node[j].t ][ j ].pre_mole = dp[ node[i].t ][ i ].pre_mole;
122                             }
123                         }
124                     }        
125                 }
126             }
127             //for( int k=1;k<=m;k++ ){
128                 //printf("num=%d, pre=%d, cur=%d\n",dp[node[k].t][k].val,dp[node[k].t][k].pre_mole,dp[node[k].t][k].cur_mole);
129             //}
130         }
131         int ans = 0;
132         for( int i=1;i<=M;i++ ){
133             for( int j=1;j<=m;j++ ){
134                 ans = max( ans,dp[i][j].val );
135             }
136         }
137         printf("%d\n",ans);
138     }
139     return 0;
140 }
View Code

 

posted @ 2013-10-06 14:48  xxx0624  阅读(388)  评论(0)  编辑  收藏  举报