BNUOJ 1021 信息战（七）——情报传递

信息战（七）——情报传递

Time Limit: 3000ms

Memory Limit: 262144KB

64-bit integer IO format: %lld      Java class name: Main

 

虽说现在是信息战，但是有些情报却是不能通过计算机进行传递的。所以呢，C国的情报员LZM在这种情况下就派上用场了，LZM可是情报界的神牛。（Orz，拜一个先～）所谓神牛见首不见尾（那位同学你说啥？神龙？可以活用嘛，给个面子哈……），作为一名优秀的情报员，LZM在传递情报的时候是需要避免让任何人看见的，尤其是A国的巡逻塔。
某日，LZM获得了一份关于A国的重要情报，他需要在最短的时间内把这份情报传递到司令部。我们假设现在LZM位于地图的(X,Y)点，而司令部位于(M,N)点，LZM在单位时间内只能往东南西北四个方向移动一个单位距离，地图上有若干个A国军队的哨塔，哨塔所在坐标以及它东西南北四个方向相邻的坐标都属于监视范围，如果LZM踏入那些区域就会被发现。定义LZM到司令部所需的最短时间为没有任何哨塔时LZM到司令部的最短时间。LZM想知道在有哨塔的情况下有多少种行走方法可以让他在最短时间内到达司令部。

 

Input

第一行：一个整数K，代表数据组数。
对于每一组数据：
第一行：四个整数，对应题目中的X、Y、M、N，范围均为[0,200]。
第二行：一个整数P(0<=P<M*N)，代表哨塔个数。
第三～P+2行：两个整数I、J代表哨塔位置，范围均为[0,200]。

 

Output

对于每一组输出一个数，表示行走方法种数。

 

Sample Input

2
0 0 5 5
2
3 3
5 2
5 5 3 3
1
4 4

Sample Output

11
0

Source

第七届北京师范大学程序设计竞赛热身赛第二场

Author

51isoft

 

 #include <bits/stdc++.h>
 using namespace std;
 const int INF = 0x3f3f3f3f;
 const int maxn = ;
 const int dir[][] = {-,,,,,-,,};
 #define MAXN 200
 struct HP {
     int len,s[MAXN];
     HP() {
         memset(s,,sizeof(s));
         len=;
     }
     HP operator =(const char *num) { //字符串赋值
         len=strlen(num);
         for(int i=; i<len; i++) s[i]=num[len-i-]-'';
     }
 
     HP operator =(int num) { //int 赋值
         char s[MAXN];
         sprintf(s,"%d",num);
         *this=s;
         return *this;
     }
 
     HP(int num) {
         *this=num;
     }
 
     HP(const char*num) {
         *this=num;
     }
 
     string str()const { //转化成string
         string res="";
         for(int i=; i<len; i++) res=(char)(s[i]+'')+res;
         if(res=="") res="";
         return res;
     }
 
     HP operator +(const HP& b) const {
         HP c;
         c.len=;
         for(int i=,g=; g||i<max(len,b.len); i++) {
             int x=g;
             if(i<len) x+=s[i];
             if(i<b.len) x+=b.s[i];
             c.s[c.len++]=x%;
             g=x/;
         }
         return c;
     }
     void clean() {
         while(len >  && !s[len-]) len--;
     }
 
     HP operator *(const HP& b) {
         HP c;
         c.len=len+b.len;
         for(int i=; i<len; i++)
             for(int j=; j<b.len; j++)
                 c.s[i+j]+=s[i]*b.s[j];
         for(int i=; i<c.len-; i++) {
             c.s[i+]+=c.s[i]/;
             c.s[i]%=;
         }
         c.clean();
         return c;
     }
 
     HP operator - (const HP& b) {
         HP c;
         c.len = ;
         for(int i=,g=; i<len; i++) {
             int x=s[i]-g;
             if(i<b.len) x-=b.s[i];
             if(x>=) g=;
             else {
                 g=;
                 x+=;
             }
             c.s[c.len++]=x;
         }
         c.clean();
         return c;
     }
     HP operator / (const HP &b) {
         HP c, f = ;
         for(int i = len-; i >= ; i--) {
             f = f*;
             f.s[] = s[i];
             while(f>=b) {
                 f =f-b;
                 c.s[i]++;
             }
         }
         c.len = len;
         c.clean();
         return c;
     }
     HP operator % (const HP &b) {
         HP r = *this / b;
         r = *this - r*b;
         return r;
     }
 
     HP operator /= (const HP &b) {
         *this  = *this / b;
         return *this;
     }
 
     HP operator %= (const HP &b) {
         *this = *this % b;
         return *this;
     }
 
     bool operator < (const HP& b) const {
         if(len != b.len) return len < b.len;
         for(int i = len-; i >= ; i--)
             if(s[i] != b.s[i]) return s[i] < b.s[i];
         return false;
     }
 
     bool operator > (const HP& b) const {
         return b < *this;
     }
 
     bool operator <= (const HP& b) {
         return !(b < *this);
     }
 
     bool operator == (const HP& b) {
         return !(b < *this) && !(*this < b);
     }
     bool operator != (const HP &b) {
         return !(*this == b);
     }
     HP operator += (const HP& b) {
         *this = *this + b;
         return *this;
     }
     bool operator >= (const HP &b) {
         return *this > b || *this == b;
     }
 
 };
 
 istream& operator >>(istream &in, HP& x) {
     string s;
     in >> s;
     x = s.c_str();
     return in;
 }
 
 ostream& operator <<(ostream &out, const HP& x) {
     out << x.str();
     return out;
 }
 int dp[maxn][maxn],sx,sy,m,n,p;
 HP cnt[maxn][maxn];
 bool isIn(int x,int y) {
     return x >=  && y >=  && x <  && y < ;
 }
 struct node {
     int x,y;
     node(int x = ,int y = ) {
         this->x = x;
         this->y = y;
     }
 };
 queue<node>q;
 void bfs() {
     while(!q.empty()) q.pop();
     if(dp[sx][sy] == -) {
         dp[sx][sy] = ;
         cnt[sx][sy] = ;
         q.push(node(sx,sy));
     }
     while(!q.empty()) {
         node now = q.front();
         q.pop();
         if(now.x == m && now.y == n && dp[now.x][now.y] != abs(m - sx) + abs(n - sy)) break;
         for(int i = ; i < ; ++i) {
             int nx = now.x + dir[i][];
             int ny = now.y + dir[i][];
             if(!isIn(nx,ny) || dp[nx][ny] == INF) continue;
             if(dp[nx][ny] == - || dp[nx][ny] > dp[now.x][now.y] + ) {
                 dp[nx][ny] = dp[now.x][now.y] + ;
                 cnt[nx][ny] = cnt[now.x][now.y];
                 q.push(node(nx,ny));
             } else if(dp[nx][ny] == dp[now.x][now.y] + ) {
                 cnt[nx][ny] += cnt[now.x][now.y];
             }
         }
     }
 }
 int main() {
     int x,y,kase;
     scanf("%d",&kase);
     while(kase--) {
         scanf("%d%d%d%d",&sx,&sy,&m,&n);
         scanf("%d",&p);
         memset(dp,-,sizeof dp);
         memset(cnt,,sizeof cnt);
         while(p--) {
             scanf("%d%d",&x,&y);
             dp[x][y] = INF;
             for(int i = ; i < ; ++i) {
                 int nx = x + dir[i][];
                 int ny = y + dir[i][];
                 if(!isIn(nx,ny)) continue;
                 dp[nx][ny] = INF;
             }
         }
         bfs();
         if(dp[m][n] != abs(m - sx) + abs(n - sy)) cnt[m][n] = ;
         cout<<cnt[m][n]<<endl;
     }
     return ;
 }