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

→ Обратите внимание

До соревнования
CodeTON Round 9 (Div. 1 + Div. 2, Rated, Prizes!)
25:30:43
Зарегистрироваться »

*есть доп. регистрация

→ Лидеры (рейтинг)

№	Пользователь	Рейтинг
1	tourist	4009
2	jiangly	3823
3	Benq	3738
4	Radewoosh	3633
5	jqdai0815	3620
6	orzdevinwang	3529
7	ecnerwala	3446
8	Um_nik	3396
9	ksun48	3390
10	gamegame	3386

Страны | Города | Организации

→ Лидеры (вклад)

№	Пользователь	Вклад
1	cry	167
2	Um_nik	163
3	maomao90	162
3	atcoder_official	162
5	adamant	159
6	-is-this-fft-	158
7	awoo	157
8	TheScrasse	154
9	Dominater069	153
9	nor	153

Всё →

→ Найти пользователя

→ Прямой эфир

Детальнее →

Блог пользователя Sumanto

How to Optimise GRID PATHS from CSES Problem Set?

Автор Sumanto, 4 года назад, По-английски

По-английски

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 года назад
28

Комментарии

Комментарии (13)

Показать архивные | Написать комментарий?

»

4 года назад, # |

Проголосовать: нравится

0

Проголосовать: не нравится

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

→ Ответить

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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

→ Ответить

»

4 года назад, # |

Проголосовать: нравится

0

Проголосовать: не нравится

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;
}

→ Ответить

»

»

4 года назад, # ^ |

← Rev. 2 →

Проголосовать: нравится

0

Проголосовать: не нравится

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;
}

→ Ответить

»

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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;
}

→ Ответить

»

»

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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?

→ Ответить

»

»

»

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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.

→ Ответить

»

»

»

»

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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--

→ Ответить

»

»

»

»

»

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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.

→ Ответить

»

»

»

»

»

»

»

»

4 года назад, # ^ |

← Rev. 3 →

Проголосовать: нравится

0

Проголосовать: не нравится

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”.

→ Ответить

»

»

»

»

»

»

»

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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

→ Ответить

»

»

»

»

»

»

»

»

»

4 года назад, # ^ |

Проголосовать: нравится

0

Проголосовать: не нравится

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;
}

...

→ Ответить

»

3 года назад, # |

Проголосовать: нравится

0

Проголосовать: не нравится

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

→ Ответить

Codeforces (c) Copyright 2010-2024 Михаил Мирзаянов

Соревнования по программированию 2.0

Время на сервере: 22.11.2024 16:04:17 (j2).

Десктопная версия, переключиться на мобильную.

При поддержке