How to optimize my code (CSES Hamiltonian Flights)

№	Пользователь	Рейтинг
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	166
2	maomao90	163
2	Um_nik	163
4	atcoder_official	161
5	adamant	159
6	-is-this-fft-	158
7	awoo	157
8	TheScrasse	154
9	nor	153
9	Dominater069	153

Link to the problem I use bottom up DP, where $$$dp[\text{mask of visited vertices}][\text{ending vertex}]$$$. I'm pretty sure my time complexity is $$$O(N \cdot 2^N + 2^N \cdot N^2)$$$ however it gives TLE. Are there any way to optimize my code, and what's the reason for TLE (probably big constant factor?)

My code

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

const int M = 1e9 + 7;

const int N = 20;

int dp[1 << N][N];

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n, m;
	cin >> n >> m;
	vector<tuple<int, int, int>> edges(m);
	for(int i = 0; i < m; ++i) {
		int u, v;
		cin >> u >> v;
		--u, --v;
		edges[i] = {u, v, (1 << u) | (1 << v)};
	}
	vector<pair<int, int>> masks;
	for(int i = 0; i < (1 << n); ++i) {
		int j = __builtin_popcount(i);
		if(j >= 2) {
			masks.emplace_back(j, i);
		}
	}
	sort(masks.begin(), masks.end());
	dp[1][0] = 1;
	for(int id = 0; id < (int) masks.size(); ++id) {
		int mask = masks[id].second;
		for(auto& [u, v, c] : edges) {
			if((mask & c) == c) {
				dp[mask][v] = (dp[mask][v] + dp[mask ^ (1 << v)][u]) % M;
			}
		}
	}
	cout << dp[(1 << n) - 1][n - 1] << "\n";
	return 0;
}

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

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

Alon-Tanay

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

Your dp idea could work, if you eliminate the N^2 factor. Try using a top-bottom approach, so start with the full mask and ending, and work to the bottom (recursion should be an easy implementation). don't forget to use memoization in that case, since you don't want to compute the same value more than once.

→ Ответить

Polyn0mial

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

Is it because bottom-up approach checked to many unimportant states?

Scratch that, looking at my submission I think I'm using N^2*2^N as well, the problem is probably you sorting the masks.

Also quick tip for speeding up your code by about x5 is only doing dp on the middle nodes (2,3,...,n-1) because you know for sure when you'll reach 1 and n.

Sorting is only $$$O(N \cdot 2^N)$$$ which is way smaller than $$$O(2^N \cdot N^2)$$$. Also, only do dp on the middle nodes like this $$$dp[\text{first_node}][\text{visited_nodes}][\text{ending_node}]$$$ ? However it requires $$$O(2^N \cdot N^2)$$$ memory which is too much.

no no, do the same dp, but only with middle nodes, don't do it for 1 and n

Not sure how. If we only do the middle ones, what will be the final answer? Some of the $$$\text{full_mask}$$$ could be starting from some nodes that isn't directly connected to node $$$1$$$.

the only difference is the starting values, which will be 1 for each direct neighbor of node 1 (for the 1 bit mask).

The calculation at the end will be the sum of full masks over all nodes that connect to n

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