Skip to content

Commit 3a445f5

Browse files
keshavnandankeshavnandan
committed
srm 156 div 1 900
1 parent 1404292 commit 3a445f5

File tree

2 files changed

+247
-0
lines changed

2 files changed

+247
-0
lines changed

‎PathFinding.cpp

+146
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,146 @@
1+
#include <iostream>
2+
#include <sstream>
3+
#include <vector>
4+
#include <algorithm>
5+
#include <set>
6+
#include <map>
7+
#include <queue>
8+
#include <cstring>
9+
#include <climits>
10+
using namespace std;
11+
typedef pair<int,int> pi;
12+
typedef vector<int> vi;
13+
typedef vector<vi> vvi;
14+
typedef vector<string> vs;
15+
typedef vector<vs> vvs;
16+
17+
int hf(int ax, int ay, int bx, int by){
18+
return ay+20*ax+by*20*20+bx*20*20*20;
19+
}
20+
21+
int mf(int ax, int ay){
22+
return ay + 20*ax;
23+
}
24+
25+
class PathFinding {
26+
public:
27+
int minTurns(vector <string> board)
28+
{
29+
int v[20*20*20*20+20];
30+
fill(v, v+20*20*20*20+20, 0);
31+
32+
vector<pi> M = { {0,0}, {0,1}, {1,0}, {0,-1}, {-1,0}, {1,1}, {1,-1}, {-1,1}, {-1,-1} };
33+
vs s = board;
34+
queue<pi> Q;
35+
36+
int n = s.size(), m = s[0].size();
37+
int sax, say, sbx, sby;
38+
for(int i = 0; i < n; i++)
39+
for(int j = 0; j < m; j++){
40+
if(s[i][j] == 'A'){
41+
sax = i; say = j;
42+
}
43+
if(s[i][j] == 'B'){
44+
sbx = i; sby = j;
45+
}
46+
}
47+
int ss = hf(sax, say, sbx, sby), st = hf(sbx, sby, sax, say);
48+
if(ss == st) return 0;
49+
Q.push(make_pair(ss, 0));
50+
v[ss] = 1;
51+
52+
while(!Q.empty()){
53+
54+
int p = (Q.front()).first;
55+
int l = (Q.front()).second;
56+
Q.pop();
57+
58+
int ax = -1, ay = -1, bx = -1, by = -1;
59+
ay = p%20; p /= 20;
60+
ax = p%20; p /= 20;
61+
by = p%20; p /= 20;
62+
bx = p%20;
63+
64+
for(pi x : M)
65+
for(pi y : M){
66+
67+
int ai = x.first, aj = x.second;
68+
int bi = y.first, bj = y.second;
69+
int ax1 = ax+ai, ay1 = ay+aj;
70+
int bx1 = bx+bi, by1 = by+bj;
71+
int q = hf(ax1, ay1, bx1, by1);
72+
int ah = mf(ax, ay), bh = mf(bx, by), a1h = mf(ax1, ay1), b1h = mf(bx1, by1);
73+
#define valid(a, b) ( 0 <= (a) && (a) < (n) && 0 <= (b) && (b) < (m) )
74+
if( valid(ax1, ay1) && valid(bx1, by1)
75+
&& q != p && (a1h != b1h) && !(ah == b1h && bh == a1h) && v[q] == 0){
76+
77+
if(q == st) return l+1;
78+
79+
if(s[ax1][ay1] != 'X' && s[bx1][by1] != 'X'){
80+
v[q] = 1;
81+
Q.push(make_pair(q, l+1));
82+
}
83+
}
84+
}
85+
}
86+
87+
return -1;
88+
}
89+
90+
// BEGIN CUT HERE
91+
public:
92+
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
93+
private:
94+
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
95+
void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
96+
void test_case_0() { string Arr0[] = {"....",
97+
".A..",
98+
"..B.",
99+
"...."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; verify_case(0, Arg1, minTurns(Arg0)); }
100+
void test_case_1() { string Arr0[] = {"XXXXXXXXX",
101+
"A...X...B",
102+
"XXXXXXXXX"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = -1; verify_case(1, Arg1, minTurns(Arg0)); }
103+
void test_case_2() { string Arr0[] = {"XXXXXXXXX",
104+
"A.......B",
105+
"XXXXXXXXX"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = -1; verify_case(2, Arg1, minTurns(Arg0)); }
106+
void test_case_3() { string Arr0[] = {"XXXXXXXXX",
107+
"A.......B",
108+
"XXXX.XXXX"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 8; verify_case(3, Arg1, minTurns(Arg0)); }
109+
void test_case_4() { string Arr0[] = {"...A.XXXXX.....",
110+
".....XXXXX.....",
111+
"...............",
112+
".....XXXXX.B...",
113+
".....XXXXX....."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 13; verify_case(4, Arg1, minTurns(Arg0)); }
114+
void test_case_5() { string Arr0[] = {"AB.................X",
115+
"XXXXXXXXXXXXXXXXXXX.",
116+
"X..................X",
117+
".XXXXXXXXXXXXXXXXXXX",
118+
"X..................X",
119+
"XXXXXXXXXXXXXXXXXXX.",
120+
"X..................X",
121+
".XXXXXXXXXXXXXXXXXXX",
122+
"X..................X",
123+
"XXXXXXXXXXXXXXXXXXX.",
124+
"X..................X",
125+
".XXXXXXXXXXXXXXXXXXX",
126+
"X..................X",
127+
"XXXXXXXXXXXXXXXXXXX.",
128+
"X..................X",
129+
".XXXXXXXXXXXXXXXXXXX",
130+
"X..................X",
131+
"XXXXXXXXXXXXXXXXXXX.",
132+
"...................X",
133+
".XXXXXXXXXXXXXXXXXXX"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 379; verify_case(5, Arg1, minTurns(Arg0)); }
134+
135+
// END CUT HERE
136+
137+
};
138+
139+
// BEGIN CUT HERE
140+
int main(){
141+
142+
PathFinding ___test;
143+
___test.run_test(-1);
144+
145+
}
146+
// END CUT HERE

‎PathFinding.txt

+101
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,101 @@
1+
PROBLEM STATEMENT
2+
Given a board consisting of empty space, walls, and the starting positions of two players A and B, determine the minimum number of turns it will take for players A and B to switch positions on the board.
3+
4+
During a turn, one or both players may take a step. A step is defined as a unit movement up, down, left, right, or in any of the four diagonals. Players may not step into walls or off the board. Players may never share the same square at the end of a turn. Players may not cross paths during a turn. Crossing paths occurs when players A and B switch positions in a single turn. For example, assume player A is in the upper left corner of the board, and player B is in the square immediately to his right. Player A may not move right while player B moves left, since they would be passing each other. Player A can, however, move right if player B moves in any other direction.
5+
6+
You will be given a vector <string> board, representing the game board. board will contain exactly one 'A' and exactly one 'B'; each other character will be either '.' (empty space), or 'X' (a wall). Your method should return the minimum number of turns necessary for players A and B to switch positions, or -1 if this is impossible.
7+
8+
DEFINITION
9+
Class:PathFinding
10+
Method:minTurns
11+
Parameters:vector <string>
12+
Returns:int
13+
Method signature:int minTurns(vector <string> board)
14+
15+
16+
NOTES
17+
-(In the following notes, assume that the coordinate system is given as (row, col). For example, the upper-left corner of the board is (0,0), and the square immedately below it is (1,0).)
18+
-If player A is at (0,0) and player B is at (0,1), player A would be allowed to move down-right at the same time that player B moves down-left. This is not considered crossing paths, even though the two players would meet at (0.5, 0.5).
19+
-However, if player A is at (0,0) and player B is at (1,1), player A would not be allowed to move down-right at the same time that player B moves up-left. This is considered crossing paths because players A and B have switched positions at the end of a single turn.
20+
-It is permissible to move diagonally through walls. That is, a player may move from (0,0) to (1,1) even if there are walls at (0,1) and (1,0).
21+
22+
23+
CONSTRAINTS
24+
-board will contain between 2 and 20 elements, inclusive.
25+
-Each element of board will contain between 2 and 20 characters, inclusive.
26+
-Each element of board will contain the same number of characters.
27+
-Each element of board will consist of only the characters '.', 'X'. 'A', and 'B'.
28+
-board will contain exactly one 'A' and exactly one 'B'.
29+
30+
31+
EXAMPLES
32+
33+
0)
34+
{"....",
35+
".A..",
36+
"..B.",
37+
"...."}
38+
39+
Returns: 2
40+
41+
There are many ways to switch positions in two turns. For example, on turn one, player A could move right while player B moves up-right. Then, on turn two, player A could move down while player B stays where he is. It is illegal for the players to switch positions in a single turn. Therefore, the method returns 2.
42+
43+
1)
44+
{"XXXXXXXXX",
45+
"A...X...B",
46+
"XXXXXXXXX"}
47+
48+
Returns: -1
49+
50+
Since the players cannot reach each other, they obviously cannot switch positions.
51+
52+
2)
53+
{"XXXXXXXXX",
54+
"A.......B",
55+
"XXXXXXXXX"}
56+
57+
Returns: -1
58+
59+
Even though the players can reach each other, there is still no way for player B to ever get on the left side of player A.
60+
61+
3)
62+
{"XXXXXXXXX",
63+
"A.......B",
64+
"XXXX.XXXX"}
65+
66+
Returns: 8
67+
68+
Players A and B spend the first three turns moving towards each other. On turn four, player A moves down-right while player B moves left. On turn five, player A moves up-right while player B moves left. It then takes three more turns of the players moving away from each other before they have switched positions, for a total of 8 turns.
69+
70+
4)
71+
{"...A.XXXXX.....",
72+
".....XXXXX.....",
73+
"...............",
74+
".....XXXXX.B...",
75+
".....XXXXX....."}
76+
77+
Returns: 13
78+
79+
5)
80+
{"AB.................X",
81+
"XXXXXXXXXXXXXXXXXXX.",
82+
"X..................X",
83+
".XXXXXXXXXXXXXXXXXXX",
84+
"X..................X",
85+
"XXXXXXXXXXXXXXXXXXX.",
86+
"X..................X",
87+
".XXXXXXXXXXXXXXXXXXX",
88+
"X..................X",
89+
"XXXXXXXXXXXXXXXXXXX.",
90+
"X..................X",
91+
".XXXXXXXXXXXXXXXXXXX",
92+
"X..................X",
93+
"XXXXXXXXXXXXXXXXXXX.",
94+
"X..................X",
95+
".XXXXXXXXXXXXXXXXXXX",
96+
"X..................X",
97+
"XXXXXXXXXXXXXXXXXXX.",
98+
"...................X",
99+
".XXXXXXXXXXXXXXXXXXX"}
100+
101+
Returns: 379

0 commit comments

Comments
 (0)