POJ3034+DP

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

 /*
 dp
 题意：给定一个N*N的矩阵, 然后在这个矩阵的每个格子在任意时间会出现一个鼹鼠,这个出现
      出现鼹鼠的时间是输出信息所确定的. 现在你手里有一把锤子能够去锤这些鼹鼠. 你能
      够移动锤子,移动的两点之间的距离不能超过d,且中心在这条路径上的鼹鼠到都要受到
      打击. 每个鼹鼠出现的时间值维持一秒钟. 现在问在一次游戏中最多打到多少鼹鼠
 思路：一开始状态定义正确，但是思路有问题，不能处理 k-1时刻 到 k时刻 的鼹鼠（也就是没法判断这“两种”鼹鼠的距离是否小于<=d）

 */
 #include<algorithm>
 #include<iostream>
 #include<string.h>
 #include<stdlib.h>
 #include<stdio.h>
 #include<math.h>
 #include<queue>
 #include<stack>
 #include<map>
 #include<set>
 using namespace std;
 typedef long long int64;
 //typedef __int64 int64;
 typedef pair<int64,int64> PII;
 #define MP(a,b) make_pair((a),(b))
 const int inf = 0x3f3f3f3f;
 const double pi=acos(-1.0);
 const int dx[]={,-,,};
 const int dy[]={,,,-};
 const double eps = 1e-;
 const int maxm = ;
 const int maxn = ;

 int mat[  ][ maxn ][ maxn ];
 int dp[  ][ maxn ][ maxn ];
 //dp[t][x][y]:当t时刻，锤子打了xy的鼹鼠的MaxVal
 int d;

 int dis2( int x1,int y1,int x2,int y2 ){
     return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
 }

 int Count( int cur_ti,int x1,int y1,int x2,int y2 ){
     int cnt = ;
     if( x1==x2 ){
         if( y1>y2 ) swap( y1,y2 );
         for( int i=y1;i<=y2;i++ ){
             cnt += mat[ cur_ti ][ x1 ][ i ];
         }
         return cnt;
     }
     if( y1==y2 ){
         if( x1>x2 ) swap( x1,x2 );
         for( int i=x1;i<=x2;i++ ){
             cnt += mat[ cur_ti ][ i ][ y1 ];
         }
         return cnt;
     }
     if( x1>x2 ){
         swap( x1,x2 );
         swap( y1,y2 );
     }
     for( int i=x1;i<=x2;i++ ){
         if( ((i-x1)*y2+(x2-i)*y1)%(x2-x1)== ){
             cnt += mat[ cur_ti ][ i ][ ((i-x1)*y2+(x2-i)*y1)/(x2-x1) ];
         }
     }
     return cnt;
 }

 int DP( int n,int MaxTi ){
     n+=;
     int ans = ;
     for( int i=;i<=MaxTi+;i++ ){
         for( int x=;x<n;x++ ){
             for( int y=;y<n;y++ ){
                 dp[ i ][ x ][ y ] = ;
                 int Ymax = min( y+d,n- );
                 int Ymin = max( ,y-d );
                 int Xmax = min( x+d,n- );
                 int Xmin = max( ,x-d );
                 for( int x2=Xmin;x2<=Xmax;x2++ ){
                     for( int y2=Ymin;y2<=Ymax;y2++ ){
                         if( dis2( x,y,x2,y2 )<=d*d ){
                             dp[i][x][y] = max( dp[i][x][y],dp[i-][x2][y2]+Count( i-,x,y,x2,y2 ) );
                         }
                     }
                 }
                 ans = max( ans,dp[ i ][ x ][ y ] );
             }
         }
     }
     return ans;
 }        

 int main(){
     int n,m;
     while( scanf("%d%d%d",&n,&d,&m)== ){
         if( n==&&d==&&m== )
             break;
         memset( mat,,sizeof( mat ) );
         int MaxTi = ;
         for( int i=;i<m;i++ ){
             int x,y,t;
             scanf("%d%d%d",&x,&y,&t);
             x += ;
             y += ;
             MaxTi = max( MaxTi,t );
             mat[ t ][ x ][ y ] = ;
         }
         int ans = DP( n,MaxTi );
         printf("%d\n",ans);
     }
     return ;
 }

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

 /*

 */
 #include<algorithm>
 #include<iostream>
 #include<string.h>
 #include<stdlib.h>
 #include<stdio.h>
 #include<math.h>
 #include<queue>
 #include<stack>
 #include<map>
 #include<set>
 using namespace std;
 typedef long long int64;
 //typedef __int64 int64;
 typedef pair<int64,int64> PII;
 #define MP(a,b) make_pair((a),(b))
 const int inf = 0x3f3f3f3f;
 const double pi=acos(-1.0);
 const int dx[]={,-,,};
 const int dy[]={,,,-};
 const double eps = 1e-;
 const int maxm = ;
 const int maxn = ;

 struct Node{
     double x,y;
     int t;
 }node[ maxn ];
 double d;

 double dis( int i,int j ){
     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) );
 }

 struct Node2{
     int val;
     int pre_mole;
     int cur_mole;
 }dp[  ][ maxn ];
 //dp[i][j]:时刻i打了第j只地鼠
 int cmp( Node a,Node b ){
     if( a.t!=b.t ) return a.t<b.t;
     else if( a.x!=b.x ) return a.x<b.x;
     else if( a.y<b.y ) return a.y<b.y;
 }

 bool OnLine3( int x,int y,int z ){
     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);
     if( sum== ) return true;
     return false;
 }

 bool JudgeDis( int x,int y,int z ){
     double d1 = dis( x,y );
     double d2 = dis( x,z );
     double d3 = dis( y,z );
     if( d1>d||d2>d||d3>d ) return false;
     return true;
 }

 int main(){
     int n,m;
     //double d;
     freopen("in.txt","r",stdin);
     while( scanf("%d%lf%d",&n,&d,&m)== ){
         if( n==&&d==&&m== )
             break;
         int M = -;
         for( int i=;i<=m;i++ ){
             scanf("%lf%lf%d",&node[i].x,&node[i].y,&node[i].t);
             M = max( M,node[i].t );
         }
         sort( node+,node++m,cmp );
         //for( int i=1;i<=m;i++ )
         //    printf("%lf %lf\n",node[i].x,node[i].y);
         for( int i=;i<;i++ ){
             for( int j=;j<maxn;j++ ){
                 dp[i][j].pre_mole = -;
                 dp[i][j].cur_mole = -;
                 dp[i][j].val = ;
             }
         }//init
         for( int i=;i<=m;i++ ){
             dp[ node[i].t ][ i ].val = ;
             dp[ node[i].t ][ i ].cur_mole = i;
         }
         for( int i=;i<=m;i++ ){
             //printf("\nNow = %d\n",i);
             for( int j=i+;j<=m;j++ ){
                 //if( i==j ) continue;
                 //printf("j = %d\n",j);
                 if( node[j].t>node[i].t && dis( i,j )<=d ){
                     if( dp[ node[j].t ][ j ].val<dp[ node[i].t ][ i ].val+ ) {
                         dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+;
                         dp[ node[j].t ][ j ].cur_mole = j;
                         dp[ node[j].t ][ j ].pre_mole = i;
                     }
                 }
                 else if( node[j].t==node[i].t ){
                     if( dp[ node[i].t ][ i ].pre_mole==- ){
                         if( dis(i,j)<=d && dp[ node[i].t ][ i ].val+>dp[ node[j].t ][ j ].val ){
                             dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+;
                             dp[ node[j].t ][ j ].cur_mole = j;
                             dp[ node[j].t ][ j ].pre_mole = i;
                         }
                     }//
                     else {
                         if( OnLine3( dp[ node[i].t ][ i ].pre_mole,i,j )==true ){
                             if( JudgeDis( dp[ node[i].t ][ i ].pre_mole,i,j )==true && dp[ node[i].t ][ i ].val+>dp[ node[j].t ][ j ].val ){
                                 dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+;
                                 dp[ node[j].t ][ j ].cur_mole = j;
                                 dp[ node[j].t ][ j ].pre_mole = dp[ node[i].t ][ i ].pre_mole;
                             }
                         }
                         else if( node[j].t>node[dp[ node[i].t ][ i ].pre_mole].t ){
                             if( dis( i,j )<=d &&dp[ node[i].t ][ i ].val+>dp[ node[j].t ][ j ].val ){
                                 dp[ node[j].t ][ j ].val = dp[ node[i].t ][ i ].val+;
                                 dp[ node[j].t ][ j ].cur_mole = j;
                                 dp[ node[j].t ][ j ].pre_mole = dp[ node[i].t ][ i ].pre_mole;
                             }
                         }
                     }
                 }
             }
             //for( int k=1;k<=m;k++ ){
                 //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);
             //}
         }
         int ans = ;
         for( int i=;i<=M;i++ ){
             for( int j=;j<=m;j++ ){
                 ans = max( ans,dp[i][j].val );
             }
         }
         printf("%d\n",ans);
     }
     return ;
 }