Robots on a grid（DP+bfs()）

链接：http://www.bnuoj.com/bnuoj/problem_show.php?pid=25585

Current Server Time: 2013-08-27 20:42:26

Robots on a grid

Time Limit: 3000ms

Memory Limit: 65536KB

 

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

Prev Submit Status Statistics Discuss Next

Font Size: + -

Type:  
None
 
Graph Theory
 
    2-SAT
 
    Articulation/Bridge/Biconnected Component
 
    Cycles/Topological Sorting/Strongly Connected Component
 
    Shortest Path
 
        Bellman Ford
 
        Dijkstra/Floyd Warshall
 
    Euler Trail/Circuit
 
    Heavy-Light Decomposition
 
    Minimum Spanning Tree
 
    Stable Marriage Problem
 
    Trees
 
    Directed Minimum Spanning Tree
 
    Flow/Matching
 
        Graph Matching
 
            Bipartite Matching
 
            Hopcroft–Karp Bipartite Matching
 
            Weighted Bipartite Matching/Hungarian Algorithm
 
        Flow
 
            Max Flow/Min Cut
 
            Min Cost Max Flow
 
DFS-like
 
    Backtracking with Pruning/Branch and Bound
 
    Basic Recursion
 
    IDA* Search
 
    Parsing/Grammar
 
    Breadth First Search/Depth First Search
 
    Advanced Search Techniques
 
        Binary Search/Bisection
 
        Ternary Search
 
Geometry
 
    Basic Geometry
 
    Computational Geometry
 
    Convex Hull
 
    Pick's Theorem
 
Game Theory
 
    Green Hackenbush/Colon Principle/Fusion Principle
 
    Nim
 
    Sprague-Grundy Number
 
Matrix
 
    Gaussian Elimination
 
    Matrix Exponentiation
 
Data Structures
 
    Basic Data Structures
 
    Binary Indexed Tree
 
    Binary Search Tree
 
    Hashing
 
    Orthogonal Range Search
 
    Range Minimum Query/Lowest Common Ancestor
 
    Segment Tree/Interval Tree
 
    Trie Tree
 
    Sorting
 
    Disjoint Set
 
String
 
    Aho Corasick
 
    Knuth-Morris-Pratt
 
    Suffix Array/Suffix Tree
 
Math
 
    Basic Math
 
    Big Integer Arithmetic
 
    Number Theory
 
        Chinese Remainder Theorem
 
        Extended Euclid
 
        Inclusion/Exclusion
 
        Modular Arithmetic
 
    Combinatorics
 
        Group Theory/Burnside's lemma
 
        Counting
 
    Probability/Expected Value
 
Others
 
    Tricky
 
    Hardest
 
    Unusual
 
    Brute Force
 
    Implementation
 
    Constructive Algorithms
 
    Two Pointer
 
    Bitmask
 
    Beginner
 
    Discrete Logarithm/Shank's Baby-step Giant-step Algorithm
 
    Greedy
 
    Divide and Conquer
 
Dynamic Programming
                   Tag it!

You have recently made a grid traversing robot that can find its way from the top left corner of a grid to the bottom right corner. However, you had forgotten all your AI programming skills, so you only programmed your robot to go rightwards and downwards (that's after all where the goal is). You have placed your robot on a grid with some obstacles, and you sit and observe. However, after a while you get tired of observing it getting stuck, and ask yourself "How many paths are there from the start position to the goal position?", and "If there are none, could the robot have made it to the goal if it could walk upwards and leftwards?"

 

So you decide to write a program that, given a grid of size nn with some obstacles marked on it where the robot cannot walk, counts the different ways the robot could go from the top left corner s to the bottom right t, and if none, tests if it were possible if it could walk up and left as well. However, your program does not handle very large numbers, so the answer should be given modulo 2³¹-1.

Input

On the first line is one integer, 1 <= n <= 1000. Then follows n lines, each with n characters, where each character is one of '.' and '#', where '.' is to be interpreted as a walkable tile and '#' as a non-walkable tile. There will never be a wall at s, and there will never be a wall at t.

 

Output

Output one line with the number of different paths starting in s and ending in t (modulo 2³¹-1) or THE GAME IS A LIE if you cannot go from s to t going only rightwards and downwards but you can if you are allowed to go left and up as well, or INCONCEIVABLE if there simply is no path from s to t.

 

Sample Input

Sample Input 1
5
.....
#..#.
#..#.
...#.
.....

Sample Input 2
7
......#
####...
.#.....
.#...#.
.#.....
.#..###
.#.....

 

Sample Output

Sample Output 1
6

Sample Output 2
THE GAME IS A LIE

尼玛，这网页有问题！！！一个图竟然有这么大！！！！！！！
MD！！卡了老子一下午！！！！
就是一道简单的搜索+动态规划：
就是用DFS（）竟然会爆栈！！！！！
世界上最污秽的词语也无法表达我现在的心情！！！！！！！！
没什么可说的Runtime error（就是爆栈）

 #include<iostream>
 #include<string.h>
 #include<algorithm>
 #include<stdio.h>
 #include<math.h>
 #include<queue>
 using namespace std;
 int flag,n;
 int c1[][]={,,-,,,,,-};
 long long dp[][];
 const long long sb=;
 char a[][];
 void bfs(int x,int y)
 {
     int c[][];
     int i,x1,y1,x2,y2;
     queue<int> Q;
     memset(c,,sizeof(c));
     c[x][x]=;
     while(!Q.empty()) Q.pop();
     Q.push(x);
     Q.push(y);
     while(!Q.empty())
     {
         x1=Q.front();
         Q.pop();
         y1=Q.front();
         Q.pop();
         if(x1==n-&&y1==n-)
     {
         flag=;
         return ;
     }
         if(flag)
             return ;
         for(i=;i<;i++)
     {
         x2=x1+c1[i][];
         y2=y1+c1[i][];
         if(x2>=&&x2<n&&y2>=&&y2<n&&a[x2][y2]!='#'&&!c[x2][y2])
         {
             c[x2][y2]=;
             Q.push(x2);
             Q.push(y2);
         }
     }
     }
 }
 int main()
 {
     int i,j;
     while(scanf("%d",&n)!=EOF)
     {
         for(i=;i<n;i++)
             scanf("%s",a[i]);
         memset(dp,,sizeof(dp));
         dp[][]=;
         for(i=;i<n;i++)
             for(j=;j<n;j++)
                     if(a[i][j]!='#')
                 {
                     if(i->=&&a[i-][j]!='#')
                             dp[i][j]+=dp[i-][j];
                     if(j->=&&a[i][j-]!='#')
                             dp[i][j]+=dp[i][j-];
                     dp[i][j]%=sb;
                 }
         if(dp[n-][n-]==)
         {
             flag=;
             bfs(,);
             if(flag)
                 printf("THE GAME IS A LIE\n");
             else
                 printf("INCONCEIVABLE\n");
         }
         else
             printf("%lld\n",dp[n-][n-]);
     }
     return ;
 }