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