ラムダ式で再帰関数を実装する

#define N 1000001
vector<vector<int>> G(N);
vector<bool> seen(N, false);

void dfs(int v)
{
	seen[v] = true;
	for (auto next_v : G[v]) {
		if (!seen[next_v]) {
			dfs(next_v);
		}
	}
}

	vector<vector<int>> G(n + 1);
	vector<bool> seen(n + 1, false);

	auto dfs = [&](auto self, int v) -> void {
		seen[v] = true;
		for (auto next_v : G[v]) {
			if (!seen[next_v]) {
				self(self, next_v);
			}
		}
	};

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

int main()
{
	int n, m;
	cin >> n >> m;
	vector<vector<int>> G(n + 1);
	for (int i = 0; i < m; ++i) {
		int u, v;
		cin >> u >> v;
		G[u].push_back(v);
		G[v].push_back(u);
	}

	vector<bool> seen(n + 1, false);
	auto dfs = [&](auto self, int v) -> void {
		seen[v] = true;
		for (auto next_v : G[v]) {
			if (!seen[next_v]) {
				self(self, next_v);
			}
		}
	};

	int result = 0;
	for (int i = 1; i <= n; ++i) {
		if (!seen[i]) {
			++result;
			dfs(dfs, i);
		}
	}

	cout << result << endl;

	return 0;
}

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

typedef long long int ll;
#define INF (1LL << 60)

int main()
{
	int n, m;
	cin >> n >> m;
	vector<vector<ll>> dist(n, vector<ll>(n, INF));
	for (int i = 0; i < n; ++i) {
		dist[i][i] = 0;
	}
	vector<int> u(m);
	vector<int> v(m);
	vector<ll> t(m);
	for (int i = 0; i < m; ++i) {
		cin >> u[i] >> v[i] >> t[i];
		--u[i];
		--v[i];
		dist[u[i]][v[i]] = min(dist[u[i]][v[i]], t[i]);
		dist[v[i]][u[i]] = min(dist[v[i]][u[i]], t[i]);
	}

	for (int k = 0; k < n; ++k) {
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				if ((dist[i][k] < INF)&&(dist[k][j] < INF)) {
					dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
				}
			}
		}
	}

	int q;
	cin >> q;
	for (int i = 0; i < q; ++i) {
		int k;
		cin >> k;
		vector<int> b(k);
		for (int i = 0; i < k; ++i) {
			cin >> b[i];
			--b[i];
		}
		vector<bool> used(k, false);
		ll result = INF;

		auto rec = [&](auto self, int num, ll w, int from) -> void {
			if (num == k) {
				result = min(result, w + dist[from][n - 1]);
				return;
			}

			for (int i = 0; i < k; ++i) {
				if (used[i]) {
					continue;
				}
				used[i] = true;
				self(self, num + 1, w + dist[from][u[b[i]]] + t[b[i]], v[b[i]]);
				self(self, num + 1, w + dist[from][v[b[i]]] + t[b[i]], u[b[i]]);
				used[i] = false;
			}

			return;
		};

		rec(rec, 0, 0, 0);
		cout << result << endl;
	}

	return 0;
}