How to Optimise GRID PATHS from CSES Problem Set? - Codeforces

→ Pay attention

Before contest
Rayan Programming Contest 2024 - Selection (Codeforces Round 989, Div. 1 + Div. 2)
4 days
Register now »

*has extra registration

→ Top rated

#	User	Rating
1	tourist	3993
2	jiangly	3743
3	orzdevinwang	3707
4	Radewoosh	3627
5	jqdai0815	3620
6	Benq	3564
7	Kevin114514	3443
8	ksun48	3434
9	Rewinding	3397
10	Um_nik	3396

Countries | Cities | Organizations

→ Top contributors

#	User	Contrib.
1	cry	167
2	Um_nik	163
3	maomao90	162
3	atcoder_official	162
5	adamant	159
6	-is-this-fft-	158
7	awoo	155
8	TheScrasse	154
9	Dominater069	153
10	nor	152

View all →

→ Find user

→ Recent actions

Detailed →

Sumanto's blog

How to Optimise GRID PATHS from CSES Problem Set?

By Sumanto, 4 years ago, In English

In English

https://cses.fi/problemset/task/1625 I am applying staright forward DFS to the problem but it's getting Time Limit Exceeded. How to optimise the code. I checked out William Lin's Livestream but did'nt get his approach to the problem

+5

Sumanto
4 years ago
28

Comments

Comments (13)

Show archived | Write comment?

»

4 years ago, # |

Vote: I like it

0

Vote: I do not like it

https://cses.fi/book/book.pdf page 52 (the printed page number) or 62 (the pdf page number)

→ Reply

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

i understood the optimisations, but can you explain the runtime mathematically? the explanations there looks more experimental.

→ Reply

»

4 years ago, # |

Vote: I like it

0

Vote: I do not like it

Can anyone with a sharp eye help me please? I basically tried “to go by the the book”, and do the pruning of the T-shaped wall hits, — just as @tmwilliamlin168 does for this problem in his epic 11-hour stream.

Still, however, I'm getting 30+ seconds on the all-question-marks 88418 paths case. What am I missing? I tried to code it up in a clean way, so you probably won't have any trouble following the logic.

Thanks!

The code

#include <bits/stdc++.h>
using namespace std;

static constexpr int RO_MAX = 6;
static constexpr int CO_MAX = 6;
static constexpr int DEST_I = (RO_MAX + 1) * (CO_MAX + 1) - 1;
static constexpr pair<int, int> DEST_COORD{RO_MAX, 0};

template <typename T>
constexpr pair<T, T> operator+(const pair<T, T> &lhs, const pair<T, T> &rhs) {
    return {lhs.first + rhs.first, lhs.second + rhs.second};
}

constexpr pair<int, int> delta(const char dir) {
    switch (dir) {
    case 'U':
        return {-1, 0};
    case 'D':
        return {1, 0};
    case 'L':
        return {0, -1};
    case 'R':
        return {0, 1};
    default:
        assert(false && "Invalid direction char");
        return {0, 0};
    }
}

constexpr bool in_bounds(const pair<int, int> &coord) {
    const auto [ro, co] = coord;
    return ro >= 0 && ro <= RO_MAX && co >= 0 && co <= CO_MAX;
}

constexpr bool is_possible(const vector<vector<bool>> &covered,
                           const pair<int, int> &coord) {
    const auto [ro, co] = coord;
    return in_bounds(coord) && !covered[ro][co];
}

int matching_paths_count(const string &pattern) {
    vector<vector<bool>> covered(RO_MAX + 1, vector<bool>(CO_MAX + 1, false));
    covered[0][0] = true;
    int ans = 0;
    function<void(int, pair<int, int>)> recur;

    recur = [&recur, &pattern, &ans, &covered](const int i,
                                               const pair<int, int> &coord) {
        if (coord == DEST_COORD) {
            if (i == DEST_I) ++ans;
            return;
        }

        for (const auto dir :
             pattern[i] == '?' ? string("UDLR") : string(1, pattern[i])) {
            const auto coord_prime = coord + delta(dir);

            if (!is_possible(covered, coord_prime)) continue;

            if ((dir == 'U' || dir == 'D') &&
                !is_possible(covered, coord_prime + delta(dir)) &&
                is_possible(covered, coord_prime + delta('L')) &&
                is_possible(covered, coord_prime + delta('R')))
                continue;

            if ((dir == 'L' || dir == 'R') &&
                !is_possible(covered, coord_prime + delta(dir)) &&
                is_possible(covered, coord_prime + delta('U')) &&
                is_possible(covered, coord_prime + delta('D')))
                continue;

            covered[coord_prime.first][coord_prime.second] = true;
            recur(i + 1, coord_prime);
            covered[coord_prime.first][coord_prime.second] = false;
        }
    };

    recur(0, {0, 0});

    return ans;
}

int main() {
    string s;
    cin >> s;
    cout << matching_paths_count(s) << '\n';

    return 0;
}

→ Reply

»

»

4 years ago, # ^ |

← Rev. 2 →

Vote: I like it

0

Vote: I do not like it

So, seems like, the constraints are really tight, and the constant factor caused by all the nice code factorizations was simply killing it. After I unrolled all the DRY-ness, and uglified the code to the point listed below, it got accepted.

UPD: Ah, btw, the absolute numbers in seconds I quoted above are not quite representative, as I ran the code with memory sanitization, and all the optimizations disabled. So, it should be, like, 7 times faster, when run by the OJ.

Version 3

#include <bits/stdc++.h>
using namespace std;

static constexpr int RO_MAX = 6;
static constexpr int CO_MAX = 6;
static constexpr int DEST_I = (RO_MAX + 1) * (CO_MAX + 1) - 1;

constexpr bool in_bounds(const int ro, const int co) {
    return ro >= 0 && ro <= RO_MAX && co >= 0 && co <= CO_MAX;
}

constexpr bool is_possible(const vector<vector<bool>> &covered, const int ro,
                           const int co) {
    return in_bounds(ro, co) && !covered[ro][co];
}

void recur(const string &pattern, int &ans, vector<vector<bool>> &covered,
           const int i, const int ro, const int co) {
    if (ro == RO_MAX && co == 0) {
        if (i == DEST_I) ++ans;
        return;
    }

    if ((pattern[i] == '?' || pattern[i] == 'U') &&
        is_possible(covered, ro - 1, co)) {
        bool locked = !is_possible(covered, ro - 2, co) &&
                      is_possible(covered, ro - 1, co - 1) &&
                      is_possible(covered, ro - 1, co + 1);

        if (!locked) {
            covered[ro - 1][co] = true;
            recur(pattern, ans, covered, i + 1, ro - 1, co);
            covered[ro - 1][co] = false;
        }
    }

    if ((pattern[i] == '?' || pattern[i] == 'D') &&
        is_possible(covered, ro + 1, co)) {
        bool locked = !is_possible(covered, ro + 2, co) &&
                      is_possible(covered, ro + 1, co - 1) &&
                      is_possible(covered, ro + 1, co + 1);

        if (!locked) {
            covered[ro + 1][co] = true;
            recur(pattern, ans, covered, i + 1, ro + 1, co);
            covered[ro + 1][co] = false;
        }
    }

    if ((pattern[i] == '?' || pattern[i] == 'L') &&
        is_possible(covered, ro, co - 1)) {
        bool locked = !is_possible(covered, ro, co - 2) &&
                      is_possible(covered, ro - 1, co - 1) &&
                      is_possible(covered, ro + 1, co - 1);

        if (!locked) {
            covered[ro][co - 1] = true;
            recur(pattern, ans, covered, i + 1, ro, co - 1);
            covered[ro][co - 1] = false;
        }
    }

    if ((pattern[i] == '?' || pattern[i] == 'R') &&
        is_possible(covered, ro, co + 1)) { // R
        bool locked = !is_possible(covered, ro, co + 2) &&
                      is_possible(covered, ro - 1, co + 1) &&
                      is_possible(covered, ro + 1, co + 1);

        if (!locked) {
            covered[ro][co + 1] = true;
            recur(pattern, ans, covered, i + 1, ro, co + 1);
            covered[ro][co + 1] = false;
        }
    }
}

int matching_paths_count(const string &pattern) {
    vector<vector<bool>> covered(RO_MAX + 1, vector<bool>(CO_MAX + 1, false));
    covered[0][0] = true;
    int ans = 0;
    recur(pattern, ans, covered, 0, 0, 0);
    return ans;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    string s;
    cin >> s;
    cout << matching_paths_count(s) << '\n';

    return 0;
}

→ Reply

»

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

I have also tried many optimization but still getting TLE after spending too much time on the problem. If could you please suggest me some improvements

Code

//JSD
#include<bits/stdc++.h>
#define ll long long 
using namespace std;
bool check[7][7];
int direction[7][7]; 
// 0, 1, 2, 3  -- L, R, U, D
bool inline valid(int x, ll y){
	if(x<0 or y<0 or x>6 or y>6)
		return false;
	return true;
}
ll inline findDirection(ll sx, ll sy, ll dx, ll dy){
	if(sx == dx and dy<sy) return 0;
	if(sx == dx and dy>sy) return 1;
	if(sy == dy and dx<sx) return 2;
	return 3;
}
pair<ll, ll > forward(ll x, ll y, ll directions){
	if(directions == 0) y--;
	if(directions == 1) y++;
	if(directions == 2) x--;
	if(directions == 3) x++;
	return {x, y};
}
bool inline moveTo(ll sx, ll sy, ll dx, ll dy){
	if(sx == 6 and dx == 6 and (dy>sy)) return false;
	if(sx == 0 and dx == 0 and (dy<sy)) return false;
	if(sy == 6 and dy == 6 and (dx<sx)) return false;
	if(sy == 0 and dy == 0 and (dx<sx)) return false;
	ll dir = findDirection(sx, sy, dx, dy);
	pair<ll, ll > F = forward(sx, sy, dir);
	if(valid(F.first, F.second) and check[F.first][F.second]){
		if(dir == direction[F.first][F.second])
			return false;
	}
	return true;
}
bool inline proceed(ll sx, ll sy, ll dx, ll dy){
	if(valid(dx, dy) and !check[dx][dy] and moveTo(sx, sy, dx, dy)){
		direction[dx][dy] = findDirection(sx, sy, dx, dy);
		return true;
	}
	return false;
}
bool inline checkEnd(ll x, ll y){
	if(x == 6 and y == 0)
		return true;
	return false;
}
bool inline final(ll x, ll y, ll move){
	if(checkEnd(x, y) and move == 48)
		return true;
	return false;
}

ll solve(ll x, ll y, ll move, string &s){
	if(final(x, y, move))
		return 1;
	if(checkEnd(x, y))
		return 0;
	check[x][y] = 1;
	ll ans = 0;
	if(s[move] == 'L' or s[move] == '?'){
		if(proceed(x, y, x, y-1))
			ans += solve(x, y-1, move+1, s);
	}
	if(s[move] == 'R' or s[move] == '?'){
		if(proceed(x, y, x, y+1))
			ans += solve(x, y+1, move+1, s);
	}
	if(s[move] == 'U' or s[move] == '?'){
		if(proceed(x, y, x-1, y))
			ans += solve(x-1, y, move+1, s);
	}
	if(s[move] == 'D' or s[move] == '?'){
		if(proceed(x, y, x+1, y))
			ans += solve(x+1, y, move+1, s);
	}
	check[x][y] = 0;
	return ans;
}
int main(){
	string s;
	cin>>s;
	memset(direction, -1, sizeof(direction));
	memset(check, 0, sizeof(check));
	cout<<solve(0, 0, 0, s)<<"\n";
	return 0;
}

→ Reply

»

»

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

It doesn't seem like the code is pruning the impossible paths early enough. Am I right, that it recurs until it runs out of moves, or hits the end point?

Did you read “Pruning the search” section starting from the page 51 of the CSES book?

→ Reply

»

»

»

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

the moveTo method is doing the pruning part as mentioned in the book. whenever I reach the boundary I avoid atleast one direction of movement.

Other optimization which I have done is the generalized part as mentioned in the book. Though I am not sure the way I have implemented is correct or not.

→ Reply

»

»

»

»

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

Ah! I see, indeed. So, right, there's pruning in case of hitting a wall. For me it was not enough. It was also necessary to prune when hitting an already visited cell, and forming a T-shape, not just a T-shape on the boundary.

x--x
|  |
x->|
   x--

→ Reply

»

»

»

»

»

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

I have handled that too, by using the concept of direction. For each cell I have stored the direction from which I have arrived that cell, and in case (the one which you have mentioned about) suppose I reach cell (i, j) and I notice that cell (i, j+1) is already visited so in that case I have only two directions to move, out of which only one direction is good. I tried some examples and deduced that the direction which is not favourable is the direction specified by me in proceed() method [which is the direction of arrival at that cell]. so if up direction is stored in direction[i, j+1] then I will avoid going upwards from cell (i, j). I think that's what you mean by the T-shape. I am not sure if my way of handling is inappropriate or it is just time consuming.

→ Reply

»

»

»

»

»

»

»

»

4 years ago, # ^ |

← Rev. 3 →

Vote: I like it

0

Vote: I do not like it

Oh… Ok.

Could it be that in such a case — $$$(i, j + 1)$$$ visited, you shouldn't even consider visiting the $$$(i, j)$$$?

Here's my code handling that exact situation:

if ((pattern[i] == '?' || pattern[i] == 'R') &&
    is_possible(covered, ro, co + 1)) { // R
    bool locked = !is_possible(covered, ro, co + 2) &&
                  is_possible(covered, ro - 1, co + 1) &&
                  is_possible(covered, ro + 1, co + 1);

    if (!locked) {
        covered[ro][co + 1] = true;
        recur(pattern, ans, covered, i + 1, ro, co + 1);
        covered[ro][co + 1] = false;
    }
}

So, if $$$(i, j + 1)$$$ is visited, and the path would form a T-shape, I don't even go from $$$(i, j - 1)$$$ to $$$(i, j)$$$. The $$$locked$$$ boolean here means “there would be a T-shape”.

→ Reply

»

»

»

»

»

»

»

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

thought of something like that but got confused regarding the correctness. Thanks by the way!!

→ Reply

»

»

»

»

»

»

»

»

»

4 years ago, # ^ |

Vote: I like it

0

Vote: I do not like it

one update!! I did one more optimization which is if somehow I have created an Island of zeroes surrounded by ones in the matrix then again the answer is not possible. For that I am doing an explicit dfs for checking the number of connected components with zeroes if such number is greater then one then the answer is not possible in such case and we need to do backtrack rather than moving on. But still I am getting TLE on some cases.

updated code (10/20 testcases passed)

...

//JSD
#include<bits/stdc++.h>
#define ll long long 
using namespace std;
bool check[7][7];
int direction[7][7]; 
// 0, 1, 2, 3  -- L, R, U, D
string s;
bool inline valid(int x, ll y){
	if(x<0 or y<0 or x>6 or y>6)
		return false;
	return true;
}
ll inline findDirection(ll sx, ll sy, ll dx, ll dy){
	if(sx == dx and dy<sy) return 0;
	if(sx == dx and dy>sy) return 1;
	if(sy == dy and dx<sx) return 2;
	return 3;
}
bool visited[7][7];
int xx[4] = {1, -1, 0, 0};
int yy[4] = {0, 0, 1, -1};
void dfs(int x, int y){
	visited[x][y] = 1;
	for(int i=0;i<4;i++){
		int p = xx[i]+x;
		int q = yy[i]+y;
		if(valid(p, q) and !visited[p][q] and !check[p][q]){
			dfs(p, q);
		}
	}
}
int components(){
	memset(visited, 0, sizeof(visited));
	int ans = 0;
	for(int i=0;i<7;i++){
		for(int j=0;j<7;j++){
			if(!visited[i][j] and check[i][j]==0){
				ans++;
				dfs(i, j);
			}
		}
	}
	return ans;
}
pair<ll, ll > inline forward(ll x, ll y, ll directions){
	if(directions == 0) y--;
	if(directions == 1) y++;
	if(directions == 2) x--;
	if(directions == 3) x++;
	return {x, y};
}
bool inline moveTo(ll sx, ll sy, ll dx, ll dy){
	if(sx == 6 and dx == 6 and (dy>sy)) return false;
	if(sx == 0 and dx == 0 and (dy<sy)) return false;
	if(sy == 6 and dy == 6 and (dx<sx)) return false;
	if(sy == 0 and dy == 0 and (dx<sx)) return false;
	ll dir = findDirection(sx, sy, dx, dy);
	pair<ll, ll > F = forward(sx, sy, dir);
	if(valid(F.first, F.second) and check[F.first][F.second]){
		if(dir == direction[F.first][F.second])
			return false;
	}
	int comps = components();
	if(comps>1)
		return false;
	return true;
}
bool inline proceed(ll sx, ll sy, ll dx, ll dy){
	if(valid(dx, dy) and !check[dx][dy] and moveTo(sx, sy, dx, dy)){
		direction[dx][dy] = findDirection(sx, sy, dx, dy);
		return true;
	}
	return false;
}
bool inline checkEnd(ll x, ll y){
	if(x == 6 and y == 0)
		return true;
	return false;
}
bool inline final(ll x, ll y, ll move){
	if(checkEnd(x, y) and move == 48)
		return true;
	return false;
}

ll solve(ll x, ll y, ll move){
	if(final(x, y, move))
		return 1;
	if(checkEnd(x, y))
		return 0;
	check[x][y] = 1;
	ll ans = 0;
	if(s[move] == 'L' or s[move] == '?'){
		if(proceed(x, y, x, y-1))
			ans += solve(x, y-1, move+1);
	}
	if(s[move] == 'R' or s[move] == '?'){
		if(proceed(x, y, x, y+1))
			ans += solve(x, y+1, move+1);
	}
	if(s[move] == 'U' or s[move] == '?'){
		if(proceed(x, y, x-1, y))
			ans += solve(x-1, y, move+1);
	}
	if(s[move] == 'D' or s[move] == '?'){
		if(proceed(x, y, x+1, y))
			ans += solve(x+1, y, move+1);	
	}
	check[x][y] = 0;
	return ans;
}
int main(){
	cin>>s;
	memset(direction, -1, sizeof(direction));
	memset(check, 0, sizeof(check));
	cout<<solve(0, 0, 0)<<"\n";
	return 0;
}

...

→ Reply

»

3 years ago, # |

Vote: I like it

0

Vote: I do not like it

I've done the optimizations but still TLE, it turned out switching from

vector<vector<bool>> seen(7, vector<bool>(7, false));

to

bool seen[7][7]; memset(seen, false, sizeof(seen));

Made the difference from TLE on 5 testcases (including all '?') to getting AC. This sucks because I hate memset :P

→ Reply